diff options
Diffstat (limited to 'kexi/3rdparty/kexisql')
57 files changed, 60355 insertions, 0 deletions
diff --git a/kexi/3rdparty/kexisql/Makefile.am b/kexi/3rdparty/kexisql/Makefile.am new file mode 100644 index 00000000..22a0a17b --- /dev/null +++ b/kexi/3rdparty/kexisql/Makefile.am @@ -0,0 +1 @@ +SUBDIRS = tool src diff --git a/kexi/3rdparty/kexisql/Makefile.msvc b/kexi/3rdparty/kexisql/Makefile.msvc new file mode 100644 index 00000000..0be28d92 --- /dev/null +++ b/kexi/3rdparty/kexisql/Makefile.msvc @@ -0,0 +1,167 @@ +############################################################################# +# Makefile for building: sqlite2 +############################################################################# + +####### Compiler, tools and options + +CC = cl +CXX = cl +LEX = flex +YACC = byacc +CFLAGS = -nologo -Zm200 -W3 -MDd -Z7 -GX -GR -DTHREADSAFE=1 +CXXFLAGS = -nologo -Zm200 /GR /GX /GZ /TP -W3 -MDd -Z7 -GX -GR -DUNICODE +LEXFLAGS = +YACCFLAGS =-d +INCPATH = -Isrc +LINK = link +LFLAGS = /NOLOGO /FORCE:MULTIPLE /DEBUG /SUBSYSTEM:console /DEF:kexisql.def /DLL +VERSION=2.8.2 +LIBS = "kernel32.lib" "user32.lib" "gdi32.lib" "comdlg32.lib" "advapi32.lib" "shell32.lib" "ole32.lib" "oleaut32.lib" "uuid.lib" "imm32.lib" "winmm.lib" "wsock32.lib" "winspool.lib" +IDC = $(QTDIR)\bin\idc.exe +IDL = midl +ZIP = zip -r -9 +COPY_FILE = copy +COPY_DIR = copy +DEL_FILE = del +DEL_DIR = rmdir +MOVE = move +CHK_DIR_EXISTS = if not exist +MKDIR = mkdir + +####### Files + +HEADERS = +SOURCES = \ +src/attach.c \ +src/auth.c \ +src/btree.c \ +src/btree_rb.c \ +src/build.c \ +src/copy.c \ +src/date.c \ +src/delete.c \ +src/expr.c \ +src/func.c \ +src/hash.c \ +src/insert.c \ +src/main.c \ +src/os.c \ +src/pager.c \ +src/pragma.c \ +src/printf.c \ +src/random.c \ +src/select.c \ +src/table.c \ +src/tokenize.c \ +src/trigger.c \ +src/update.c \ +src/util.c \ +src/vacuum.c \ +src/vdbe.c \ +src/vdbeaux.c \ +src/where.c \ +src/opcodes.c \ +src/parse.c \ +src/shell.c + +OBJECTS = \ +obj/attach.obj \ +obj/auth.obj \ +obj/btree.obj \ +obj/btree_rb.obj \ +obj/build.obj \ +obj/copy.obj \ +obj/date.obj \ +obj/delete.obj \ +obj/expr.obj \ +obj/func.obj \ +obj/hash.obj \ +obj/insert.obj \ +obj/main.obj \ +obj/os.obj \ +obj/pager.obj \ +obj/pragma.obj \ +obj/printf.obj \ +obj/random.obj \ +obj/select.obj \ +obj/table.obj \ +obj/tokenize.obj \ +obj/trigger.obj \ +obj/update.obj \ +obj/util.obj \ +obj/vacuum.obj \ +obj/vdbe.obj \ +obj/vdbeaux.obj \ +obj/where.obj \ +obj/opcodes.obj \ +obj/parse.obj \ +obj/shell.obj + +FORMS = +UICDECLS = +UICIMPLS = +SRCMOC = +OBJMOC = +DIST = +TARGET = $(KDEDIR)/bin/kexisql2_d.dll + +####### Implicit rules + +.SUFFIXES: .c .cpp .cc .cxx .C + +{.}.cpp{obj\}.obj:: + $(CXX) -c $(CXXFLAGS) $(INCPATH) -Foobj\ @<< + $< +<< + +{.}.cc{obj\}.obj:: + $(CXX) -c $(CXXFLAGS) $(INCPATH) -Foobj\ @<< + $< +<< + +{.}.cxx{obj\}.obj:: + $(CXX) -c $(CXXFLAGS) $(INCPATH) -Foobj\ @<< + $< +<< + +{.}.C{obj\}.obj:: + $(CXX) -c $(CXXFLAGS) $(INCPATH) -Foobj\ @<< + $< +<< + +{.}.c{obj\}.obj:: + $(CC) -c $(CFLAGS) $(INCPATH) -Foobj\ @<< + $< +<< + +{src\}.c{obj\}.obj:: + $(CC) -c $(CFLAGS) $(INCPATH) -Foobj\ @<< + $< +<< + +####### Build rules + +all: $(TARGET) sqlite2 + +$(TARGET): $(UICDECLS) $(OBJECTS) $(OBJMOC) + $(LINK) $(LFLAGS) /OUT:$(TARGET) @<< + $(OBJECTS) $(OBJMOC) $(LIBS) +<< + +sqlite2: obj/shell.obj $(KDEDIR)/bin/kexisql2.lib + link $(READLINE_FLAGS) $(LIBPTHREAD) \ + /OUT:$(KDEDIR)/bin/ksqlite2.exe obj/shell.obj $(KDEDIR)/bin/kexisql2.lib $(LIBREADLINE) + +mocables: $(SRCMOC) +uicables: $(UICIMPLS) $(UICDECLS) + +clean: + -del obj\*.obj + +distclean: clean + -del $(TARGET) + +install: all + +uninstall: + diff --git a/kexi/3rdparty/kexisql/kexisql.def b/kexi/3rdparty/kexisql/kexisql.def new file mode 100644 index 00000000..681aa63e --- /dev/null +++ b/kexi/3rdparty/kexisql/kexisql.def @@ -0,0 +1,40 @@ +EXPORTS +sqlite_open +sqlite_close +sqlite_exec +sqlite_last_insert_rowid +sqlite_error_string +sqlite_interrupt +sqlite_complete +sqlite_busy_handler +sqlite_busy_timeout +sqlite_get_table +sqlite_free_table +sqlite_mprintf +sqlite_vmprintf +sqlite_exec_printf +sqlite_exec_vprintf +sqlite_get_table_printf +sqlite_get_table_vprintf +sqlite_freemem +sqlite_libversion +sqlite_libencoding +sqlite_changes +sqlite_create_function +sqlite_create_aggregate +sqlite_function_type +sqlite_user_data +sqlite_aggregate_context +sqlite_aggregate_count +sqlite_set_result_string +sqlite_set_result_int +sqlite_set_result_double +sqlite_set_result_error +sqliteMalloc +sqliteFree +sqliteRealloc +sqlite_set_authorizer +sqlite_trace +sqlite_compile +sqlite_step +sqlite_finalize diff --git a/kexi/3rdparty/kexisql/src/Makefile.am b/kexi/3rdparty/kexisql/src/Makefile.am new file mode 100644 index 00000000..0678eece --- /dev/null +++ b/kexi/3rdparty/kexisql/src/Makefile.am @@ -0,0 +1,20 @@ +include $(top_srcdir)/kexi/Makefile.global + +lib_LTLIBRARIES = libkexisql2.la + +bin_PROGRAMS = ksqlite2 + +INCLUDES = $(all_includes) + +libkexisql2_la_SOURCES = attach.c auth.c btree.c btree_rb.c build.c date.c expr.c func.c hash.c \ +insert.c os.c pager.c parse.c pragma.c printf.c random.c select.c copy.c delete.c encode.c \ +table.c tokenize.c trigger.c update.c util.c vacuum.c vdbe.c vdbeaux.c where.c opcodes.c main.c + +AM_CFLAGS = -DNO_TCL=1 + +ksqlite2_SOURCES = shell.c +ksqlite2_LDADD = libkexisql2.la $(LIBREADLINE) + +libkexisql2_la_LIBADD = +libkexisql2_la_LDFLAGS = -version-info 2:8 $(all_libraries) --no-undefined + diff --git a/kexi/3rdparty/kexisql/src/attach.c b/kexi/3rdparty/kexisql/src/attach.c new file mode 100644 index 00000000..b41134be --- /dev/null +++ b/kexi/3rdparty/kexisql/src/attach.c @@ -0,0 +1,311 @@ +/* +** 2003 April 6 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains code used to implement the ATTACH and DETACH commands. +** +** $Id: attach.c 410099 2005-05-06 17:52:07Z staniek $ +*/ +#include "sqliteInt.h" + +/* +** This routine is called by the parser to process an ATTACH statement: +** +** ATTACH DATABASE filename AS dbname +** +** The pFilename and pDbname arguments are the tokens that define the +** filename and dbname in the ATTACH statement. +*/ +void sqliteAttach(Parse *pParse, Token *pFilename, Token *pDbname, Token *pKey){ + Db *aNew; + int rc, i; + char *zFile, *zName; + sqlite *db; + Vdbe *v; + + 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; + } + if( db->nDb>=MAX_ATTACHED+2 ){ + sqliteErrorMsg(pParse, "too many attached databases - max %d", + MAX_ATTACHED); + pParse->rc = SQLITE_ERROR; + return; + } + + zFile = 0; + sqliteSetNString(&zFile, pFilename->z, pFilename->n, 0); + if( zFile==0 ) return; + sqliteDequote(zFile); +#ifndef SQLITE_OMIT_AUTHORIZATION + if( sqliteAuthCheck(pParse, SQLITE_ATTACH, zFile, 0, 0)!=SQLITE_OK ){ + sqliteFree(zFile); + return; + } +#endif /* SQLITE_OMIT_AUTHORIZATION */ + + zName = 0; + sqliteSetNString(&zName, pDbname->z, pDbname->n, 0); + if( zName==0 ) return; + sqliteDequote(zName); + for(i=0; i<db->nDb; i++){ + if( db->aDb[i].zName && sqliteStrICmp(db->aDb[i].zName, zName)==0 ){ + sqliteErrorMsg(pParse, "database %z is already in use", zName); + pParse->rc = SQLITE_ERROR; + sqliteFree(zFile); + return; + } + } + + if( db->aDb==db->aDbStatic ){ + aNew = sqliteMalloc( sizeof(db->aDb[0])*3 ); + if( aNew==0 ) return; + memcpy(aNew, db->aDb, sizeof(db->aDb[0])*2); + }else{ + aNew = sqliteRealloc(db->aDb, sizeof(db->aDb[0])*(db->nDb+1) ); + if( aNew==0 ) return; + } + db->aDb = aNew; + aNew = &db->aDb[db->nDb++]; + memset(aNew, 0, sizeof(*aNew)); + sqliteHashInit(&aNew->tblHash, SQLITE_HASH_STRING, 0); + sqliteHashInit(&aNew->idxHash, SQLITE_HASH_STRING, 0); + sqliteHashInit(&aNew->trigHash, SQLITE_HASH_STRING, 0); + sqliteHashInit(&aNew->aFKey, SQLITE_HASH_STRING, 1); + aNew->zName = zName; + rc = sqliteBtreeFactory(db, zFile, 0, MAX_PAGES, &aNew->pBt); + if( rc ){ + sqliteErrorMsg(pParse, "unable to open database: %s", zFile); + } +#if SQLITE_HAS_CODEC + { + extern int sqliteCodecAttach(sqlite*, int, void*, int); + char *zKey = 0; + int nKey; + if( pKey && pKey->z && pKey->n ){ + sqliteSetNString(&zKey, pKey->z, pKey->n, 0); + sqliteDequote(zKey); + nKey = strlen(zKey); + }else{ + zKey = 0; + nKey = 0; + } + sqliteCodecAttach(db, db->nDb-1, zKey, nKey); + } +#endif + sqliteFree(zFile); + db->flags &= ~SQLITE_Initialized; + if( pParse->nErr ) return; + if( rc==SQLITE_OK ){ + rc = sqliteInit(pParse->db, &pParse->zErrMsg); + } + if( rc ){ + int i = db->nDb - 1; + assert( i>=2 ); + if( db->aDb[i].pBt ){ + sqliteBtreeClose(db->aDb[i].pBt); + db->aDb[i].pBt = 0; + } + sqliteResetInternalSchema(db, 0); + pParse->nErr++; + pParse->rc = SQLITE_ERROR; + } +} + +/* +** This routine is called by the parser to process a DETACH statement: +** +** DETACH DATABASE dbname +** +** The pDbname argument is the name of the database in the DETACH statement. +*/ +void sqliteDetach(Parse *pParse, Token *pDbname){ + int i; + sqlite *db; + Vdbe *v; + Db *pDb; + + v = sqliteGetVdbe(pParse); + sqliteVdbeAddOp(v, OP_Halt, 0, 0); + if( pParse->explain ) return; + db = pParse->db; + for(i=0; i<db->nDb; i++){ + pDb = &db->aDb[i]; + if( pDb->pBt==0 || pDb->zName==0 ) continue; + if( strlen(pDb->zName)!=pDbname->n ) continue; + if( sqliteStrNICmp(pDb->zName, pDbname->z, pDbname->n)==0 ) break; + } + if( i>=db->nDb ){ + sqliteErrorMsg(pParse, "no such database: %T", pDbname); + return; + } + if( i<2 ){ + sqliteErrorMsg(pParse, "cannot detach database %T", pDbname); + return; + } +#ifndef SQLITE_OMIT_AUTHORIZATION + if( sqliteAuthCheck(pParse,SQLITE_DETACH,db->aDb[i].zName,0,0)!=SQLITE_OK ){ + return; + } +#endif /* SQLITE_OMIT_AUTHORIZATION */ + sqliteBtreeClose(pDb->pBt); + pDb->pBt = 0; + sqliteFree(pDb->zName); + sqliteResetInternalSchema(db, i); + if( pDb->pAux && pDb->xFreeAux ) pDb->xFreeAux(pDb->pAux); + db->nDb--; + if( i<db->nDb ){ + db->aDb[i] = db->aDb[db->nDb]; + memset(&db->aDb[db->nDb], 0, sizeof(db->aDb[0])); + sqliteResetInternalSchema(db, i); + } +} + +/* +** Initialize a DbFixer structure. This routine must be called prior +** to passing the structure to one of the sqliteFixAAAA() routines below. +** +** The return value indicates whether or not fixation is required. TRUE +** means we do need to fix the database references, FALSE means we do not. +*/ +int sqliteFixInit( + DbFixer *pFix, /* The fixer to be initialized */ + Parse *pParse, /* Error messages will be written here */ + int iDb, /* This is the database that must must be used */ + const char *zType, /* "view", "trigger", or "index" */ + const Token *pName /* Name of the view, trigger, or index */ +){ + sqlite *db; + + if( iDb<0 || iDb==1 ) return 0; + db = pParse->db; + assert( db->nDb>iDb ); + pFix->pParse = pParse; + pFix->zDb = db->aDb[iDb].zName; + pFix->zType = zType; + pFix->pName = pName; + return 1; +} + +/* +** The following set of routines walk through the parse tree and assign +** a specific database to all table references where the database name +** was left unspecified in the original SQL statement. The pFix structure +** must have been initialized by a prior call to sqliteFixInit(). +** +** These routines are used to make sure that an index, trigger, or +** view in one database does not refer to objects in a different database. +** (Exception: indices, triggers, and views in the TEMP database are +** allowed to refer to anything.) If a reference is explicitly made +** to an object in a different database, an error message is added to +** pParse->zErrMsg and these routines return non-zero. If everything +** checks out, these routines return 0. +*/ +int sqliteFixSrcList( + DbFixer *pFix, /* Context of the fixation */ + SrcList *pList /* The Source list to check and modify */ +){ + int i; + const char *zDb; + + if( pList==0 ) return 0; + zDb = pFix->zDb; + for(i=0; i<pList->nSrc; i++){ + if( pList->a[i].zDatabase==0 ){ + pList->a[i].zDatabase = sqliteStrDup(zDb); + }else if( sqliteStrICmp(pList->a[i].zDatabase,zDb)!=0 ){ + sqliteErrorMsg(pFix->pParse, + "%s %z cannot reference objects in database %s", + pFix->zType, sqliteStrNDup(pFix->pName->z, pFix->pName->n), + pList->a[i].zDatabase); + return 1; + } + if( sqliteFixSelect(pFix, pList->a[i].pSelect) ) return 1; + if( sqliteFixExpr(pFix, pList->a[i].pOn) ) return 1; + } + return 0; +} +int sqliteFixSelect( + DbFixer *pFix, /* Context of the fixation */ + Select *pSelect /* The SELECT statement to be fixed to one database */ +){ + while( pSelect ){ + if( sqliteFixExprList(pFix, pSelect->pEList) ){ + return 1; + } + if( sqliteFixSrcList(pFix, pSelect->pSrc) ){ + return 1; + } + if( sqliteFixExpr(pFix, pSelect->pWhere) ){ + return 1; + } + if( sqliteFixExpr(pFix, pSelect->pHaving) ){ + return 1; + } + pSelect = pSelect->pPrior; + } + return 0; +} +int sqliteFixExpr( + DbFixer *pFix, /* Context of the fixation */ + Expr *pExpr /* The expression to be fixed to one database */ +){ + while( pExpr ){ + if( sqliteFixSelect(pFix, pExpr->pSelect) ){ + return 1; + } + if( sqliteFixExprList(pFix, pExpr->pList) ){ + return 1; + } + if( sqliteFixExpr(pFix, pExpr->pRight) ){ + return 1; + } + pExpr = pExpr->pLeft; + } + return 0; +} +int sqliteFixExprList( + DbFixer *pFix, /* Context of the fixation */ + ExprList *pList /* The expression to be fixed to one database */ +){ + int i; + if( pList==0 ) return 0; + for(i=0; i<pList->nExpr; i++){ + if( sqliteFixExpr(pFix, pList->a[i].pExpr) ){ + return 1; + } + } + return 0; +} +int sqliteFixTriggerStep( + DbFixer *pFix, /* Context of the fixation */ + TriggerStep *pStep /* The trigger step be fixed to one database */ +){ + while( pStep ){ + if( sqliteFixSelect(pFix, pStep->pSelect) ){ + return 1; + } + if( sqliteFixExpr(pFix, pStep->pWhere) ){ + return 1; + } + if( sqliteFixExprList(pFix, pStep->pExprList) ){ + return 1; + } + pStep = pStep->pNext; + } + return 0; +} diff --git a/kexi/3rdparty/kexisql/src/auth.c b/kexi/3rdparty/kexisql/src/auth.c new file mode 100644 index 00000000..61a3ad94 --- /dev/null +++ b/kexi/3rdparty/kexisql/src/auth.c @@ -0,0 +1,219 @@ +/* +** 2003 January 11 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains code used to implement the sqlite_set_authorizer() +** API. This facility is an optional feature of the library. Embedded +** systems that do not need this facility may omit it by recompiling +** the library with -DSQLITE_OMIT_AUTHORIZATION=1 +** +** $Id: auth.c 410099 2005-05-06 17:52:07Z staniek $ +*/ +#include "sqliteInt.h" + +/* +** All of the code in this file may be omitted by defining a single +** macro. +*/ +#ifndef SQLITE_OMIT_AUTHORIZATION + +/* +** Set or clear the access authorization function. +** +** The access authorization function is be called during the compilation +** phase to verify that the user has read and/or write access permission on +** various fields of the database. The first argument to the auth function +** is a copy of the 3rd argument to this routine. The second argument +** to the auth function is one of these constants: +** +** SQLITE_COPY +** SQLITE_CREATE_INDEX +** SQLITE_CREATE_TABLE +** SQLITE_CREATE_TEMP_INDEX +** SQLITE_CREATE_TEMP_TABLE +** SQLITE_CREATE_TEMP_TRIGGER +** SQLITE_CREATE_TEMP_VIEW +** SQLITE_CREATE_TRIGGER +** SQLITE_CREATE_VIEW +** SQLITE_DELETE +** SQLITE_DROP_INDEX +** SQLITE_DROP_TABLE +** SQLITE_DROP_TEMP_INDEX +** SQLITE_DROP_TEMP_TABLE +** SQLITE_DROP_TEMP_TRIGGER +** SQLITE_DROP_TEMP_VIEW +** SQLITE_DROP_TRIGGER +** SQLITE_DROP_VIEW +** SQLITE_INSERT +** SQLITE_PRAGMA +** SQLITE_READ +** SQLITE_SELECT +** SQLITE_TRANSACTION +** SQLITE_UPDATE +** +** The third and fourth arguments to the auth function are the name of +** the table and the column that are being accessed. The auth function +** should return either SQLITE_OK, SQLITE_DENY, or SQLITE_IGNORE. If +** SQLITE_OK is returned, it means that access is allowed. SQLITE_DENY +** means that the SQL statement will never-run - the sqlite_exec() call +** will return with an error. SQLITE_IGNORE means that the SQL statement +** should run but attempts to read the specified column will return NULL +** and attempts to write the column will be ignored. +** +** Setting the auth function to NULL disables this hook. The default +** setting of the auth function is NULL. +*/ +int sqlite_set_authorizer( + sqlite *db, + int (*xAuth)(void*,int,const char*,const char*,const char*,const char*), + void *pArg +){ + db->xAuth = xAuth; + db->pAuthArg = pArg; + return SQLITE_OK; +} + +/* +** Write an error message into pParse->zErrMsg that explains that the +** user-supplied authorization function returned an illegal value. +*/ +static void sqliteAuthBadReturnCode(Parse *pParse, int rc){ + sqliteErrorMsg(pParse, "illegal return value (%d) from the " + "authorization function - should be SQLITE_OK, SQLITE_IGNORE, " + "or SQLITE_DENY", rc); + pParse->rc = SQLITE_MISUSE; +} + +/* +** The pExpr should be a TK_COLUMN expression. The table referred to +** is in pTabList or else it is the NEW or OLD table of a trigger. +** Check to see if it is OK to read this particular column. +** +** If the auth function returns SQLITE_IGNORE, change the TK_COLUMN +** instruction into a TK_NULL. If the auth function returns SQLITE_DENY, +** then generate an error. +*/ +void sqliteAuthRead( + Parse *pParse, /* The parser context */ + Expr *pExpr, /* The expression to check authorization on */ + SrcList *pTabList /* All table that pExpr might refer to */ +){ + sqlite *db = pParse->db; + int rc; + Table *pTab; /* The table being read */ + const char *zCol; /* Name of the column of the table */ + int iSrc; /* Index in pTabList->a[] of table being read */ + const char *zDBase; /* Name of database being accessed */ + + if( db->xAuth==0 ) return; + assert( pExpr->op==TK_COLUMN ); + for(iSrc=0; iSrc<pTabList->nSrc; iSrc++){ + if( pExpr->iTable==pTabList->a[iSrc].iCursor ) break; + } + if( iSrc>=0 && iSrc<pTabList->nSrc ){ + pTab = pTabList->a[iSrc].pTab; + }else{ + /* 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; + } + if( pTab==0 ) return; + if( pExpr->iColumn>=0 ){ + assert( pExpr->iColumn<pTab->nCol ); + zCol = pTab->aCol[pExpr->iColumn].zName; + }else if( pTab->iPKey>=0 ){ + assert( pTab->iPKey<pTab->nCol ); + zCol = pTab->aCol[pTab->iPKey].zName; + }else{ + zCol = "ROWID"; + } + assert( pExpr->iDb<db->nDb ); + zDBase = db->aDb[pExpr->iDb].zName; + rc = db->xAuth(db->pAuthArg, SQLITE_READ, pTab->zName, zCol, zDBase, + pParse->zAuthContext); + if( rc==SQLITE_IGNORE ){ + pExpr->op = TK_NULL; + }else if( rc==SQLITE_DENY ){ + if( db->nDb>2 || pExpr->iDb!=0 ){ + sqliteErrorMsg(pParse, "access to %s.%s.%s is prohibited", + zDBase, pTab->zName, zCol); + }else{ + sqliteErrorMsg(pParse, "access to %s.%s is prohibited", pTab->zName,zCol); + } + pParse->rc = SQLITE_AUTH; + }else if( rc!=SQLITE_OK ){ + sqliteAuthBadReturnCode(pParse, rc); + } +} + +/* +** Do an authorization check using the code and arguments given. Return +** either SQLITE_OK (zero) or SQLITE_IGNORE or SQLITE_DENY. If SQLITE_DENY +** is returned, then the error count and error message in pParse are +** modified appropriately. +*/ +int sqliteAuthCheck( + Parse *pParse, + int code, + const char *zArg1, + const char *zArg2, + const char *zArg3 +){ + sqlite *db = pParse->db; + int rc; + + if( db->init.busy || db->xAuth==0 ){ + return SQLITE_OK; + } + rc = db->xAuth(db->pAuthArg, code, zArg1, zArg2, zArg3, pParse->zAuthContext); + if( rc==SQLITE_DENY ){ + sqliteErrorMsg(pParse, "not authorized"); + pParse->rc = SQLITE_AUTH; + }else if( rc!=SQLITE_OK && rc!=SQLITE_IGNORE ){ + rc = SQLITE_DENY; + sqliteAuthBadReturnCode(pParse, rc); + } + return rc; +} + +/* +** Push an authorization context. After this routine is called, the +** zArg3 argument to authorization callbacks will be zContext until +** popped. Or if pParse==0, this routine is a no-op. +*/ +void sqliteAuthContextPush( + Parse *pParse, + AuthContext *pContext, + const char *zContext +){ + pContext->pParse = pParse; + if( pParse ){ + pContext->zAuthContext = pParse->zAuthContext; + pParse->zAuthContext = zContext; + } +} + +/* +** Pop an authorization context that was previously pushed +** by sqliteAuthContextPush +*/ +void sqliteAuthContextPop(AuthContext *pContext){ + if( pContext->pParse ){ + pContext->pParse->zAuthContext = pContext->zAuthContext; + pContext->pParse = 0; + } +} + +#endif /* SQLITE_OMIT_AUTHORIZATION */ diff --git a/kexi/3rdparty/kexisql/src/btree.c b/kexi/3rdparty/kexisql/src/btree.c new file mode 100644 index 00000000..02e01249 --- /dev/null +++ b/kexi/3rdparty/kexisql/src/btree.c @@ -0,0 +1,3584 @@ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** $Id: btree.c 410099 2005-05-06 17:52:07Z staniek $ +** +** This file implements a external (disk-based) database using BTrees. +** For a detailed discussion of BTrees, refer to +** +** Donald E. Knuth, THE ART OF COMPUTER PROGRAMMING, Volume 3: +** "Sorting And Searching", pages 473-480. Addison-Wesley +** Publishing Company, Reading, Massachusetts. +** +** The basic idea is that each page of the file contains N database +** entries and N+1 pointers to subpages. +** +** ---------------------------------------------------------------- +** | Ptr(0) | Key(0) | Ptr(1) | Key(1) | ... | Key(N) | Ptr(N+1) | +** ---------------------------------------------------------------- +** +** All of the keys on the page that Ptr(0) points to have values less +** than Key(0). All of the keys on page Ptr(1) and its subpages have +** values greater than Key(0) and less than Key(1). All of the keys +** on Ptr(N+1) and its subpages have values greater than Key(N). And +** so forth. +** +** Finding a particular key requires reading O(log(M)) pages from the +** disk where M is the number of entries in the tree. +** +** In this implementation, a single file can hold one or more separate +** BTrees. Each BTree is identified by the index of its root page. The +** key and data for any entry are combined to form the "payload". Up to +** MX_LOCAL_PAYLOAD bytes of payload can be carried directly on the +** database page. If the payload is larger than MX_LOCAL_PAYLOAD bytes +** then surplus bytes are stored on overflow pages. The payload for an +** entry and the preceding pointer are combined to form a "Cell". Each +** page has a small header which contains the Ptr(N+1) pointer. +** +** The first page of the file contains a magic string used to verify that +** the file really is a valid BTree database, a pointer to a list of unused +** pages in the file, and some meta information. The root of the first +** BTree begins on page 2 of the file. (Pages are numbered beginning with +** 1, not 0.) Thus a minimum database contains 2 pages. +*/ +#include "sqliteInt.h" +#include "pager.h" +#include "btree.h" +#include <assert.h> + +/* Forward declarations */ +static BtOps sqliteBtreeOps; +static BtCursorOps sqliteBtreeCursorOps; + +/* +** Macros used for byteswapping. B is a pointer to the Btree +** structure. This is needed to access the Btree.needSwab boolean +** in order to tell if byte swapping is needed or not. +** X is an unsigned integer. SWAB16 byte swaps a 16-bit integer. +** SWAB32 byteswaps a 32-bit integer. +*/ +#define SWAB16(B,X) ((B)->needSwab? swab16((u16)X) : ((u16)X)) +#define SWAB32(B,X) ((B)->needSwab? swab32(X) : (X)) +#define SWAB_ADD(B,X,A) \ + if((B)->needSwab){ X=swab32(swab32(X)+A); }else{ X += (A); } + +/* +** The following global variable - available only if SQLITE_TEST is +** defined - is used to determine whether new databases are created in +** native byte order or in non-native byte order. Non-native byte order +** databases are created for testing purposes only. Under normal operation, +** only native byte-order databases should be created, but we should be +** able to read or write existing databases regardless of the byteorder. +*/ +#ifdef SQLITE_TEST +int btree_native_byte_order = 1; +#else +# define btree_native_byte_order 1 +#endif + +/* +** Forward declarations of structures used only in this file. +*/ +typedef struct PageOne PageOne; +typedef struct MemPage MemPage; +typedef struct PageHdr PageHdr; +typedef struct Cell Cell; +typedef struct CellHdr CellHdr; +typedef struct FreeBlk FreeBlk; +typedef struct OverflowPage OverflowPage; +typedef struct FreelistInfo FreelistInfo; + +/* +** All structures on a database page are aligned to 4-byte boundries. +** This routine rounds up a number of bytes to the next multiple of 4. +** +** This might need to change for computer architectures that require +** and 8-byte alignment boundry for structures. +*/ +#define ROUNDUP(X) ((X+3) & ~3) + +/* +** This is a magic string that appears at the beginning of every +** SQLite database in order to identify the file as a real database. +*/ +static const char zMagicHeader[] = + "** This file contains an SQLite 2.1 database **"; +#define MAGIC_SIZE (sizeof(zMagicHeader)) + +/* +** This is a magic integer also used to test the integrity of the database +** file. This integer is used in addition to the string above so that +** if the file is written on a little-endian architecture and read +** on a big-endian architectures (or vice versa) we can detect the +** problem. +** +** The number used was obtained at random and has no special +** significance other than the fact that it represents a different +** integer on little-endian and big-endian machines. +*/ +#define MAGIC 0xdae37528 + +/* +** The first page of the database file contains a magic header string +** to identify the file as an SQLite database file. It also contains +** a pointer to the first free page of the file. Page 2 contains the +** root of the principle BTree. The file might contain other BTrees +** rooted on pages above 2. +** +** The first page also contains SQLITE_N_BTREE_META integers that +** can be used by higher-level routines. +** +** Remember that pages are numbered beginning with 1. (See pager.c +** for additional information.) Page 0 does not exist and a page +** number of 0 is used to mean "no such page". +*/ +struct PageOne { + char zMagic[MAGIC_SIZE]; /* String that identifies the file as a database */ + int iMagic; /* Integer to verify correct byte order */ + Pgno freeList; /* First free page in a list of all free pages */ + int nFree; /* Number of pages on the free list */ + int aMeta[SQLITE_N_BTREE_META-1]; /* User defined integers */ +}; + +/* +** Each database page has a header that is an instance of this +** structure. +** +** PageHdr.firstFree is 0 if there is no free space on this page. +** Otherwise, PageHdr.firstFree is the index in MemPage.u.aDisk[] of a +** FreeBlk structure that describes the first block of free space. +** All free space is defined by a linked list of FreeBlk structures. +** +** Data is stored in a linked list of Cell structures. PageHdr.firstCell +** is the index into MemPage.u.aDisk[] of the first cell on the page. The +** Cells are kept in sorted order. +** +** A Cell contains all information about a database entry and a pointer +** to a child page that contains other entries less than itself. In +** other words, the i-th Cell contains both Ptr(i) and Key(i). The +** right-most pointer of the page is contained in PageHdr.rightChild. +*/ +struct PageHdr { + Pgno rightChild; /* Child page that comes after all cells on this page */ + u16 firstCell; /* Index in MemPage.u.aDisk[] of the first cell */ + u16 firstFree; /* Index in MemPage.u.aDisk[] of the first free block */ +}; + +/* +** Entries on a page of the database are called "Cells". Each Cell +** has a header and data. This structure defines the header. The +** key and data (collectively the "payload") follow this header on +** the database page. +** +** A definition of the complete Cell structure is given below. The +** header for the cell must be defined first in order to do some +** of the sizing #defines that follow. +*/ +struct CellHdr { + Pgno leftChild; /* Child page that comes before this cell */ + u16 nKey; /* Number of bytes in the key */ + u16 iNext; /* Index in MemPage.u.aDisk[] of next cell in sorted order */ + u8 nKeyHi; /* Upper 8 bits of key size for keys larger than 64K bytes */ + u8 nDataHi; /* Upper 8 bits of data size when the size is more than 64K */ + u16 nData; /* Number of bytes of data */ +}; + +/* +** The key and data size are split into a lower 16-bit segment and an +** upper 8-bit segment in order to pack them together into a smaller +** space. The following macros reassembly a key or data size back +** into an integer. +*/ +#define NKEY(b,h) (SWAB16(b,h.nKey) + h.nKeyHi*65536) +#define NDATA(b,h) (SWAB16(b,h.nData) + h.nDataHi*65536) + +/* +** The minimum size of a complete Cell. The Cell must contain a header +** and at least 4 bytes of payload. +*/ +#define MIN_CELL_SIZE (sizeof(CellHdr)+4) + +/* +** The maximum number of database entries that can be held in a single +** page of the database. +*/ +#define MX_CELL ((SQLITE_USABLE_SIZE-sizeof(PageHdr))/MIN_CELL_SIZE) + +/* +** The amount of usable space on a single page of the BTree. This is the +** page size minus the overhead of the page header. +*/ +#define USABLE_SPACE (SQLITE_USABLE_SIZE - sizeof(PageHdr)) + +/* +** The maximum amount of payload (in bytes) that can be stored locally for +** a database entry. If the entry contains more data than this, the +** extra goes onto overflow pages. +** +** This number is chosen so that at least 4 cells will fit on every page. +*/ +#define MX_LOCAL_PAYLOAD ((USABLE_SPACE/4-(sizeof(CellHdr)+sizeof(Pgno)))&~3) + +/* +** Data on a database page is stored as a linked list of Cell structures. +** Both the key and the data are stored in aPayload[]. The key always comes +** first. The aPayload[] field grows as necessary to hold the key and data, +** up to a maximum of MX_LOCAL_PAYLOAD bytes. If the size of the key and +** data combined exceeds MX_LOCAL_PAYLOAD bytes, then Cell.ovfl is the +** page number of the first overflow page. +** +** Though this structure is fixed in size, the Cell on the database +** page varies in size. Every cell has a CellHdr and at least 4 bytes +** of payload space. Additional payload bytes (up to the maximum of +** MX_LOCAL_PAYLOAD) and the Cell.ovfl value are allocated only as +** needed. +*/ +struct Cell { + CellHdr h; /* The cell header */ + char aPayload[MX_LOCAL_PAYLOAD]; /* Key and data */ + Pgno ovfl; /* The first overflow page */ +}; + +/* +** Free space on a page is remembered using a linked list of the FreeBlk +** structures. Space on a database page is allocated in increments of +** at least 4 bytes and is always aligned to a 4-byte boundry. The +** linked list of FreeBlks is always kept in order by address. +*/ +struct FreeBlk { + u16 iSize; /* Number of bytes in this block of free space */ + u16 iNext; /* Index in MemPage.u.aDisk[] of the next free block */ +}; + +/* +** The number of bytes of payload that will fit on a single overflow page. +*/ +#define OVERFLOW_SIZE (SQLITE_USABLE_SIZE-sizeof(Pgno)) + +/* +** When the key and data for a single entry in the BTree will not fit in +** the MX_LOCAL_PAYLOAD bytes of space available on the database page, +** then all extra bytes are written to a linked list of overflow pages. +** Each overflow page is an instance of the following structure. +** +** Unused pages in the database are also represented by instances of +** the OverflowPage structure. The PageOne.freeList field is the +** page number of the first page in a linked list of unused database +** pages. +*/ +struct OverflowPage { + Pgno iNext; + char aPayload[OVERFLOW_SIZE]; +}; + +/* +** The PageOne.freeList field points to a linked list of overflow pages +** hold information about free pages. The aPayload section of each +** overflow page contains an instance of the following structure. The +** aFree[] array holds the page number of nFree unused pages in the disk +** file. +*/ +struct FreelistInfo { + int nFree; + Pgno aFree[(OVERFLOW_SIZE-sizeof(int))/sizeof(Pgno)]; +}; + +/* +** For every page in the database file, an instance of the following structure +** is stored in memory. The u.aDisk[] array contains the raw bits read from +** the disk. The rest is auxiliary information held in memory only. The +** auxiliary info is only valid for regular database pages - it is not +** used for overflow pages and pages on the freelist. +** +** Of particular interest in the auxiliary info is the apCell[] entry. Each +** apCell[] entry is a pointer to a Cell structure in u.aDisk[]. The cells are +** put in this array so that they can be accessed in constant time, rather +** than in linear time which would be needed if we had to walk the linked +** list on every access. +** +** Note that apCell[] contains enough space to hold up to two more Cells +** than can possibly fit on one page. In the steady state, every apCell[] +** points to memory inside u.aDisk[]. But in the middle of an insert +** operation, some apCell[] entries may temporarily point to data space +** outside of u.aDisk[]. This is a transient situation that is quickly +** resolved. But while it is happening, it is possible for a database +** page to hold as many as two more cells than it might otherwise hold. +** The extra two entries in apCell[] are an allowance for this situation. +** +** The pParent field points back to the parent page. This allows us to +** walk up the BTree from any leaf to the root. Care must be taken to +** unref() the parent page pointer when this page is no longer referenced. +** The pageDestructor() routine handles that chore. +*/ +struct MemPage { + union u_page_data { + char aDisk[SQLITE_PAGE_SIZE]; /* Page data stored on disk */ + PageHdr hdr; /* Overlay page header */ + } u; + u8 isInit; /* True if auxiliary data is initialized */ + u8 idxShift; /* True if apCell[] indices have changed */ + u8 isOverfull; /* Some apCell[] points outside u.aDisk[] */ + MemPage *pParent; /* The parent of this page. NULL for root */ + int idxParent; /* Index in pParent->apCell[] of this node */ + int nFree; /* Number of free bytes in u.aDisk[] */ + int nCell; /* Number of entries on this page */ + Cell *apCell[MX_CELL+2]; /* All data entires in sorted order */ +}; + +/* +** The in-memory image of a disk page has the auxiliary information appended +** to the end. EXTRA_SIZE is the number of bytes of space needed to hold +** that extra information. +*/ +#define EXTRA_SIZE (sizeof(MemPage)-sizeof(union u_page_data)) + +/* +** Everything we need to know about an open database +*/ +struct Btree { + BtOps *pOps; /* Function table */ + Pager *pPager; /* The page cache */ + BtCursor *pCursor; /* A list of all open cursors */ + PageOne *page1; /* First page of the database */ + u8 inTrans; /* True if a transaction is in progress */ + u8 inCkpt; /* True if there is a checkpoint on the transaction */ + u8 readOnly; /* True if the underlying file is readonly */ + u8 needSwab; /* Need to byte-swapping */ +}; +typedef Btree Bt; + +/* +** A cursor is a pointer to a particular entry in the BTree. +** The entry is identified by its MemPage and the index in +** MemPage.apCell[] of the entry. +*/ +struct BtCursor { + BtCursorOps *pOps; /* Function table */ + Btree *pBt; /* The Btree to which this cursor belongs */ + BtCursor *pNext, *pPrev; /* Forms a linked list of all cursors */ + BtCursor *pShared; /* Loop of cursors with the same root page */ + Pgno pgnoRoot; /* The root page of this tree */ + MemPage *pPage; /* Page that contains the entry */ + int idx; /* Index of the entry in pPage->apCell[] */ + u8 wrFlag; /* True if writable */ + u8 eSkip; /* Determines if next step operation is a no-op */ + u8 iMatch; /* compare result from last sqliteBtreeMoveto() */ +}; + +/* +** Legal values for BtCursor.eSkip. +*/ +#define SKIP_NONE 0 /* Always step the cursor */ +#define SKIP_NEXT 1 /* The next sqliteBtreeNext() is a no-op */ +#define SKIP_PREV 2 /* The next sqliteBtreePrevious() is a no-op */ +#define SKIP_INVALID 3 /* Calls to Next() and Previous() are invalid */ + +/* Forward declarations */ +static int fileBtreeCloseCursor(BtCursor *pCur); + +/* +** Routines for byte swapping. +*/ +u16 swab16(u16 x){ + return ((x & 0xff)<<8) | ((x>>8)&0xff); +} +u32 swab32(u32 x){ + return ((x & 0xff)<<24) | ((x & 0xff00)<<8) | + ((x>>8) & 0xff00) | ((x>>24)&0xff); +} + +/* +** Compute the total number of bytes that a Cell needs on the main +** database page. The number returned includes the Cell header, +** local payload storage, and the pointer to overflow pages (if +** applicable). Additional space allocated on overflow pages +** is NOT included in the value returned from this routine. +*/ +static int cellSize(Btree *pBt, Cell *pCell){ + int n = NKEY(pBt, pCell->h) + NDATA(pBt, pCell->h); + if( n>MX_LOCAL_PAYLOAD ){ + n = MX_LOCAL_PAYLOAD + sizeof(Pgno); + }else{ + n = ROUNDUP(n); + } + n += sizeof(CellHdr); + return n; +} + +/* +** Defragment the page given. All Cells are moved to the +** beginning of the page and all free space is collected +** into one big FreeBlk at the end of the page. +*/ +static void defragmentPage(Btree *pBt, MemPage *pPage){ + int pc, i, n; + FreeBlk *pFBlk; + char newPage[SQLITE_USABLE_SIZE]; + + assert( sqlitepager_iswriteable(pPage) ); + assert( pPage->isInit ); + pc = sizeof(PageHdr); + pPage->u.hdr.firstCell = SWAB16(pBt, pc); + memcpy(newPage, pPage->u.aDisk, pc); + for(i=0; i<pPage->nCell; i++){ + Cell *pCell = pPage->apCell[i]; + + /* This routine should never be called on an overfull page. The + ** following asserts verify that constraint. */ + assert( Addr(pCell) > Addr(pPage) ); + assert( Addr(pCell) < Addr(pPage) + SQLITE_USABLE_SIZE ); + + n = cellSize(pBt, pCell); + pCell->h.iNext = SWAB16(pBt, pc + n); + memcpy(&newPage[pc], pCell, n); + pPage->apCell[i] = (Cell*)&pPage->u.aDisk[pc]; + pc += n; + } + assert( pPage->nFree==SQLITE_USABLE_SIZE-pc ); + memcpy(pPage->u.aDisk, newPage, pc); + if( pPage->nCell>0 ){ + pPage->apCell[pPage->nCell-1]->h.iNext = 0; + } + pFBlk = (FreeBlk*)&pPage->u.aDisk[pc]; + pFBlk->iSize = SWAB16(pBt, SQLITE_USABLE_SIZE - pc); + pFBlk->iNext = 0; + pPage->u.hdr.firstFree = SWAB16(pBt, pc); + memset(&pFBlk[1], 0, SQLITE_USABLE_SIZE - pc - sizeof(FreeBlk)); +} + +/* +** Allocate nByte bytes of space on a page. nByte must be a +** multiple of 4. +** +** Return the index into pPage->u.aDisk[] of the first byte of +** the new allocation. Or return 0 if there is not enough free +** space on the page to satisfy the allocation request. +** +** If the page contains nBytes of free space but does not contain +** nBytes of contiguous free space, then this routine automatically +** calls defragementPage() to consolidate all free space before +** allocating the new chunk. +*/ +static int allocateSpace(Btree *pBt, MemPage *pPage, int nByte){ + FreeBlk *p; + u16 *pIdx; + int start; + int iSize; +#ifndef NDEBUG + int cnt = 0; +#endif + + assert( sqlitepager_iswriteable(pPage) ); + assert( nByte==ROUNDUP(nByte) ); + assert( pPage->isInit ); + if( pPage->nFree<nByte || pPage->isOverfull ) return 0; + pIdx = &pPage->u.hdr.firstFree; + p = (FreeBlk*)&pPage->u.aDisk[SWAB16(pBt, *pIdx)]; + while( (iSize = SWAB16(pBt, p->iSize))<nByte ){ + assert( cnt++ < SQLITE_USABLE_SIZE/4 ); + if( p->iNext==0 ){ + defragmentPage(pBt, pPage); + pIdx = &pPage->u.hdr.firstFree; + }else{ + pIdx = &p->iNext; + } + p = (FreeBlk*)&pPage->u.aDisk[SWAB16(pBt, *pIdx)]; + } + if( iSize==nByte ){ + start = SWAB16(pBt, *pIdx); + *pIdx = p->iNext; + }else{ + FreeBlk *pNew; + start = SWAB16(pBt, *pIdx); + pNew = (FreeBlk*)&pPage->u.aDisk[start + nByte]; + pNew->iNext = p->iNext; + pNew->iSize = SWAB16(pBt, iSize - nByte); + *pIdx = SWAB16(pBt, start + nByte); + } + pPage->nFree -= nByte; + return start; +} + +/* +** Return a section of the MemPage.u.aDisk[] to the freelist. +** The first byte of the new free block is pPage->u.aDisk[start] +** and the size of the block is "size" bytes. Size must be +** a multiple of 4. +** +** Most of the effort here is involved in coalesing adjacent +** free blocks into a single big free block. +*/ +static void freeSpace(Btree *pBt, MemPage *pPage, int start, int size){ + int end = start + size; + u16 *pIdx, idx; + FreeBlk *pFBlk; + FreeBlk *pNew; + FreeBlk *pNext; + int iSize; + + assert( sqlitepager_iswriteable(pPage) ); + assert( size == ROUNDUP(size) ); + assert( start == ROUNDUP(start) ); + assert( pPage->isInit ); + pIdx = &pPage->u.hdr.firstFree; + idx = SWAB16(pBt, *pIdx); + while( idx!=0 && idx<start ){ + pFBlk = (FreeBlk*)&pPage->u.aDisk[idx]; + iSize = SWAB16(pBt, pFBlk->iSize); + if( idx + iSize == start ){ + pFBlk->iSize = SWAB16(pBt, iSize + size); + if( idx + iSize + size == SWAB16(pBt, pFBlk->iNext) ){ + pNext = (FreeBlk*)&pPage->u.aDisk[idx + iSize + size]; + if( pBt->needSwab ){ + pFBlk->iSize = swab16((u16)swab16(pNext->iSize)+iSize+size); + }else{ + pFBlk->iSize += pNext->iSize; + } + pFBlk->iNext = pNext->iNext; + } + pPage->nFree += size; + return; + } + pIdx = &pFBlk->iNext; + idx = SWAB16(pBt, *pIdx); + } + pNew = (FreeBlk*)&pPage->u.aDisk[start]; + if( idx != end ){ + pNew->iSize = SWAB16(pBt, size); + pNew->iNext = SWAB16(pBt, idx); + }else{ + pNext = (FreeBlk*)&pPage->u.aDisk[idx]; + pNew->iSize = SWAB16(pBt, size + SWAB16(pBt, pNext->iSize)); + pNew->iNext = pNext->iNext; + } + *pIdx = SWAB16(pBt, start); + pPage->nFree += size; +} + +/* +** Initialize the auxiliary information for a disk block. +** +** The pParent parameter must be a pointer to the MemPage which +** is the parent of the page being initialized. The root of the +** BTree (usually page 2) has no parent and so for that page, +** pParent==NULL. +** +** Return SQLITE_OK on success. If we see that the page does +** not contain a well-formed database page, then return +** SQLITE_CORRUPT. Note that a return of SQLITE_OK does not +** guarantee that the page is well-formed. It only shows that +** we failed to detect any corruption. +*/ +static int initPage(Bt *pBt, MemPage *pPage, Pgno pgnoThis, MemPage *pParent){ + int idx; /* An index into pPage->u.aDisk[] */ + Cell *pCell; /* A pointer to a Cell in pPage->u.aDisk[] */ + FreeBlk *pFBlk; /* A pointer to a free block in pPage->u.aDisk[] */ + int sz; /* The size of a Cell in bytes */ + int freeSpace; /* Amount of free space on the page */ + + if( pPage->pParent ){ + assert( pPage->pParent==pParent ); + return SQLITE_OK; + } + if( pParent ){ + pPage->pParent = pParent; + sqlitepager_ref(pParent); + } + if( pPage->isInit ) return SQLITE_OK; + pPage->isInit = 1; + pPage->nCell = 0; + freeSpace = USABLE_SPACE; + idx = SWAB16(pBt, pPage->u.hdr.firstCell); + while( idx!=0 ){ + if( idx>SQLITE_USABLE_SIZE-MIN_CELL_SIZE ) goto page_format_error; + if( idx<sizeof(PageHdr) ) goto page_format_error; + if( idx!=ROUNDUP(idx) ) goto page_format_error; + pCell = (Cell*)&pPage->u.aDisk[idx]; + sz = cellSize(pBt, pCell); + if( idx+sz > SQLITE_USABLE_SIZE ) goto page_format_error; + freeSpace -= sz; + pPage->apCell[pPage->nCell++] = pCell; + idx = SWAB16(pBt, pCell->h.iNext); + } + pPage->nFree = 0; + idx = SWAB16(pBt, pPage->u.hdr.firstFree); + while( idx!=0 ){ + int iNext; + if( idx>SQLITE_USABLE_SIZE-sizeof(FreeBlk) ) goto page_format_error; + if( idx<sizeof(PageHdr) ) goto page_format_error; + pFBlk = (FreeBlk*)&pPage->u.aDisk[idx]; + pPage->nFree += SWAB16(pBt, pFBlk->iSize); + iNext = SWAB16(pBt, pFBlk->iNext); + if( iNext>0 && iNext <= idx ) goto page_format_error; + idx = iNext; + } + if( pPage->nCell==0 && pPage->nFree==0 ){ + /* As a special case, an uninitialized root page appears to be + ** an empty database */ + return SQLITE_OK; + } + if( pPage->nFree!=freeSpace ) goto page_format_error; + return SQLITE_OK; + +page_format_error: + return SQLITE_CORRUPT; +} + +/* +** Set up a raw page so that it looks like a database page holding +** no entries. +*/ +static void zeroPage(Btree *pBt, MemPage *pPage){ + PageHdr *pHdr; + FreeBlk *pFBlk; + assert( sqlitepager_iswriteable(pPage) ); + memset(pPage, 0, SQLITE_USABLE_SIZE); + pHdr = &pPage->u.hdr; + pHdr->firstCell = 0; + pHdr->firstFree = SWAB16(pBt, sizeof(*pHdr)); + pFBlk = (FreeBlk*)&pHdr[1]; + pFBlk->iNext = 0; + pPage->nFree = SQLITE_USABLE_SIZE - sizeof(*pHdr); + pFBlk->iSize = SWAB16(pBt, pPage->nFree); + pPage->nCell = 0; + pPage->isOverfull = 0; +} + +/* +** This routine is called when the reference count for a page +** reaches zero. We need to unref the pParent pointer when that +** happens. +*/ +static void pageDestructor(void *pData){ + MemPage *pPage = (MemPage*)pData; + if( pPage->pParent ){ + MemPage *pParent = pPage->pParent; + pPage->pParent = 0; + sqlitepager_unref(pParent); + } +} + +/* +** Open a new database. +** +** Actually, this routine just sets up the internal data structures +** for accessing the database. We do not open the database file +** until the first page is loaded. +** +** zFilename is the name of the database file. If zFilename is NULL +** a new database with a random name is created. This randomly named +** database file will be deleted when sqliteBtreeClose() is called. +*/ +int sqliteBtreeOpen( + const char *zFilename, /* Name of the file containing the BTree database */ + int omitJournal, /* if TRUE then do not journal this file */ + int nCache, /* How many pages in the page cache */ + Btree **ppBtree /* Pointer to new Btree object written here */ +){ + Btree *pBt; + int rc; + + /* + ** The following asserts make sure that structures used by the btree are + ** the right size. This is to guard against size changes that result + ** when compiling on a different architecture. + */ + assert( sizeof(u32)==4 ); + assert( sizeof(u16)==2 ); + assert( sizeof(Pgno)==4 ); + assert( sizeof(PageHdr)==8 ); + assert( sizeof(CellHdr)==12 ); + assert( sizeof(FreeBlk)==4 ); + assert( sizeof(OverflowPage)==SQLITE_USABLE_SIZE ); + assert( sizeof(FreelistInfo)==OVERFLOW_SIZE ); + assert( sizeof(ptr)==sizeof(char*) ); + assert( sizeof(uptr)==sizeof(ptr) ); + + pBt = sqliteMalloc( sizeof(*pBt) ); + if( pBt==0 ){ + *ppBtree = 0; + return SQLITE_NOMEM; + } + if( nCache<10 ) nCache = 10; + rc = sqlitepager_open(&pBt->pPager, zFilename, nCache, EXTRA_SIZE, + !omitJournal); + if( rc!=SQLITE_OK ){ + if( pBt->pPager ) sqlitepager_close(pBt->pPager); + sqliteFree(pBt); + *ppBtree = 0; + return rc; + } + sqlitepager_set_destructor(pBt->pPager, pageDestructor); + pBt->pCursor = 0; + pBt->page1 = 0; + pBt->readOnly = sqlitepager_isreadonly(pBt->pPager); + pBt->pOps = &sqliteBtreeOps; + *ppBtree = pBt; + return SQLITE_OK; +} + +/* +** Close an open database and invalidate all cursors. +*/ +static int fileBtreeClose(Btree *pBt){ + while( pBt->pCursor ){ + fileBtreeCloseCursor(pBt->pCursor); + } + sqlitepager_close(pBt->pPager); + sqliteFree(pBt); + return SQLITE_OK; +} + +/* +** Change the limit on the number of pages allowed in the cache. +** +** The maximum number of cache pages is set to the absolute +** value of mxPage. If mxPage is negative, the pager will +** operate asynchronously - it will not stop to do fsync()s +** to insure data is written to the disk surface before +** continuing. Transactions still work if synchronous is off, +** and the database cannot be corrupted if this program +** crashes. But if the operating system crashes or there is +** an abrupt power failure when synchronous is off, the database +** could be left in an inconsistent and unrecoverable state. +** Synchronous is on by default so database corruption is not +** normally a worry. +*/ +static int fileBtreeSetCacheSize(Btree *pBt, int mxPage){ + sqlitepager_set_cachesize(pBt->pPager, mxPage); + return SQLITE_OK; +} + +/* +** Change the way data is synced to disk in order to increase or decrease +** how well the database resists damage due to OS crashes and power +** failures. Level 1 is the same as asynchronous (no syncs() occur and +** there is a high probability of damage) Level 2 is the default. There +** is a very low but non-zero probability of damage. Level 3 reduces the +** probability of damage to near zero but with a write performance reduction. +*/ +static int fileBtreeSetSafetyLevel(Btree *pBt, int level){ + sqlitepager_set_safety_level(pBt->pPager, level); + return SQLITE_OK; +} + +/* +** Get a reference to page1 of the database file. This will +** also acquire a readlock on that file. +** +** SQLITE_OK is returned on success. If the file is not a +** well-formed database file, then SQLITE_CORRUPT is returned. +** SQLITE_BUSY is returned if the database is locked. SQLITE_NOMEM +** is returned if we run out of memory. SQLITE_PROTOCOL is returned +** if there is a locking protocol violation. +*/ +static int lockBtree(Btree *pBt){ + int rc; + if( pBt->page1 ) return SQLITE_OK; + rc = sqlitepager_get(pBt->pPager, 1, (void**)&pBt->page1); + if( rc!=SQLITE_OK ) return rc; + + /* Do some checking to help insure the file we opened really is + ** a valid database file. + */ + if( sqlitepager_pagecount(pBt->pPager)>0 ){ + PageOne *pP1 = pBt->page1; + if( strcmp(pP1->zMagic,zMagicHeader)!=0 || + (pP1->iMagic!=MAGIC && swab32(pP1->iMagic)!=MAGIC) ){ + rc = SQLITE_NOTADB; + goto page1_init_failed; + } + pBt->needSwab = pP1->iMagic!=MAGIC; + } + return rc; + +page1_init_failed: + sqlitepager_unref(pBt->page1); + pBt->page1 = 0; + return rc; +} + +/* +** If there are no outstanding cursors and we are not in the middle +** of a transaction but there is a read lock on the database, then +** this routine unrefs the first page of the database file which +** has the effect of releasing the read lock. +** +** If there are any outstanding cursors, this routine is a no-op. +** +** If there is a transaction in progress, this routine is a no-op. +*/ +static void unlockBtreeIfUnused(Btree *pBt){ + if( pBt->inTrans==0 && pBt->pCursor==0 && pBt->page1!=0 ){ + sqlitepager_unref(pBt->page1); + pBt->page1 = 0; + pBt->inTrans = 0; + pBt->inCkpt = 0; + } +} + +/* +** Create a new database by initializing the first two pages of the +** file. +*/ +static int newDatabase(Btree *pBt){ + MemPage *pRoot; + PageOne *pP1; + int rc; + if( sqlitepager_pagecount(pBt->pPager)>1 ) return SQLITE_OK; + pP1 = pBt->page1; + rc = sqlitepager_write(pBt->page1); + if( rc ) return rc; + rc = sqlitepager_get(pBt->pPager, 2, (void**)&pRoot); + if( rc ) return rc; + rc = sqlitepager_write(pRoot); + if( rc ){ + sqlitepager_unref(pRoot); + return rc; + } + strcpy(pP1->zMagic, zMagicHeader); + if( btree_native_byte_order ){ + pP1->iMagic = MAGIC; + pBt->needSwab = 0; + }else{ + pP1->iMagic = swab32(MAGIC); + pBt->needSwab = 1; + } + zeroPage(pBt, pRoot); + sqlitepager_unref(pRoot); + return SQLITE_OK; +} + +/* +** Attempt to start a new transaction. +** +** A transaction must be started before attempting any changes +** to the database. None of the following routines will work +** unless a transaction is started first: +** +** sqliteBtreeCreateTable() +** sqliteBtreeCreateIndex() +** sqliteBtreeClearTable() +** sqliteBtreeDropTable() +** sqliteBtreeInsert() +** sqliteBtreeDelete() +** sqliteBtreeUpdateMeta() +*/ +static int fileBtreeBeginTrans(Btree *pBt){ + int rc; + if( pBt->inTrans ) return SQLITE_ERROR; + if( pBt->readOnly ) return SQLITE_READONLY; + if( pBt->page1==0 ){ + rc = lockBtree(pBt); + if( rc!=SQLITE_OK ){ + return rc; + } + } + rc = sqlitepager_begin(pBt->page1); + if( rc==SQLITE_OK ){ + rc = newDatabase(pBt); + } + if( rc==SQLITE_OK ){ + pBt->inTrans = 1; + pBt->inCkpt = 0; + }else{ + unlockBtreeIfUnused(pBt); + } + return rc; +} + +/* +** Commit the transaction currently in progress. +** +** This will release the write lock on the database file. If there +** are no active cursors, it also releases the read lock. +*/ +static int fileBtreeCommit(Btree *pBt){ + int rc; + rc = pBt->readOnly ? SQLITE_OK : sqlitepager_commit(pBt->pPager); + pBt->inTrans = 0; + pBt->inCkpt = 0; + unlockBtreeIfUnused(pBt); + return rc; +} + +/* +** Rollback the transaction in progress. All cursors will be +** invalided by this operation. Any attempt to use a cursor +** that was open at the beginning of this operation will result +** in an error. +** +** This will release the write lock on the database file. If there +** are no active cursors, it also releases the read lock. +*/ +static int fileBtreeRollback(Btree *pBt){ + int rc; + BtCursor *pCur; + if( pBt->inTrans==0 ) return SQLITE_OK; + pBt->inTrans = 0; + pBt->inCkpt = 0; + rc = pBt->readOnly ? SQLITE_OK : sqlitepager_rollback(pBt->pPager); + for(pCur=pBt->pCursor; pCur; pCur=pCur->pNext){ + if( pCur->pPage && pCur->pPage->isInit==0 ){ + sqlitepager_unref(pCur->pPage); + pCur->pPage = 0; + } + } + unlockBtreeIfUnused(pBt); + return rc; +} + +/* +** Set the checkpoint for the current transaction. The checkpoint serves +** as a sub-transaction that can be rolled back independently of the +** main transaction. You must start a transaction before starting a +** checkpoint. The checkpoint is ended automatically if the transaction +** commits or rolls back. +** +** Only one checkpoint may be active at a time. It is an error to try +** to start a new checkpoint if another checkpoint is already active. +*/ +static int fileBtreeBeginCkpt(Btree *pBt){ + int rc; + if( !pBt->inTrans || pBt->inCkpt ){ + return pBt->readOnly ? SQLITE_READONLY : SQLITE_ERROR; + } + rc = pBt->readOnly ? SQLITE_OK : sqlitepager_ckpt_begin(pBt->pPager); + pBt->inCkpt = 1; + return rc; +} + + +/* +** Commit a checkpoint to transaction currently in progress. If no +** checkpoint is active, this is a no-op. +*/ +static int fileBtreeCommitCkpt(Btree *pBt){ + int rc; + if( pBt->inCkpt && !pBt->readOnly ){ + rc = sqlitepager_ckpt_commit(pBt->pPager); + }else{ + rc = SQLITE_OK; + } + pBt->inCkpt = 0; + return rc; +} + +/* +** Rollback the checkpoint to the current transaction. If there +** is no active checkpoint or transaction, this routine is a no-op. +** +** All cursors will be invalided by this operation. Any attempt +** to use a cursor that was open at the beginning of this operation +** will result in an error. +*/ +static int fileBtreeRollbackCkpt(Btree *pBt){ + int rc; + BtCursor *pCur; + if( pBt->inCkpt==0 || pBt->readOnly ) return SQLITE_OK; + rc = sqlitepager_ckpt_rollback(pBt->pPager); + for(pCur=pBt->pCursor; pCur; pCur=pCur->pNext){ + if( pCur->pPage && pCur->pPage->isInit==0 ){ + sqlitepager_unref(pCur->pPage); + pCur->pPage = 0; + } + } + pBt->inCkpt = 0; + return rc; +} + +/* +** Create a new cursor for the BTree whose root is on the page +** iTable. The act of acquiring a cursor gets a read lock on +** the database file. +** +** If wrFlag==0, then the cursor can only be used for reading. +** If wrFlag==1, then the cursor can be used for reading or for +** writing if other conditions for writing are also met. These +** are the conditions that must be met in order for writing to +** be allowed: +** +** 1: The cursor must have been opened with wrFlag==1 +** +** 2: No other cursors may be open with wrFlag==0 on the same table +** +** 3: The database must be writable (not on read-only media) +** +** 4: There must be an active transaction. +** +** Condition 2 warrants further discussion. If any cursor is opened +** on a table with wrFlag==0, that prevents all other cursors from +** writing to that table. This is a kind of "read-lock". When a cursor +** is opened with wrFlag==0 it is guaranteed that the table will not +** change as long as the cursor is open. This allows the cursor to +** do a sequential scan of the table without having to worry about +** entries being inserted or deleted during the scan. Cursors should +** be opened with wrFlag==0 only if this read-lock property is needed. +** That is to say, cursors should be opened with wrFlag==0 only if they +** intend to use the sqliteBtreeNext() system call. All other cursors +** should be opened with wrFlag==1 even if they never really intend +** to write. +** +** No checking is done to make sure that page iTable really is the +** root page of a b-tree. If it is not, then the cursor acquired +** will not work correctly. +*/ +static +int fileBtreeCursor(Btree *pBt, int iTable, int wrFlag, BtCursor **ppCur){ + int rc; + BtCursor *pCur, *pRing; + + if( pBt->readOnly && wrFlag ){ + *ppCur = 0; + return SQLITE_READONLY; + } + if( pBt->page1==0 ){ + rc = lockBtree(pBt); + if( rc!=SQLITE_OK ){ + *ppCur = 0; + return rc; + } + } + pCur = sqliteMalloc( sizeof(*pCur) ); + if( pCur==0 ){ + rc = SQLITE_NOMEM; + goto create_cursor_exception; + } + pCur->pgnoRoot = (Pgno)iTable; + rc = sqlitepager_get(pBt->pPager, pCur->pgnoRoot, (void**)&pCur->pPage); + if( rc!=SQLITE_OK ){ + goto create_cursor_exception; + } + rc = initPage(pBt, pCur->pPage, pCur->pgnoRoot, 0); + if( rc!=SQLITE_OK ){ + goto create_cursor_exception; + } + pCur->pOps = &sqliteBtreeCursorOps; + pCur->pBt = pBt; + pCur->wrFlag = wrFlag; + pCur->idx = 0; + pCur->eSkip = SKIP_INVALID; + pCur->pNext = pBt->pCursor; + if( pCur->pNext ){ + pCur->pNext->pPrev = pCur; + } + pCur->pPrev = 0; + pRing = pBt->pCursor; + while( pRing && pRing->pgnoRoot!=pCur->pgnoRoot ){ pRing = pRing->pNext; } + if( pRing ){ + pCur->pShared = pRing->pShared; + pRing->pShared = pCur; + }else{ + pCur->pShared = pCur; + } + pBt->pCursor = pCur; + *ppCur = pCur; + return SQLITE_OK; + +create_cursor_exception: + *ppCur = 0; + if( pCur ){ + if( pCur->pPage ) sqlitepager_unref(pCur->pPage); + sqliteFree(pCur); + } + unlockBtreeIfUnused(pBt); + return rc; +} + +/* +** Close a cursor. The read lock on the database file is released +** when the last cursor is closed. +*/ +static int fileBtreeCloseCursor(BtCursor *pCur){ + Btree *pBt = pCur->pBt; + if( pCur->pPrev ){ + pCur->pPrev->pNext = pCur->pNext; + }else{ + pBt->pCursor = pCur->pNext; + } + if( pCur->pNext ){ + pCur->pNext->pPrev = pCur->pPrev; + } + if( pCur->pPage ){ + sqlitepager_unref(pCur->pPage); + } + if( pCur->pShared!=pCur ){ + BtCursor *pRing = pCur->pShared; + while( pRing->pShared!=pCur ){ pRing = pRing->pShared; } + pRing->pShared = pCur->pShared; + } + unlockBtreeIfUnused(pBt); + sqliteFree(pCur); + return SQLITE_OK; +} + +/* +** Make a temporary cursor by filling in the fields of pTempCur. +** The temporary cursor is not on the cursor list for the Btree. +*/ +static void getTempCursor(BtCursor *pCur, BtCursor *pTempCur){ + memcpy(pTempCur, pCur, sizeof(*pCur)); + pTempCur->pNext = 0; + pTempCur->pPrev = 0; + if( pTempCur->pPage ){ + sqlitepager_ref(pTempCur->pPage); + } +} + +/* +** Delete a temporary cursor such as was made by the CreateTemporaryCursor() +** function above. +*/ +static void releaseTempCursor(BtCursor *pCur){ + if( pCur->pPage ){ + sqlitepager_unref(pCur->pPage); + } +} + +/* +** Set *pSize to the number of bytes of key in the entry the +** cursor currently points to. Always return SQLITE_OK. +** Failure is not possible. If the cursor is not currently +** pointing to an entry (which can happen, for example, if +** the database is empty) then *pSize is set to 0. +*/ +static int fileBtreeKeySize(BtCursor *pCur, int *pSize){ + Cell *pCell; + MemPage *pPage; + + pPage = pCur->pPage; + assert( pPage!=0 ); + if( pCur->idx >= pPage->nCell ){ + *pSize = 0; + }else{ + pCell = pPage->apCell[pCur->idx]; + *pSize = NKEY(pCur->pBt, pCell->h); + } + return SQLITE_OK; +} + +/* +** Read payload information from the entry that the pCur cursor is +** pointing to. Begin reading the payload at "offset" and read +** a total of "amt" bytes. Put the result in zBuf. +** +** This routine does not make a distinction between key and data. +** It just reads bytes from the payload area. +*/ +static int getPayload(BtCursor *pCur, int offset, int amt, char *zBuf){ + char *aPayload; + Pgno nextPage; + int rc; + Btree *pBt = pCur->pBt; + assert( pCur!=0 && pCur->pPage!=0 ); + assert( pCur->idx>=0 && pCur->idx<pCur->pPage->nCell ); + aPayload = pCur->pPage->apCell[pCur->idx]->aPayload; + if( offset<MX_LOCAL_PAYLOAD ){ + int a = amt; + if( a+offset>MX_LOCAL_PAYLOAD ){ + a = MX_LOCAL_PAYLOAD - offset; + } + memcpy(zBuf, &aPayload[offset], a); + if( a==amt ){ + return SQLITE_OK; + } + offset = 0; + zBuf += a; + amt -= a; + }else{ + offset -= MX_LOCAL_PAYLOAD; + } + if( amt>0 ){ + nextPage = SWAB32(pBt, pCur->pPage->apCell[pCur->idx]->ovfl); + } + while( amt>0 && nextPage ){ + OverflowPage *pOvfl; + rc = sqlitepager_get(pBt->pPager, nextPage, (void**)&pOvfl); + if( rc!=0 ){ + return rc; + } + nextPage = SWAB32(pBt, pOvfl->iNext); + if( offset<OVERFLOW_SIZE ){ + int a = amt; + if( a + offset > OVERFLOW_SIZE ){ + a = OVERFLOW_SIZE - offset; + } + memcpy(zBuf, &pOvfl->aPayload[offset], a); + offset = 0; + amt -= a; + zBuf += a; + }else{ + offset -= OVERFLOW_SIZE; + } + sqlitepager_unref(pOvfl); + } + if( amt>0 ){ + return SQLITE_CORRUPT; + } + return SQLITE_OK; +} + +/* +** Read part of the key associated with cursor pCur. A maximum +** of "amt" bytes will be transfered into zBuf[]. The transfer +** begins at "offset". The number of bytes actually read is +** returned. +** +** Change: It used to be that the amount returned will be smaller +** than the amount requested if there are not enough bytes in the key +** to satisfy the request. But now, it must be the case that there +** is enough data available to satisfy the request. If not, an exception +** is raised. The change was made in an effort to boost performance +** by eliminating unneeded tests. +*/ +static int fileBtreeKey(BtCursor *pCur, int offset, int amt, char *zBuf){ + MemPage *pPage; + + assert( amt>=0 ); + assert( offset>=0 ); + assert( pCur->pPage!=0 ); + pPage = pCur->pPage; + if( pCur->idx >= pPage->nCell ){ + return 0; + } + assert( amt+offset <= NKEY(pCur->pBt, pPage->apCell[pCur->idx]->h) ); + getPayload(pCur, offset, amt, zBuf); + return amt; +} + +/* +** Set *pSize to the number of bytes of data in the entry the +** cursor currently points to. Always return SQLITE_OK. +** Failure is not possible. If the cursor is not currently +** pointing to an entry (which can happen, for example, if +** the database is empty) then *pSize is set to 0. +*/ +static int fileBtreeDataSize(BtCursor *pCur, int *pSize){ + Cell *pCell; + MemPage *pPage; + + pPage = pCur->pPage; + assert( pPage!=0 ); + if( pCur->idx >= pPage->nCell ){ + *pSize = 0; + }else{ + pCell = pPage->apCell[pCur->idx]; + *pSize = NDATA(pCur->pBt, pCell->h); + } + return SQLITE_OK; +} + +/* +** Read part of the data associated with cursor pCur. A maximum +** of "amt" bytes will be transfered into zBuf[]. The transfer +** begins at "offset". The number of bytes actually read is +** returned. The amount returned will be smaller than the +** amount requested if there are not enough bytes in the data +** to satisfy the request. +*/ +static int fileBtreeData(BtCursor *pCur, int offset, int amt, char *zBuf){ + Cell *pCell; + MemPage *pPage; + + assert( amt>=0 ); + assert( offset>=0 ); + assert( pCur->pPage!=0 ); + pPage = pCur->pPage; + if( pCur->idx >= pPage->nCell ){ + return 0; + } + pCell = pPage->apCell[pCur->idx]; + assert( amt+offset <= NDATA(pCur->pBt, pCell->h) ); + getPayload(pCur, offset + NKEY(pCur->pBt, pCell->h), amt, zBuf); + return amt; +} + +/* +** Compare an external key against the key on the entry that pCur points to. +** +** The external key is pKey and is nKey bytes long. The last nIgnore bytes +** of the key associated with pCur are ignored, as if they do not exist. +** (The normal case is for nIgnore to be zero in which case the entire +** internal key is used in the comparison.) +** +** The comparison result is written to *pRes as follows: +** +** *pRes<0 This means pCur<pKey +** +** *pRes==0 This means pCur==pKey for all nKey bytes +** +** *pRes>0 This means pCur>pKey +** +** When one key is an exact prefix of the other, the shorter key is +** considered less than the longer one. In order to be equal the +** keys must be exactly the same length. (The length of the pCur key +** is the actual key length minus nIgnore bytes.) +*/ +static int fileBtreeKeyCompare( + BtCursor *pCur, /* Pointer to entry to compare against */ + const void *pKey, /* Key to compare against entry that pCur points to */ + int nKey, /* Number of bytes in pKey */ + int nIgnore, /* Ignore this many bytes at the end of pCur */ + int *pResult /* Write the result here */ +){ + Pgno nextPage; + int n, c, rc, nLocal; + Cell *pCell; + Btree *pBt = pCur->pBt; + const char *zKey = (const char*)pKey; + + assert( pCur->pPage ); + assert( pCur->idx>=0 && pCur->idx<pCur->pPage->nCell ); + pCell = pCur->pPage->apCell[pCur->idx]; + nLocal = NKEY(pBt, pCell->h) - nIgnore; + if( nLocal<0 ) nLocal = 0; + n = nKey<nLocal ? nKey : nLocal; + if( n>MX_LOCAL_PAYLOAD ){ + n = MX_LOCAL_PAYLOAD; + } + c = memcmp(pCell->aPayload, zKey, n); + if( c!=0 ){ + *pResult = c; + return SQLITE_OK; + } + zKey += n; + nKey -= n; + nLocal -= n; + nextPage = SWAB32(pBt, pCell->ovfl); + while( nKey>0 && nLocal>0 ){ + OverflowPage *pOvfl; + if( nextPage==0 ){ + return SQLITE_CORRUPT; + } + rc = sqlitepager_get(pBt->pPager, nextPage, (void**)&pOvfl); + if( rc ){ + return rc; + } + nextPage = SWAB32(pBt, pOvfl->iNext); + n = nKey<nLocal ? nKey : nLocal; + if( n>OVERFLOW_SIZE ){ + n = OVERFLOW_SIZE; + } + c = memcmp(pOvfl->aPayload, zKey, n); + sqlitepager_unref(pOvfl); + if( c!=0 ){ + *pResult = c; + return SQLITE_OK; + } + nKey -= n; + nLocal -= n; + zKey += n; + } + if( c==0 ){ + c = nLocal - nKey; + } + *pResult = c; + return SQLITE_OK; +} + +/* +** Move the cursor down to a new child page. The newPgno argument is the +** page number of the child page in the byte order of the disk image. +*/ +static int moveToChild(BtCursor *pCur, int newPgno){ + int rc; + MemPage *pNewPage; + Btree *pBt = pCur->pBt; + + newPgno = SWAB32(pBt, newPgno); + rc = sqlitepager_get(pBt->pPager, newPgno, (void**)&pNewPage); + if( rc ) return rc; + rc = initPage(pBt, pNewPage, newPgno, pCur->pPage); + if( rc ) return rc; + assert( pCur->idx>=pCur->pPage->nCell + || pCur->pPage->apCell[pCur->idx]->h.leftChild==SWAB32(pBt,newPgno) ); + assert( pCur->idx<pCur->pPage->nCell + || pCur->pPage->u.hdr.rightChild==SWAB32(pBt,newPgno) ); + pNewPage->idxParent = pCur->idx; + pCur->pPage->idxShift = 0; + sqlitepager_unref(pCur->pPage); + pCur->pPage = pNewPage; + pCur->idx = 0; + if( pNewPage->nCell<1 ){ + return SQLITE_CORRUPT; + } + return SQLITE_OK; +} + +/* +** Move the cursor up to the parent page. +** +** pCur->idx is set to the cell index that contains the pointer +** to the page we are coming from. If we are coming from the +** right-most child page then pCur->idx is set to one more than +** the largest cell index. +*/ +static void moveToParent(BtCursor *pCur){ + Pgno oldPgno; + MemPage *pParent; + MemPage *pPage; + int idxParent; + pPage = pCur->pPage; + assert( pPage!=0 ); + pParent = pPage->pParent; + assert( pParent!=0 ); + idxParent = pPage->idxParent; + sqlitepager_ref(pParent); + sqlitepager_unref(pPage); + pCur->pPage = pParent; + assert( pParent->idxShift==0 ); + if( pParent->idxShift==0 ){ + pCur->idx = idxParent; +#ifndef NDEBUG + /* Verify that pCur->idx is the correct index to point back to the child + ** page we just came from + */ + oldPgno = SWAB32(pCur->pBt, sqlitepager_pagenumber(pPage)); + if( pCur->idx<pParent->nCell ){ + 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; i<pParent->nCell; i++){ + if( pParent->apCell[i]->h.leftChild==oldPgno ){ + pCur->idx = i; + break; + } + } + } +} + +/* +** Move the cursor to the root page +*/ +static int moveToRoot(BtCursor *pCur){ + MemPage *pNew; + int rc; + Btree *pBt = pCur->pBt; + + rc = sqlitepager_get(pBt->pPager, pCur->pgnoRoot, (void**)&pNew); + if( rc ) return rc; + rc = initPage(pBt, pNew, pCur->pgnoRoot, 0); + if( rc ) return rc; + sqlitepager_unref(pCur->pPage); + pCur->pPage = pNew; + pCur->idx = 0; + return SQLITE_OK; +} + +/* +** Move the cursor down to the left-most leaf entry beneath the +** entry to which it is currently pointing. +*/ +static int moveToLeftmost(BtCursor *pCur){ + Pgno pgno; + int rc; + + while( (pgno = pCur->pPage->apCell[pCur->idx]->h.leftChild)!=0 ){ + rc = moveToChild(pCur, pgno); + if( rc ) return rc; + } + return SQLITE_OK; +} + +/* +** Move the cursor down to the right-most leaf entry beneath the +** page to which it is currently pointing. Notice the difference +** between moveToLeftmost() and moveToRightmost(). moveToLeftmost() +** finds the left-most entry beneath the *entry* whereas moveToRightmost() +** finds the right-most entry beneath the *page*. +*/ +static int moveToRightmost(BtCursor *pCur){ + Pgno pgno; + int rc; + + while( (pgno = pCur->pPage->u.hdr.rightChild)!=0 ){ + pCur->idx = pCur->pPage->nCell; + rc = moveToChild(pCur, pgno); + if( rc ) return rc; + } + pCur->idx = pCur->pPage->nCell - 1; + return SQLITE_OK; +} + +/* Move the cursor to the first entry in the table. Return SQLITE_OK +** on success. Set *pRes to 0 if the cursor actually points to something +** or set *pRes to 1 if the table is empty. +*/ +static int fileBtreeFirst(BtCursor *pCur, int *pRes){ + int rc; + if( pCur->pPage==0 ) return SQLITE_ABORT; + rc = moveToRoot(pCur); + if( rc ) return rc; + if( pCur->pPage->nCell==0 ){ + *pRes = 1; + return SQLITE_OK; + } + *pRes = 0; + rc = moveToLeftmost(pCur); + pCur->eSkip = SKIP_NONE; + return rc; +} + +/* Move the cursor to the last entry in the table. Return SQLITE_OK +** on success. Set *pRes to 0 if the cursor actually points to something +** or set *pRes to 1 if the table is empty. +*/ +static int fileBtreeLast(BtCursor *pCur, int *pRes){ + int rc; + if( pCur->pPage==0 ) return SQLITE_ABORT; + rc = moveToRoot(pCur); + if( rc ) return rc; + assert( pCur->pPage->isInit ); + if( pCur->pPage->nCell==0 ){ + *pRes = 1; + return SQLITE_OK; + } + *pRes = 0; + rc = moveToRightmost(pCur); + pCur->eSkip = SKIP_NONE; + return rc; +} + +/* Move the cursor so that it points to an entry near pKey. +** Return a success code. +** +** If an exact match is not found, then the cursor is always +** left pointing at a leaf page which would hold the entry if it +** were present. The cursor might point to an entry that comes +** before or after the key. +** +** The result of comparing the key with the entry to which the +** cursor is left pointing is stored in pCur->iMatch. The same +** value is also written to *pRes if pRes!=NULL. The meaning of +** this value is as follows: +** +** *pRes<0 The cursor is left pointing at an entry that +** is smaller than pKey or if the table is empty +** and the cursor is therefore left point to nothing. +** +** *pRes==0 The cursor is left pointing at an entry that +** exactly matches pKey. +** +** *pRes>0 The cursor is left pointing at an entry that +** is larger than pKey. +*/ +static +int fileBtreeMoveto(BtCursor *pCur, const void *pKey, int nKey, int *pRes){ + int rc; + if( pCur->pPage==0 ) return SQLITE_ABORT; + pCur->eSkip = SKIP_NONE; + rc = moveToRoot(pCur); + if( rc ) return rc; + for(;;){ + int lwr, upr; + Pgno chldPg; + MemPage *pPage = pCur->pPage; + int c = -1; /* pRes return if table is empty must be -1 */ + lwr = 0; + upr = pPage->nCell-1; + while( lwr<=upr ){ + pCur->idx = (lwr+upr)/2; + rc = fileBtreeKeyCompare(pCur, pKey, nKey, 0, &c); + if( rc ) return rc; + if( c==0 ){ + pCur->iMatch = c; + if( pRes ) *pRes = 0; + return SQLITE_OK; + } + if( c<0 ){ + lwr = pCur->idx+1; + }else{ + upr = pCur->idx-1; + } + } + assert( lwr==upr+1 ); + assert( pPage->isInit ); + if( lwr>=pPage->nCell ){ + chldPg = pPage->u.hdr.rightChild; + }else{ + chldPg = pPage->apCell[lwr]->h.leftChild; + } + if( chldPg==0 ){ + pCur->iMatch = c; + if( pRes ) *pRes = c; + return SQLITE_OK; + } + pCur->idx = lwr; + rc = moveToChild(pCur, chldPg); + if( rc ) return rc; + } + /* NOT REACHED */ +} + +/* +** Advance the cursor to the next entry in the database. If +** successful then set *pRes=0. If the cursor +** was already pointing to the last entry in the database before +** this routine was called, then set *pRes=1. +*/ +static int fileBtreeNext(BtCursor *pCur, int *pRes){ + int rc; + MemPage *pPage = pCur->pPage; + assert( pRes!=0 ); + if( pPage==0 ){ + *pRes = 1; + return SQLITE_ABORT; + } + assert( pPage->isInit ); + assert( pCur->eSkip!=SKIP_INVALID ); + if( pPage->nCell==0 ){ + *pRes = 1; + return SQLITE_OK; + } + assert( pCur->idx<pPage->nCell ); + if( pCur->eSkip==SKIP_NEXT ){ + pCur->eSkip = SKIP_NONE; + *pRes = 0; + return SQLITE_OK; + } + pCur->eSkip = SKIP_NONE; + pCur->idx++; + if( pCur->idx>=pPage->nCell ){ + if( pPage->u.hdr.rightChild ){ + rc = moveToChild(pCur, pPage->u.hdr.rightChild); + if( rc ) return rc; + rc = moveToLeftmost(pCur); + *pRes = 0; + return rc; + } + do{ + if( pPage->pParent==0 ){ + *pRes = 1; + return SQLITE_OK; + } + moveToParent(pCur); + pPage = pCur->pPage; + }while( pCur->idx>=pPage->nCell ); + *pRes = 0; + return SQLITE_OK; + } + *pRes = 0; + if( pPage->u.hdr.rightChild==0 ){ + return SQLITE_OK; + } + rc = moveToLeftmost(pCur); + return rc; +} + +/* +** Step the cursor to the back to the previous entry in the database. If +** successful then set *pRes=0. If the cursor +** was already pointing to the first entry in the database before +** this routine was called, then set *pRes=1. +*/ +static int fileBtreePrevious(BtCursor *pCur, int *pRes){ + int rc; + Pgno pgno; + MemPage *pPage; + pPage = pCur->pPage; + if( pPage==0 ){ + *pRes = 1; + return SQLITE_ABORT; + } + assert( pPage->isInit ); + assert( pCur->eSkip!=SKIP_INVALID ); + if( pPage->nCell==0 ){ + *pRes = 1; + return SQLITE_OK; + } + if( pCur->eSkip==SKIP_PREV ){ + pCur->eSkip = SKIP_NONE; + *pRes = 0; + return SQLITE_OK; + } + pCur->eSkip = SKIP_NONE; + assert( pCur->idx>=0 ); + if( (pgno = pPage->apCell[pCur->idx]->h.leftChild)!=0 ){ + rc = moveToChild(pCur, pgno); + if( rc ) return rc; + rc = moveToRightmost(pCur); + }else{ + while( pCur->idx==0 ){ + if( pPage->pParent==0 ){ + if( pRes ) *pRes = 1; + return SQLITE_OK; + } + moveToParent(pCur); + pPage = pCur->pPage; + } + pCur->idx--; + rc = SQLITE_OK; + } + *pRes = 0; + return rc; +} + +/* +** Allocate a new page from the database file. +** +** The new page is marked as dirty. (In other words, sqlitepager_write() +** has already been called on the new page.) The new page has also +** been referenced and the calling routine is responsible for calling +** sqlitepager_unref() on the new page when it is done. +** +** SQLITE_OK is returned on success. Any other return value indicates +** an error. *ppPage and *pPgno are undefined in the event of an error. +** Do not invoke sqlitepager_unref() on *ppPage if an error is returned. +** +** If the "nearby" parameter is not 0, then a (feeble) effort is made to +** locate a page close to the page number "nearby". This can be used in an +** attempt to keep related pages close to each other in the database file, +** which in turn can make database access faster. +*/ +static int allocatePage(Btree *pBt, MemPage **ppPage, Pgno *pPgno, Pgno nearby){ + PageOne *pPage1 = pBt->page1; + int rc; + if( pPage1->freeList ){ + OverflowPage *pOvfl; + FreelistInfo *pInfo; + + rc = sqlitepager_write(pPage1); + if( rc ) return rc; + SWAB_ADD(pBt, pPage1->nFree, -1); + rc = sqlitepager_get(pBt->pPager, SWAB32(pBt, pPage1->freeList), + (void**)&pOvfl); + if( rc ) return rc; + rc = sqlitepager_write(pOvfl); + if( rc ){ + sqlitepager_unref(pOvfl); + return rc; + } + pInfo = (FreelistInfo*)pOvfl->aPayload; + if( pInfo->nFree==0 ){ + *pPgno = SWAB32(pBt, pPage1->freeList); + pPage1->freeList = pOvfl->iNext; + *ppPage = (MemPage*)pOvfl; + }else{ + int closest, n; + n = SWAB32(pBt, pInfo->nFree); + if( n>1 && nearby>0 ){ + int i, dist; + closest = 0; + dist = SWAB32(pBt, pInfo->aFree[0]) - nearby; + if( dist<0 ) dist = -dist; + for(i=1; i<n; i++){ + int d2 = SWAB32(pBt, pInfo->aFree[i]) - nearby; + if( d2<0 ) d2 = -d2; + if( d2<dist ) closest = i; + } + }else{ + closest = 0; + } + SWAB_ADD(pBt, pInfo->nFree, -1); + *pPgno = SWAB32(pBt, pInfo->aFree[closest]); + pInfo->aFree[closest] = pInfo->aFree[n-1]; + rc = sqlitepager_get(pBt->pPager, *pPgno, (void**)ppPage); + sqlitepager_unref(pOvfl); + if( rc==SQLITE_OK ){ + sqlitepager_dont_rollback(*ppPage); + rc = sqlitepager_write(*ppPage); + } + } + }else{ + *pPgno = sqlitepager_pagecount(pBt->pPager) + 1; + rc = sqlitepager_get(pBt->pPager, *pPgno, (void**)ppPage); + if( rc ) return rc; + rc = sqlitepager_write(*ppPage); + } + return rc; +} + +/* +** Add a page of the database file to the freelist. Either pgno or +** pPage but not both may be 0. +** +** sqlitepager_unref() is NOT called for pPage. +*/ +static int freePage(Btree *pBt, void *pPage, Pgno pgno){ + PageOne *pPage1 = pBt->page1; + OverflowPage *pOvfl = (OverflowPage*)pPage; + int rc; + int needUnref = 0; + MemPage *pMemPage; + + if( pgno==0 ){ + assert( pOvfl!=0 ); + pgno = sqlitepager_pagenumber(pOvfl); + } + assert( pgno>2 ); + assert( sqlitepager_pagenumber(pOvfl)==pgno ); + pMemPage = (MemPage*)pPage; + pMemPage->isInit = 0; + if( pMemPage->pParent ){ + sqlitepager_unref(pMemPage->pParent); + pMemPage->pParent = 0; + } + rc = sqlitepager_write(pPage1); + if( rc ){ + return rc; + } + SWAB_ADD(pBt, pPage1->nFree, 1); + if( pPage1->nFree!=0 && pPage1->freeList!=0 ){ + OverflowPage *pFreeIdx; + rc = sqlitepager_get(pBt->pPager, SWAB32(pBt, pPage1->freeList), + (void**)&pFreeIdx); + if( rc==SQLITE_OK ){ + FreelistInfo *pInfo = (FreelistInfo*)pFreeIdx->aPayload; + int n = SWAB32(pBt, pInfo->nFree); + if( n<(sizeof(pInfo->aFree)/sizeof(pInfo->aFree[0])) ){ + rc = sqlitepager_write(pFreeIdx); + if( rc==SQLITE_OK ){ + pInfo->aFree[n] = SWAB32(pBt, pgno); + SWAB_ADD(pBt, pInfo->nFree, 1); + sqlitepager_unref(pFreeIdx); + sqlitepager_dont_write(pBt->pPager, pgno); + return rc; + } + } + sqlitepager_unref(pFreeIdx); + } + } + if( pOvfl==0 ){ + assert( pgno>0 ); + rc = sqlitepager_get(pBt->pPager, pgno, (void**)&pOvfl); + if( rc ) return rc; + needUnref = 1; + } + rc = sqlitepager_write(pOvfl); + if( rc ){ + if( needUnref ) sqlitepager_unref(pOvfl); + return rc; + } + pOvfl->iNext = pPage1->freeList; + pPage1->freeList = SWAB32(pBt, pgno); + memset(pOvfl->aPayload, 0, OVERFLOW_SIZE); + if( needUnref ) rc = sqlitepager_unref(pOvfl); + return rc; +} + +/* +** Erase all the data out of a cell. This involves returning overflow +** pages back the freelist. +*/ +static int clearCell(Btree *pBt, Cell *pCell){ + Pager *pPager = pBt->pPager; + OverflowPage *pOvfl; + Pgno ovfl, nextOvfl; + int rc; + + if( NKEY(pBt, pCell->h) + NDATA(pBt, pCell->h) <= MX_LOCAL_PAYLOAD ){ + return SQLITE_OK; + } + ovfl = SWAB32(pBt, pCell->ovfl); + pCell->ovfl = 0; + while( ovfl ){ + rc = sqlitepager_get(pPager, ovfl, (void**)&pOvfl); + if( rc ) return rc; + nextOvfl = SWAB32(pBt, pOvfl->iNext); + rc = freePage(pBt, pOvfl, ovfl); + if( rc ) return rc; + sqlitepager_unref(pOvfl); + ovfl = nextOvfl; + } + return SQLITE_OK; +} + +/* +** Create a new cell from key and data. Overflow pages are allocated as +** necessary and linked to this cell. +*/ +static int fillInCell( + Btree *pBt, /* The whole Btree. Needed to allocate pages */ + Cell *pCell, /* Populate this Cell structure */ + const void *pKey, int nKey, /* The key */ + const void *pData,int nData /* The data */ +){ + OverflowPage *pOvfl, *pPrior; + Pgno *pNext; + int spaceLeft; + int n, rc; + int nPayload; + const char *pPayload; + char *pSpace; + Pgno nearby = 0; + + pCell->h.leftChild = 0; + pCell->h.nKey = SWAB16(pBt, nKey & 0xffff); + pCell->h.nKeyHi = nKey >> 16; + pCell->h.nData = SWAB16(pBt, nData & 0xffff); + pCell->h.nDataHi = nData >> 16; + pCell->h.iNext = 0; + + pNext = &pCell->ovfl; + pSpace = pCell->aPayload; + spaceLeft = MX_LOCAL_PAYLOAD; + pPayload = pKey; + pKey = 0; + nPayload = nKey; + pPrior = 0; + while( nPayload>0 ){ + if( spaceLeft==0 ){ + rc = allocatePage(pBt, (MemPage**)&pOvfl, pNext, nearby); + if( rc ){ + *pNext = 0; + }else{ + nearby = *pNext; + } + if( pPrior ) sqlitepager_unref(pPrior); + if( rc ){ + clearCell(pBt, pCell); + return rc; + } + if( pBt->needSwab ) *pNext = swab32(*pNext); + pPrior = pOvfl; + spaceLeft = OVERFLOW_SIZE; + pSpace = pOvfl->aPayload; + pNext = &pOvfl->iNext; + } + n = nPayload; + if( n>spaceLeft ) n = spaceLeft; + memcpy(pSpace, pPayload, n); + nPayload -= n; + if( nPayload==0 && pData ){ + pPayload = pData; + nPayload = nData; + pData = 0; + }else{ + pPayload += n; + } + spaceLeft -= n; + pSpace += n; + } + *pNext = 0; + if( pPrior ){ + sqlitepager_unref(pPrior); + } + return SQLITE_OK; +} + +/* +** Change the MemPage.pParent pointer on the page whose number is +** given in the second argument so that MemPage.pParent holds the +** pointer in the third argument. +*/ +static void reparentPage(Pager *pPager, Pgno pgno, MemPage *pNewParent,int idx){ + MemPage *pThis; + + if( pgno==0 ) return; + assert( pPager!=0 ); + pThis = sqlitepager_lookup(pPager, pgno); + if( pThis && pThis->isInit ){ + if( pThis->pParent!=pNewParent ){ + if( pThis->pParent ) sqlitepager_unref(pThis->pParent); + pThis->pParent = pNewParent; + if( pNewParent ) sqlitepager_ref(pNewParent); + } + pThis->idxParent = idx; + sqlitepager_unref(pThis); + } +} + +/* +** Reparent all children of the given page to be the given page. +** In other words, for every child of pPage, invoke reparentPage() +** to make sure that each child knows that pPage is its parent. +** +** This routine gets called after you memcpy() one page into +** another. +*/ +static void reparentChildPages(Btree *pBt, MemPage *pPage){ + int i; + Pager *pPager = pBt->pPager; + for(i=0; i<pPage->nCell; i++){ + reparentPage(pPager, SWAB32(pBt, pPage->apCell[i]->h.leftChild), pPage, i); + } + reparentPage(pPager, SWAB32(pBt, pPage->u.hdr.rightChild), pPage, i); + pPage->idxShift = 0; +} + +/* +** Remove the i-th cell from pPage. This routine effects pPage only. +** The cell content is not freed or deallocated. It is assumed that +** the cell content has been copied someplace else. This routine just +** removes the reference to the cell from pPage. +** +** "sz" must be the number of bytes in the cell. +** +** Do not bother maintaining the integrity of the linked list of Cells. +** Only the pPage->apCell[] array is important. The relinkCellList() +** routine will be called soon after this routine in order to rebuild +** the linked list. +*/ +static void dropCell(Btree *pBt, MemPage *pPage, int idx, int sz){ + int j; + assert( idx>=0 && idx<pPage->nCell ); + assert( sz==cellSize(pBt, pPage->apCell[idx]) ); + assert( sqlitepager_iswriteable(pPage) ); + freeSpace(pBt, pPage, Addr(pPage->apCell[idx]) - Addr(pPage), sz); + for(j=idx; j<pPage->nCell-1; j++){ + pPage->apCell[j] = pPage->apCell[j+1]; + } + pPage->nCell--; + pPage->idxShift = 1; +} + +/* +** Insert a new cell on pPage at cell index "i". pCell points to the +** content of the cell. +** +** If the cell content will fit on the page, then put it there. If it +** will not fit, then just make pPage->apCell[i] point to the content +** and set pPage->isOverfull. +** +** Do not bother maintaining the integrity of the linked list of Cells. +** Only the pPage->apCell[] array is important. The relinkCellList() +** routine will be called soon after this routine in order to rebuild +** the linked list. +*/ +static void insertCell(Btree *pBt, MemPage *pPage, int i, Cell *pCell, int sz){ + int idx, j; + assert( i>=0 && i<=pPage->nCell ); + assert( sz==cellSize(pBt, pCell) ); + assert( sqlitepager_iswriteable(pPage) ); + idx = allocateSpace(pBt, pPage, sz); + for(j=pPage->nCell; j>i; j--){ + pPage->apCell[j] = pPage->apCell[j-1]; + } + pPage->nCell++; + if( idx<=0 ){ + pPage->isOverfull = 1; + pPage->apCell[i] = pCell; + }else{ + memcpy(&pPage->u.aDisk[idx], pCell, sz); + pPage->apCell[i] = (Cell*)&pPage->u.aDisk[idx]; + } + pPage->idxShift = 1; +} + +/* +** Rebuild the linked list of cells on a page so that the cells +** occur in the order specified by the pPage->apCell[] array. +** Invoke this routine once to repair damage after one or more +** invocations of either insertCell() or dropCell(). +*/ +static void relinkCellList(Btree *pBt, MemPage *pPage){ + int i; + u16 *pIdx; + assert( sqlitepager_iswriteable(pPage) ); + pIdx = &pPage->u.hdr.firstCell; + for(i=0; i<pPage->nCell; i++){ + int idx = Addr(pPage->apCell[i]) - Addr(pPage); + assert( idx>0 && idx<SQLITE_USABLE_SIZE ); + *pIdx = SWAB16(pBt, idx); + pIdx = &pPage->apCell[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; i<pTo->nCell; i++){ + uptr x = Addr(pFrom->apCell[i]); + if( x>from && x<from+SQLITE_USABLE_SIZE ){ + *((uptr*)&pTo->apCell[i]) = x + to - from; + }else{ + pTo->apCell[i] = pFrom->apCell[i]; + } + } +} + +/* +** The following parameters determine how many adjacent pages get involved +** in a balancing operation. NN is the number of neighbors on either side +** of the page that participate in the balancing operation. NB is the +** total number of pages that participate, including the target page and +** NN neighbors on either side. +** +** The minimum value of NN is 1 (of course). Increasing NN above 1 +** (to 2 or 3) gives a modest improvement in SELECT and DELETE performance +** in exchange for a larger degradation in INSERT and UPDATE performance. +** The value of NN appears to give the best results overall. +*/ +#define NN 1 /* Number of neighbors on either side of pPage */ +#define NB (NN*2+1) /* Total pages involved in the balance */ + +/* +** This routine redistributes Cells on pPage and up to two siblings +** of pPage so that all pages have about the same amount of free space. +** Usually one sibling on either side of pPage is used in the balancing, +** though both siblings might come from one side if pPage is the first +** or last child of its parent. If pPage has fewer than two siblings +** (something which can only happen if pPage is the root page or a +** child of root) then all available siblings participate in the balancing. +** +** The number of siblings of pPage might be increased or decreased by +** one in an effort to keep pages between 66% and 100% full. The root page +** is special and is allowed to be less than 66% full. If pPage is +** the root page, then the depth of the tree might be increased +** or decreased by one, as necessary, to keep the root page from being +** overfull or empty. +** +** This routine calls relinkCellList() on its input page regardless of +** whether or not it does any real balancing. Client routines will typically +** invoke insertCell() or dropCell() before calling this routine, so we +** need to call relinkCellList() to clean up the mess that those other +** routines left behind. +** +** pCur is left pointing to the same cell as when this routine was called +** even if that cell gets moved to a different page. pCur may be NULL. +** Set the pCur parameter to NULL if you do not care about keeping track +** of a cell as that will save this routine the work of keeping track of it. +** +** Note that when this routine is called, some of the Cells on pPage +** might not actually be stored in pPage->u.aDisk[]. This can happen +** if the page is overfull. Part of the job of this routine is to +** make sure all Cells for pPage once again fit in pPage->u.aDisk[]. +** +** In the course of balancing the siblings of pPage, the parent of pPage +** might become overfull or underfull. If that happens, then this routine +** is called recursively on the parent. +** +** If this routine fails for any reason, it might leave the database +** in a corrupted state. So if this routine fails, the database should +** be rolled back. +*/ +static int balance(Btree *pBt, MemPage *pPage, BtCursor *pCur){ + MemPage *pParent; /* The parent of pPage */ + int nCell; /* Number of cells in apCell[] */ + int nOld; /* Number of pages in apOld[] */ + int nNew; /* Number of pages in apNew[] */ + int nDiv; /* Number of cells in apDiv[] */ + int i, j, k; /* Loop counters */ + int idx; /* Index of pPage in pParent->apCell[] */ + int nxDiv; /* Next divider slot in pParent->apCell[] */ + int rc; /* The return code */ + int iCur; /* apCell[iCur] is the cell of the cursor */ + MemPage *pOldCurPage; /* The cursor originally points to this page */ + int subtotal; /* Subtotal of bytes in cells on one page */ + MemPage *extraUnref = 0; /* A page that needs to be unref-ed */ + MemPage *apOld[NB]; /* pPage and up to two siblings */ + Pgno pgnoOld[NB]; /* Page numbers for each page in apOld[] */ + MemPage *apNew[NB+1]; /* pPage and up to NB siblings after balancing */ + Pgno pgnoNew[NB+1]; /* Page numbers for each page in apNew[] */ + int idxDiv[NB]; /* Indices of divider cells in pParent */ + Cell *apDiv[NB]; /* Divider cells in pParent */ + Cell aTemp[NB]; /* Temporary holding area for apDiv[] */ + int cntNew[NB+1]; /* Index in apCell[] of cell after i-th page */ + int szNew[NB+1]; /* Combined size of cells place on i-th page */ + MemPage aOld[NB]; /* Temporary copies of pPage and its siblings */ + Cell *apCell[(MX_CELL+2)*NB]; /* All cells from pages being balanced */ + int szCell[(MX_CELL+2)*NB]; /* Local size of all cells */ + + /* + ** Return without doing any work if pPage is neither overfull nor + ** underfull. + */ + assert( sqlitepager_iswriteable(pPage) ); + if( !pPage->isOverfull && pPage->nFree<SQLITE_USABLE_SIZE/2 + && pPage->nCell>=2){ + relinkCellList(pBt, pPage); + return SQLITE_OK; + } + + /* + ** Find the parent of the page to be balanceed. + ** If there is no parent, it means this page is the root page and + ** special rules apply. + */ + pParent = pPage->pParent; + if( pParent==0 ){ + Pgno pgnoChild; + MemPage *pChild; + assert( pPage->isInit ); + if( pPage->nCell==0 ){ + if( pPage->u.hdr.rightChild ){ + /* + ** The root page is empty. Copy the one child page + ** into the root page and return. This reduces the depth + ** of the BTree by one. + */ + pgnoChild = SWAB32(pBt, pPage->u.hdr.rightChild); + rc = sqlitepager_get(pBt->pPager, pgnoChild, (void**)&pChild); + if( rc ) return rc; + memcpy(pPage, pChild, SQLITE_USABLE_SIZE); + pPage->isInit = 0; + rc = initPage(pBt, pPage, sqlitepager_pagenumber(pPage), 0); + assert( rc==SQLITE_OK ); + reparentChildPages(pBt, pPage); + if( pCur && pCur->pPage==pChild ){ + sqlitepager_unref(pChild); + pCur->pPage = pPage; + sqlitepager_ref(pPage); + } + freePage(pBt, pChild, pgnoChild); + sqlitepager_unref(pChild); + }else{ + relinkCellList(pBt, pPage); + } + return SQLITE_OK; + } + if( !pPage->isOverfull ){ + /* It is OK for the root page to be less than half full. + */ + relinkCellList(pBt, pPage); + return SQLITE_OK; + } + /* + ** If we get to here, it means the root page is overfull. + ** When this happens, Create a new child page and copy the + ** contents of the root into the child. Then make the root + ** page an empty page with rightChild pointing to the new + ** child. Then fall thru to the code below which will cause + ** the overfull child page to be split. + */ + rc = sqlitepager_write(pPage); + if( rc ) return rc; + rc = allocatePage(pBt, &pChild, &pgnoChild, sqlitepager_pagenumber(pPage)); + if( rc ) return rc; + assert( sqlitepager_iswriteable(pChild) ); + copyPage(pChild, pPage); + pChild->pParent = pPage; + pChild->idxParent = 0; + sqlitepager_ref(pPage); + pChild->isOverfull = 1; + if( pCur && pCur->pPage==pPage ){ + sqlitepager_unref(pPage); + pCur->pPage = pChild; + }else{ + extraUnref = pChild; + } + zeroPage(pBt, pPage); + pPage->u.hdr.rightChild = SWAB32(pBt, pgnoChild); + pParent = pPage; + pPage = pChild; + } + rc = sqlitepager_write(pParent); + if( rc ) return rc; + assert( pParent->isInit ); + + /* + ** Find the Cell in the parent page whose h.leftChild points back + ** to pPage. The "idx" variable is the index of that cell. If pPage + ** is the rightmost child of pParent then set idx to pParent->nCell + */ + if( pParent->idxShift ){ + Pgno pgno, swabPgno; + pgno = sqlitepager_pagenumber(pPage); + swabPgno = SWAB32(pBt, pgno); + for(idx=0; idx<pParent->nCell; idx++){ + if( pParent->apCell[idx]->h.leftChild==swabPgno ){ + break; + } + } + assert( idx<pParent->nCell || pParent->u.hdr.rightChild==swabPgno ); + }else{ + idx = pPage->idxParent; + } + + /* + ** Initialize variables so that it will be safe to jump + ** directly to balance_cleanup at any moment. + */ + nOld = nNew = 0; + sqlitepager_ref(pParent); + + /* + ** Find sibling pages to pPage and the Cells in pParent that divide + ** the siblings. An attempt is made to find NN siblings on either + ** side of pPage. More siblings are taken from one side, however, if + ** pPage there are fewer than NN siblings on the other side. If pParent + ** has NB or fewer children then all children of pParent are taken. + */ + nxDiv = idx - NN; + if( nxDiv + NB > pParent->nCell ){ + nxDiv = pParent->nCell - NB + 1; + } + if( nxDiv<0 ){ + nxDiv = 0; + } + nDiv = 0; + for(i=0, k=nxDiv; i<NB; i++, k++){ + if( k<pParent->nCell ){ + idxDiv[i] = k; + apDiv[i] = pParent->apCell[k]; + nDiv++; + pgnoOld[i] = SWAB32(pBt, apDiv[i]->h.leftChild); + }else if( k==pParent->nCell ){ + pgnoOld[i] = SWAB32(pBt, pParent->u.hdr.rightChild); + }else{ + break; + } + rc = sqlitepager_get(pBt->pPager, pgnoOld[i], (void**)&apOld[i]); + if( rc ) goto balance_cleanup; + rc = initPage(pBt, apOld[i], pgnoOld[i], pParent); + if( rc ) goto balance_cleanup; + apOld[i]->idxParent = k; + nOld++; + } + + /* + ** Set iCur to be the index in apCell[] of the cell that the cursor + ** is pointing to. We will need this later on in order to keep the + ** cursor pointing at the same cell. If pCur points to a page that + ** has no involvement with this rebalancing, then set iCur to a large + ** number so that the iCur==j tests always fail in the main cell + ** distribution loop below. + */ + if( pCur ){ + iCur = 0; + for(i=0; i<nOld; i++){ + if( pCur->pPage==apOld[i] ){ + iCur += pCur->idx; + break; + } + iCur += apOld[i]->nCell; + if( i<nOld-1 && pCur->pPage==pParent && pCur->idx==idxDiv[i] ){ + break; + } + iCur++; + } + pOldCurPage = pCur->pPage; + } + + /* + ** Make copies of the content of pPage and its siblings into aOld[]. + ** The rest of this function will use data from the copies rather + ** that the original pages since the original pages will be in the + ** process of being overwritten. + */ + for(i=0; i<nOld; i++){ + copyPage(&aOld[i], apOld[i]); + } + + /* + ** 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. + */ + nCell = 0; + for(i=0; i<nOld; i++){ + MemPage *pOld = &aOld[i]; + for(j=0; j<pOld->nCell; j++){ + apCell[nCell] = pOld->apCell[j]; + szCell[nCell] = cellSize(pBt, apCell[nCell]); + nCell++; + } + if( i<nOld-1 ){ + szCell[nCell] = cellSize(pBt, apDiv[i]); + memcpy(&aTemp[i], apDiv[i], szCell[nCell]); + apCell[nCell] = &aTemp[i]; + dropCell(pBt, pParent, nxDiv, szCell[nCell]); + assert( SWAB32(pBt, apCell[nCell]->h.leftChild)==pgnoOld[i] ); + apCell[nCell]->h.leftChild = pOld->u.hdr.rightChild; + nCell++; + } + } + + /* + ** Figure out the number of pages needed to hold all nCell cells. + ** Store this number in "k". Also compute szNew[] which is the total + ** size of all cells on the i-th page and cntNew[] which is the index + ** in apCell[] of the cell that divides path i from path i+1. + ** cntNew[k] should equal nCell. + ** + ** This little patch of code is critical for keeping the tree + ** balanced. + */ + for(subtotal=k=i=0; i<nCell; i++){ + subtotal += szCell[i]; + if( subtotal > USABLE_SPACE ){ + szNew[k] = subtotal - szCell[i]; + cntNew[k] = i; + subtotal = 0; + k++; + } + } + szNew[k] = subtotal; + cntNew[k] = nCell; + k++; + for(i=k-1; i>0; i--){ + while( szNew[i]<USABLE_SPACE/2 ){ + cntNew[i-1]--; + assert( cntNew[i-1]>0 ); + szNew[i] += szCell[cntNew[i-1]]; + szNew[i-1] -= szCell[cntNew[i-1]-1]; + } + } + assert( cntNew[0]>0 ); + + /* + ** Allocate k new pages. Reuse old pages where possible. + */ + for(i=0; i<k; i++){ + if( i<nOld ){ + apNew[i] = apOld[i]; + pgnoNew[i] = pgnoOld[i]; + apOld[i] = 0; + sqlitepager_write(apNew[i]); + }else{ + rc = allocatePage(pBt, &apNew[i], &pgnoNew[i], pgnoNew[i-1]); + if( rc ) goto balance_cleanup; + } + nNew++; + zeroPage(pBt, apNew[i]); + apNew[i]->isInit = 1; + } + + /* Free any old pages that were not reused as new pages. + */ + while( i<nOld ){ + rc = freePage(pBt, apOld[i], pgnoOld[i]); + if( rc ) goto balance_cleanup; + sqlitepager_unref(apOld[i]); + apOld[i] = 0; + i++; + } + + /* + ** Put the new pages in accending order. This helps to + ** keep entries in the disk file in order so that a scan + ** of the table is a linear scan through the file. That + ** in turn helps the operating system to deliver pages + ** from the disk more rapidly. + ** + ** An O(n^2) insertion sort algorithm is used, but since + ** n is never more than NB (a small constant), that should + ** not be a problem. + ** + ** When NB==3, this one optimization makes the database + ** about 25% faster for large insertions and deletions. + */ + for(i=0; i<k-1; i++){ + int minV = pgnoNew[i]; + int minI = i; + for(j=i+1; j<k; j++){ + if( pgnoNew[j]<(unsigned)minV ){ + minI = j; + minV = pgnoNew[j]; + } + } + if( minI>i ){ + int t; + MemPage *pT; + t = pgnoNew[i]; + pT = apNew[i]; + pgnoNew[i] = pgnoNew[minI]; + apNew[i] = apNew[minI]; + pgnoNew[minI] = t; + apNew[minI] = pT; + } + } + + /* + ** Evenly distribute the data in apCell[] across the new pages. + ** Insert divider cells into pParent as necessary. + */ + j = 0; + for(i=0; i<nNew; i++){ + MemPage *pNew = apNew[i]; + while( j<cntNew[i] ){ + assert( pNew->nFree>=szCell[j] ); + if( pCur && iCur==j ){ pCur->pPage = pNew; pCur->idx = pNew->nCell; } + insertCell(pBt, pNew, pNew->nCell, apCell[j], szCell[j]); + j++; + } + assert( pNew->nCell>0 ); + assert( !pNew->isOverfull ); + relinkCellList(pBt, pNew); + if( i<nNew-1 && j<nCell ){ + pNew->u.hdr.rightChild = apCell[j]->h.leftChild; + apCell[j]->h.leftChild = SWAB32(pBt, pgnoNew[i]); + if( pCur && iCur==j ){ pCur->pPage = pParent; pCur->idx = nxDiv; } + insertCell(pBt, pParent, nxDiv, apCell[j], szCell[j]); + j++; + nxDiv++; + } + } + assert( j==nCell ); + apNew[nNew-1]->u.hdr.rightChild = aOld[nOld-1].u.hdr.rightChild; + if( nxDiv==pParent->nCell ){ + pParent->u.hdr.rightChild = SWAB32(pBt, pgnoNew[nNew-1]); + }else{ + pParent->apCell[nxDiv]->h.leftChild = SWAB32(pBt, pgnoNew[nNew-1]); + } + if( pCur ){ + if( j<=iCur && pCur->pPage==pParent && pCur->idx>idxDiv[nOld-1] ){ + assert( pCur->pPage==pOldCurPage ); + pCur->idx += nNew - nOld; + }else{ + assert( pOldCurPage!=0 ); + sqlitepager_ref(pCur->pPage); + sqlitepager_unref(pOldCurPage); + } + } + + /* + ** Reparent children of all cells. + */ + for(i=0; i<nNew; i++){ + reparentChildPages(pBt, apNew[i]); + } + reparentChildPages(pBt, pParent); + + /* + ** balance the parent page. + */ + rc = balance(pBt, pParent, pCur); + + /* + ** Cleanup before returning. + */ +balance_cleanup: + if( extraUnref ){ + sqlitepager_unref(extraUnref); + } + for(i=0; i<nOld; i++){ + if( apOld[i]!=0 && apOld[i]!=&aOld[i] ) sqlitepager_unref(apOld[i]); + } + for(i=0; i<nNew; i++){ + sqlitepager_unref(apNew[i]); + } + if( pCur && pCur->pPage==0 ){ + pCur->pPage = pParent; + pCur->idx = 0; + }else{ + sqlitepager_unref(pParent); + } + return rc; +} + +/* +** This routine checks all cursors that point to the same table +** as pCur points to. If any of those cursors were opened with +** wrFlag==0 then this routine returns SQLITE_LOCKED. If all +** cursors point to the same table were opened with wrFlag==1 +** then this routine returns SQLITE_OK. +** +** In addition to checking for read-locks (where a read-lock +** means a cursor opened with wrFlag==0) this routine also moves +** all cursors other than pCur so that they are pointing to the +** first Cell on root page. This is necessary because an insert +** or delete might change the number of cells on a page or delete +** a page entirely and we do not want to leave any cursors +** pointing to non-existant pages or cells. +*/ +static int checkReadLocks(BtCursor *pCur){ + BtCursor *p; + assert( pCur->wrFlag ); + for(p=pCur->pShared; p!=pCur; p=p->pShared){ + assert( p ); + assert( p->pgnoRoot==pCur->pgnoRoot ); + if( p->wrFlag==0 ) return SQLITE_LOCKED; + if( sqlitepager_pagenumber(p->pPage)!=p->pgnoRoot ){ + moveToRoot(p); + } + } + return SQLITE_OK; +} + +/* +** Insert a new record into the BTree. The key is given by (pKey,nKey) +** and the data is given by (pData,nData). The cursor is used only to +** define what database the record should be inserted into. The cursor +** is left pointing at the new record. +*/ +static int fileBtreeInsert( + BtCursor *pCur, /* Insert data into the table of this cursor */ + const void *pKey, int nKey, /* The key of the new record */ + const void *pData, int nData /* The data of the new record */ +){ + Cell newCell; + int rc; + int loc; + int szNew; + MemPage *pPage; + Btree *pBt = pCur->pBt; + + if( pCur->pPage==0 ){ + return SQLITE_ABORT; /* A rollback destroyed this cursor */ + } + if( !pBt->inTrans || nKey+nData==0 ){ + /* Must start a transaction before doing an insert */ + return pBt->readOnly ? SQLITE_READONLY : SQLITE_ERROR; + } + assert( !pBt->readOnly ); + if( !pCur->wrFlag ){ + return SQLITE_PERM; /* Cursor not open for writing */ + } + if( checkReadLocks(pCur) ){ + return SQLITE_LOCKED; /* The table pCur points to has a read lock */ + } + rc = fileBtreeMoveto(pCur, pKey, nKey, &loc); + if( rc ) return rc; + pPage = pCur->pPage; + assert( pPage->isInit ); + rc = sqlitepager_write(pPage); + if( rc ) return rc; + rc = fillInCell(pBt, &newCell, pKey, nKey, pData, nData); + if( rc ) return rc; + szNew = cellSize(pBt, &newCell); + if( loc==0 ){ + newCell.h.leftChild = pPage->apCell[pCur->idx]->h.leftChild; + rc = clearCell(pBt, pPage->apCell[pCur->idx]); + if( rc ) return rc; + dropCell(pBt, pPage, pCur->idx, cellSize(pBt, pPage->apCell[pCur->idx])); + }else if( loc<0 && pPage->nCell>0 ){ + assert( pPage->u.hdr.rightChild==0 ); /* Must be a leaf page */ + pCur->idx++; + }else{ + assert( pPage->u.hdr.rightChild==0 ); /* Must be a leaf page */ + } + insertCell(pBt, pPage, pCur->idx, &newCell, szNew); + rc = balance(pCur->pBt, pPage, pCur); + /* sqliteBtreePageDump(pCur->pBt, pCur->pgnoRoot, 1); */ + /* fflush(stdout); */ + pCur->eSkip = SKIP_INVALID; + return rc; +} + +/* +** Delete the entry that the cursor is pointing to. +** +** The cursor is left pointing at either the next or the previous +** entry. If the cursor is left pointing to the next entry, then +** the pCur->eSkip flag is set to SKIP_NEXT which forces the next call to +** sqliteBtreeNext() to be a no-op. That way, you can always call +** sqliteBtreeNext() after a delete and the cursor will be left +** pointing to the first entry after the deleted entry. Similarly, +** pCur->eSkip is set to SKIP_PREV is the cursor is left pointing to +** the entry prior to the deleted entry so that a subsequent call to +** sqliteBtreePrevious() will always leave the cursor pointing at the +** entry immediately before the one that was deleted. +*/ +static int fileBtreeDelete(BtCursor *pCur){ + MemPage *pPage = pCur->pPage; + Cell *pCell; + int rc; + Pgno pgnoChild; + Btree *pBt = pCur->pBt; + + assert( pPage->isInit ); + if( pCur->pPage==0 ){ + return SQLITE_ABORT; /* A rollback destroyed this cursor */ + } + if( !pBt->inTrans ){ + /* Must start a transaction before doing a delete */ + return pBt->readOnly ? SQLITE_READONLY : SQLITE_ERROR; + } + assert( !pBt->readOnly ); + if( pCur->idx >= pPage->nCell ){ + return SQLITE_ERROR; /* The cursor is not pointing to anything */ + } + if( !pCur->wrFlag ){ + return SQLITE_PERM; /* Did not open this cursor for writing */ + } + if( checkReadLocks(pCur) ){ + return SQLITE_LOCKED; /* The table pCur points to has a read lock */ + } + rc = sqlitepager_write(pPage); + if( rc ) return rc; + pCell = pPage->apCell[pCur->idx]; + pgnoChild = SWAB32(pBt, pCell->h.leftChild); + clearCell(pBt, pCell); + if( pgnoChild ){ + /* + ** The entry we are about to delete is not a leaf so if we do not + ** do something we will leave a hole on an internal page. + ** We have to fill the hole by moving in a cell from a leaf. The + ** next Cell after the one to be deleted is guaranteed to exist and + ** to be a leaf so we can use it. + */ + BtCursor leafCur; + Cell *pNext; + int szNext; + int notUsed; + getTempCursor(pCur, &leafCur); + rc = fileBtreeNext(&leafCur, ¬Used); + if( rc!=SQLITE_OK ){ + if( rc!=SQLITE_NOMEM ) rc = SQLITE_CORRUPT; + return rc; + } + rc = sqlitepager_write(leafCur.pPage); + if( rc ) return rc; + dropCell(pBt, pPage, pCur->idx, cellSize(pBt, pCell)); + pNext = leafCur.pPage->apCell[leafCur.idx]; + szNext = cellSize(pBt, pNext); + pNext->h.leftChild = SWAB32(pBt, pgnoChild); + insertCell(pBt, pPage, pCur->idx, pNext, szNext); + rc = balance(pBt, pPage, pCur); + if( rc ) return rc; + pCur->eSkip = SKIP_NEXT; + dropCell(pBt, leafCur.pPage, leafCur.idx, szNext); + rc = balance(pBt, leafCur.pPage, pCur); + releaseTempCursor(&leafCur); + }else{ + dropCell(pBt, pPage, pCur->idx, cellSize(pBt, pCell)); + if( pCur->idx>=pPage->nCell ){ + pCur->idx = pPage->nCell-1; + if( pCur->idx<0 ){ + pCur->idx = 0; + pCur->eSkip = SKIP_NEXT; + }else{ + pCur->eSkip = SKIP_PREV; + } + }else{ + pCur->eSkip = SKIP_NEXT; + } + rc = balance(pBt, pPage, pCur); + } + return rc; +} + +/* +** Create a new BTree table. Write into *piTable the page +** number for the root page of the new table. +** +** In the current implementation, BTree tables and BTree indices are the +** the same. In the future, we may change this so that BTree tables +** are restricted to having a 4-byte integer key and arbitrary data and +** BTree indices are restricted to having an arbitrary key and no data. +** But for now, this routine also serves to create indices. +*/ +static int fileBtreeCreateTable(Btree *pBt, int *piTable){ + MemPage *pRoot; + Pgno pgnoRoot; + int rc; + if( !pBt->inTrans ){ + /* Must start a transaction first */ + return pBt->readOnly ? SQLITE_READONLY : SQLITE_ERROR; + } + if( pBt->readOnly ){ + return SQLITE_READONLY; + } + rc = allocatePage(pBt, &pRoot, &pgnoRoot, 0); + if( rc ) return rc; + assert( sqlitepager_iswriteable(pRoot) ); + zeroPage(pBt, pRoot); + sqlitepager_unref(pRoot); + *piTable = (int)pgnoRoot; + return SQLITE_OK; +} + +/* +** Erase the given database page and all its children. Return +** the page to the freelist. +*/ +static int clearDatabasePage(Btree *pBt, Pgno pgno, int freePageFlag){ + MemPage *pPage; + int rc; + Cell *pCell; + int idx; + + rc = sqlitepager_get(pBt->pPager, pgno, (void**)&pPage); + if( rc ) return rc; + rc = sqlitepager_write(pPage); + if( rc ) return rc; + rc = initPage(pBt, pPage, pgno, 0); + if( rc ) return rc; + idx = SWAB16(pBt, pPage->u.hdr.firstCell); + while( idx>0 ){ + pCell = (Cell*)&pPage->u.aDisk[idx]; + idx = SWAB16(pBt, pCell->h.iNext); + if( pCell->h.leftChild ){ + rc = clearDatabasePage(pBt, SWAB32(pBt, pCell->h.leftChild), 1); + if( rc ) return rc; + } + rc = clearCell(pBt, pCell); + if( rc ) return rc; + } + if( pPage->u.hdr.rightChild ){ + rc = clearDatabasePage(pBt, SWAB32(pBt, pPage->u.hdr.rightChild), 1); + if( rc ) return rc; + } + if( freePageFlag ){ + rc = freePage(pBt, pPage, pgno); + }else{ + zeroPage(pBt, pPage); + } + sqlitepager_unref(pPage); + return rc; +} + +/* +** Delete all information from a single table in the database. +*/ +static int fileBtreeClearTable(Btree *pBt, int iTable){ + int rc; + BtCursor *pCur; + if( !pBt->inTrans ){ + return pBt->readOnly ? SQLITE_READONLY : SQLITE_ERROR; + } + for(pCur=pBt->pCursor; pCur; pCur=pCur->pNext){ + if( pCur->pgnoRoot==(Pgno)iTable ){ + if( pCur->wrFlag==0 ) return SQLITE_LOCKED; + moveToRoot(pCur); + } + } + rc = clearDatabasePage(pBt, (Pgno)iTable, 0); + if( rc ){ + fileBtreeRollback(pBt); + } + return rc; +} + +/* +** Erase all information in a table and add the root of the table to +** the freelist. Except, the root of the principle table (the one on +** page 2) is never added to the freelist. +*/ +static int fileBtreeDropTable(Btree *pBt, int iTable){ + int rc; + MemPage *pPage; + BtCursor *pCur; + if( !pBt->inTrans ){ + return pBt->readOnly ? SQLITE_READONLY : SQLITE_ERROR; + } + for(pCur=pBt->pCursor; pCur; pCur=pCur->pNext){ + if( pCur->pgnoRoot==(Pgno)iTable ){ + return SQLITE_LOCKED; /* Cannot drop a table that has a cursor */ + } + } + rc = sqlitepager_get(pBt->pPager, (Pgno)iTable, (void**)&pPage); + if( rc ) return rc; + rc = fileBtreeClearTable(pBt, iTable); + if( rc ) return rc; + if( iTable>2 ){ + rc = freePage(pBt, pPage, iTable); + }else{ + zeroPage(pBt, pPage); + } + sqlitepager_unref(pPage); + return rc; +} + +#if 0 /* UNTESTED */ +/* +** Copy all cell data from one database file into another. +** pages back the freelist. +*/ +static int copyCell(Btree *pBtFrom, BTree *pBtTo, Cell *pCell){ + Pager *pFromPager = pBtFrom->pPager; + OverflowPage *pOvfl; + Pgno ovfl, nextOvfl; + Pgno *pPrev; + int rc = SQLITE_OK; + MemPage *pNew, *pPrevPg; + Pgno new; + + if( NKEY(pBtTo, pCell->h) + NDATA(pBtTo, pCell->h) <= MX_LOCAL_PAYLOAD ){ + return SQLITE_OK; + } + pPrev = &pCell->ovfl; + pPrevPg = 0; + ovfl = SWAB32(pBtTo, pCell->ovfl); + while( ovfl && rc==SQLITE_OK ){ + rc = sqlitepager_get(pFromPager, ovfl, (void**)&pOvfl); + if( rc ) return rc; + nextOvfl = SWAB32(pBtFrom, pOvfl->iNext); + rc = allocatePage(pBtTo, &pNew, &new, 0); + if( rc==SQLITE_OK ){ + rc = sqlitepager_write(pNew); + if( rc==SQLITE_OK ){ + memcpy(pNew, pOvfl, SQLITE_USABLE_SIZE); + *pPrev = SWAB32(pBtTo, new); + if( pPrevPg ){ + sqlitepager_unref(pPrevPg); + } + pPrev = &pOvfl->iNext; + pPrevPg = pNew; + } + } + sqlitepager_unref(pOvfl); + ovfl = nextOvfl; + } + if( pPrevPg ){ + sqlitepager_unref(pPrevPg); + } + return rc; +} +#endif + + +#if 0 /* UNTESTED */ +/* +** Copy a page of data from one database over to another. +*/ +static int copyDatabasePage( + Btree *pBtFrom, + Pgno pgnoFrom, + Btree *pBtTo, + Pgno *pTo +){ + MemPage *pPageFrom, *pPage; + Pgno to; + int rc; + Cell *pCell; + int idx; + + rc = sqlitepager_get(pBtFrom->pPager, pgno, (void**)&pPageFrom); + if( rc ) return rc; + rc = allocatePage(pBt, &pPage, pTo, 0); + if( rc==SQLITE_OK ){ + rc = sqlitepager_write(pPage); + } + if( rc==SQLITE_OK ){ + memcpy(pPage, pPageFrom, SQLITE_USABLE_SIZE); + idx = SWAB16(pBt, pPage->u.hdr.firstCell); + while( idx>0 ){ + pCell = (Cell*)&pPage->u.aDisk[idx]; + idx = SWAB16(pBt, pCell->h.iNext); + if( pCell->h.leftChild ){ + Pgno newChld; + rc = copyDatabasePage(pBtFrom, SWAB32(pBtFrom, pCell->h.leftChild), + pBtTo, &newChld); + if( rc ) return rc; + pCell->h.leftChild = SWAB32(pBtFrom, newChld); + } + rc = copyCell(pBtFrom, pBtTo, pCell); + if( rc ) return rc; + } + if( pPage->u.hdr.rightChild ){ + Pgno newChld; + rc = copyDatabasePage(pBtFrom, SWAB32(pBtFrom, pPage->u.hdr.rightChild), + pBtTo, &newChld); + if( rc ) return rc; + pPage->u.hdr.rightChild = SWAB32(pBtTo, newChild); + } + } + sqlitepager_unref(pPage); + return rc; +} +#endif + +/* +** Read the meta-information out of a database file. +*/ +static int fileBtreeGetMeta(Btree *pBt, int *aMeta){ + PageOne *pP1; + int rc; + int i; + + rc = sqlitepager_get(pBt->pPager, 1, (void**)&pP1); + if( rc ) return rc; + aMeta[0] = SWAB32(pBt, pP1->nFree); + for(i=0; i<sizeof(pP1->aMeta)/sizeof(pP1->aMeta[0]); i++){ + aMeta[i+1] = SWAB32(pBt, pP1->aMeta[i]); + } + sqlitepager_unref(pP1); + return SQLITE_OK; +} + +/* +** Write meta-information back into the database. +*/ +static int fileBtreeUpdateMeta(Btree *pBt, int *aMeta){ + PageOne *pP1; + int rc, i; + if( !pBt->inTrans ){ + return pBt->readOnly ? SQLITE_READONLY : SQLITE_ERROR; + } + pP1 = pBt->page1; + rc = sqlitepager_write(pP1); + if( rc ) return rc; + for(i=0; i<sizeof(pP1->aMeta)/sizeof(pP1->aMeta[0]); i++){ + pP1->aMeta[i] = SWAB32(pBt, aMeta[i+1]); + } + return SQLITE_OK; +} + +/****************************************************************************** +** The complete implementation of the BTree subsystem is above this line. +** All the code the follows is for testing and troubleshooting the BTree +** subsystem. None of the code that follows is used during normal operation. +******************************************************************************/ + +/* +** Print a disassembly of the given page on standard output. This routine +** is used for debugging and testing only. +*/ +#ifdef SQLITE_TEST +static int fileBtreePageDump(Btree *pBt, int pgno, int recursive){ + int rc; + MemPage *pPage; + int i, j; + int nFree; + u16 idx; + char range[20]; + unsigned char payload[20]; + rc = sqlitepager_get(pBt->pPager, (Pgno)pgno, (void**)&pPage); + if( rc ){ + return rc; + } + if( recursive ) printf("PAGE %d:\n", pgno); + i = 0; + idx = SWAB16(pBt, pPage->u.hdr.firstCell); + while( idx>0 && idx<=SQLITE_USABLE_SIZE-MIN_CELL_SIZE ){ + Cell *pCell = (Cell*)&pPage->u.aDisk[idx]; + int sz = cellSize(pBt, pCell); + sprintf(range,"%d..%d", idx, idx+sz-1); + sz = NKEY(pBt, pCell->h) + NDATA(pBt, pCell->h); + if( sz>sizeof(payload)-1 ) sz = sizeof(payload)-1; + memcpy(payload, pCell->aPayload, sz); + for(j=0; j<sz; j++){ + if( payload[j]<0x20 || payload[j]>0x7f ) payload[j] = '.'; + } + payload[sz] = 0; + printf( + "cell %2d: i=%-10s chld=%-4d nk=%-4d nd=%-4d payload=%s\n", + i, range, (int)pCell->h.leftChild, + NKEY(pBt, pCell->h), NDATA(pBt, pCell->h), + payload + ); + if( pPage->isInit && pPage->apCell[i]!=pCell ){ + printf("**** apCell[%d] does not match on prior entry ****\n", i); + } + i++; + idx = SWAB16(pBt, pCell->h.iNext); + } + if( idx!=0 ){ + printf("ERROR: next cell index out of range: %d\n", idx); + } + printf("right_child: %d\n", SWAB32(pBt, pPage->u.hdr.rightChild)); + nFree = 0; + i = 0; + idx = SWAB16(pBt, pPage->u.hdr.firstFree); + while( idx>0 && idx<SQLITE_USABLE_SIZE ){ + FreeBlk *p = (FreeBlk*)&pPage->u.aDisk[idx]; + sprintf(range,"%d..%d", idx, idx+p->iSize-1); + nFree += SWAB16(pBt, p->iSize); + printf("freeblock %2d: i=%-10s size=%-4d total=%d\n", + i, range, SWAB16(pBt, p->iSize), nFree); + idx = SWAB16(pBt, p->iNext); + i++; + } + if( idx!=0 ){ + printf("ERROR: next freeblock index out of range: %d\n", idx); + } + if( recursive && pPage->u.hdr.rightChild!=0 ){ + idx = SWAB16(pBt, pPage->u.hdr.firstCell); + while( idx>0 && idx<SQLITE_USABLE_SIZE-MIN_CELL_SIZE ){ + Cell *pCell = (Cell*)&pPage->u.aDisk[idx]; + fileBtreePageDump(pBt, SWAB32(pBt, pCell->h.leftChild), 1); + idx = SWAB16(pBt, pCell->h.iNext); + } + fileBtreePageDump(pBt, SWAB32(pBt, pPage->u.hdr.rightChild), 1); + } + sqlitepager_unref(pPage); + return SQLITE_OK; +} +#endif + +#ifdef SQLITE_TEST +/* +** Fill aResult[] with information about the entry and page that the +** cursor is pointing to. +** +** aResult[0] = The page number +** aResult[1] = The entry number +** aResult[2] = Total number of entries on this page +** aResult[3] = Size of this entry +** aResult[4] = Number of free bytes on this page +** aResult[5] = Number of free blocks on the page +** aResult[6] = Page number of the left child of this entry +** aResult[7] = Page number of the right child for the whole page +** +** This routine is used for testing and debugging only. +*/ +static int fileBtreeCursorDump(BtCursor *pCur, int *aResult){ + int cnt, idx; + MemPage *pPage = pCur->pPage; + Btree *pBt = pCur->pBt; + aResult[0] = sqlitepager_pagenumber(pPage); + aResult[1] = pCur->idx; + aResult[2] = pPage->nCell; + if( pCur->idx>=0 && pCur->idx<pPage->nCell ){ + aResult[3] = cellSize(pBt, pPage->apCell[pCur->idx]); + aResult[6] = SWAB32(pBt, pPage->apCell[pCur->idx]->h.leftChild); + }else{ + aResult[3] = 0; + aResult[6] = 0; + } + aResult[4] = pPage->nFree; + cnt = 0; + idx = SWAB16(pBt, pPage->u.hdr.firstFree); + while( idx>0 && idx<SQLITE_USABLE_SIZE ){ + cnt++; + idx = SWAB16(pBt, ((FreeBlk*)&pPage->u.aDisk[idx])->iNext); + } + aResult[5] = cnt; + aResult[7] = SWAB32(pBt, pPage->u.hdr.rightChild); + return SQLITE_OK; +} +#endif + +/* +** Return the pager associated with a BTree. This routine is used for +** testing and debugging only. +*/ +static Pager *fileBtreePager(Btree *pBt){ + return pBt->pPager; +} + +/* +** This structure is passed around through all the sanity checking routines +** in order to keep track of some global state information. +*/ +typedef struct IntegrityCk IntegrityCk; +struct IntegrityCk { + Btree *pBt; /* The tree being checked out */ + Pager *pPager; /* The associated pager. Also accessible by pBt->pPager */ + int nPage; /* Number of pages in the database */ + int *anRef; /* Number of times each page is referenced */ + char *zErrMsg; /* An error message. NULL of no errors seen. */ +}; + +/* +** Append a message to the error message string. +*/ +static void checkAppendMsg(IntegrityCk *pCheck, char *zMsg1, char *zMsg2){ + if( pCheck->zErrMsg ){ + char *zOld = pCheck->zErrMsg; + pCheck->zErrMsg = 0; + sqliteSetString(&pCheck->zErrMsg, zOld, "\n", zMsg1, zMsg2, (char*)0); + sqliteFree(zOld); + }else{ + sqliteSetString(&pCheck->zErrMsg, zMsg1, zMsg2, (char*)0); + } +} + +/* +** Add 1 to the reference count for page iPage. If this is the second +** reference to the page, add an error message to pCheck->zErrMsg. +** Return 1 if there are 2 ore more references to the page and 0 if +** if this is the first reference to the page. +** +** Also check that the page number is in bounds. +*/ +static int checkRef(IntegrityCk *pCheck, int iPage, char *zContext){ + if( iPage==0 ) return 1; + if( iPage>pCheck->nPage || iPage<0 ){ + char zBuf[100]; + sprintf(zBuf, "invalid page number %d", iPage); + checkAppendMsg(pCheck, zContext, zBuf); + return 1; + } + if( pCheck->anRef[iPage]==1 ){ + char zBuf[100]; + sprintf(zBuf, "2nd reference to page %d", iPage); + checkAppendMsg(pCheck, zContext, zBuf); + return 1; + } + return (pCheck->anRef[iPage]++)>1; +} + +/* +** Check the integrity of the freelist or of an overflow page list. +** Verify that the number of pages on the list is N. +*/ +static void checkList( + IntegrityCk *pCheck, /* Integrity checking context */ + int isFreeList, /* True for a freelist. False for overflow page list */ + int iPage, /* Page number for first page in the list */ + int N, /* Expected number of pages in the list */ + char *zContext /* Context for error messages */ +){ + int i; + char zMsg[100]; + while( N-- > 0 ){ + OverflowPage *pOvfl; + if( iPage<1 ){ + sprintf(zMsg, "%d pages missing from overflow list", N+1); + checkAppendMsg(pCheck, zContext, zMsg); + break; + } + if( checkRef(pCheck, iPage, zContext) ) break; + if( sqlitepager_get(pCheck->pPager, (Pgno)iPage, (void**)&pOvfl) ){ + sprintf(zMsg, "failed to get page %d", iPage); + checkAppendMsg(pCheck, zContext, zMsg); + break; + } + if( isFreeList ){ + FreelistInfo *pInfo = (FreelistInfo*)pOvfl->aPayload; + int n = SWAB32(pCheck->pBt, pInfo->nFree); + for(i=0; i<n; i++){ + checkRef(pCheck, SWAB32(pCheck->pBt, pInfo->aFree[i]), zContext); + } + N -= n; + } + iPage = SWAB32(pCheck->pBt, pOvfl->iNext); + sqlitepager_unref(pOvfl); + } +} + +/* +** Return negative if zKey1<zKey2. +** Return zero if zKey1==zKey2. +** Return positive if zKey1>zKey2. +*/ +static int keyCompare( + const char *zKey1, int nKey1, + const char *zKey2, int nKey2 +){ + int min = nKey1>nKey2 ? nKey2 : nKey1; + int c = memcmp(zKey1, zKey2, min); + if( c==0 ){ + c = nKey1 - nKey2; + } + return c; +} + +/* +** Do various sanity checks on a single page of a tree. Return +** the tree depth. Root pages return 0. Parents of root pages +** return 1, and so forth. +** +** These checks are done: +** +** 1. Make sure that cells and freeblocks do not overlap +** but combine to completely cover the page. +** 2. Make sure cell keys are in order. +** 3. Make sure no key is less than or equal to zLowerBound. +** 4. Make sure no key is greater than or equal to zUpperBound. +** 5. Check the integrity of overflow pages. +** 6. Recursively call checkTreePage on all children. +** 7. Verify that the depth of all children is the same. +** 8. Make sure this page is at least 33% full or else it is +** the root of the tree. +*/ +static int checkTreePage( + IntegrityCk *pCheck, /* Context for the sanity check */ + int iPage, /* Page number of the page to check */ + MemPage *pParent, /* Parent page */ + char *zParentContext, /* Parent context */ + char *zLowerBound, /* All keys should be greater than this, if not NULL */ + int nLower, /* Number of characters in zLowerBound */ + char *zUpperBound, /* All keys should be less than this, if not NULL */ + int nUpper /* Number of characters in zUpperBound */ +){ + MemPage *pPage; + int i, rc, depth, d2, pgno; + char *zKey1, *zKey2; + int nKey1, nKey2; + BtCursor cur; + Btree *pBt; + char zMsg[100]; + char zContext[100]; + char hit[SQLITE_USABLE_SIZE]; + + /* Check that the page exists + */ + cur.pBt = pBt = pCheck->pBt; + if( iPage==0 ) return 0; + if( checkRef(pCheck, iPage, zParentContext) ) return 0; + sprintf(zContext, "On tree page %d: ", iPage); + if( (rc = sqlitepager_get(pCheck->pPager, (Pgno)iPage, (void**)&pPage))!=0 ){ + sprintf(zMsg, "unable to get the page. error code=%d", rc); + checkAppendMsg(pCheck, zContext, zMsg); + return 0; + } + if( (rc = initPage(pBt, pPage, (Pgno)iPage, pParent))!=0 ){ + sprintf(zMsg, "initPage() returns error code %d", rc); + checkAppendMsg(pCheck, zContext, zMsg); + sqlitepager_unref(pPage); + return 0; + } + + /* Check out all the cells. + */ + depth = 0; + if( zLowerBound ){ + zKey1 = sqliteMalloc( nLower+1 ); + memcpy(zKey1, zLowerBound, nLower); + zKey1[nLower] = 0; + }else{ + zKey1 = 0; + } + nKey1 = nLower; + cur.pPage = pPage; + for(i=0; i<pPage->nCell; i++){ + Cell *pCell = pPage->apCell[i]; + int sz; + + /* Check payload overflow pages + */ + nKey2 = NKEY(pBt, pCell->h); + sz = nKey2 + NDATA(pBt, pCell->h); + sprintf(zContext, "On page %d cell %d: ", iPage, i); + if( sz>MX_LOCAL_PAYLOAD ){ + int nPage = (sz - MX_LOCAL_PAYLOAD + OVERFLOW_SIZE - 1)/OVERFLOW_SIZE; + checkList(pCheck, 0, SWAB32(pBt, pCell->ovfl), nPage, zContext); + } + + /* Check that keys are in the right order + */ + cur.idx = i; + zKey2 = sqliteMallocRaw( nKey2+1 ); + getPayload(&cur, 0, nKey2, zKey2); + if( zKey1 && keyCompare(zKey1, nKey1, zKey2, nKey2)>=0 ){ + checkAppendMsg(pCheck, zContext, "Key is out of order"); + } + + /* Check sanity of left child page. + */ + pgno = SWAB32(pBt, pCell->h.leftChild); + d2 = checkTreePage(pCheck, pgno, pPage, zContext, zKey1,nKey1,zKey2,nKey2); + if( i>0 && d2!=depth ){ + checkAppendMsg(pCheck, zContext, "Child page depth differs"); + } + depth = d2; + sqliteFree(zKey1); + zKey1 = zKey2; + nKey1 = nKey2; + } + pgno = SWAB32(pBt, pPage->u.hdr.rightChild); + sprintf(zContext, "On page %d at right child: ", iPage); + checkTreePage(pCheck, pgno, pPage, zContext, zKey1,nKey1,zUpperBound,nUpper); + sqliteFree(zKey1); + + /* Check for complete coverage of the page + */ + memset(hit, 0, sizeof(hit)); + memset(hit, 1, sizeof(PageHdr)); + for(i=SWAB16(pBt, pPage->u.hdr.firstCell); i>0 && i<SQLITE_USABLE_SIZE; ){ + Cell *pCell = (Cell*)&pPage->u.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 && i<SQLITE_USABLE_SIZE; ){ + FreeBlk *pFBlk = (FreeBlk*)&pPage->u.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; i<SQLITE_USABLE_SIZE; i++){ + if( hit[i]==0 ){ + sprintf(zMsg, "Unused space at byte %d of page %d", i, iPage); + checkAppendMsg(pCheck, zMsg, 0); + break; + }else if( hit[i]>1 ){ + sprintf(zMsg, "Multiple uses for byte %d of page %d", i, iPage); + checkAppendMsg(pCheck, zMsg, 0); + break; + } + } + + /* Check that free space is kept to a minimum + */ +#if 0 + if( pParent && pParent->nCell>2 && pPage->nFree>3*SQLITE_USABLE_SIZE/4 ){ + sprintf(zMsg, "free space (%d) greater than max (%d)", pPage->nFree, + SQLITE_USABLE_SIZE/3); + checkAppendMsg(pCheck, zContext, zMsg); + } +#endif + + sqlitepager_unref(pPage); + return depth; +} + +/* +** This routine does a complete check of the given BTree file. aRoot[] is +** an array of pages numbers were each page number is the root page of +** a table. nRoot is the number of entries in aRoot. +** +** If everything checks out, this routine returns NULL. If something is +** amiss, an error message is written into memory obtained from malloc() +** and a pointer to that error message is returned. The calling function +** is responsible for freeing the error message when it is done. +*/ +char *fileBtreeIntegrityCheck(Btree *pBt, int *aRoot, int nRoot){ + int i; + int nRef; + IntegrityCk sCheck; + + nRef = *sqlitepager_stats(pBt->pPager); + if( lockBtree(pBt)!=SQLITE_OK ){ + return sqliteStrDup("Unable to acquire a read lock on the database"); + } + sCheck.pBt = pBt; + sCheck.pPager = pBt->pPager; + sCheck.nPage = sqlitepager_pagecount(sCheck.pPager); + if( sCheck.nPage==0 ){ + unlockBtreeIfUnused(pBt); + return 0; + } + sCheck.anRef = sqliteMallocRaw( (sCheck.nPage+1)*sizeof(sCheck.anRef[0]) ); + sCheck.anRef[1] = 1; + for(i=2; i<=sCheck.nPage; i++){ sCheck.anRef[i] = 0; } + sCheck.zErrMsg = 0; + + /* Check the integrity of the freelist + */ + checkList(&sCheck, 1, SWAB32(pBt, pBt->page1->freeList), + SWAB32(pBt, pBt->page1->nFree), "Main freelist: "); + + /* Check all the tables. + */ + for(i=0; i<nRoot; i++){ + if( aRoot[i]==0 ) continue; + checkTreePage(&sCheck, aRoot[i], 0, "List of tree roots: ", 0,0,0,0); + } + + /* Make sure every page in the file is referenced + */ + for(i=1; i<=sCheck.nPage; i++){ + if( sCheck.anRef[i]==0 ){ + char zBuf[100]; + sprintf(zBuf, "Page %d is never used", i); + checkAppendMsg(&sCheck, zBuf, 0); + } + } + + /* Make sure this analysis did not leave any unref() pages + */ + unlockBtreeIfUnused(pBt); + if( nRef != *sqlitepager_stats(pBt->pPager) ){ + char zBuf[100]; + sprintf(zBuf, + "Outstanding page count goes from %d to %d during this analysis", + nRef, *sqlitepager_stats(pBt->pPager) + ); + checkAppendMsg(&sCheck, zBuf, 0); + } + + /* Clean up and report errors. + */ + sqliteFree(sCheck.anRef); + return sCheck.zErrMsg; +} + +/* +** Return the full pathname of the underlying database file. +*/ +static const char *fileBtreeGetFilename(Btree *pBt){ + assert( pBt->pPager!=0 ); + return sqlitepager_filename(pBt->pPager); +} + +/* +** Copy the complete content of pBtFrom into pBtTo. A transaction +** must be active for both files. +** +** The size of file pBtFrom may be reduced by this operation. +** If anything goes wrong, the transaction on pBtFrom is rolled back. +*/ +static int fileBtreeCopyFile(Btree *pBtTo, Btree *pBtFrom){ + int rc = SQLITE_OK; + Pgno i, nPage, nToPage; + + if( !pBtTo->inTrans || !pBtFrom->inTrans ) return SQLITE_ERROR; + if( pBtTo->needSwab!=pBtFrom->needSwab ) return SQLITE_ERROR; + if( pBtTo->pCursor ) return SQLITE_BUSY; + memcpy(pBtTo->page1, pBtFrom->page1, SQLITE_USABLE_SIZE); + rc = sqlitepager_overwrite(pBtTo->pPager, 1, pBtFrom->page1); + nToPage = sqlitepager_pagecount(pBtTo->pPager); + nPage = sqlitepager_pagecount(pBtFrom->pPager); + for(i=2; rc==SQLITE_OK && i<=nPage; i++){ + void *pPage; + rc = sqlitepager_get(pBtFrom->pPager, i, &pPage); + if( rc ) break; + rc = sqlitepager_overwrite(pBtTo->pPager, i, pPage); + if( rc ) break; + sqlitepager_unref(pPage); + } + for(i=nPage+1; rc==SQLITE_OK && i<=nToPage; i++){ + void *pPage; + rc = sqlitepager_get(pBtTo->pPager, i, &pPage); + if( rc ) break; + rc = sqlitepager_write(pPage); + sqlitepager_unref(pPage); + sqlitepager_dont_write(pBtTo->pPager, i); + } + if( !rc && nPage<nToPage ){ + rc = sqlitepager_truncate(pBtTo->pPager, nPage); + } + if( rc ){ + fileBtreeRollback(pBtTo); + } + return rc; +} + +/* +** The following tables contain pointers to all of the interface +** routines for this implementation of the B*Tree backend. To +** substitute a different implemention of the backend, one has merely +** to provide pointers to alternative functions in similar tables. +*/ +static BtOps sqliteBtreeOps = { + fileBtreeClose, + fileBtreeSetCacheSize, + fileBtreeSetSafetyLevel, + fileBtreeBeginTrans, + fileBtreeCommit, + fileBtreeRollback, + fileBtreeBeginCkpt, + fileBtreeCommitCkpt, + fileBtreeRollbackCkpt, + fileBtreeCreateTable, + fileBtreeCreateTable, /* Really sqliteBtreeCreateIndex() */ + fileBtreeDropTable, + fileBtreeClearTable, + fileBtreeCursor, + fileBtreeGetMeta, + fileBtreeUpdateMeta, + fileBtreeIntegrityCheck, + fileBtreeGetFilename, + fileBtreeCopyFile, + fileBtreePager, +#ifdef SQLITE_TEST + fileBtreePageDump, +#endif +}; +static BtCursorOps sqliteBtreeCursorOps = { + fileBtreeMoveto, + fileBtreeDelete, + fileBtreeInsert, + fileBtreeFirst, + fileBtreeLast, + fileBtreeNext, + fileBtreePrevious, + fileBtreeKeySize, + fileBtreeKey, + fileBtreeKeyCompare, + fileBtreeDataSize, + fileBtreeData, + fileBtreeCloseCursor, +#ifdef SQLITE_TEST + fileBtreeCursorDump, +#endif +}; diff --git a/kexi/3rdparty/kexisql/src/btree.h b/kexi/3rdparty/kexisql/src/btree.h new file mode 100644 index 00000000..6152b308 --- /dev/null +++ b/kexi/3rdparty/kexisql/src/btree.h @@ -0,0 +1,156 @@ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This header file defines the interface that the sqlite B-Tree file +** subsystem. See comments in the source code for a detailed description +** of what each interface routine does. +** +** @(#) $Id: btree.h 410099 2005-05-06 17:52:07Z staniek $ +*/ +#ifndef _BTREE_H_ +#define _BTREE_H_ + +/* +** Forward declarations of structure +*/ +typedef struct Btree Btree; +typedef struct BtCursor BtCursor; +typedef struct BtOps BtOps; +typedef struct BtCursorOps BtCursorOps; + + +/* +** An instance of the following structure contains pointers to all +** methods against an open BTree. Alternative BTree implementations +** (examples: file based versus in-memory) can be created by substituting +** different methods. Users of the BTree cannot tell the difference. +** +** In C++ we could do this by defining a virtual base class and then +** creating subclasses for each different implementation. But this is +** C not C++ so we have to be a little more explicit. +*/ +struct BtOps { + int (*Close)(Btree*); + int (*SetCacheSize)(Btree*, int); + int (*SetSafetyLevel)(Btree*, int); + int (*BeginTrans)(Btree*); + int (*Commit)(Btree*); + int (*Rollback)(Btree*); + int (*BeginCkpt)(Btree*); + int (*CommitCkpt)(Btree*); + int (*RollbackCkpt)(Btree*); + int (*CreateTable)(Btree*, int*); + int (*CreateIndex)(Btree*, int*); + int (*DropTable)(Btree*, int); + int (*ClearTable)(Btree*, int); + int (*Cursor)(Btree*, int iTable, int wrFlag, BtCursor **ppCur); + int (*GetMeta)(Btree*, int*); + int (*UpdateMeta)(Btree*, int*); + char *(*IntegrityCheck)(Btree*, int*, int); + const char *(*GetFilename)(Btree*); + int (*Copyfile)(Btree*,Btree*); + struct Pager *(*Pager)(Btree*); +#ifdef SQLITE_TEST + int (*PageDump)(Btree*, int, int); +#endif +}; + +/* +** An instance of this structure defines all of the methods that can +** be executed against a cursor. +*/ +struct BtCursorOps { + int (*Moveto)(BtCursor*, const void *pKey, int nKey, int *pRes); + int (*Delete)(BtCursor*); + int (*Insert)(BtCursor*, const void *pKey, int nKey, + const void *pData, int nData); + int (*First)(BtCursor*, int *pRes); + int (*Last)(BtCursor*, int *pRes); + int (*Next)(BtCursor*, int *pRes); + int (*Previous)(BtCursor*, int *pRes); + int (*KeySize)(BtCursor*, int *pSize); + int (*Key)(BtCursor*, int offset, int amt, char *zBuf); + int (*KeyCompare)(BtCursor*, const void *pKey, int nKey, + int nIgnore, int *pRes); + int (*DataSize)(BtCursor*, int *pSize); + int (*Data)(BtCursor*, int offset, int amt, char *zBuf); + int (*CloseCursor)(BtCursor*); +#ifdef SQLITE_TEST + int (*CursorDump)(BtCursor*, int*); +#endif +}; + +/* +** The number of 4-byte "meta" values contained on the first page of each +** database file. +*/ +#define SQLITE_N_BTREE_META 10 + +int sqliteBtreeOpen(const char *zFilename, int mode, int nPg, Btree **ppBtree); +int sqliteRbtreeOpen(const char *zFilename, int mode, int nPg, Btree **ppBtree); + +#define btOps(pBt) (*((BtOps **)(pBt))) +#define btCOps(pCur) (*((BtCursorOps **)(pCur))) + +#define sqliteBtreeClose(pBt) (btOps(pBt)->Close(pBt)) +#define sqliteBtreeSetCacheSize(pBt, sz) (btOps(pBt)->SetCacheSize(pBt, sz)) +#define sqliteBtreeSetSafetyLevel(pBt, sl) (btOps(pBt)->SetSafetyLevel(pBt, sl)) +#define sqliteBtreeBeginTrans(pBt) (btOps(pBt)->BeginTrans(pBt)) +#define sqliteBtreeCommit(pBt) (btOps(pBt)->Commit(pBt)) +#define sqliteBtreeRollback(pBt) (btOps(pBt)->Rollback(pBt)) +#define sqliteBtreeBeginCkpt(pBt) (btOps(pBt)->BeginCkpt(pBt)) +#define sqliteBtreeCommitCkpt(pBt) (btOps(pBt)->CommitCkpt(pBt)) +#define sqliteBtreeRollbackCkpt(pBt) (btOps(pBt)->RollbackCkpt(pBt)) +#define sqliteBtreeCreateTable(pBt,piTable)\ + (btOps(pBt)->CreateTable(pBt,piTable)) +#define sqliteBtreeCreateIndex(pBt, piIndex)\ + (btOps(pBt)->CreateIndex(pBt, piIndex)) +#define sqliteBtreeDropTable(pBt, iTable) (btOps(pBt)->DropTable(pBt, iTable)) +#define sqliteBtreeClearTable(pBt, iTable)\ + (btOps(pBt)->ClearTable(pBt, iTable)) +#define sqliteBtreeCursor(pBt, iTable, wrFlag, ppCur)\ + (btOps(pBt)->Cursor(pBt, iTable, wrFlag, ppCur)) +#define sqliteBtreeMoveto(pCur, pKey, nKey, pRes)\ + (btCOps(pCur)->Moveto(pCur, pKey, nKey, pRes)) +#define sqliteBtreeDelete(pCur) (btCOps(pCur)->Delete(pCur)) +#define sqliteBtreeInsert(pCur, pKey, nKey, pData, nData) \ + (btCOps(pCur)->Insert(pCur, pKey, nKey, pData, nData)) +#define sqliteBtreeFirst(pCur, pRes) (btCOps(pCur)->First(pCur, pRes)) +#define sqliteBtreeLast(pCur, pRes) (btCOps(pCur)->Last(pCur, pRes)) +#define sqliteBtreeNext(pCur, pRes) (btCOps(pCur)->Next(pCur, pRes)) +#define sqliteBtreePrevious(pCur, pRes) (btCOps(pCur)->Previous(pCur, pRes)) +#define sqliteBtreeKeySize(pCur, pSize) (btCOps(pCur)->KeySize(pCur, pSize) ) +#define sqliteBtreeKey(pCur, offset, amt, zBuf)\ + (btCOps(pCur)->Key(pCur, offset, amt, zBuf)) +#define sqliteBtreeKeyCompare(pCur, pKey, nKey, nIgnore, pRes)\ + (btCOps(pCur)->KeyCompare(pCur, pKey, nKey, nIgnore, pRes)) +#define sqliteBtreeDataSize(pCur, pSize) (btCOps(pCur)->DataSize(pCur, pSize)) +#define sqliteBtreeData(pCur, offset, amt, zBuf)\ + (btCOps(pCur)->Data(pCur, offset, amt, zBuf)) +#define sqliteBtreeCloseCursor(pCur) (btCOps(pCur)->CloseCursor(pCur)) +#define sqliteBtreeGetMeta(pBt, aMeta) (btOps(pBt)->GetMeta(pBt, aMeta)) +#define sqliteBtreeUpdateMeta(pBt, aMeta) (btOps(pBt)->UpdateMeta(pBt, aMeta)) +#define sqliteBtreeIntegrityCheck(pBt, aRoot, nRoot)\ + (btOps(pBt)->IntegrityCheck(pBt, aRoot, nRoot)) +#define sqliteBtreeGetFilename(pBt) (btOps(pBt)->GetFilename(pBt)) +#define sqliteBtreeCopyFile(pBt1, pBt2) (btOps(pBt1)->Copyfile(pBt1, pBt2)) +#define sqliteBtreePager(pBt) (btOps(pBt)->Pager(pBt)) + +#ifdef SQLITE_TEST +#define sqliteBtreePageDump(pBt, pgno, recursive)\ + (btOps(pBt)->PageDump(pBt, pgno, recursive)) +#define sqliteBtreeCursorDump(pCur, aResult)\ + (btCOps(pCur)->CursorDump(pCur, aResult)) +int btree_native_byte_order; +#endif /* SQLITE_TEST */ + + +#endif /* _BTREE_H_ */ diff --git a/kexi/3rdparty/kexisql/src/btree_rb.c b/kexi/3rdparty/kexisql/src/btree_rb.c new file mode 100644 index 00000000..3954fe6d --- /dev/null +++ b/kexi/3rdparty/kexisql/src/btree_rb.c @@ -0,0 +1,1488 @@ +/* +** 2003 Feb 4 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** $Id: btree_rb.c 410099 2005-05-06 17:52:07Z staniek $ +** +** 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 <assert.h> + +/* +** 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; i<indent; i++ ){ + orig = append_val(orig, " "); + } + + sprintf(buf, "%p", pNode); + orig = append_val(orig, buf); + + if( pNode ){ + indent += 3; + if( pNode->isBlack ){ + orig = append_val(orig, " B \n"); + }else{ + orig = append_val(orig, " R \n"); + } + orig = append_node( orig, pNode->pLeft, indent ); + orig = append_node( orig, pNode->pRight, indent ); + }else{ + orig = append_val(orig, "\n"); + } + return orig; +} + +/* + * Print a representation of a node to stdout. This function is only included + * so you can call it from within a debugger if things get really bad. It + * is not called from anyplace in the code. + */ +static void print_node(BtRbNode *pNode) +{ + char * str = append_node(0, pNode, 0); + printf("%s", str); + + /* Suppress a warning message about print_node() being unused */ + (void)print_node; +} + +/* + * Check the following properties of the red-black tree: + * (1) - If a node is red, both of it's children are black + * (2) - Each path from a given node to a leaf (NULL) node passes thru the + * same number of black nodes + * + * If there is a problem, append a description (using append_val() ) to *msg. + */ +static void check_redblack_tree(BtRbTree * tree, char ** msg) +{ + BtRbNode *pNode; + + /* 0 -> came from parent + * 1 -> came from left + * 2 -> came from right */ + int prev_step = 0; + + pNode = tree->pHead; + while( pNode ){ + switch( prev_step ){ + case 0: + if( pNode->pLeft ){ + pNode = pNode->pLeft; + }else{ + prev_step = 1; + } + break; + case 1: + if( pNode->pRight ){ + pNode = pNode->pRight; + prev_step = 0; + }else{ + prev_step = 2; + } + break; + case 2: + /* Check red-black property (1) */ + if( !pNode->isBlack && + ( (pNode->pLeft && !pNode->pLeft->isBlack) || + (pNode->pRight && !pNode->pRight->isBlack) ) + ){ + char buf[128]; + sprintf(buf, "Red node with red child at %p\n", pNode); + *msg = append_val(*msg, buf); + *msg = append_node(*msg, tree->pHead, 0); + *msg = append_val(*msg, "\n"); + } + + /* Check red-black property (2) */ + { + int leftHeight = 0; + int rightHeight = 0; + if( pNode->pLeft ){ + leftHeight += pNode->pLeft->nBlackHeight; + leftHeight += (pNode->pLeft->isBlack?1:0); + } + if( pNode->pRight ){ + rightHeight += pNode->pRight->nBlackHeight; + rightHeight += (pNode->pRight->isBlack?1:0); + } + if( leftHeight != rightHeight ){ + char buf[128]; + sprintf(buf, "Different black-heights at %p\n", pNode); + *msg = append_val(*msg, buf); + *msg = append_node(*msg, tree->pHead, 0); + *msg = append_val(*msg, "\n"); + } + pNode->nBlackHeight = leftHeight; + } + + if( pNode->pParent ){ + if( pNode == pNode->pParent->pLeft ) prev_step = 1; + else prev_step = 2; + } + pNode = pNode->pParent; + break; + default: assert(0); + } + } +} + +/* + * Node pX has just been inserted into pTree (by code in sqliteRbtreeInsert()). + * It is possible that pX is a red node with a red parent, which is a violation + * of the red-black tree properties. This function performs rotations and + * color changes to rebalance the tree + */ +static void do_insert_balancing(BtRbTree *pTree, BtRbNode *pX) +{ + /* In the first iteration of this loop, pX points to the red node just + * inserted in the tree. If the parent of pX exists (pX is not the root + * node) and is red, then the properties of the red-black tree are + * violated. + * + * At the start of any subsequent iterations, pX points to a red node + * with a red parent. In all other respects the tree is a legal red-black + * binary tree. */ + while( pX != pTree->pHead && !pX->pParent->isBlack ){ + BtRbNode *pUncle; + BtRbNode *pGrandparent; + + /* Grandparent of pX must exist and must be black. */ + pGrandparent = pX->pParent->pParent; + assert( pGrandparent ); + assert( pGrandparent->isBlack ); + + /* Uncle of pX may or may not exist. */ + if( pX->pParent == pGrandparent->pLeft ) + pUncle = pGrandparent->pRight; + else + pUncle = pGrandparent->pLeft; + + /* If the uncle of pX exists and is red, we do the following: + * | | + * G(b) G(r) + * / \ / \ + * U(r) P(r) U(b) P(b) + * \ \ + * X(r) X(r) + * + * BEFORE AFTER + * pX is then set to G. If the parent of G is red, then the while loop + * will run again. */ + if( pUncle && !pUncle->isBlack ){ + pGrandparent->isBlack = 0; + pUncle->isBlack = 1; + pX->pParent->isBlack = 1; + pX = pGrandparent; + }else{ + + if( pX->pParent == pGrandparent->pLeft ){ + if( pX == pX->pParent->pRight ){ + /* If pX is a right-child, do the following transform, essentially + * to change pX into a left-child: + * | | + * G(b) G(b) + * / \ / \ + * P(r) U(b) X(r) U(b) + * \ / + * X(r) P(r) <-- new X + * + * BEFORE AFTER + */ + pX = pX->pParent; + leftRotate(pTree, pX); + } + + /* Do the following transform, which balances the tree :) + * | | + * G(b) P(b) + * / \ / \ + * P(r) U(b) X(r) G(r) + * / \ + * X(r) U(b) + * + * BEFORE AFTER + */ + assert( pGrandparent == pX->pParent->pParent ); + pGrandparent->isBlack = 0; + pX->pParent->isBlack = 1; + rightRotate( pTree, pGrandparent ); + + }else{ + /* This code is symetric to the illustrated case above. */ + if( pX == pX->pParent->pLeft ){ + pX = pX->pParent; + rightRotate(pTree, pX); + } + assert( pGrandparent == pX->pParent->pParent ); + pGrandparent->isBlack = 0; + pX->pParent->isBlack = 1; + leftRotate( pTree, pGrandparent ); + } + } + } + pTree->pHead->isBlack = 1; +} + +/* + * A child of pParent, which in turn had child pX, has just been removed from + * pTree (the figure below depicts the operation, Z is being removed). pParent + * or pX, or both may be NULL. + * | | + * P P + * / \ / \ + * Z X + * / \ + * X nil + * + * This function is only called if Z was black. In this case the red-black tree + * properties have been violated, and pX has an "extra black". This function + * performs rotations and color-changes to re-balance the tree. + */ +static +void do_delete_balancing(BtRbTree *pTree, BtRbNode *pX, BtRbNode *pParent) +{ + BtRbNode *pSib; + + /* TODO: Comment this code! */ + while( pX != pTree->pHead && (!pX || pX->isBlack) ){ + if( pX == pParent->pLeft ){ + pSib = pParent->pRight; + if( pSib && !(pSib->isBlack) ){ + pSib->isBlack = 1; + pParent->isBlack = 0; + leftRotate(pTree, pParent); + pSib = pParent->pRight; + } + if( !pSib ){ + pX = pParent; + }else if( + (!pSib->pLeft || pSib->pLeft->isBlack) && + (!pSib->pRight || pSib->pRight->isBlack) ) { + pSib->isBlack = 0; + pX = pParent; + }else{ + if( (!pSib->pRight || pSib->pRight->isBlack) ){ + if( pSib->pLeft ) pSib->pLeft->isBlack = 1; + pSib->isBlack = 0; + rightRotate( pTree, pSib ); + pSib = pParent->pRight; + } + pSib->isBlack = pParent->isBlack; + pParent->isBlack = 1; + if( pSib->pRight ) pSib->pRight->isBlack = 1; + leftRotate(pTree, pParent); + pX = pTree->pHead; + } + }else{ + pSib = pParent->pLeft; + if( pSib && !(pSib->isBlack) ){ + pSib->isBlack = 1; + pParent->isBlack = 0; + rightRotate(pTree, pParent); + pSib = pParent->pLeft; + } + if( !pSib ){ + pX = pParent; + }else if( + (!pSib->pLeft || pSib->pLeft->isBlack) && + (!pSib->pRight || pSib->pRight->isBlack) ){ + pSib->isBlack = 0; + pX = pParent; + }else{ + if( (!pSib->pLeft || pSib->pLeft->isBlack) ){ + if( pSib->pRight ) pSib->pRight->isBlack = 1; + pSib->isBlack = 0; + leftRotate( pTree, pSib ); + pSib = pParent->pLeft; + } + pSib->isBlack = pParent->isBlack; + pParent->isBlack = 1; + if( pSib->pLeft ) pSib->pLeft->isBlack = 1; + rightRotate(pTree, pParent); + pX = pTree->pHead; + } + } + pParent = pX->pParent; + } + if( pX ) pX->isBlack = 1; +} + +/* + * Create table n in tree pRbtree. Table n must not exist. + */ +static void btreeCreateTable(Rbtree* pRbtree, int n) +{ + BtRbTree *pNewTbl = sqliteMalloc(sizeof(BtRbTree)); + sqliteHashInsert(&pRbtree->tblHash, 0, n, pNewTbl); +} + +/* + * Log a single "rollback-op" for the given Rbtree. See comments for struct + * BtRollbackOp. + */ +static void btreeLogRollbackOp(Rbtree* pRbtree, BtRollbackOp *pRollbackOp) +{ + assert( pRbtree->eTransState == TRANS_INCHECKPOINT || + pRbtree->eTransState == TRANS_INTRANSACTION ); + if( pRbtree->eTransState == TRANS_INTRANSACTION ){ + pRollbackOp->pNext = pRbtree->pTransRollback; + pRbtree->pTransRollback = pRollbackOp; + } + if( pRbtree->eTransState == TRANS_INCHECKPOINT ){ + if( !pRbtree->pCheckRollback ){ + pRbtree->pCheckRollbackTail = pRollbackOp; + } + pRollbackOp->pNext = pRbtree->pCheckRollback; + pRbtree->pCheckRollback = pRollbackOp; + } +} + +int sqliteRbtreeOpen( + const char *zFilename, + int mode, + int nPg, + Btree **ppBtree +){ + Rbtree **ppRbtree = (Rbtree**)ppBtree; + *ppRbtree = (Rbtree *)sqliteMalloc(sizeof(Rbtree)); + if( sqlite_malloc_failed ) goto open_no_mem; + sqliteHashInit(&(*ppRbtree)->tblHash, SQLITE_HASH_INT, 0); + + /* Create a binary tree for the SQLITE_MASTER table at location 2 */ + btreeCreateTable(*ppRbtree, 2); + if( sqlite_malloc_failed ) goto open_no_mem; + (*ppRbtree)->next_idx = 3; + (*ppRbtree)->pOps = &sqliteRbtreeOps; + /* Set file type to 4; this is so that "attach ':memory:' as ...." does not + ** think that the database in uninitialised and refuse to attach + */ + (*ppRbtree)->aMetaData[2] = 4; + + return SQLITE_OK; + +open_no_mem: + *ppBtree = 0; + return SQLITE_NOMEM; +} + +/* + * Create a new table in the supplied Rbtree. Set *n to the new table number. + * Return SQLITE_OK if the operation is a success. + */ +static int memRbtreeCreateTable(Rbtree* tree, int* n) +{ + assert( tree->eTransState != TRANS_NONE ); + + *n = tree->next_idx++; + btreeCreateTable(tree, *n); + if( sqlite_malloc_failed ) return SQLITE_NOMEM; + + /* Set up the rollback structure (if we are not doing this as part of a + * rollback) */ + if( tree->eTransState != TRANS_ROLLBACK ){ + BtRollbackOp *pRollbackOp = sqliteMalloc(sizeof(BtRollbackOp)); + if( pRollbackOp==0 ) return SQLITE_NOMEM; + pRollbackOp->eOp = ROLLBACK_DROP; + pRollbackOp->iTab = *n; + btreeLogRollbackOp(tree, pRollbackOp); + } + + return SQLITE_OK; +} + +/* + * Delete table n from the supplied Rbtree. + */ +static int memRbtreeDropTable(Rbtree* tree, int n) +{ + BtRbTree *pTree; + assert( tree->eTransState != TRANS_NONE ); + + memRbtreeClearTable(tree, n); + pTree = sqliteHashInsert(&tree->tblHash, 0, n, 0); + assert(pTree); + assert( pTree->pCursors==0 ); + sqliteFree(pTree); + + if( tree->eTransState != TRANS_ROLLBACK ){ + BtRollbackOp *pRollbackOp = sqliteMalloc(sizeof(BtRollbackOp)); + if( pRollbackOp==0 ) return SQLITE_NOMEM; + pRollbackOp->eOp = ROLLBACK_CREATE; + pRollbackOp->iTab = n; + btreeLogRollbackOp(tree, pRollbackOp); + } + + return SQLITE_OK; +} + +static int memRbtreeKeyCompare(RbtCursor* pCur, const void *pKey, int nKey, + int nIgnore, int *pRes) +{ + assert(pCur); + + if( !pCur->pNode ) { + *pRes = -1; + } else { + if( (pCur->pNode->nKey - nIgnore) < 0 ){ + *pRes = -1; + }else{ + *pRes = key_compare(pCur->pNode->pKey, pCur->pNode->nKey-nIgnore, + pKey, nKey); + } + } + return SQLITE_OK; +} + +/* + * Get a new cursor for table iTable of the supplied Rbtree. The wrFlag + * parameter indicates that the cursor is open for writing. + * + * Note that RbtCursor.eSkip and RbtCursor.pNode both initialize to 0. + */ +static int memRbtreeCursor( + Rbtree* tree, + int iTable, + int wrFlag, + RbtCursor **ppCur +){ + RbtCursor *pCur; + assert(tree); + pCur = *ppCur = sqliteMalloc(sizeof(RbtCursor)); + if( sqlite_malloc_failed ) return SQLITE_NOMEM; + pCur->pTree = sqliteHashFind(&tree->tblHash, 0, iTable); + assert( pCur->pTree ); + pCur->pRbtree = tree; + pCur->iTree = iTable; + pCur->pOps = &sqliteRbtreeCursorOps; + pCur->wrFlag = wrFlag; + pCur->pShared = pCur->pTree->pCursors; + pCur->pTree->pCursors = pCur; + + assert( (*ppCur)->pTree ); + return SQLITE_OK; +} + +/* + * Insert a new record into the Rbtree. The key is given by (pKey,nKey) + * and the data is given by (pData,nData). The cursor is used only to + * define what database the record should be inserted into. The cursor + * is left pointing at the new record. + * + * If the key exists already in the tree, just replace the data. + */ +static int memRbtreeInsert( + RbtCursor* pCur, + const void *pKey, + int nKey, + const void *pDataInput, + int nData +){ + void * pData; + int match; + + /* It is illegal to call sqliteRbtreeInsert() if we are + ** not in a transaction */ + assert( pCur->pRbtree->eTransState != TRANS_NONE ); + + /* Make sure some other cursor isn't trying to read this same table */ + if( checkReadLocks(pCur) ){ + return SQLITE_LOCKED; /* The table pCur points to has a read lock */ + } + + /* Take a copy of the input data now, in case we need it for the + * replace case */ + pData = sqliteMallocRaw(nData); + if( sqlite_malloc_failed ) return SQLITE_NOMEM; + memcpy(pData, pDataInput, nData); + + /* Move the cursor to a node near the key to be inserted. If the key already + * exists in the table, then (match == 0). In this case we can just replace + * the data associated with the entry, we don't need to manipulate the tree. + * + * If there is no exact match, then the cursor points at what would be either + * the predecessor (match == -1) or successor (match == 1) of the + * searched-for key, were it to be inserted. The new node becomes a child of + * this node. + * + * The new node is initially red. + */ + memRbtreeMoveto( pCur, pKey, nKey, &match); + if( match ){ + BtRbNode *pNode = sqliteMalloc(sizeof(BtRbNode)); + if( pNode==0 ) return SQLITE_NOMEM; + pNode->nKey = nKey; + pNode->pKey = sqliteMallocRaw(nKey); + if( sqlite_malloc_failed ) return SQLITE_NOMEM; + memcpy(pNode->pKey, pKey, nKey); + pNode->nData = nData; + pNode->pData = pData; + if( pCur->pNode ){ + switch( match ){ + case -1: + assert( !pCur->pNode->pRight ); + pNode->pParent = pCur->pNode; + pCur->pNode->pRight = pNode; + break; + case 1: + assert( !pCur->pNode->pLeft ); + pNode->pParent = pCur->pNode; + pCur->pNode->pLeft = pNode; + break; + default: + assert(0); + } + }else{ + pCur->pTree->pHead = pNode; + } + + /* Point the cursor at the node just inserted, as per SQLite requirements */ + pCur->pNode = pNode; + + /* A new node has just been inserted, so run the balancing code */ + do_insert_balancing(pCur->pTree, pNode); + + /* Set up a rollback-op in case we have to roll this operation back */ + if( pCur->pRbtree->eTransState != TRANS_ROLLBACK ){ + BtRollbackOp *pOp = sqliteMalloc( sizeof(BtRollbackOp) ); + if( pOp==0 ) return SQLITE_NOMEM; + pOp->eOp = ROLLBACK_DELETE; + pOp->iTab = pCur->iTree; + pOp->nKey = pNode->nKey; + pOp->pKey = sqliteMallocRaw( pOp->nKey ); + if( sqlite_malloc_failed ) return SQLITE_NOMEM; + memcpy( pOp->pKey, pNode->pKey, pOp->nKey ); + btreeLogRollbackOp(pCur->pRbtree, pOp); + } + + }else{ + /* No need to insert a new node in the tree, as the key already exists. + * Just clobber the current nodes data. */ + + /* Set up a rollback-op in case we have to roll this operation back */ + if( pCur->pRbtree->eTransState != TRANS_ROLLBACK ){ + BtRollbackOp *pOp = sqliteMalloc( sizeof(BtRollbackOp) ); + if( pOp==0 ) return SQLITE_NOMEM; + pOp->iTab = pCur->iTree; + pOp->nKey = pCur->pNode->nKey; + pOp->pKey = sqliteMallocRaw( pOp->nKey ); + if( sqlite_malloc_failed ) return SQLITE_NOMEM; + memcpy( pOp->pKey, pCur->pNode->pKey, pOp->nKey ); + pOp->nData = pCur->pNode->nData; + pOp->pData = pCur->pNode->pData; + pOp->eOp = ROLLBACK_INSERT; + btreeLogRollbackOp(pCur->pRbtree, pOp); + }else{ + sqliteFree( pCur->pNode->pData ); + } + + /* Actually clobber the nodes data */ + pCur->pNode->pData = pData; + pCur->pNode->nData = nData; + } + + return SQLITE_OK; +} + +/* Move the cursor so that it points to an entry near pKey. +** Return a success code. +** +** *pRes<0 The cursor is left pointing at an entry that +** is smaller than pKey or if the table is empty +** and the cursor is therefore left point to nothing. +** +** *pRes==0 The cursor is left pointing at an entry that +** exactly matches pKey. +** +** *pRes>0 The cursor is left pointing at an entry that +** is larger than pKey. +*/ +static int memRbtreeMoveto( + RbtCursor* pCur, + const void *pKey, + int nKey, + int *pRes +){ + BtRbNode *pTmp = 0; + + pCur->pNode = pCur->pTree->pHead; + *pRes = -1; + while( pCur->pNode && *pRes ) { + *pRes = key_compare(pCur->pNode->pKey, pCur->pNode->nKey, pKey, nKey); + pTmp = pCur->pNode; + switch( *pRes ){ + case 1: /* cursor > key */ + pCur->pNode = pCur->pNode->pLeft; + break; + case -1: /* cursor < key */ + pCur->pNode = pCur->pNode->pRight; + break; + } + } + + /* If (pCur->pNode == NULL), then we have failed to find a match. Set + * pCur->pNode to pTmp, which is either NULL (if the tree is empty) or the + * last node traversed in the search. In either case the relation ship + * between pTmp and the searched for key is already stored in *pRes. pTmp is + * either the successor or predecessor of the key we tried to move to. */ + if( !pCur->pNode ) pCur->pNode = pTmp; + pCur->eSkip = SKIP_NONE; + + return SQLITE_OK; +} + + +/* +** Delete the entry that the cursor is pointing to. +** +** The cursor is left pointing at either the next or the previous +** entry. If the cursor is left pointing to the next entry, then +** the pCur->eSkip flag is set to SKIP_NEXT which forces the next call to +** sqliteRbtreeNext() to be a no-op. That way, you can always call +** sqliteRbtreeNext() after a delete and the cursor will be left +** pointing to the first entry after the deleted entry. Similarly, +** pCur->eSkip is set to SKIP_PREV is the cursor is left pointing to +** the entry prior to the deleted entry so that a subsequent call to +** sqliteRbtreePrevious() will always leave the cursor pointing at the +** entry immediately before the one that was deleted. +*/ +static int memRbtreeDelete(RbtCursor* pCur) +{ + BtRbNode *pZ; /* The one being deleted */ + BtRbNode *pChild; /* The child of the spliced out node */ + + /* It is illegal to call sqliteRbtreeDelete() if we are + ** not in a transaction */ + assert( pCur->pRbtree->eTransState != TRANS_NONE ); + + /* Make sure some other cursor isn't trying to read this same table */ + if( checkReadLocks(pCur) ){ + return SQLITE_LOCKED; /* The table pCur points to has a read lock */ + } + + pZ = pCur->pNode; + if( !pZ ){ + return SQLITE_OK; + } + + /* If we are not currently doing a rollback, set up a rollback op for this + * deletion */ + if( pCur->pRbtree->eTransState != TRANS_ROLLBACK ){ + BtRollbackOp *pOp = sqliteMalloc( sizeof(BtRollbackOp) ); + if( pOp==0 ) return SQLITE_NOMEM; + pOp->iTab = pCur->iTree; + pOp->nKey = pZ->nKey; + pOp->pKey = pZ->pKey; + pOp->nData = pZ->nData; + pOp->pData = pZ->pData; + pOp->eOp = ROLLBACK_INSERT; + btreeLogRollbackOp(pCur->pRbtree, pOp); + } + + /* First do a standard binary-tree delete (node pZ is to be deleted). How + * to do this depends on how many children pZ has: + * + * If pZ has no children or one child, then splice out pZ. If pZ has two + * children, splice out the successor of pZ and replace the key and data of + * pZ with the key and data of the spliced out successor. */ + if( pZ->pLeft && pZ->pRight ){ + BtRbNode *pTmp; + int dummy; + pCur->eSkip = SKIP_NONE; + memRbtreeNext(pCur, &dummy); + assert( dummy == 0 ); + if( pCur->pRbtree->eTransState == TRANS_ROLLBACK ){ + sqliteFree(pZ->pKey); + sqliteFree(pZ->pData); + } + pZ->pData = pCur->pNode->pData; + pZ->nData = pCur->pNode->nData; + pZ->pKey = pCur->pNode->pKey; + pZ->nKey = pCur->pNode->nKey; + pTmp = pZ; + pZ = pCur->pNode; + pCur->pNode = pTmp; + pCur->eSkip = SKIP_NEXT; + }else{ + int res; + pCur->eSkip = SKIP_NONE; + memRbtreeNext(pCur, &res); + pCur->eSkip = SKIP_NEXT; + if( res ){ + memRbtreeLast(pCur, &res); + memRbtreePrevious(pCur, &res); + pCur->eSkip = SKIP_PREV; + } + if( pCur->pRbtree->eTransState == TRANS_ROLLBACK ){ + sqliteFree(pZ->pKey); + sqliteFree(pZ->pData); + } + } + + /* pZ now points at the node to be spliced out. This block does the + * splicing. */ + { + BtRbNode **ppParentSlot = 0; + assert( !pZ->pLeft || !pZ->pRight ); /* pZ has at most one child */ + pChild = ((pZ->pLeft)?pZ->pLeft:pZ->pRight); + if( pZ->pParent ){ + assert( pZ == pZ->pParent->pLeft || pZ == pZ->pParent->pRight ); + ppParentSlot = ((pZ == pZ->pParent->pLeft) + ?&pZ->pParent->pLeft:&pZ->pParent->pRight); + *ppParentSlot = pChild; + }else{ + pCur->pTree->pHead = pChild; + } + if( pChild ) pChild->pParent = pZ->pParent; + } + + /* pZ now points at the spliced out node. pChild is the only child of pZ, or + * NULL if pZ has no children. If pZ is black, and not the tree root, then we + * will have violated the "same number of black nodes in every path to a + * leaf" property of the red-black tree. The code in do_delete_balancing() + * repairs this. */ + if( pZ->isBlack ){ + do_delete_balancing(pCur->pTree, pChild, pZ->pParent); + } + + sqliteFree(pZ); + return SQLITE_OK; +} + +/* + * Empty table n of the Rbtree. + */ +static int memRbtreeClearTable(Rbtree* tree, int n) +{ + BtRbTree *pTree; + BtRbNode *pNode; + + pTree = sqliteHashFind(&tree->tblHash, 0, n); + assert(pTree); + + pNode = pTree->pHead; + while( pNode ){ + if( pNode->pLeft ){ + pNode = pNode->pLeft; + } + else if( pNode->pRight ){ + pNode = pNode->pRight; + } + else { + BtRbNode *pTmp = pNode->pParent; + if( tree->eTransState == TRANS_ROLLBACK ){ + sqliteFree( pNode->pKey ); + sqliteFree( pNode->pData ); + }else{ + BtRollbackOp *pRollbackOp = sqliteMallocRaw(sizeof(BtRollbackOp)); + if( pRollbackOp==0 ) return SQLITE_NOMEM; + pRollbackOp->eOp = ROLLBACK_INSERT; + pRollbackOp->iTab = n; + pRollbackOp->nKey = pNode->nKey; + pRollbackOp->pKey = pNode->pKey; + pRollbackOp->nData = pNode->nData; + pRollbackOp->pData = pNode->pData; + btreeLogRollbackOp(tree, pRollbackOp); + } + sqliteFree( pNode ); + if( pTmp ){ + if( pTmp->pLeft == pNode ) pTmp->pLeft = 0; + else if( pTmp->pRight == pNode ) pTmp->pRight = 0; + } + pNode = pTmp; + } + } + + pTree->pHead = 0; + return SQLITE_OK; +} + +static int memRbtreeFirst(RbtCursor* pCur, int *pRes) +{ + if( pCur->pTree->pHead ){ + pCur->pNode = pCur->pTree->pHead; + while( pCur->pNode->pLeft ){ + pCur->pNode = pCur->pNode->pLeft; + } + } + if( pCur->pNode ){ + *pRes = 0; + }else{ + *pRes = 1; + } + pCur->eSkip = SKIP_NONE; + return SQLITE_OK; +} + +static int memRbtreeLast(RbtCursor* pCur, int *pRes) +{ + if( pCur->pTree->pHead ){ + pCur->pNode = pCur->pTree->pHead; + while( pCur->pNode->pRight ){ + pCur->pNode = pCur->pNode->pRight; + } + } + if( pCur->pNode ){ + *pRes = 0; + }else{ + *pRes = 1; + } + pCur->eSkip = SKIP_NONE; + return SQLITE_OK; +} + +/* +** Advance the cursor to the next entry in the database. If +** successful then set *pRes=0. If the cursor +** was already pointing to the last entry in the database before +** this routine was called, then set *pRes=1. +*/ +static int memRbtreeNext(RbtCursor* pCur, int *pRes) +{ + if( pCur->pNode && pCur->eSkip != SKIP_NEXT ){ + if( pCur->pNode->pRight ){ + pCur->pNode = pCur->pNode->pRight; + while( pCur->pNode->pLeft ) + pCur->pNode = pCur->pNode->pLeft; + }else{ + BtRbNode * pX = pCur->pNode; + pCur->pNode = pX->pParent; + while( pCur->pNode && (pCur->pNode->pRight == pX) ){ + pX = pCur->pNode; + pCur->pNode = pX->pParent; + } + } + } + pCur->eSkip = SKIP_NONE; + + if( !pCur->pNode ){ + *pRes = 1; + }else{ + *pRes = 0; + } + + return SQLITE_OK; +} + +static int memRbtreePrevious(RbtCursor* pCur, int *pRes) +{ + if( pCur->pNode && pCur->eSkip != SKIP_PREV ){ + if( pCur->pNode->pLeft ){ + pCur->pNode = pCur->pNode->pLeft; + while( pCur->pNode->pRight ) + pCur->pNode = pCur->pNode->pRight; + }else{ + BtRbNode * pX = pCur->pNode; + pCur->pNode = pX->pParent; + while( pCur->pNode && (pCur->pNode->pLeft == pX) ){ + pX = pCur->pNode; + pCur->pNode = pX->pParent; + } + } + } + pCur->eSkip = SKIP_NONE; + + if( !pCur->pNode ){ + *pRes = 1; + }else{ + *pRes = 0; + } + + return SQLITE_OK; +} + +static int memRbtreeKeySize(RbtCursor* pCur, int *pSize) +{ + if( pCur->pNode ){ + *pSize = pCur->pNode->nKey; + }else{ + *pSize = 0; + } + return SQLITE_OK; +} + +static int memRbtreeKey(RbtCursor* pCur, int offset, int amt, char *zBuf) +{ + if( !pCur->pNode ) return 0; + if( !pCur->pNode->pKey || ((amt + offset) <= pCur->pNode->nKey) ){ + memcpy(zBuf, ((char*)pCur->pNode->pKey)+offset, amt); + }else{ + memcpy(zBuf, ((char*)pCur->pNode->pKey)+offset, pCur->pNode->nKey-offset); + amt = pCur->pNode->nKey-offset; + } + return amt; +} + +static int memRbtreeDataSize(RbtCursor* pCur, int *pSize) +{ + if( pCur->pNode ){ + *pSize = pCur->pNode->nData; + }else{ + *pSize = 0; + } + return SQLITE_OK; +} + +static int memRbtreeData(RbtCursor *pCur, int offset, int amt, char *zBuf) +{ + if( !pCur->pNode ) return 0; + if( (amt + offset) <= pCur->pNode->nData ){ + memcpy(zBuf, ((char*)pCur->pNode->pData)+offset, amt); + }else{ + memcpy(zBuf, ((char*)pCur->pNode->pData)+offset ,pCur->pNode->nData-offset); + amt = pCur->pNode->nData-offset; + } + return amt; +} + +static int memRbtreeCloseCursor(RbtCursor* pCur) +{ + if( pCur->pTree->pCursors==pCur ){ + pCur->pTree->pCursors = pCur->pShared; + }else{ + RbtCursor *p = pCur->pTree->pCursors; + while( p && p->pShared!=pCur ){ p = p->pShared; } + assert( p!=0 ); + if( p ){ + p->pShared = pCur->pShared; + } + } + sqliteFree(pCur); + return SQLITE_OK; +} + +static int memRbtreeGetMeta(Rbtree* tree, int* aMeta) +{ + memcpy( aMeta, tree->aMetaData, sizeof(int) * SQLITE_N_BTREE_META ); + return SQLITE_OK; +} + +static int memRbtreeUpdateMeta(Rbtree* tree, int* aMeta) +{ + memcpy( tree->aMetaData, aMeta, sizeof(int) * SQLITE_N_BTREE_META ); + return SQLITE_OK; +} + +/* + * Check that each table in the Rbtree meets the requirements for a red-black + * binary tree. If an error is found, return an explanation of the problem in + * memory obtained from sqliteMalloc(). Parameters aRoot and nRoot are ignored. + */ +static char *memRbtreeIntegrityCheck(Rbtree* tree, int* aRoot, int nRoot) +{ + char * msg = 0; + HashElem *p; + + for(p=sqliteHashFirst(&tree->tblHash); p; p=sqliteHashNext(p)){ + BtRbTree *pTree = sqliteHashData(p); + check_redblack_tree(pTree, &msg); + } + + return msg; +} + +static int memRbtreeSetCacheSize(Rbtree* tree, int sz) +{ + return SQLITE_OK; +} + +static int memRbtreeSetSafetyLevel(Rbtree *pBt, int level){ + return SQLITE_OK; +} + +static int memRbtreeBeginTrans(Rbtree* tree) +{ + if( tree->eTransState != TRANS_NONE ) + return SQLITE_ERROR; + + assert( tree->pTransRollback == 0 ); + tree->eTransState = TRANS_INTRANSACTION; + return SQLITE_OK; +} + +/* +** Delete a linked list of BtRollbackOp structures. +*/ +static void deleteRollbackList(BtRollbackOp *pOp){ + while( pOp ){ + BtRollbackOp *pTmp = pOp->pNext; + sqliteFree(pOp->pData); + sqliteFree(pOp->pKey); + sqliteFree(pOp); + pOp = pTmp; + } +} + +static int memRbtreeCommit(Rbtree* tree){ + /* Just delete pTransRollback and pCheckRollback */ + deleteRollbackList(tree->pCheckRollback); + deleteRollbackList(tree->pTransRollback); + tree->pTransRollback = 0; + tree->pCheckRollback = 0; + tree->pCheckRollbackTail = 0; + tree->eTransState = TRANS_NONE; + return SQLITE_OK; +} + +/* + * Close the supplied Rbtree. Delete everything associated with it. + */ +static int memRbtreeClose(Rbtree* tree) +{ + HashElem *p; + memRbtreeCommit(tree); + while( (p=sqliteHashFirst(&tree->tblHash))!=0 ){ + tree->eTransState = TRANS_ROLLBACK; + memRbtreeDropTable(tree, sqliteHashKeysize(p)); + } + sqliteHashClear(&tree->tblHash); + sqliteFree(tree); + return SQLITE_OK; +} + +/* + * Execute and delete the supplied rollback-list on pRbtree. + */ +static void execute_rollback_list(Rbtree *pRbtree, BtRollbackOp *pList) +{ + BtRollbackOp *pTmp; + RbtCursor cur; + int res; + + cur.pRbtree = pRbtree; + cur.wrFlag = 1; + while( pList ){ + switch( pList->eOp ){ + case ROLLBACK_INSERT: + cur.pTree = sqliteHashFind( &pRbtree->tblHash, 0, pList->iTab ); + assert(cur.pTree); + cur.iTree = pList->iTab; + cur.eSkip = SKIP_NONE; + memRbtreeInsert( &cur, pList->pKey, + pList->nKey, pList->pData, pList->nData ); + break; + case ROLLBACK_DELETE: + cur.pTree = sqliteHashFind( &pRbtree->tblHash, 0, pList->iTab ); + assert(cur.pTree); + cur.iTree = pList->iTab; + cur.eSkip = SKIP_NONE; + memRbtreeMoveto(&cur, pList->pKey, pList->nKey, &res); + assert(res == 0); + memRbtreeDelete( &cur ); + break; + case ROLLBACK_CREATE: + btreeCreateTable(pRbtree, pList->iTab); + break; + case ROLLBACK_DROP: + memRbtreeDropTable(pRbtree, pList->iTab); + break; + default: + assert(0); + } + sqliteFree(pList->pKey); + sqliteFree(pList->pData); + pTmp = pList->pNext; + sqliteFree(pList); + pList = pTmp; + } +} + +static int memRbtreeRollback(Rbtree* tree) +{ + tree->eTransState = TRANS_ROLLBACK; + execute_rollback_list(tree, tree->pCheckRollback); + execute_rollback_list(tree, tree->pTransRollback); + tree->pTransRollback = 0; + tree->pCheckRollback = 0; + tree->pCheckRollbackTail = 0; + tree->eTransState = TRANS_NONE; + return SQLITE_OK; +} + +static int memRbtreeBeginCkpt(Rbtree* tree) +{ + if( tree->eTransState != TRANS_INTRANSACTION ) + return SQLITE_ERROR; + + assert( tree->pCheckRollback == 0 ); + assert( tree->pCheckRollbackTail == 0 ); + tree->eTransState = TRANS_INCHECKPOINT; + return SQLITE_OK; +} + +static int memRbtreeCommitCkpt(Rbtree* tree) +{ + if( tree->eTransState == TRANS_INCHECKPOINT ){ + if( tree->pCheckRollback ){ + tree->pCheckRollbackTail->pNext = tree->pTransRollback; + tree->pTransRollback = tree->pCheckRollback; + tree->pCheckRollback = 0; + tree->pCheckRollbackTail = 0; + } + tree->eTransState = TRANS_INTRANSACTION; + } + return SQLITE_OK; +} + +static int memRbtreeRollbackCkpt(Rbtree* tree) +{ + if( tree->eTransState != TRANS_INCHECKPOINT ) return SQLITE_OK; + tree->eTransState = TRANS_ROLLBACK; + execute_rollback_list(tree, tree->pCheckRollback); + tree->pCheckRollback = 0; + tree->pCheckRollbackTail = 0; + tree->eTransState = TRANS_INTRANSACTION; + return SQLITE_OK; +} + +#ifdef SQLITE_TEST +static int memRbtreePageDump(Rbtree* tree, int pgno, int rec) +{ + assert(!"Cannot call sqliteRbtreePageDump"); + return SQLITE_OK; +} + +static int memRbtreeCursorDump(RbtCursor* pCur, int* aRes) +{ + assert(!"Cannot call sqliteRbtreeCursorDump"); + return SQLITE_OK; +} +#endif + +static struct Pager *memRbtreePager(Rbtree* tree) +{ + return 0; +} + +/* +** Return the full pathname of the underlying database file. +*/ +static const char *memRbtreeGetFilename(Rbtree *pBt){ + return 0; /* A NULL return indicates there is no underlying file */ +} + +/* +** The copy file function is not implemented for the in-memory database +*/ +static int memRbtreeCopyFile(Rbtree *pBt, Rbtree *pBt2){ + return SQLITE_INTERNAL; /* Not implemented */ +} + +static BtOps sqliteRbtreeOps = { + (int(*)(Btree*)) memRbtreeClose, + (int(*)(Btree*,int)) memRbtreeSetCacheSize, + (int(*)(Btree*,int)) memRbtreeSetSafetyLevel, + (int(*)(Btree*)) memRbtreeBeginTrans, + (int(*)(Btree*)) memRbtreeCommit, + (int(*)(Btree*)) memRbtreeRollback, + (int(*)(Btree*)) memRbtreeBeginCkpt, + (int(*)(Btree*)) memRbtreeCommitCkpt, + (int(*)(Btree*)) memRbtreeRollbackCkpt, + (int(*)(Btree*,int*)) memRbtreeCreateTable, + (int(*)(Btree*,int*)) memRbtreeCreateTable, + (int(*)(Btree*,int)) memRbtreeDropTable, + (int(*)(Btree*,int)) memRbtreeClearTable, + (int(*)(Btree*,int,int,BtCursor**)) memRbtreeCursor, + (int(*)(Btree*,int*)) memRbtreeGetMeta, + (int(*)(Btree*,int*)) memRbtreeUpdateMeta, + (char*(*)(Btree*,int*,int)) memRbtreeIntegrityCheck, + (const char*(*)(Btree*)) memRbtreeGetFilename, + (int(*)(Btree*,Btree*)) memRbtreeCopyFile, + (struct Pager*(*)(Btree*)) memRbtreePager, +#ifdef SQLITE_TEST + (int(*)(Btree*,int,int)) memRbtreePageDump, +#endif +}; + +static BtCursorOps sqliteRbtreeCursorOps = { + (int(*)(BtCursor*,const void*,int,int*)) memRbtreeMoveto, + (int(*)(BtCursor*)) memRbtreeDelete, + (int(*)(BtCursor*,const void*,int,const void*,int)) memRbtreeInsert, + (int(*)(BtCursor*,int*)) memRbtreeFirst, + (int(*)(BtCursor*,int*)) memRbtreeLast, + (int(*)(BtCursor*,int*)) memRbtreeNext, + (int(*)(BtCursor*,int*)) memRbtreePrevious, + (int(*)(BtCursor*,int*)) memRbtreeKeySize, + (int(*)(BtCursor*,int,int,char*)) memRbtreeKey, + (int(*)(BtCursor*,const void*,int,int,int*)) memRbtreeKeyCompare, + (int(*)(BtCursor*,int*)) memRbtreeDataSize, + (int(*)(BtCursor*,int,int,char*)) memRbtreeData, + (int(*)(BtCursor*)) memRbtreeCloseCursor, +#ifdef SQLITE_TEST + (int(*)(BtCursor*,int*)) memRbtreeCursorDump, +#endif + +}; + +#endif /* SQLITE_OMIT_INMEMORYDB */ diff --git a/kexi/3rdparty/kexisql/src/build.c b/kexi/3rdparty/kexisql/src/build.c new file mode 100644 index 00000000..1dece406 --- /dev/null +++ b/kexi/3rdparty/kexisql/src/build.c @@ -0,0 +1,2156 @@ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains C code routines that are called by the SQLite parser +** when syntax rules are reduced. The routines in this file handle the +** following kinds of SQL syntax: +** +** CREATE TABLE +** DROP TABLE +** CREATE INDEX +** DROP INDEX +** creating ID lists +** BEGIN TRANSACTION +** COMMIT +** ROLLBACK +** PRAGMA +** +** $Id: build.c 410099 2005-05-06 17:52:07Z staniek $ +*/ +#include "sqliteInt.h" +#include <ctype.h> + +/* +** This routine is called when a new SQL statement is beginning to +** be parsed. Check to see if the schema for the database needs +** to be read from the SQLITE_MASTER and SQLITE_TEMP_MASTER tables. +** If it does, then read it. +*/ +void sqliteBeginParse(Parse *pParse, int explainFlag){ + sqlite *db = pParse->db; + int i; + pParse->explain = explainFlag; + if((db->flags & SQLITE_Initialized)==0 && db->init.busy==0 ){ + int rc = sqliteInit(db, &pParse->zErrMsg); + if( rc!=SQLITE_OK ){ + pParse->rc = rc; + pParse->nErr++; + } + } + for(i=0; i<db->nDb; i++){ + DbClearProperty(db, i, DB_Locked); + if( !db->aDb[i].inTrans ){ + DbClearProperty(db, i, DB_Cookie); + } + } + pParse->nVar = 0; +} + +/* +** This routine is called after a single SQL statement has been +** parsed and we want to execute the VDBE code to implement +** that statement. Prior action routines should have already +** constructed VDBE code to do the work of the SQL statement. +** This routine just has to execute the VDBE code. +** +** Note that if an error occurred, it might be the case that +** no VDBE code was generated. +*/ +void sqliteExec(Parse *pParse){ + sqlite *db = pParse->db; + Vdbe *v = pParse->pVdbe; + + if( v==0 && (v = sqliteGetVdbe(pParse))!=0 ){ + sqliteVdbeAddOp(v, OP_Halt, 0, 0); + } + if( sqlite_malloc_failed ) return; + if( v && pParse->nErr==0 ){ + FILE *trace = (db->flags & SQLITE_VdbeTrace)!=0 ? stdout : 0; + sqliteVdbeTrace(v, trace); + sqliteVdbeMakeReady(v, pParse->nVar, pParse->explain); + pParse->rc = pParse->nErr ? SQLITE_ERROR : SQLITE_DONE; + pParse->colNamesSet = 0; + }else if( pParse->rc==SQLITE_OK ){ + pParse->rc = SQLITE_ERROR; + } + pParse->nTab = 0; + pParse->nMem = 0; + pParse->nSet = 0; + pParse->nAgg = 0; + pParse->nVar = 0; +} + +/* +** Locate the in-memory structure that describes +** a particular database table given the name +** of that table and (optionally) the name of the database +** containing the table. Return NULL if not found. +** +** If zDatabase is 0, all databases are searched for the +** table and the first matching table is returned. (No checking +** for duplicate table names is done.) The search order is +** TEMP first, then MAIN, then any auxiliary databases added +** using the ATTACH command. +** +** See also sqliteLocateTable(). +*/ +Table *sqliteFindTable(sqlite *db, const char *zName, const char *zDatabase){ + Table *p = 0; + int i; + for(i=0; i<db->nDb; i++){ + int j = (i<2) ? i^1 : i; /* Search TEMP before MAIN */ + if( zDatabase!=0 && sqliteStrICmp(zDatabase, db->aDb[j].zName) ) continue; + p = sqliteHashFind(&db->aDb[j].tblHash, zName, strlen(zName)+1); + if( p ) break; + } + return p; +} + +/* +** Locate the in-memory structure that describes +** a particular database table given the name +** of that table and (optionally) the name of the database +** containing the table. Return NULL if not found. +** Also leave an error message in pParse->zErrMsg. +** +** The difference between this routine and sqliteFindTable() +** is that this routine leaves an error message in pParse->zErrMsg +** where sqliteFindTable() does not. +*/ +Table *sqliteLocateTable(Parse *pParse, const char *zName, const char *zDbase){ + Table *p; + + p = sqliteFindTable(pParse->db, zName, zDbase); + if( p==0 ){ + if( zDbase ){ + sqliteErrorMsg(pParse, "no such table: %s.%s", zDbase, zName); + }else if( sqliteFindTable(pParse->db, zName, 0)!=0 ){ + sqliteErrorMsg(pParse, "table \"%s\" is not in database \"%s\"", + zName, zDbase); + }else{ + sqliteErrorMsg(pParse, "no such table: %s", zName); + } + } + return p; +} + +/* +** Locate the in-memory structure that describes +** a particular index given the name of that index +** and the name of the database that contains the index. +** Return NULL if not found. +** +** If zDatabase is 0, all databases are searched for the +** table and the first matching index is returned. (No checking +** for duplicate index names is done.) The search order is +** TEMP first, then MAIN, then any auxiliary databases added +** using the ATTACH command. +*/ +Index *sqliteFindIndex(sqlite *db, const char *zName, const char *zDb){ + Index *p = 0; + int i; + for(i=0; i<db->nDb; i++){ + int j = (i<2) ? i^1 : i; /* Search TEMP before MAIN */ + if( zDb && sqliteStrICmp(zDb, db->aDb[j].zName) ) continue; + p = sqliteHashFind(&db->aDb[j].idxHash, zName, strlen(zName)+1); + if( p ) break; + } + return p; +} + +/* +** Remove the given index from the index hash table, and free +** its memory structures. +** +** The index is removed from the database hash tables but +** it is not unlinked from the Table that it indexes. +** Unlinking from the Table must be done by the calling function. +*/ +static void sqliteDeleteIndex(sqlite *db, Index *p){ + Index *pOld; + + assert( db!=0 && p->zName!=0 ); + pOld = sqliteHashInsert(&db->aDb[p->iDb].idxHash, p->zName, + strlen(p->zName)+1, 0); + if( pOld!=0 && pOld!=p ){ + sqliteHashInsert(&db->aDb[p->iDb].idxHash, pOld->zName, + strlen(pOld->zName)+1, pOld); + } + sqliteFree(p); +} + +/* +** Unlink the given index from its table, then remove +** the index from the index hash table and free its memory +** structures. +*/ +void sqliteUnlinkAndDeleteIndex(sqlite *db, Index *pIndex){ + if( pIndex->pTable->pIndex==pIndex ){ + pIndex->pTable->pIndex = pIndex->pNext; + }else{ + Index *p; + for(p=pIndex->pTable->pIndex; p && p->pNext!=pIndex; p=p->pNext){} + if( p && p->pNext==pIndex ){ + p->pNext = pIndex->pNext; + } + } + sqliteDeleteIndex(db, pIndex); +} + +/* +** Erase all schema information from the in-memory hash tables of +** database connection. This routine is called to reclaim memory +** before the connection closes. It is also called during a rollback +** if there were schema changes during the transaction. +** +** If iDb<=0 then reset the internal schema tables for all database +** files. If iDb>=2 then reset the internal schema for only the +** single file indicated. +*/ +void sqliteResetInternalSchema(sqlite *db, int iDb){ + HashElem *pElem; + Hash temp1; + Hash temp2; + int i, j; + + assert( iDb>=0 && iDb<db->nDb ); + db->flags &= ~SQLITE_Initialized; + for(i=iDb; i<db->nDb; i++){ + Db *pDb = &db->aDb[i]; + temp1 = pDb->tblHash; + temp2 = pDb->trigHash; + sqliteHashInit(&pDb->trigHash, SQLITE_HASH_STRING, 0); + sqliteHashClear(&pDb->aFKey); + sqliteHashClear(&pDb->idxHash); + for(pElem=sqliteHashFirst(&temp2); pElem; pElem=sqliteHashNext(pElem)){ + Trigger *pTrigger = sqliteHashData(pElem); + sqliteDeleteTrigger(pTrigger); + } + sqliteHashClear(&temp2); + sqliteHashInit(&pDb->tblHash, SQLITE_HASH_STRING, 0); + for(pElem=sqliteHashFirst(&temp1); pElem; pElem=sqliteHashNext(pElem)){ + Table *pTab = sqliteHashData(pElem); + sqliteDeleteTable(db, pTab); + } + sqliteHashClear(&temp1); + DbClearProperty(db, i, DB_SchemaLoaded); + if( iDb>0 ) return; + } + assert( iDb==0 ); + db->flags &= ~SQLITE_InternChanges; + + /* If one or more of the auxiliary database files has been closed, + ** then remove then from the auxiliary database list. We take the + ** opportunity to do this here since we have just deleted all of the + ** schema hash tables and therefore do not have to make any changes + ** to any of those tables. + */ + for(i=0; i<db->nDb; i++){ + struct Db *pDb = &db->aDb[i]; + if( pDb->pBt==0 ){ + if( pDb->pAux && pDb->xFreeAux ) pDb->xFreeAux(pDb->pAux); + pDb->pAux = 0; + } + } + for(i=j=2; i<db->nDb; i++){ + struct Db *pDb = &db->aDb[i]; + if( pDb->pBt==0 ){ + sqliteFree(pDb->zName); + pDb->zName = 0; + continue; + } + if( j<i ){ + db->aDb[j] = db->aDb[i]; + } + j++; + } + memset(&db->aDb[j], 0, (db->nDb-j)*sizeof(db->aDb[j])); + db->nDb = j; + if( db->nDb<=2 && db->aDb!=db->aDbStatic ){ + memcpy(db->aDbStatic, db->aDb, 2*sizeof(db->aDb[0])); + sqliteFree(db->aDb); + db->aDb = db->aDbStatic; + } +} + +/* +** This routine is called whenever a rollback occurs. If there were +** schema changes during the transaction, then we have to reset the +** internal hash tables and reload them from disk. +*/ +void sqliteRollbackInternalChanges(sqlite *db){ + if( db->flags & SQLITE_InternChanges ){ + sqliteResetInternalSchema(db, 0); + } +} + +/* +** This routine is called when a commit occurs. +*/ +void sqliteCommitInternalChanges(sqlite *db){ + db->aDb[0].schema_cookie = db->next_cookie; + db->flags &= ~SQLITE_InternChanges; +} + +/* +** Remove the memory data structures associated with the given +** Table. No changes are made to disk by this routine. +** +** This routine just deletes the data structure. It does not unlink +** the table data structure from the hash table. Nor does it remove +** foreign keys from the sqlite.aFKey hash table. But it does destroy +** memory structures of the indices and foreign keys associated with +** the table. +** +** Indices associated with the table are unlinked from the "db" +** data structure if db!=NULL. If db==NULL, indices attached to +** the table are deleted, but it is assumed they have already been +** unlinked. +*/ +void sqliteDeleteTable(sqlite *db, Table *pTable){ + int i; + Index *pIndex, *pNext; + FKey *pFKey, *pNextFKey; + + if( pTable==0 ) return; + + /* Delete all indices associated with this table + */ + for(pIndex = pTable->pIndex; pIndex; pIndex=pNext){ + pNext = pIndex->pNext; + assert( pIndex->iDb==pTable->iDb || (pTable->iDb==0 && pIndex->iDb==1) ); + sqliteDeleteIndex(db, pIndex); + } + + /* Delete all foreign keys associated with this table. The keys + ** should have already been unlinked from the db->aFKey hash table + */ + for(pFKey=pTable->pFKey; pFKey; pFKey=pNextFKey){ + pNextFKey = pFKey->pNextFrom; + assert( pTable->iDb<db->nDb ); + assert( sqliteHashFind(&db->aDb[pTable->iDb].aFKey, + pFKey->zTo, strlen(pFKey->zTo)+1)!=pFKey ); + sqliteFree(pFKey); + } + + /* Delete the Table structure itself. + */ + for(i=0; i<pTable->nCol; i++){ + sqliteFree(pTable->aCol[i].zName); + sqliteFree(pTable->aCol[i].zDflt); + sqliteFree(pTable->aCol[i].zType); + } + sqliteFree(pTable->zName); + sqliteFree(pTable->aCol); + sqliteSelectDelete(pTable->pSelect); + sqliteFree(pTable); +} + +/* +** Unlink the given table from the hash tables and the delete the +** table structure with all its indices and foreign keys. +*/ +static void sqliteUnlinkAndDeleteTable(sqlite *db, Table *p){ + Table *pOld; + FKey *pF1, *pF2; + int i = p->iDb; + assert( db!=0 ); + pOld = sqliteHashInsert(&db->aDb[i].tblHash, p->zName, strlen(p->zName)+1, 0); + assert( pOld==0 || pOld==p ); + for(pF1=p->pFKey; pF1; pF1=pF1->pNextFrom){ + int nTo = strlen(pF1->zTo) + 1; + pF2 = sqliteHashFind(&db->aDb[i].aFKey, pF1->zTo, nTo); + if( pF2==pF1 ){ + sqliteHashInsert(&db->aDb[i].aFKey, pF1->zTo, nTo, pF1->pNextTo); + }else{ + while( pF2 && pF2->pNextTo!=pF1 ){ pF2=pF2->pNextTo; } + if( pF2 ){ + pF2->pNextTo = pF1->pNextTo; + } + } + } + sqliteDeleteTable(db, p); +} + +/* +** Construct the name of a user table or index from a token. +** +** Space to hold the name is obtained from sqliteMalloc() and must +** be freed by the calling function. +*/ +char *sqliteTableNameFromToken(Token *pName){ + char *zName = sqliteStrNDup(pName->z, pName->n); + sqliteDequote(zName); + return zName; +} + +/* +** Generate code to open the appropriate master table. The table +** opened will be SQLITE_MASTER for persistent tables and +** SQLITE_TEMP_MASTER for temporary tables. The table is opened +** on cursor 0. +*/ +void sqliteOpenMasterTable(Vdbe *v, int isTemp){ + sqliteVdbeAddOp(v, OP_Integer, isTemp, 0); + sqliteVdbeAddOp(v, OP_OpenWrite, 0, 2); +} + +/* +** Begin constructing a new table representation in memory. This is +** the first of several action routines that get called in response +** to a CREATE TABLE statement. In particular, this routine is called +** after seeing tokens "CREATE" and "TABLE" and the table name. The +** pStart token is the CREATE and pName is the table name. The isTemp +** flag is true if the table should be stored in the auxiliary database +** file instead of in the main database file. This is normally the case +** when the "TEMP" or "TEMPORARY" keyword occurs in between +** CREATE and TABLE. +** +** The new table record is initialized and put in pParse->pNewTable. +** As more of the CREATE TABLE statement is parsed, additional action +** routines will be called to add more information to this record. +** At the end of the CREATE TABLE statement, the sqliteEndTable() routine +** is called to complete the construction of the new table record. +*/ +void sqliteStartTable( + Parse *pParse, /* Parser context */ + Token *pStart, /* The "CREATE" token */ + Token *pName, /* Name of table or view to create */ + int isTemp, /* True if this is a TEMP table */ + int isView /* True if this is a VIEW */ +){ + Table *pTable; + Index *pIdx; + char *zName; + sqlite *db = pParse->db; + Vdbe *v; + int iDb; + + pParse->sFirstToken = *pStart; + zName = sqliteTableNameFromToken(pName); + if( zName==0 ) return; + if( db->init.iDb==1 ) isTemp = 1; +#ifndef SQLITE_OMIT_AUTHORIZATION + assert( (isTemp & 1)==isTemp ); + { + int code; + char *zDb = isTemp ? "temp" : "main"; + if( sqliteAuthCheck(pParse, SQLITE_INSERT, SCHEMA_TABLE(isTemp), 0, zDb) ){ + sqliteFree(zName); + return; + } + if( isView ){ + if( isTemp ){ + code = SQLITE_CREATE_TEMP_VIEW; + }else{ + code = SQLITE_CREATE_VIEW; + } + }else{ + if( isTemp ){ + code = SQLITE_CREATE_TEMP_TABLE; + }else{ + code = SQLITE_CREATE_TABLE; + } + } + if( sqliteAuthCheck(pParse, code, zName, 0, zDb) ){ + sqliteFree(zName); + return; + } + } +#endif + + + /* Before trying to create a temporary table, make sure the Btree for + ** holding temporary tables is open. + */ + if( isTemp && db->aDb[1].pBt==0 && !pParse->explain ){ + int rc = sqliteBtreeFactory(db, 0, 0, MAX_PAGES, &db->aDb[1].pBt); + if( rc!=SQLITE_OK ){ + sqliteErrorMsg(pParse, "unable to open a temporary database " + "file for storing temporary tables"); + pParse->nErr++; + return; + } + if( db->flags & SQLITE_InTrans ){ + rc = sqliteBtreeBeginTrans(db->aDb[1].pBt); + if( rc!=SQLITE_OK ){ + sqliteErrorMsg(pParse, "unable to get a write lock on " + "the temporary database file"); + return; + } + } + } + + /* Make sure the new table name does not collide with an existing + ** index or table name. Issue an error message if it does. + ** + ** If we are re-reading the sqlite_master table because of a schema + ** change and a new permanent table is found whose name collides with + ** an existing temporary table, that is not an error. + */ + pTable = sqliteFindTable(db, zName, 0); + iDb = isTemp ? 1 : db->init.iDb; + if( pTable!=0 && (pTable->iDb==iDb || !db->init.busy) ){ + sqliteErrorMsg(pParse, "table %T already exists", pName); + sqliteFree(zName); + return; + } + if( (pIdx = sqliteFindIndex(db, zName, 0))!=0 && + (pIdx->iDb==0 || !db->init.busy) ){ + sqliteErrorMsg(pParse, "there is already an index named %s", zName); + sqliteFree(zName); + return; + } + pTable = sqliteMalloc( sizeof(Table) ); + if( pTable==0 ){ + sqliteFree(zName); + return; + } + pTable->zName = zName; + pTable->nCol = 0; + pTable->aCol = 0; + pTable->iPKey = -1; + pTable->pIndex = 0; + pTable->iDb = iDb; + if( pParse->pNewTable ) sqliteDeleteTable(db, pParse->pNewTable); + pParse->pNewTable = pTable; + + /* Begin generating the code that will insert the table record into + ** the SQLITE_MASTER table. Note in particular that we must go ahead + ** and allocate the record number for the table entry now. Before any + ** PRIMARY KEY or UNIQUE keywords are parsed. Those keywords will cause + ** indices to be created and the table record must come before the + ** indices. Hence, the record number for the table must be allocated + ** now. + */ + if( !db->init.busy && (v = sqliteGetVdbe(pParse))!=0 ){ + sqliteBeginWriteOperation(pParse, 0, isTemp); + if( !isTemp ){ + sqliteVdbeAddOp(v, OP_Integer, db->file_format, 0); + sqliteVdbeAddOp(v, OP_SetCookie, 0, 1); + } + sqliteOpenMasterTable(v, isTemp); + sqliteVdbeAddOp(v, OP_NewRecno, 0, 0); + sqliteVdbeAddOp(v, OP_Dup, 0, 0); + sqliteVdbeAddOp(v, OP_String, 0, 0); + sqliteVdbeAddOp(v, OP_PutIntKey, 0, 0); + } +} + +/* +** Add a new column to the table currently being constructed. +** +** The parser calls this routine once for each column declaration +** in a CREATE TABLE statement. sqliteStartTable() gets called +** first to get things going. Then this routine is called for each +** column. +*/ +void sqliteAddColumn(Parse *pParse, Token *pName){ + Table *p; + int i; + char *z = 0; + Column *pCol; + if( (p = pParse->pNewTable)==0 ) return; + sqliteSetNString(&z, pName->z, pName->n, 0); + if( z==0 ) return; + sqliteDequote(z); + for(i=0; i<p->nCol; i++){ + if( sqliteStrICmp(z, p->aCol[i].zName)==0 ){ + sqliteErrorMsg(pParse, "duplicate column name: %s", z); + sqliteFree(z); + return; + } + } + if( (p->nCol & 0x7)==0 ){ + Column *aNew; + aNew = sqliteRealloc( p->aCol, (p->nCol+8)*sizeof(p->aCol[0])); + if( aNew==0 ) return; + p->aCol = aNew; + } + pCol = &p->aCol[p->nCol]; + memset(pCol, 0, sizeof(p->aCol[0])); + pCol->zName = z; + pCol->sortOrder = SQLITE_SO_NUM; + p->nCol++; +} + +/* +** This routine is called by the parser while in the middle of +** parsing a CREATE TABLE statement. A "NOT NULL" constraint has +** been seen on a column. This routine sets the notNull flag on +** the column currently under construction. +*/ +void sqliteAddNotNull(Parse *pParse, int onError){ + Table *p; + int i; + if( (p = pParse->pNewTable)==0 ) return; + i = p->nCol-1; + if( i>=0 ) p->aCol[i].notNull = onError; +} + +/* +** This routine is called by the parser while in the middle of +** parsing a CREATE TABLE statement. The pFirst token is the first +** token in the sequence of tokens that describe the type of the +** column currently under construction. pLast is the last token +** in the sequence. Use this information to construct a string +** that contains the typename of the column and store that string +** in zType. +*/ +void sqliteAddColumnType(Parse *pParse, Token *pFirst, Token *pLast){ + Table *p; + int i, j; + int n; + char *z, **pz; + Column *pCol; + if( (p = pParse->pNewTable)==0 ) return; + i = p->nCol-1; + if( i<0 ) return; + pCol = &p->aCol[i]; + pz = &pCol->zType; + n = pLast->n + Addr(pLast->z) - Addr(pFirst->z); + sqliteSetNString(pz, pFirst->z, n, 0); + z = *pz; + if( z==0 ) return; + for(i=j=0; z[i]; i++){ + int c = z[i]; + if( isspace(c) ) continue; + z[j++] = c; + } + z[j] = 0; + if( pParse->db->file_format>=4 ){ + pCol->sortOrder = sqliteCollateType(z, n); + }else{ + pCol->sortOrder = SQLITE_SO_NUM; + } +} + +/* +** The given token is the default value for the last column added to +** the table currently under construction. If "minusFlag" is true, it +** means the value token was preceded by a minus sign. +** +** This routine is called by the parser while in the middle of +** parsing a CREATE TABLE statement. +*/ +void sqliteAddDefaultValue(Parse *pParse, Token *pVal, int minusFlag){ + Table *p; + int i; + char **pz; + if( (p = pParse->pNewTable)==0 ) return; + i = p->nCol-1; + if( i<0 ) return; + pz = &p->aCol[i].zDflt; + if( minusFlag ){ + sqliteSetNString(pz, "-", 1, pVal->z, pVal->n, 0); + }else{ + sqliteSetNString(pz, pVal->z, pVal->n, 0); + } + sqliteDequote(*pz); +} + +/* +** Designate the PRIMARY KEY for the table. pList is a list of names +** of columns that form the primary key. If pList is NULL, then the +** most recently added column of the table is the primary key. +** +** A table can have at most one primary key. If the table already has +** a primary key (and this is the second primary key) then create an +** error. +** +** If the PRIMARY KEY is on a single column whose datatype is INTEGER, +** then we will try to use that column as the row id. (Exception: +** For backwards compatibility with older databases, do not do this +** if the file format version number is less than 1.) Set the Table.iPKey +** field of the table under construction to be the index of the +** INTEGER PRIMARY KEY column. Table.iPKey is set to -1 if there is +** no INTEGER PRIMARY KEY. +** +** If the key is not an INTEGER PRIMARY KEY, then create a unique +** index for the key. No index is created for INTEGER PRIMARY KEYs. +*/ +void sqliteAddPrimaryKey(Parse *pParse, IdList *pList, int onError){ + Table *pTab = pParse->pNewTable; + char *zType = 0; + int iCol = -1, i; + if( pTab==0 ) goto primary_key_exit; + if( pTab->hasPrimKey ){ + sqliteErrorMsg(pParse, + "table \"%s\" has more than one primary key", pTab->zName); + goto primary_key_exit; + } + pTab->hasPrimKey = 1; + if( pList==0 ){ + iCol = pTab->nCol - 1; + pTab->aCol[iCol].isPrimKey = 1; + }else{ + for(i=0; i<pList->nId; i++){ + for(iCol=0; iCol<pTab->nCol; iCol++){ + if( sqliteStrICmp(pList->a[i].zName, pTab->aCol[iCol].zName)==0 ) break; + } + if( iCol<pTab->nCol ) pTab->aCol[iCol].isPrimKey = 1; + } + if( pList->nId>1 ) iCol = -1; + } + if( iCol>=0 && iCol<pTab->nCol ){ + zType = pTab->aCol[iCol].zType; + } + if( pParse->db->file_format>=1 && + zType && sqliteStrICmp(zType, "INTEGER")==0 ){ + pTab->iPKey = iCol; + pTab->keyConf = onError; + }else{ + sqliteCreateIndex(pParse, 0, 0, pList, onError, 0, 0); + pList = 0; + } + +primary_key_exit: + sqliteIdListDelete(pList); + return; +} + +/* +** Return the appropriate collating type given a type name. +** +** The collation type is text (SQLITE_SO_TEXT) if the type +** name contains the character stream "text" or "blob" or +** "clob". Any other type name is collated as numeric +** (SQLITE_SO_NUM). +*/ +int sqliteCollateType(const char *zType, int nType){ + int i; + for(i=0; i<nType-3; i++){ + int c = *(zType++) | 0x60; + if( (c=='b' || c=='c') && sqliteStrNICmp(zType, "lob", 3)==0 ){ + return SQLITE_SO_TEXT; + } + if( c=='c' && sqliteStrNICmp(zType, "har", 3)==0 ){ + return SQLITE_SO_TEXT; + } + if( c=='t' && sqliteStrNICmp(zType, "ext", 3)==0 ){ + return SQLITE_SO_TEXT; + } + } + return SQLITE_SO_NUM; +} + +/* +** 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. +*/ +void sqliteAddCollateType(Parse *pParse, int collType){ + Table *p; + int i; + if( (p = pParse->pNewTable)==0 ) return; + i = p->nCol-1; + if( i>=0 ) p->aCol[i].sortOrder = collType; +} + +/* +** Come up with a new random value for the schema cookie. Make sure +** the new value is different from the old. +** +** The schema cookie is used to determine when the schema for the +** database changes. After each schema change, the cookie value +** changes. When a process first reads the schema it records the +** cookie. Thereafter, whenever it goes to access the database, +** it checks the cookie to make sure the schema has not changed +** since it was last read. +** +** This plan is not completely bullet-proof. It is possible for +** the schema to change multiple times and for the cookie to be +** set back to prior value. But schema changes are infrequent +** and the probability of hitting the same cookie value is only +** 1 chance in 2^32. So we're safe enough. +*/ +void sqliteChangeCookie(sqlite *db, Vdbe *v){ + if( db->next_cookie==db->aDb[0].schema_cookie ){ + unsigned char r; + sqliteRandomness(1, &r); + db->next_cookie = db->aDb[0].schema_cookie + r + 1; + db->flags |= SQLITE_InternChanges; + sqliteVdbeAddOp(v, OP_Integer, db->next_cookie, 0); + sqliteVdbeAddOp(v, OP_SetCookie, 0, 0); + } +} + +/* +** Measure the number of characters needed to output the given +** identifier. The number returned includes any quotes used +** but does not include the null terminator. +*/ +static int identLength(const char *z){ + int n; + int needQuote = 0; + for(n=0; *z; n++, z++){ + if( *z=='\'' ){ n++; needQuote=1; } + } + return n + needQuote*2; +} + +/* +** Write an identifier onto the end of the given string. Add +** quote characters as needed. +*/ +static void identPut(char *z, int *pIdx, char *zIdent){ + int i, j, needQuote; + i = *pIdx; + for(j=0; zIdent[j]; j++){ + if( !isalnum(zIdent[j]) && zIdent[j]!='_' ) break; + } + needQuote = zIdent[j]!=0 || isdigit(zIdent[0]) + || sqliteKeywordCode(zIdent, j)!=TK_ID; + if( needQuote ) z[i++] = '\''; + for(j=0; zIdent[j]; j++){ + z[i++] = zIdent[j]; + if( zIdent[j]=='\'' ) z[i++] = '\''; + } + if( needQuote ) z[i++] = '\''; + z[i] = 0; + *pIdx = i; +} + +/* +** Generate a CREATE TABLE statement appropriate for the given +** table. Memory to hold the text of the statement is obtained +** from sqliteMalloc() and must be freed by the calling function. +*/ +static char *createTableStmt(Table *p){ + int i, k, n; + char *zStmt; + char *zSep, *zSep2, *zEnd; + n = 0; + for(i=0; i<p->nCol; i++){ + n += identLength(p->aCol[i].zName); + } + n += identLength(p->zName); + if( n<40 ){ + zSep = ""; + zSep2 = ","; + zEnd = ")"; + }else{ + zSep = "\n "; + zSep2 = ",\n "; + zEnd = "\n)"; + } + n += 35 + 6*p->nCol; + zStmt = sqliteMallocRaw( n ); + if( zStmt==0 ) return 0; + strcpy(zStmt, p->iDb==1 ? "CREATE TEMP TABLE " : "CREATE TABLE "); + k = strlen(zStmt); + identPut(zStmt, &k, p->zName); + zStmt[k++] = '('; + for(i=0; i<p->nCol; i++){ + strcpy(&zStmt[k], zSep); + k += strlen(&zStmt[k]); + zSep = zSep2; + identPut(zStmt, &k, p->aCol[i].zName); + } + strcpy(&zStmt[k], zEnd); + return zStmt; +} + +/* +** This routine is called to report the final ")" that terminates +** a CREATE TABLE statement. +** +** The table structure that other action routines have been building +** is added to the internal hash tables, assuming no errors have +** occurred. +** +** An entry for the table is made in the master table on disk, unless +** this is a temporary table or db->init.busy==1. When db->init.busy==1 +** it means we are reading the sqlite_master table because we just +** connected to the database or because the sqlite_master table has +** recently changes, so the entry for this table already exists in +** the sqlite_master table. We do not want to create it again. +** +** If the pSelect argument is not NULL, it means that this routine +** was called to create a table generated from a +** "CREATE TABLE ... AS SELECT ..." statement. The column names of +** the new table will match the result set of the SELECT. +*/ +void sqliteEndTable(Parse *pParse, Token *pEnd, Select *pSelect){ + Table *p; + sqlite *db = pParse->db; + + if( (pEnd==0 && pSelect==0) || pParse->nErr || sqlite_malloc_failed ) return; + p = pParse->pNewTable; + if( p==0 ) return; + + /* If the table is generated from a SELECT, then construct the + ** list of columns and the text of the table. + */ + if( pSelect ){ + Table *pSelTab = sqliteResultSetOfSelect(pParse, 0, pSelect); + if( pSelTab==0 ) return; + assert( p->aCol==0 ); + p->nCol = pSelTab->nCol; + p->aCol = pSelTab->aCol; + pSelTab->nCol = 0; + pSelTab->aCol = 0; + sqliteDeleteTable(0, pSelTab); + } + + /* If the db->init.busy is 1 it means we are reading the SQL off the + ** "sqlite_master" or "sqlite_temp_master" table on the disk. + ** So do not write to the disk again. Extract the root page number + ** for the table from the db->init.newTnum field. (The page number + ** should have been put there by the sqliteOpenCb routine.) + */ + if( db->init.busy ){ + p->tnum = db->init.newTnum; + } + + /* If not initializing, then create a record for the new table + ** in the SQLITE_MASTER table of the database. The record number + ** for the new table entry should already be on the stack. + ** + ** If this is a TEMPORARY table, write the entry into the auxiliary + ** file instead of into the main database file. + */ + if( !db->init.busy ){ + int n; + Vdbe *v; + + v = sqliteGetVdbe(pParse); + if( v==0 ) return; + if( p->pSelect==0 ){ + /* A regular table */ + sqliteVdbeOp3(v, OP_CreateTable, 0, p->iDb, (char*)&p->tnum, P3_POINTER); + }else{ + /* A view */ + sqliteVdbeAddOp(v, OP_Integer, 0, 0); + } + p->tnum = 0; + sqliteVdbeAddOp(v, OP_Pull, 1, 0); + sqliteVdbeOp3(v, OP_String, 0, 0, p->pSelect==0?"table":"view", P3_STATIC); + sqliteVdbeOp3(v, OP_String, 0, 0, p->zName, 0); + sqliteVdbeOp3(v, OP_String, 0, 0, p->zName, 0); + sqliteVdbeAddOp(v, OP_Dup, 4, 0); + sqliteVdbeAddOp(v, OP_String, 0, 0); + if( pSelect ){ + char *z = createTableStmt(p); + n = z ? strlen(z) : 0; + sqliteVdbeChangeP3(v, -1, z, n); + sqliteFree(z); + }else{ + assert( pEnd!=0 ); + n = Addr(pEnd->z) - Addr(pParse->sFirstToken.z) + 1; + sqliteVdbeChangeP3(v, -1, pParse->sFirstToken.z, n); + } + sqliteVdbeAddOp(v, OP_MakeRecord, 5, 0); + sqliteVdbeAddOp(v, OP_PutIntKey, 0, 0); + if( !p->iDb ){ + sqliteChangeCookie(db, v); + } + sqliteVdbeAddOp(v, OP_Close, 0, 0); + if( pSelect ){ + sqliteVdbeAddOp(v, OP_Integer, p->iDb, 0); + sqliteVdbeAddOp(v, OP_OpenWrite, 1, 0); + pParse->nTab = 2; + sqliteSelect(pParse, pSelect, SRT_Table, 1, 0, 0, 0); + } + sqliteEndWriteOperation(pParse); + } + + /* Add the table to the in-memory representation of the database. + */ + if( pParse->explain==0 && pParse->nErr==0 ){ + Table *pOld; + FKey *pFKey; + pOld = sqliteHashInsert(&db->aDb[p->iDb].tblHash, + p->zName, strlen(p->zName)+1, p); + if( pOld ){ + assert( p==pOld ); /* Malloc must have failed inside HashInsert() */ + return; + } + for(pFKey=p->pFKey; pFKey; pFKey=pFKey->pNextFrom){ + int nTo = strlen(pFKey->zTo) + 1; + pFKey->pNextTo = sqliteHashFind(&db->aDb[p->iDb].aFKey, pFKey->zTo, nTo); + sqliteHashInsert(&db->aDb[p->iDb].aFKey, pFKey->zTo, nTo, pFKey); + } + pParse->pNewTable = 0; + db->nTable++; + db->flags |= SQLITE_InternChanges; + } +} + +/* +** The parser calls this routine in order to create a new VIEW +*/ +void sqliteCreateView( + Parse *pParse, /* The parsing context */ + Token *pBegin, /* The CREATE token that begins the statement */ + Token *pName, /* The token that holds the name of the view */ + Select *pSelect, /* A SELECT statement that will become the new view */ + int isTemp /* TRUE for a TEMPORARY view */ +){ + Table *p; + int n; + const char *z; + Token sEnd; + DbFixer sFix; + + sqliteStartTable(pParse, pBegin, pName, isTemp, 1); + p = pParse->pNewTable; + if( p==0 || pParse->nErr ){ + sqliteSelectDelete(pSelect); + return; + } + if( sqliteFixInit(&sFix, pParse, p->iDb, "view", pName) + && sqliteFixSelect(&sFix, pSelect) + ){ + sqliteSelectDelete(pSelect); + return; + } + + /* Make a copy of the entire SELECT statement that defines the view. + ** This will force all the Expr.token.z values to be dynamically + ** allocated rather than point to the input string - which means that + ** they will persist after the current sqlite_exec() call returns. + */ + p->pSelect = sqliteSelectDup(pSelect); + sqliteSelectDelete(pSelect); + if( !pParse->db->init.busy ){ + sqliteViewGetColumnNames(pParse, p); + } + + /* Locate the end of the CREATE VIEW statement. Make sEnd point to + ** the end. + */ + sEnd = pParse->sLastToken; + if( sEnd.z[0]!=0 && sEnd.z[0]!=';' ){ + sEnd.z += sEnd.n; + } + sEnd.n = 0; + n = sEnd.z - pBegin->z; + z = pBegin->z; + while( n>0 && (z[n-1]==';' || isspace(z[n-1])) ){ n--; } + sEnd.z = &z[n-1]; + sEnd.n = 1; + + /* Use sqliteEndTable() to add the view to the SQLITE_MASTER table */ + sqliteEndTable(pParse, &sEnd, 0); + return; +} + +/* +** The Table structure pTable is really a VIEW. Fill in the names of +** the columns of the view in the pTable structure. Return the number +** of errors. If an error is seen leave an error message in pParse->zErrMsg. +*/ +int sqliteViewGetColumnNames(Parse *pParse, Table *pTable){ + ExprList *pEList; + Select *pSel; + Table *pSelTab; + int nErr = 0; + + assert( pTable ); + + /* A positive nCol means the columns names for this view are + ** already known. + */ + if( pTable->nCol>0 ) return 0; + + /* A negative nCol is a special marker meaning that we are currently + ** trying to compute the column names. If we enter this routine with + ** a negative nCol, it means two or more views form a loop, like this: + ** + ** CREATE VIEW one AS SELECT * FROM two; + ** CREATE VIEW two AS SELECT * FROM one; + ** + ** Actually, this error is caught previously and so the following test + ** should always fail. But we will leave it in place just to be safe. + */ + if( pTable->nCol<0 ){ + sqliteErrorMsg(pParse, "view %s is circularly defined", pTable->zName); + return 1; + } + + /* If we get this far, it means we need to compute the table names. + */ + assert( pTable->pSelect ); /* If nCol==0, then pTable must be a VIEW */ + pSel = pTable->pSelect; + + /* Note that the call to sqliteResultSetOfSelect() will expand any + ** "*" elements in this list. But we will need to restore the list + ** back to its original configuration afterwards, so we save a copy of + ** the original in pEList. + */ + pEList = pSel->pEList; + pSel->pEList = sqliteExprListDup(pEList); + if( pSel->pEList==0 ){ + pSel->pEList = pEList; + return 1; /* Malloc failed */ + } + pTable->nCol = -1; + pSelTab = sqliteResultSetOfSelect(pParse, 0, pSel); + if( pSelTab ){ + assert( pTable->aCol==0 ); + pTable->nCol = pSelTab->nCol; + pTable->aCol = pSelTab->aCol; + pSelTab->nCol = 0; + pSelTab->aCol = 0; + sqliteDeleteTable(0, pSelTab); + DbSetProperty(pParse->db, pTable->iDb, DB_UnresetViews); + }else{ + pTable->nCol = 0; + nErr++; + } + sqliteSelectUnbind(pSel); + sqliteExprListDelete(pSel->pEList); + pSel->pEList = pEList; + return nErr; +} + +/* +** Clear the column names from the VIEW pTable. +** +** This routine is called whenever any other table or view is modified. +** The view passed into this routine might depend directly or indirectly +** on the modified or deleted table so we need to clear the old column +** names so that they will be recomputed. +*/ +static void sqliteViewResetColumnNames(Table *pTable){ + int i; + Column *pCol; + assert( pTable!=0 && pTable->pSelect!=0 ); + for(i=0, pCol=pTable->aCol; i<pTable->nCol; i++, pCol++){ + sqliteFree(pCol->zName); + sqliteFree(pCol->zDflt); + sqliteFree(pCol->zType); + } + sqliteFree(pTable->aCol); + pTable->aCol = 0; + pTable->nCol = 0; +} + +/* +** Clear the column names from every VIEW in database idx. +*/ +static void sqliteViewResetAll(sqlite *db, int idx){ + HashElem *i; + if( !DbHasProperty(db, idx, DB_UnresetViews) ) return; + for(i=sqliteHashFirst(&db->aDb[idx].tblHash); i; i=sqliteHashNext(i)){ + Table *pTab = sqliteHashData(i); + if( pTab->pSelect ){ + sqliteViewResetColumnNames(pTab); + } + } + DbClearProperty(db, idx, DB_UnresetViews); +} + +/* +** Given a token, look up a table with that name. If not found, leave +** an error for the parser to find and return NULL. +*/ +Table *sqliteTableFromToken(Parse *pParse, Token *pTok){ + char *zName; + Table *pTab; + zName = sqliteTableNameFromToken(pTok); + if( zName==0 ) return 0; + pTab = sqliteFindTable(pParse->db, zName, 0); + sqliteFree(zName); + if( pTab==0 ){ + sqliteErrorMsg(pParse, "no such table: %T", pTok); + } + return pTab; +} + +/* +** This routine is called to do the work of a DROP TABLE statement. +** pName is the name of the table to be dropped. +*/ +void sqliteDropTable(Parse *pParse, Token *pName, int isView){ + Table *pTable; + Vdbe *v; + int base; + sqlite *db = pParse->db; + int iDb; + + if( pParse->nErr || sqlite_malloc_failed ) return; + pTable = sqliteTableFromToken(pParse, pName); + if( pTable==0 ) return; + iDb = pTable->iDb; + assert( iDb>=0 && iDb<db->nDb ); +#ifndef SQLITE_OMIT_AUTHORIZATION + { + int code; + const char *zTab = SCHEMA_TABLE(pTable->iDb); + const char *zDb = db->aDb[pTable->iDb].zName; + if( sqliteAuthCheck(pParse, SQLITE_DELETE, zTab, 0, zDb)){ + return; + } + if( isView ){ + if( iDb==1 ){ + code = SQLITE_DROP_TEMP_VIEW; + }else{ + code = SQLITE_DROP_VIEW; + } + }else{ + if( iDb==1 ){ + code = SQLITE_DROP_TEMP_TABLE; + }else{ + code = SQLITE_DROP_TABLE; + } + } + if( sqliteAuthCheck(pParse, code, pTable->zName, 0, zDb) ){ + return; + } + if( sqliteAuthCheck(pParse, SQLITE_DELETE, pTable->zName, 0, zDb) ){ + return; + } + } +#endif + if( pTable->readOnly ){ + sqliteErrorMsg(pParse, "table %s may not be dropped", pTable->zName); + pParse->nErr++; + return; + } + if( isView && pTable->pSelect==0 ){ + sqliteErrorMsg(pParse, "use DROP TABLE to delete table %s", pTable->zName); + return; + } + if( !isView && pTable->pSelect ){ + sqliteErrorMsg(pParse, "use DROP VIEW to delete view %s", pTable->zName); + return; + } + + /* Generate code to remove the table from the master table + ** on disk. + */ + v = sqliteGetVdbe(pParse); + if( v ){ + static VdbeOpList dropTable[] = { + { OP_Rewind, 0, ADDR(8), 0}, + { OP_String, 0, 0, 0}, /* 1 */ + { OP_MemStore, 1, 1, 0}, + { OP_MemLoad, 1, 0, 0}, /* 3 */ + { OP_Column, 0, 2, 0}, + { OP_Ne, 0, ADDR(7), 0}, + { OP_Delete, 0, 0, 0}, + { OP_Next, 0, ADDR(3), 0}, /* 7 */ + }; + Index *pIdx; + Trigger *pTrigger; + sqliteBeginWriteOperation(pParse, 0, pTable->iDb); + + /* Drop all triggers associated with the table being dropped */ + pTrigger = pTable->pTrigger; + while( pTrigger ){ + assert( pTrigger->iDb==pTable->iDb || pTrigger->iDb==1 ); + sqliteDropTriggerPtr(pParse, pTrigger, 1); + if( pParse->explain ){ + pTrigger = pTrigger->pNext; + }else{ + pTrigger = pTable->pTrigger; + } + } + + /* Drop all SQLITE_MASTER entries that refer to the table */ + sqliteOpenMasterTable(v, pTable->iDb); + base = sqliteVdbeAddOpList(v, ArraySize(dropTable), dropTable); + sqliteVdbeChangeP3(v, base+1, pTable->zName, 0); + + /* Drop all SQLITE_TEMP_MASTER entries that refer to the table */ + if( pTable->iDb!=1 ){ + sqliteOpenMasterTable(v, 1); + base = sqliteVdbeAddOpList(v, ArraySize(dropTable), dropTable); + sqliteVdbeChangeP3(v, base+1, pTable->zName, 0); + } + + if( pTable->iDb==0 ){ + sqliteChangeCookie(db, v); + } + sqliteVdbeAddOp(v, OP_Close, 0, 0); + if( !isView ){ + sqliteVdbeAddOp(v, OP_Destroy, pTable->tnum, pTable->iDb); + for(pIdx=pTable->pIndex; pIdx; pIdx=pIdx->pNext){ + sqliteVdbeAddOp(v, OP_Destroy, pIdx->tnum, pIdx->iDb); + } + } + sqliteEndWriteOperation(pParse); + } + + /* Delete the in-memory description of the table. + ** + ** Exception: if the SQL statement began with the EXPLAIN keyword, + ** then no changes should be made. + */ + if( !pParse->explain ){ + sqliteUnlinkAndDeleteTable(db, pTable); + db->flags |= SQLITE_InternChanges; + } + sqliteViewResetAll(db, iDb); +} + +/* +** This routine constructs a P3 string suitable for an OP_MakeIdxKey +** opcode and adds that P3 string to the most recently inserted instruction +** in the virtual machine. The P3 string consists of a single character +** for each column in the index pIdx of table pTab. If the column uses +** a numeric sort order, then the P3 string character corresponding to +** that column is 'n'. If the column uses a text sort order, then the +** P3 string is 't'. See the OP_MakeIdxKey opcode documentation for +** additional information. See also the sqliteAddKeyType() routine. +*/ +void sqliteAddIdxKeyType(Vdbe *v, Index *pIdx){ + char *zType; + Table *pTab; + int i, n; + assert( pIdx!=0 && pIdx->pTable!=0 ); + pTab = pIdx->pTable; + n = pIdx->nColumn; + zType = sqliteMallocRaw( n+1 ); + if( zType==0 ) return; + for(i=0; i<n; i++){ + int iCol = pIdx->aiColumn[i]; + assert( iCol>=0 && iCol<pTab->nCol ); + if( (pTab->aCol[iCol].sortOrder & SQLITE_SO_TYPEMASK)==SQLITE_SO_TEXT ){ + zType[i] = 't'; + }else{ + zType[i] = 'n'; + } + } + zType[n] = 0; + sqliteVdbeChangeP3(v, -1, zType, n); + sqliteFree(zType); +} + +/* +** This routine is called to create a new foreign key on the table +** currently under construction. pFromCol determines which columns +** in the current table point to the foreign key. If pFromCol==0 then +** connect the key to the last column inserted. pTo is the name of +** the table referred to. pToCol is a list of tables in the other +** pTo table that the foreign key points to. flags contains all +** information about the conflict resolution algorithms specified +** in the ON DELETE, ON UPDATE and ON INSERT clauses. +** +** An FKey structure is created and added to the table currently +** under construction in the pParse->pNewTable field. The new FKey +** is not linked into db->aFKey at this point - that does not happen +** until sqliteEndTable(). +** +** The foreign key is set for IMMEDIATE processing. A subsequent call +** to sqliteDeferForeignKey() might change this to DEFERRED. +*/ +void sqliteCreateForeignKey( + Parse *pParse, /* Parsing context */ + IdList *pFromCol, /* Columns in this table that point to other table */ + Token *pTo, /* Name of the other table */ + IdList *pToCol, /* Columns in the other table */ + int flags /* Conflict resolution algorithms. */ +){ + Table *p = pParse->pNewTable; + int nByte; + int i; + int nCol; + char *z; + FKey *pFKey = 0; + + assert( pTo!=0 ); + if( p==0 || pParse->nErr ) goto fk_end; + if( pFromCol==0 ){ + int iCol = p->nCol-1; + if( iCol<0 ) goto fk_end; + if( pToCol && pToCol->nId!=1 ){ + sqliteErrorMsg(pParse, "foreign key on %s" + " should reference only one column of table %T", + p->aCol[iCol].zName, pTo); + goto fk_end; + } + nCol = 1; + }else if( pToCol && pToCol->nId!=pFromCol->nId ){ + sqliteErrorMsg(pParse, + "number of columns in foreign key does not match the number of " + "columns in the referenced table"); + goto fk_end; + }else{ + nCol = pFromCol->nId; + } + nByte = sizeof(*pFKey) + nCol*sizeof(pFKey->aCol[0]) + pTo->n + 1; + if( pToCol ){ + for(i=0; i<pToCol->nId; i++){ + nByte += strlen(pToCol->a[i].zName) + 1; + } + } + pFKey = sqliteMalloc( nByte ); + if( pFKey==0 ) goto fk_end; + pFKey->pFrom = p; + pFKey->pNextFrom = p->pFKey; + z = (char*)&pFKey[1]; + pFKey->aCol = (struct sColMap*)z; + z += sizeof(struct sColMap)*nCol; + pFKey->zTo = z; + memcpy(z, pTo->z, pTo->n); + z[pTo->n] = 0; + z += pTo->n+1; + pFKey->pNextTo = 0; + pFKey->nCol = nCol; + if( pFromCol==0 ){ + pFKey->aCol[0].iFrom = p->nCol-1; + }else{ + for(i=0; i<nCol; i++){ + int j; + for(j=0; j<p->nCol; j++){ + if( sqliteStrICmp(p->aCol[j].zName, pFromCol->a[i].zName)==0 ){ + pFKey->aCol[i].iFrom = j; + break; + } + } + if( j>=p->nCol ){ + sqliteErrorMsg(pParse, + "unknown column \"%s\" in foreign key definition", + pFromCol->a[i].zName); + goto fk_end; + } + } + } + if( pToCol ){ + for(i=0; i<nCol; i++){ + int n = strlen(pToCol->a[i].zName); + pFKey->aCol[i].zCol = z; + memcpy(z, pToCol->a[i].zName, n); + z[n] = 0; + z += n+1; + } + } + pFKey->isDeferred = 0; + pFKey->deleteConf = flags & 0xff; + pFKey->updateConf = (flags >> 8 ) & 0xff; + pFKey->insertConf = (flags >> 16 ) & 0xff; + + /* Link the foreign key to the table as the last step. + */ + p->pFKey = pFKey; + pFKey = 0; + +fk_end: + sqliteFree(pFKey); + sqliteIdListDelete(pFromCol); + sqliteIdListDelete(pToCol); +} + +/* +** This routine is called when an INITIALLY IMMEDIATE or INITIALLY DEFERRED +** clause is seen as part of a foreign key definition. The isDeferred +** parameter is 1 for INITIALLY DEFERRED and 0 for INITIALLY IMMEDIATE. +** The behavior of the most recently created foreign key is adjusted +** accordingly. +*/ +void sqliteDeferForeignKey(Parse *pParse, int isDeferred){ + Table *pTab; + FKey *pFKey; + if( (pTab = pParse->pNewTable)==0 || (pFKey = pTab->pFKey)==0 ) return; + pFKey->isDeferred = isDeferred; +} + +/* +** Create a new index for an SQL table. pIndex is the name of the index +** and pTable is the name of the table that is to be indexed. Both will +** be NULL for a primary key or an index that is created to satisfy a +** UNIQUE constraint. If pTable and pIndex are NULL, use pParse->pNewTable +** as the table to be indexed. pParse->pNewTable is a table that is +** currently being constructed by a CREATE TABLE statement. +** +** pList is a list of columns to be indexed. pList will be NULL if this +** is a primary key or unique-constraint on the most recent column added +** to the table currently under construction. +*/ +void sqliteCreateIndex( + Parse *pParse, /* All information about this parse */ + Token *pName, /* Name of the index. May be NULL */ + SrcList *pTable, /* Name of the table to index. Use pParse->pNewTable if 0 */ + IdList *pList, /* A list of columns to be indexed */ + int onError, /* OE_Abort, OE_Ignore, OE_Replace, or OE_None */ + Token *pStart, /* The CREATE token that begins a CREATE TABLE statement */ + Token *pEnd /* The ")" that closes the CREATE INDEX statement */ +){ + Table *pTab; /* Table to be indexed */ + Index *pIndex; /* The index to be created */ + char *zName = 0; + int i, j; + Token nullId; /* Fake token for an empty ID list */ + DbFixer sFix; /* For assigning database names to pTable */ + int isTemp; /* True for a temporary index */ + sqlite *db = pParse->db; + + if( pParse->nErr || sqlite_malloc_failed ) goto exit_create_index; + if( db->init.busy + && sqliteFixInit(&sFix, pParse, db->init.iDb, "index", pName) + && sqliteFixSrcList(&sFix, pTable) + ){ + goto exit_create_index; + } + + /* + ** Find the table that is to be indexed. Return early if not found. + */ + if( pTable!=0 ){ + assert( pName!=0 ); + assert( pTable->nSrc==1 ); + pTab = sqliteSrcListLookup(pParse, pTable); + }else{ + assert( pName==0 ); + pTab = pParse->pNewTable; + } + if( pTab==0 || pParse->nErr ) goto exit_create_index; + if( pTab->readOnly ){ + sqliteErrorMsg(pParse, "table %s may not be indexed", pTab->zName); + goto exit_create_index; + } + if( pTab->iDb>=2 && db->init.busy==0 ){ + sqliteErrorMsg(pParse, "table %s may not have indices added", pTab->zName); + goto exit_create_index; + } + if( pTab->pSelect ){ + sqliteErrorMsg(pParse, "views may not be indexed"); + goto exit_create_index; + } + isTemp = pTab->iDb==1; + + /* + ** Find the name of the index. Make sure there is not already another + ** index or table with the same name. + ** + ** Exception: If we are reading the names of permanent indices from the + ** sqlite_master table (because some other process changed the schema) and + ** one of the index names collides with the name of a temporary table or + ** index, then we will continue to process this index. + ** + ** If pName==0 it means that we are + ** dealing with a primary key or UNIQUE constraint. We have to invent our + ** own name. + */ + if( pName && !db->init.busy ){ + Index *pISameName; /* Another index with the same name */ + Table *pTSameName; /* A table with same name as the index */ + zName = sqliteTableNameFromToken(pName); + if( zName==0 ) goto exit_create_index; + if( (pISameName = sqliteFindIndex(db, zName, 0))!=0 ){ + sqliteErrorMsg(pParse, "index %s already exists", zName); + goto exit_create_index; + } + if( (pTSameName = sqliteFindTable(db, zName, 0))!=0 ){ + sqliteErrorMsg(pParse, "there is already a table named %s", zName); + goto exit_create_index; + } + }else if( pName==0 ){ + char zBuf[30]; + int n; + Index *pLoop; + for(pLoop=pTab->pIndex, n=1; pLoop; pLoop=pLoop->pNext, n++){} + sprintf(zBuf,"%d)",n); + zName = 0; + sqliteSetString(&zName, "(", pTab->zName, " autoindex ", zBuf, (char*)0); + if( zName==0 ) goto exit_create_index; + }else{ + zName = 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) ){ + goto exit_create_index; + } + i = SQLITE_CREATE_INDEX; + if( isTemp ) i = SQLITE_CREATE_TEMP_INDEX; + if( sqliteAuthCheck(pParse, i, zName, pTab->zName, zDb) ){ + goto exit_create_index; + } + } +#endif + + /* If pList==0, it means this routine was called to make a primary + ** key out of the last column added to the table under construction. + ** So create a fake list to simulate this. + */ + if( pList==0 ){ + nullId.z = pTab->aCol[pTab->nCol-1].zName; + nullId.n = strlen(nullId.z); + pList = sqliteIdListAppend(0, &nullId); + if( pList==0 ) goto exit_create_index; + } + + /* + ** Allocate the index structure. + */ + pIndex = sqliteMalloc( sizeof(Index) + strlen(zName) + 1 + + sizeof(int)*pList->nId ); + if( pIndex==0 ) goto exit_create_index; + pIndex->aiColumn = (int*)&pIndex[1]; + pIndex->zName = (char*)&pIndex->aiColumn[pList->nId]; + strcpy(pIndex->zName, zName); + pIndex->pTable = pTab; + pIndex->nColumn = pList->nId; + pIndex->onError = onError; + pIndex->autoIndex = pName==0; + pIndex->iDb = isTemp ? 1 : db->init.iDb; + + /* Scan the names of the columns of the table to be indexed and + ** load the column indices into the Index structure. Report an error + ** if any column is not found. + */ + for(i=0; i<pList->nId; i++){ + for(j=0; j<pTab->nCol; j++){ + if( sqliteStrICmp(pList->a[i].zName, pTab->aCol[j].zName)==0 ) break; + } + if( j>=pTab->nCol ){ + sqliteErrorMsg(pParse, "table %s has no column named %s", + pTab->zName, pList->a[i].zName); + sqliteFree(pIndex); + goto exit_create_index; + } + pIndex->aiColumn[i] = j; + } + + /* Link the new Index structure to its table and to the other + ** in-memory database structures. + */ + if( !pParse->explain ){ + Index *p; + p = sqliteHashInsert(&db->aDb[pIndex->iDb].idxHash, + pIndex->zName, strlen(pIndex->zName)+1, pIndex); + if( p ){ + assert( p==pIndex ); /* Malloc must have failed */ + sqliteFree(pIndex); + goto exit_create_index; + } + db->flags |= SQLITE_InternChanges; + } + + /* When adding an index to the list of indices for a table, make + ** sure all indices labeled OE_Replace come after all those labeled + ** OE_Ignore. This is necessary for the correct operation of UPDATE + ** and INSERT. + */ + if( onError!=OE_Replace || pTab->pIndex==0 + || pTab->pIndex->onError==OE_Replace){ + pIndex->pNext = pTab->pIndex; + pTab->pIndex = pIndex; + }else{ + Index *pOther = pTab->pIndex; + while( pOther->pNext && pOther->pNext->onError!=OE_Replace ){ + pOther = pOther->pNext; + } + pIndex->pNext = pOther->pNext; + pOther->pNext = pIndex; + } + + /* If the db->init.busy is 1 it means we are reading the SQL off the + ** "sqlite_master" table on the disk. So do not write to the disk + ** again. Extract the table number from the db->init.newTnum field. + */ + if( db->init.busy && pTable!=0 ){ + pIndex->tnum = db->init.newTnum; + } + + /* If the db->init.busy is 0 then create the index on disk. This + ** involves writing the index into the master table and filling in the + ** index with the current table contents. + ** + ** The db->init.busy is 0 when the user first enters a CREATE INDEX + ** command. db->init.busy is 1 when a database is opened and + ** CREATE INDEX statements are read out of the master table. In + ** the latter case the index already exists on disk, which is why + ** we don't want to recreate it. + ** + ** If pTable==0 it means this index is generated as a primary key + ** or UNIQUE constraint of a CREATE TABLE statement. Since the table + ** has just been created, it contains no data and the index initialization + ** step can be skipped. + */ + else if( db->init.busy==0 ){ + int n; + Vdbe *v; + int lbl1, lbl2; + int i; + int addr; + + v = sqliteGetVdbe(pParse); + if( v==0 ) goto exit_create_index; + if( pTable!=0 ){ + sqliteBeginWriteOperation(pParse, 0, isTemp); + sqliteOpenMasterTable(v, isTemp); + } + sqliteVdbeAddOp(v, OP_NewRecno, 0, 0); + sqliteVdbeOp3(v, OP_String, 0, 0, "index", P3_STATIC); + sqliteVdbeOp3(v, OP_String, 0, 0, pIndex->zName, 0); + sqliteVdbeOp3(v, OP_String, 0, 0, pTab->zName, 0); + sqliteVdbeOp3(v, OP_CreateIndex, 0, isTemp,(char*)&pIndex->tnum,P3_POINTER); + pIndex->tnum = 0; + if( pTable ){ + sqliteVdbeCode(v, + OP_Dup, 0, 0, + OP_Integer, isTemp, 0, + OP_OpenWrite, 1, 0, + 0); + } + addr = sqliteVdbeAddOp(v, OP_String, 0, 0); + if( pStart && pEnd ){ + n = Addr(pEnd->z) - Addr(pStart->z) + 1; + sqliteVdbeChangeP3(v, addr, pStart->z, n); + } + sqliteVdbeAddOp(v, OP_MakeRecord, 5, 0); + sqliteVdbeAddOp(v, OP_PutIntKey, 0, 0); + if( pTable ){ + sqliteVdbeAddOp(v, OP_Integer, pTab->iDb, 0); + sqliteVdbeOp3(v, OP_OpenRead, 2, pTab->tnum, pTab->zName, 0); + lbl2 = sqliteVdbeMakeLabel(v); + sqliteVdbeAddOp(v, OP_Rewind, 2, lbl2); + lbl1 = sqliteVdbeAddOp(v, OP_Recno, 2, 0); + for(i=0; i<pIndex->nColumn; i++){ + int iCol = pIndex->aiColumn[i]; + if( pTab->iPKey==iCol ){ + sqliteVdbeAddOp(v, OP_Dup, i, 0); + }else{ + sqliteVdbeAddOp(v, OP_Column, 2, iCol); + } + } + sqliteVdbeAddOp(v, OP_MakeIdxKey, pIndex->nColumn, 0); + if( db->file_format>=4 ) sqliteAddIdxKeyType(v, pIndex); + sqliteVdbeOp3(v, OP_IdxPut, 1, pIndex->onError!=OE_None, + "indexed columns are not unique", P3_STATIC); + sqliteVdbeAddOp(v, OP_Next, 2, lbl1); + sqliteVdbeResolveLabel(v, lbl2); + sqliteVdbeAddOp(v, OP_Close, 2, 0); + sqliteVdbeAddOp(v, OP_Close, 1, 0); + } + if( pTable!=0 ){ + if( !isTemp ){ + sqliteChangeCookie(db, v); + } + sqliteVdbeAddOp(v, OP_Close, 0, 0); + sqliteEndWriteOperation(pParse); + } + } + + /* Clean up before exiting */ +exit_create_index: + sqliteIdListDelete(pList); + sqliteSrcListDelete(pTable); + sqliteFree(zName); + return; +} + +/* +** This routine will drop an existing named index. This routine +** implements the DROP INDEX statement. +*/ +void sqliteDropIndex(Parse *pParse, SrcList *pName){ + Index *pIndex; + Vdbe *v; + sqlite *db = pParse->db; + + if( pParse->nErr || sqlite_malloc_failed ) return; + assert( pName->nSrc==1 ); + pIndex = sqliteFindIndex(db, pName->a[0].zName, pName->a[0].zDatabase); + if( pIndex==0 ){ + sqliteErrorMsg(pParse, "no such index: %S", pName, 0); + goto exit_drop_index; + } + if( pIndex->autoIndex ){ + sqliteErrorMsg(pParse, "index associated with UNIQUE " + "or PRIMARY KEY constraint cannot be dropped", 0); + goto exit_drop_index; + } + if( pIndex->iDb>1 ){ + sqliteErrorMsg(pParse, "cannot alter schema of attached " + "databases", 0); + goto exit_drop_index; + } +#ifndef SQLITE_OMIT_AUTHORIZATION + { + int code = SQLITE_DROP_INDEX; + Table *pTab = pIndex->pTable; + const char *zDb = db->aDb[pIndex->iDb].zName; + const char *zTab = SCHEMA_TABLE(pIndex->iDb); + if( sqliteAuthCheck(pParse, SQLITE_DELETE, zTab, 0, zDb) ){ + goto exit_drop_index; + } + if( pIndex->iDb ) code = SQLITE_DROP_TEMP_INDEX; + if( sqliteAuthCheck(pParse, code, pIndex->zName, pTab->zName, zDb) ){ + goto exit_drop_index; + } + } +#endif + + /* Generate code to remove the index and from the master table */ + v = sqliteGetVdbe(pParse); + if( v ){ + static VdbeOpList dropIndex[] = { + { OP_Rewind, 0, ADDR(9), 0}, + { OP_String, 0, 0, 0}, /* 1 */ + { OP_MemStore, 1, 1, 0}, + { OP_MemLoad, 1, 0, 0}, /* 3 */ + { OP_Column, 0, 1, 0}, + { OP_Eq, 0, ADDR(8), 0}, + { OP_Next, 0, ADDR(3), 0}, + { OP_Goto, 0, ADDR(9), 0}, + { OP_Delete, 0, 0, 0}, /* 8 */ + }; + int base; + + sqliteBeginWriteOperation(pParse, 0, pIndex->iDb); + sqliteOpenMasterTable(v, pIndex->iDb); + base = sqliteVdbeAddOpList(v, ArraySize(dropIndex), dropIndex); + sqliteVdbeChangeP3(v, base+1, pIndex->zName, 0); + if( pIndex->iDb==0 ){ + sqliteChangeCookie(db, v); + } + sqliteVdbeAddOp(v, OP_Close, 0, 0); + sqliteVdbeAddOp(v, OP_Destroy, pIndex->tnum, pIndex->iDb); + sqliteEndWriteOperation(pParse); + } + + /* Delete the in-memory description of this index. + */ + if( !pParse->explain ){ + sqliteUnlinkAndDeleteIndex(db, pIndex); + db->flags |= SQLITE_InternChanges; + } + +exit_drop_index: + sqliteSrcListDelete(pName); +} + +/* +** Append a new element to the given IdList. Create a new IdList if +** need be. +** +** A new IdList is returned, or NULL if malloc() fails. +*/ +IdList *sqliteIdListAppend(IdList *pList, Token *pToken){ + if( pList==0 ){ + pList = sqliteMalloc( sizeof(IdList) ); + if( pList==0 ) return 0; + pList->nAlloc = 0; + } + if( pList->nId>=pList->nAlloc ){ + struct IdList_item *a; + pList->nAlloc = pList->nAlloc*2 + 5; + a = sqliteRealloc(pList->a, pList->nAlloc*sizeof(pList->a[0]) ); + if( a==0 ){ + sqliteIdListDelete(pList); + return 0; + } + pList->a = a; + } + memset(&pList->a[pList->nId], 0, sizeof(pList->a[0])); + if( pToken ){ + char **pz = &pList->a[pList->nId].zName; + sqliteSetNString(pz, pToken->z, pToken->n, 0); + if( *pz==0 ){ + sqliteIdListDelete(pList); + return 0; + }else{ + sqliteDequote(*pz); + } + } + pList->nId++; + return pList; +} + +/* +** Append a new table name to the given SrcList. Create a new SrcList if +** need be. A new entry is created in the SrcList even if pToken is NULL. +** +** A new SrcList is returned, or NULL if malloc() fails. +** +** If pDatabase is not null, it means that the table has an optional +** database name prefix. Like this: "database.table". The pDatabase +** points to the table name and the pTable points to the database name. +** The SrcList.a[].zName field is filled with the table name which might +** come from pTable (if pDatabase is NULL) or from pDatabase. +** SrcList.a[].zDatabase is filled with the database name from pTable, +** or with NULL if no database is specified. +** +** In other words, if call like this: +** +** sqliteSrcListAppend(A,B,0); +** +** Then B is a table name and the database name is unspecified. If called +** like this: +** +** sqliteSrcListAppend(A,B,C); +** +** Then C is the table name and B is the database name. +*/ +SrcList *sqliteSrcListAppend(SrcList *pList, Token *pTable, Token *pDatabase){ + if( pList==0 ){ + pList = sqliteMalloc( sizeof(SrcList) ); + if( pList==0 ) return 0; + pList->nAlloc = 1; + } + if( pList->nSrc>=pList->nAlloc ){ + SrcList *pNew; + pList->nAlloc *= 2; + pNew = sqliteRealloc(pList, + sizeof(*pList) + (pList->nAlloc-1)*sizeof(pList->a[0]) ); + if( pNew==0 ){ + sqliteSrcListDelete(pList); + return 0; + } + pList = pNew; + } + memset(&pList->a[pList->nSrc], 0, sizeof(pList->a[0])); + if( pDatabase && pDatabase->z==0 ){ + pDatabase = 0; + } + if( pDatabase && pTable ){ + Token *pTemp = pDatabase; + pDatabase = pTable; + pTable = pTemp; + } + if( pTable ){ + char **pz = &pList->a[pList->nSrc].zName; + sqliteSetNString(pz, pTable->z, pTable->n, 0); + if( *pz==0 ){ + sqliteSrcListDelete(pList); + return 0; + }else{ + sqliteDequote(*pz); + } + } + if( pDatabase ){ + char **pz = &pList->a[pList->nSrc].zDatabase; + sqliteSetNString(pz, pDatabase->z, pDatabase->n, 0); + if( *pz==0 ){ + sqliteSrcListDelete(pList); + return 0; + }else{ + sqliteDequote(*pz); + } + } + pList->a[pList->nSrc].iCursor = -1; + pList->nSrc++; + return pList; +} + +/* +** Assign cursors to all tables in a SrcList +*/ +void sqliteSrcListAssignCursors(Parse *pParse, SrcList *pList){ + int i; + for(i=0; i<pList->nSrc; i++){ + if( pList->a[i].iCursor<0 ){ + pList->a[i].iCursor = pParse->nTab++; + } + } +} + +/* +** Add an alias to the last identifier on the given identifier list. +*/ +void sqliteSrcListAddAlias(SrcList *pList, Token *pToken){ + if( pList && pList->nSrc>0 ){ + int i = pList->nSrc - 1; + sqliteSetNString(&pList->a[i].zAlias, pToken->z, pToken->n, 0); + sqliteDequote(pList->a[i].zAlias); + } +} + +/* +** Delete an IdList. +*/ +void sqliteIdListDelete(IdList *pList){ + int i; + if( pList==0 ) return; + for(i=0; i<pList->nId; 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; i<pList->nId; i++){ + if( sqliteStrICmp(pList->a[i].zName, zName)==0 ) return i; + } + return -1; +} + +/* +** Delete an entire SrcList including all its substructure. +*/ +void sqliteSrcListDelete(SrcList *pList){ + int i; + if( pList==0 ) return; + for(i=0; i<pList->nSrc; i++){ + sqliteFree(pList->a[i].zDatabase); + sqliteFree(pList->a[i].zName); + sqliteFree(pList->a[i].zAlias); + if( pList->a[i].pTab && pList->a[i].pTab->isTransient ){ + sqliteDeleteTable(0, pList->a[i].pTab); + } + sqliteSelectDelete(pList->a[i].pSelect); + sqliteExprDelete(pList->a[i].pOn); + sqliteIdListDelete(pList->a[i].pUsing); + } + sqliteFree(pList); +} + +/* +** Begin a transaction +*/ +void sqliteBeginTransaction(Parse *pParse, int onError){ + sqlite *db; + + if( pParse==0 || (db=pParse->db)==0 || db->aDb[0].pBt==0 ) return; + if( pParse->nErr || sqlite_malloc_failed ) return; + if( sqliteAuthCheck(pParse, SQLITE_TRANSACTION, "BEGIN", 0, 0) ) return; + if( db->flags & SQLITE_InTrans ){ + sqliteErrorMsg(pParse, "cannot start a transaction within a transaction"); + return; + } + sqliteBeginWriteOperation(pParse, 0, 0); + if( !pParse->explain ){ + db->flags |= SQLITE_InTrans; + db->onError = onError; + } +} + +/* +** Commit a transaction +*/ +void sqliteCommitTransaction(Parse *pParse){ + sqlite *db; + + if( pParse==0 || (db=pParse->db)==0 || db->aDb[0].pBt==0 ) return; + if( pParse->nErr || sqlite_malloc_failed ) return; + if( sqliteAuthCheck(pParse, SQLITE_TRANSACTION, "COMMIT", 0, 0) ) return; + if( (db->flags & SQLITE_InTrans)==0 ){ + sqliteErrorMsg(pParse, "cannot commit - no transaction is active"); + return; + } + if( !pParse->explain ){ + db->flags &= ~SQLITE_InTrans; + } + sqliteEndWriteOperation(pParse); + if( !pParse->explain ){ + db->onError = OE_Default; + } +} + +/* +** Rollback a transaction +*/ +void sqliteRollbackTransaction(Parse *pParse){ + sqlite *db; + Vdbe *v; + + if( pParse==0 || (db=pParse->db)==0 || db->aDb[0].pBt==0 ) return; + if( pParse->nErr || sqlite_malloc_failed ) return; + if( sqliteAuthCheck(pParse, SQLITE_TRANSACTION, "ROLLBACK", 0, 0) ) return; + if( (db->flags & SQLITE_InTrans)==0 ){ + sqliteErrorMsg(pParse, "cannot rollback - no transaction is active"); + return; + } + v = sqliteGetVdbe(pParse); + if( v ){ + sqliteVdbeAddOp(v, OP_Rollback, 0, 0); + } + if( !pParse->explain ){ + db->flags &= ~SQLITE_InTrans; + db->onError = OE_Default; + } +} + +/* +** Generate VDBE code that will verify the schema cookie for all +** named database files. +*/ +void sqliteCodeVerifySchema(Parse *pParse, int iDb){ + sqlite *db = pParse->db; + Vdbe *v = sqliteGetVdbe(pParse); + assert( iDb>=0 && iDb<db->nDb ); + assert( db->aDb[iDb].pBt!=0 ); + if( iDb!=1 && !DbHasProperty(db, iDb, DB_Cookie) ){ + sqliteVdbeAddOp(v, OP_VerifyCookie, iDb, db->aDb[iDb].schema_cookie); + DbSetProperty(db, iDb, DB_Cookie); + } +} + +/* +** Generate VDBE code that prepares for doing an operation that +** might change the database. +** +** This routine starts a new transaction if we are not already within +** a transaction. If we are already within a transaction, then a checkpoint +** is set if the setCheckpoint parameter is true. A checkpoint should +** be set for operations that might fail (due to a constraint) part of +** the way through and which will need to undo some writes without having to +** rollback the whole transaction. For operations where all constraints +** can be checked before any changes are made to the database, it is never +** necessary to undo a write and the checkpoint should not be set. +** +** Only database iDb and the temp database are made writable by this call. +** If iDb==0, then the main and temp databases are made writable. If +** iDb==1 then only the temp database is made writable. If iDb>1 then the +** specified auxiliary database and the temp database are made writable. +*/ +void sqliteBeginWriteOperation(Parse *pParse, int setCheckpoint, int iDb){ + Vdbe *v; + sqlite *db = pParse->db; + if( DbHasProperty(db, iDb, DB_Locked) ) return; + v = sqliteGetVdbe(pParse); + if( v==0 ) return; + if( !db->aDb[iDb].inTrans ){ + sqliteVdbeAddOp(v, OP_Transaction, iDb, 0); + DbSetProperty(db, iDb, DB_Locked); + sqliteCodeVerifySchema(pParse, iDb); + if( iDb!=1 ){ + sqliteBeginWriteOperation(pParse, setCheckpoint, 1); + } + }else if( setCheckpoint ){ + sqliteVdbeAddOp(v, OP_Checkpoint, iDb, 0); + DbSetProperty(db, iDb, DB_Locked); + } +} + +/* +** Generate code that concludes an operation that may have changed +** the database. If a statement transaction was started, then emit +** an OP_Commit that will cause the changes to be committed to disk. +** +** Note that checkpoints are automatically committed at the end of +** a statement. Note also that there can be multiple calls to +** sqliteBeginWriteOperation() but there should only be a single +** call to sqliteEndWriteOperation() at the conclusion of the statement. +*/ +void sqliteEndWriteOperation(Parse *pParse){ + Vdbe *v; + sqlite *db = pParse->db; + if( pParse->trigStack ) return; /* if this is in a trigger */ + v = sqliteGetVdbe(pParse); + if( v==0 ) return; + if( db->flags & SQLITE_InTrans ){ + /* A BEGIN has executed. Do not commit until we see an explicit + ** COMMIT statement. */ + }else{ + sqliteVdbeAddOp(v, OP_Commit, 0, 0); + } +} diff --git a/kexi/3rdparty/kexisql/src/copy.c b/kexi/3rdparty/kexisql/src/copy.c new file mode 100644 index 00000000..46b86903 --- /dev/null +++ b/kexi/3rdparty/kexisql/src/copy.c @@ -0,0 +1,110 @@ +/* +** 2003 April 6 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains code used to implement the COPY command. +** +** $Id: copy.c 410099 2005-05-06 17:52:07Z staniek $ +*/ +#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->iDb<db->nDb ); + 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; i<pTab->nCol; 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/kexi/3rdparty/kexisql/src/date.c b/kexi/3rdparty/kexisql/src/date.c new file mode 100644 index 00000000..e48c9f33 --- /dev/null +++ b/kexi/3rdparty/kexisql/src/date.c @@ -0,0 +1,875 @@ +/* +** 2003 October 31 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains the C functions that implement date and time +** functions for SQLite. +** +** There is only one exported symbol in this file - the function +** sqliteRegisterDateTimeFunctions() found at the bottom of the file. +** All other code has file scope. +** +** $Id: date.c 410099 2005-05-06 17:52:07Z staniek $ +** +** NOTES: +** +** SQLite processes all times and dates as Julian Day numbers. The +** dates and times are stored as the number of days since noon +** in Greenwich on November 24, 4714 B.C. according to the Gregorian +** calendar system. +** +** 1970-01-01 00:00:00 is JD 2440587.5 +** 2000-01-01 00:00:00 is JD 2451544.5 +** +** This implemention requires years to be expressed as a 4-digit number +** which means that only dates between 0000-01-01 and 9999-12-31 can +** be represented, even though julian day numbers allow a much wider +** range of dates. +** +** The Gregorian calendar system is used for all dates and times, +** even those that predate the Gregorian calendar. Historians usually +** use the Julian calendar for dates prior to 1582-10-15 and for some +** dates afterwards, depending on locale. Beware of this difference. +** +** The conversion algorithms are implemented based on descriptions +** in the following text: +** +** Jean Meeus +** Astronomical Algorithms, 2nd Edition, 1998 +** ISBM 0-943396-61-1 +** Willmann-Bell, Inc +** Richmond, Virginia (USA) +*/ +#include "os.h" +#include "sqliteInt.h" +#include <ctype.h> +#include <stdlib.h> +#include <assert.h> +#include <time.h> + +#ifndef SQLITE_OMIT_DATETIME_FUNCS + +/* +** A structure for holding a single date and time. +*/ +typedef struct DateTime DateTime; +struct DateTime { + double rJD; /* The julian day number */ + int Y, M, D; /* Year, month, and day */ + int h, m; /* Hour and minutes */ + int tz; /* Timezone offset in minutes */ + double s; /* Seconds */ + char validYMD; /* True if Y,M,D are valid */ + char validHMS; /* True if h,m,s are valid */ + char validJD; /* True if rJD is valid */ + char validTZ; /* True if tz is valid */ +}; + + +/* +** Convert zDate into one or more integers. Additional arguments +** come in groups of 5 as follows: +** +** N number of digits in the integer +** min minimum allowed value of the integer +** max maximum allowed value of the integer +** nextC first character after the integer +** pVal where to write the integers value. +** +** Conversions continue until one with nextC==0 is encountered. +** The function returns the number of successful conversions. +*/ +static int getDigits(const char *zDate, ...){ + va_list ap; + int val; + int N; + int min; + int max; + int nextC; + int *pVal; + int cnt = 0; + va_start(ap, zDate); + do{ + N = va_arg(ap, int); + min = va_arg(ap, int); + max = va_arg(ap, int); + nextC = va_arg(ap, int); + pVal = va_arg(ap, int*); + val = 0; + while( N-- ){ + if( !isdigit(*zDate) ){ + return cnt; + } + val = val*10 + *zDate - '0'; + zDate++; + } + if( val<min || val>max || (nextC!=0 && nextC!=*zDate) ){ + return cnt; + } + *pVal = val; + zDate++; + cnt++; + }while( nextC ); + return cnt; +} + +/* +** Read text from z[] and convert into a floating point number. Return +** the number of digits converted. +*/ +static int getValue(const char *z, double *pR){ + const char *zEnd; + *pR = sqliteAtoF(z, &zEnd); + return zEnd - z; +} + +/* +** Parse a timezone extension on the end of a date-time. +** The extension is of the form: +** +** (+/-)HH:MM +** +** If the parse is successful, write the number of minutes +** of change in *pnMin and return 0. If a parser error occurs, +** return 0. +** +** A missing specifier is not considered an error. +*/ +static int parseTimezone(const char *zDate, DateTime *p){ + int sgn = 0; + int nHr, nMn; + while( isspace(*zDate) ){ zDate++; } + p->tz = 0; + if( *zDate=='-' ){ + sgn = -1; + }else if( *zDate=='+' ){ + sgn = +1; + }else{ + return *zDate!=0; + } + zDate++; + if( getDigits(zDate, 2, 0, 14, ':', &nHr, 2, 0, 59, 0, &nMn)!=2 ){ + return 1; + } + zDate += 5; + p->tz = sgn*(nMn + nHr*60); + while( isspace(*zDate) ){ zDate++; } + return *zDate!=0; +} + +/* +** Parse times of the form HH:MM or HH:MM:SS or HH:MM:SS.FFFF. +** The HH, MM, and SS must each be exactly 2 digits. The +** fractional seconds FFFF can be one or more digits. +** +** Return 1 if there is a parsing error and 0 on success. +*/ +static int parseHhMmSs(const char *zDate, DateTime *p){ + int h, m, s; + double ms = 0.0; + if( getDigits(zDate, 2, 0, 24, ':', &h, 2, 0, 59, 0, &m)!=2 ){ + return 1; + } + zDate += 5; + if( *zDate==':' ){ + zDate++; + if( getDigits(zDate, 2, 0, 59, 0, &s)!=1 ){ + return 1; + } + zDate += 2; + if( *zDate=='.' && isdigit(zDate[1]) ){ + double rScale = 1.0; + zDate++; + while( isdigit(*zDate) ){ + ms = ms*10.0 + *zDate - '0'; + rScale *= 10.0; + zDate++; + } + ms /= rScale; + } + }else{ + s = 0; + } + p->validJD = 0; + p->validHMS = 1; + p->h = h; + p->m = m; + p->s = s + ms; + if( parseTimezone(zDate, p) ) return 1; + p->validTZ = p->tz!=0; + return 0; +} + +/* +** Convert from YYYY-MM-DD HH:MM:SS to julian day. We always assume +** that the YYYY-MM-DD is according to the Gregorian calendar. +** +** Reference: Meeus page 61 +*/ +static void computeJD(DateTime *p){ + int Y, M, D, A, B, X1, X2; + + if( p->validJD ) return; + if( p->validYMD ){ + Y = p->Y; + M = p->M; + D = p->D; + }else{ + Y = 2000; /* If no YMD specified, assume 2000-Jan-01 */ + M = 1; + D = 1; + } + if( M<=2 ){ + Y--; + M += 12; + } + A = Y/100; + B = 2 - A + (A/4); + X1 = 365.25*(Y+4716); + X2 = 30.6001*(M+1); + p->rJD = X1 + X2 + D + B - 1524.5; + p->validJD = 1; + p->validYMD = 0; + if( p->validHMS ){ + p->rJD += (p->h*3600.0 + p->m*60.0 + p->s)/86400.0; + if( p->validTZ ){ + p->rJD += p->tz*60/86400.0; + p->validHMS = 0; + p->validTZ = 0; + } + } +} + +/* +** Parse dates of the form +** +** YYYY-MM-DD HH:MM:SS.FFF +** YYYY-MM-DD HH:MM:SS +** YYYY-MM-DD HH:MM +** YYYY-MM-DD +** +** Write the result into the DateTime structure and return 0 +** on success and 1 if the input string is not a well-formed +** date. +*/ +static int parseYyyyMmDd(const char *zDate, DateTime *p){ + int Y, M, D, neg; + + if( zDate[0]=='-' ){ + zDate++; + neg = 1; + }else{ + neg = 0; + } + if( getDigits(zDate,4,0,9999,'-',&Y,2,1,12,'-',&M,2,1,31,0,&D)!=3 ){ + return 1; + } + zDate += 10; + while( isspace(*zDate) ){ zDate++; } + if( parseHhMmSs(zDate, p)==0 ){ + /* We got the time */ + }else if( *zDate==0 ){ + p->validHMS = 0; + }else{ + return 1; + } + p->validJD = 0; + p->validYMD = 1; + p->Y = neg ? -Y : Y; + p->M = M; + p->D = D; + if( p->validTZ ){ + computeJD(p); + } + return 0; +} + +/* +** Attempt to parse the given string into a Julian Day Number. Return +** the number of errors. +** +** The following are acceptable forms for the input string: +** +** YYYY-MM-DD HH:MM:SS.FFF +/-HH:MM +** DDDD.DD +** now +** +** In the first form, the +/-HH:MM is always optional. The fractional +** seconds extension (the ".FFF") is optional. The seconds portion +** (":SS.FFF") is option. The year and date can be omitted as long +** as there is a time string. The time string can be omitted as long +** as there is a year and date. +*/ +static int parseDateOrTime(const char *zDate, DateTime *p){ + memset(p, 0, sizeof(*p)); + if( parseYyyyMmDd(zDate,p)==0 ){ + return 0; + }else if( parseHhMmSs(zDate, p)==0 ){ + return 0; + }else if( sqliteStrICmp(zDate,"now")==0){ + double r; + if( sqliteOsCurrentTime(&r)==0 ){ + p->rJD = r; + p->validJD = 1; + return 0; + } + return 1; + }else if( sqliteIsNumber(zDate) ){ + p->rJD = sqliteAtoF(zDate, 0); + p->validJD = 1; + return 0; + } + return 1; +} + +/* +** Compute the Year, Month, and Day from the julian day number. +*/ +static void computeYMD(DateTime *p){ + int Z, A, B, C, D, E, X1; + if( p->validYMD ) return; + if( !p->validJD ){ + p->Y = 2000; + p->M = 1; + p->D = 1; + }else{ + Z = p->rJD + 0.5; + A = (Z - 1867216.25)/36524.25; + A = Z + 1 + A - (A/4); + B = A + 1524; + C = (B - 122.1)/365.25; + D = 365.25*C; + E = (B-D)/30.6001; + X1 = 30.6001*E; + p->D = B - D - X1; + p->M = E<14 ? E-1 : E-13; + p->Y = p->M>2 ? C - 4716 : C - 4715; + } + p->validYMD = 1; +} + +/* +** Compute the Hour, Minute, and Seconds from the julian day number. +*/ +static void computeHMS(DateTime *p){ + int Z, s; + if( p->validHMS ) return; + Z = p->rJD + 0.5; + s = (p->rJD + 0.5 - Z)*86400000.0 + 0.5; + p->s = 0.001*s; + s = p->s; + p->s -= s; + p->h = s/3600; + s -= p->h*3600; + p->m = s/60; + p->s += s - p->m*60; + p->validHMS = 1; +} + +/* +** Compute both YMD and HMS +*/ +static void computeYMD_HMS(DateTime *p){ + computeYMD(p); + computeHMS(p); +} + +/* +** Clear the YMD and HMS and the TZ +*/ +static void clearYMD_HMS_TZ(DateTime *p){ + p->validYMD = 0; + p->validHMS = 0; + p->validTZ = 0; +} + +/* +** Compute the difference (in days) between localtime and UTC (a.k.a. GMT) +** for the time value p where p is in UTC. +*/ +static double localtimeOffset(DateTime *p){ + DateTime x, y; + time_t t; + struct tm *pTm; + x = *p; + computeYMD_HMS(&x); + if( x.Y<1971 || x.Y>=2038 ){ + x.Y = 2000; + x.M = 1; + x.D = 1; + x.h = 0; + x.m = 0; + x.s = 0.0; + } else { + int s = x.s + 0.5; + x.s = s; + } + x.tz = 0; + x.validJD = 0; + computeJD(&x); + t = (x.rJD-2440587.5)*86400.0 + 0.5; + sqliteOsEnterMutex(); + pTm = localtime(&t); + y.Y = pTm->tm_year + 1900; + y.M = pTm->tm_mon + 1; + y.D = pTm->tm_mday; + y.h = pTm->tm_hour; + y.m = pTm->tm_min; + y.s = pTm->tm_sec; + sqliteOsLeaveMutex(); + y.validYMD = 1; + y.validHMS = 1; + y.validJD = 0; + y.validTZ = 0; + computeJD(&y); + return y.rJD - x.rJD; +} + +/* +** Process a modifier to a date-time stamp. The modifiers are +** as follows: +** +** NNN days +** NNN hours +** NNN minutes +** NNN.NNNN seconds +** NNN months +** NNN years +** start of month +** start of year +** start of week +** start of day +** weekday N +** unixepoch +** localtime +** utc +** +** Return 0 on success and 1 if there is any kind of error. +*/ +static int parseModifier(const char *zMod, DateTime *p){ + int rc = 1; + int n; + double r; + char *z, zBuf[30]; + z = zBuf; + for(n=0; n<sizeof(zBuf)-1 && zMod[n]; n++){ + z[n] = tolower(zMod[n]); + } + z[n] = 0; + switch( z[0] ){ + case 'l': { + /* localtime + ** + ** Assuming the current time value is UTC (a.k.a. GMT), shift it to + ** show local time. + */ + if( strcmp(z, "localtime")==0 ){ + computeJD(p); + p->rJD += localtimeOffset(p); + clearYMD_HMS_TZ(p); + rc = 0; + } + break; + } + case 'u': { + /* + ** unixepoch + ** + ** Treat the current value of p->rJD as the number of + ** seconds since 1970. Convert to a real julian day number. + */ + if( strcmp(z, "unixepoch")==0 && p->validJD ){ + p->rJD = p->rJD/86400.0 + 2440587.5; + clearYMD_HMS_TZ(p); + rc = 0; + }else if( strcmp(z, "utc")==0 ){ + double c1; + computeJD(p); + c1 = localtimeOffset(p); + p->rJD -= c1; + clearYMD_HMS_TZ(p); + p->rJD += c1 - localtimeOffset(p); + rc = 0; + } + break; + } + case 'w': { + /* + ** weekday N + ** + ** Move the date to the same time on the next occurrance of + ** weekday N where 0==Sunday, 1==Monday, and so forth. If the + ** date is already on the appropriate weekday, this is a no-op. + */ + if( strncmp(z, "weekday ", 8)==0 && getValue(&z[8],&r)>0 + && (n=r)==r && n>=0 && r<7 ){ + int Z; + computeYMD_HMS(p); + p->validTZ = 0; + p->validJD = 0; + computeJD(p); + Z = p->rJD + 1.5; + Z %= 7; + if( Z>n ) Z -= 7; + p->rJD += n - Z; + clearYMD_HMS_TZ(p); + rc = 0; + } + break; + } + case 's': { + /* + ** start of TTTTT + ** + ** Move the date backwards to the beginning of the current day, + ** or month or year. + */ + if( strncmp(z, "start of ", 9)!=0 ) break; + z += 9; + computeYMD(p); + p->validHMS = 1; + p->h = p->m = 0; + p->s = 0.0; + p->validTZ = 0; + p->validJD = 0; + if( strcmp(z,"month")==0 ){ + p->D = 1; + rc = 0; + }else if( strcmp(z,"year")==0 ){ + computeYMD(p); + p->M = 1; + p->D = 1; + rc = 0; + }else if( strcmp(z,"day")==0 ){ + rc = 0; + } + break; + } + case '+': + case '-': + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': { + n = getValue(z, &r); + if( n<=0 ) break; + if( z[n]==':' ){ + /* A modifier of the form (+|-)HH:MM:SS.FFF adds (or subtracts) the + ** specified number of hours, minutes, seconds, and fractional seconds + ** to the time. The ".FFF" may be omitted. The ":SS.FFF" may be + ** omitted. + */ + const char *z2 = z; + DateTime tx; + int day; + if( !isdigit(*z2) ) z2++; + memset(&tx, 0, sizeof(tx)); + if( parseHhMmSs(z2, &tx) ) break; + computeJD(&tx); + tx.rJD -= 0.5; + day = (int)tx.rJD; + tx.rJD -= day; + if( z[0]=='-' ) tx.rJD = -tx.rJD; + computeJD(p); + clearYMD_HMS_TZ(p); + p->rJD += tx.rJD; + rc = 0; + break; + } + z += n; + while( isspace(z[0]) ) z++; + n = strlen(z); + if( n>10 || n<3 ) break; + if( z[n-1]=='s' ){ z[n-1] = 0; n--; } + computeJD(p); + rc = 0; + if( n==3 && strcmp(z,"day")==0 ){ + p->rJD += r; + }else if( n==4 && strcmp(z,"hour")==0 ){ + p->rJD += r/24.0; + }else if( n==6 && strcmp(z,"minute")==0 ){ + p->rJD += r/(24.0*60.0); + }else if( n==6 && strcmp(z,"second")==0 ){ + p->rJD += r/(24.0*60.0*60.0); + }else if( n==5 && strcmp(z,"month")==0 ){ + int x, y; + computeYMD_HMS(p); + p->M += r; + x = p->M>0 ? (p->M-1)/12 : (p->M-12)/12; + p->Y += x; + p->M -= x*12; + p->validJD = 0; + computeJD(p); + y = r; + if( y!=r ){ + p->rJD += (r - y)*30.0; + } + }else if( n==4 && strcmp(z,"year")==0 ){ + computeYMD_HMS(p); + p->Y += r; + p->validJD = 0; + computeJD(p); + }else{ + rc = 1; + } + clearYMD_HMS_TZ(p); + break; + } + default: { + break; + } + } + return rc; +} + +/* +** Process time function arguments. argv[0] is a date-time stamp. +** argv[1] and following are modifiers. Parse them all and write +** the resulting time into the DateTime structure p. Return 0 +** on success and 1 if there are any errors. +*/ +static int isDate(int argc, const char **argv, DateTime *p){ + int i; + if( argc==0 ) return 1; + if( argv[0]==0 || parseDateOrTime(argv[0], p) ) return 1; + for(i=1; i<argc; i++){ + if( argv[i]==0 || parseModifier(argv[i], p) ) return 1; + } + return 0; +} + + +/* +** The following routines implement the various date and time functions +** of SQLite. +*/ + +/* +** julianday( TIMESTRING, MOD, MOD, ...) +** +** Return the julian day number of the date specified in the arguments +*/ +static void juliandayFunc(sqlite_func *context, int argc, const char **argv){ + DateTime x; + if( isDate(argc, argv, &x)==0 ){ + computeJD(&x); + sqlite_set_result_double(context, x.rJD); + } +} + +/* +** datetime( TIMESTRING, MOD, MOD, ...) +** +** Return YYYY-MM-DD HH:MM:SS +*/ +static void datetimeFunc(sqlite_func *context, int argc, const char **argv){ + DateTime x; + if( isDate(argc, argv, &x)==0 ){ + char zBuf[100]; + computeYMD_HMS(&x); + sprintf(zBuf, "%04d-%02d-%02d %02d:%02d:%02d",x.Y, x.M, x.D, x.h, x.m, + (int)(x.s)); + sqlite_set_result_string(context, zBuf, -1); + } +} + +/* +** time( TIMESTRING, MOD, MOD, ...) +** +** Return HH:MM:SS +*/ +static void timeFunc(sqlite_func *context, int argc, const char **argv){ + DateTime x; + if( isDate(argc, argv, &x)==0 ){ + char zBuf[100]; + computeHMS(&x); + sprintf(zBuf, "%02d:%02d:%02d", x.h, x.m, (int)x.s); + sqlite_set_result_string(context, zBuf, -1); + } +} + +/* +** date( TIMESTRING, MOD, MOD, ...) +** +** Return YYYY-MM-DD +*/ +static void dateFunc(sqlite_func *context, int argc, const char **argv){ + DateTime x; + if( isDate(argc, argv, &x)==0 ){ + char zBuf[100]; + computeYMD(&x); + sprintf(zBuf, "%04d-%02d-%02d", x.Y, x.M, x.D); + sqlite_set_result_string(context, zBuf, -1); + } +} + +/* +** strftime( FORMAT, TIMESTRING, MOD, MOD, ...) +** +** Return a string described by FORMAT. Conversions as follows: +** +** %d day of month +** %f ** fractional seconds SS.SSS +** %H hour 00-24 +** %j day of year 000-366 +** %J ** Julian day number +** %m month 01-12 +** %M minute 00-59 +** %s seconds since 1970-01-01 +** %S seconds 00-59 +** %w day of week 0-6 sunday==0 +** %W week of year 00-53 +** %Y year 0000-9999 +** %% % +*/ +static void strftimeFunc(sqlite_func *context, int argc, const char **argv){ + DateTime x; + int n, i, j; + char *z; + const char *zFmt = argv[0]; + char zBuf[100]; + if( argv[0]==0 || isDate(argc-1, argv+1, &x) ) return; + for(i=0, n=1; zFmt[i]; i++, n++){ + if( zFmt[i]=='%' ){ + switch( zFmt[i+1] ){ + case 'd': + case 'H': + case 'm': + case 'M': + case 'S': + case 'W': + n++; + /* fall thru */ + case 'w': + case '%': + break; + case 'f': + n += 8; + break; + case 'j': + n += 3; + break; + case 'Y': + n += 8; + break; + case 's': + case 'J': + n += 50; + break; + default: + return; /* ERROR. return a NULL */ + } + i++; + } + } + if( n<sizeof(zBuf) ){ + z = zBuf; + }else{ + z = sqliteMalloc( n ); + if( z==0 ) return; + } + computeJD(&x); + computeYMD_HMS(&x); + for(i=j=0; zFmt[i]; i++){ + if( zFmt[i]!='%' ){ + z[j++] = zFmt[i]; + }else{ + i++; + switch( zFmt[i] ){ + case 'd': sprintf(&z[j],"%02d",x.D); j+=2; break; + case 'f': { + int s = x.s; + int ms = (x.s - s)*1000.0; + sprintf(&z[j],"%02d.%03d",s,ms); + j += strlen(&z[j]); + break; + } + case 'H': sprintf(&z[j],"%02d",x.h); j+=2; break; + case 'W': /* Fall thru */ + case 'j': { + int n; /* Number of days since 1st day of year */ + DateTime y = x; + y.validJD = 0; + y.M = 1; + y.D = 1; + computeJD(&y); + n = x.rJD - y.rJD; + if( zFmt[i]=='W' ){ + int wd; /* 0=Monday, 1=Tuesday, ... 6=Sunday */ + wd = ((int)(x.rJD+0.5)) % 7; + sprintf(&z[j],"%02d",(n+7-wd)/7); + j += 2; + }else{ + sprintf(&z[j],"%03d",n+1); + j += 3; + } + break; + } + case 'J': sprintf(&z[j],"%.16g",x.rJD); j+=strlen(&z[j]); break; + case 'm': sprintf(&z[j],"%02d",x.M); j+=2; break; + case 'M': sprintf(&z[j],"%02d",x.m); j+=2; break; + case 's': { + sprintf(&z[j],"%d",(int)((x.rJD-2440587.5)*86400.0 + 0.5)); + j += strlen(&z[j]); + break; + } + case 'S': sprintf(&z[j],"%02d",(int)(x.s+0.5)); j+=2; break; + case 'w': z[j++] = (((int)(x.rJD+1.5)) % 7) + '0'; break; + case 'Y': sprintf(&z[j],"%04d",x.Y); j+=strlen(&z[j]); break; + case '%': z[j++] = '%'; break; + } + } + } + z[j] = 0; + sqlite_set_result_string(context, z, -1); + if( z!=zBuf ){ + sqliteFree(z); + } +} + + +#endif /* !defined(SQLITE_OMIT_DATETIME_FUNCS) */ + +/* +** 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 sqliteRegisterDateTimeFunctions(sqlite *db){ +#ifndef SQLITE_OMIT_DATETIME_FUNCS + static struct { + char *zName; + int nArg; + int dataType; + void (*xFunc)(sqlite_func*,int,const char**); + } aFuncs[] = { + { "julianday", -1, SQLITE_NUMERIC, juliandayFunc }, + { "date", -1, SQLITE_TEXT, dateFunc }, + { "time", -1, SQLITE_TEXT, timeFunc }, + { "datetime", -1, SQLITE_TEXT, datetimeFunc }, + { "strftime", -1, SQLITE_TEXT, strftimeFunc }, + }; + int i; + + for(i=0; i<sizeof(aFuncs)/sizeof(aFuncs[0]); i++){ + sqlite_create_function(db, aFuncs[i].zName, + aFuncs[i].nArg, aFuncs[i].xFunc, 0); + if( aFuncs[i].xFunc ){ + sqlite_function_type(db, aFuncs[i].zName, aFuncs[i].dataType); + } + } +#endif +} diff --git a/kexi/3rdparty/kexisql/src/delete.c b/kexi/3rdparty/kexisql/src/delete.c new file mode 100644 index 00000000..54375422 --- /dev/null +++ b/kexi/3rdparty/kexisql/src/delete.c @@ -0,0 +1,393 @@ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains C code routines that are called by the parser +** to handle DELETE FROM statements. +** +** $Id: delete.c 410099 2005-05-06 17:52:07Z staniek $ +*/ +#include "sqliteInt.h" + +/* +** Look up every table that is named in pSrc. If any table is not found, +** add an error message to pParse->zErrMsg and return NULL. If all tables +** are found, return a pointer to the last table. +*/ +Table *sqliteSrcListLookup(Parse *pParse, SrcList *pSrc){ + Table *pTab = 0; + int i; + for(i=0; i<pSrc->nSrc; i++){ + const char *zTab = pSrc->a[i].zName; + const char *zDb = pSrc->a[i].zDatabase; + pTab = sqliteLocateTable(pParse, zTab, zDb); + pSrc->a[i].pTab = pTab; + } + return pTab; +} + +/* +** Check to make sure the given table is writable. If it is not +** writable, generate an error message and return 1. If it is +** writable return 0; +*/ +int sqliteIsReadOnly(Parse *pParse, Table *pTab, int viewOk){ + if( pTab->readOnly ){ + sqliteErrorMsg(pParse, "table %s may not be modified", pTab->zName); + return 1; + } + if( !viewOk && pTab->pSelect ){ + sqliteErrorMsg(pParse, "cannot modify %s because it is a view",pTab->zName); + return 1; + } + return 0; +} + +/* +** Process a DELETE FROM statement. +*/ +void sqliteDeleteFrom( + Parse *pParse, /* The parser context */ + SrcList *pTabList, /* The table from which we should delete things */ + Expr *pWhere /* The WHERE clause. May be null */ +){ + Vdbe *v; /* The virtual database engine */ + Table *pTab; /* The table from which records will be deleted */ + const char *zDb; /* Name of database holding pTab */ + int end, addr; /* A couple addresses of generated code */ + int i; /* Loop counter */ + WhereInfo *pWInfo; /* Information about the WHERE clause */ + Index *pIdx; /* For looping over indices of the table */ + int iCur; /* VDBE Cursor number for pTab */ + sqlite *db; /* Main database structure */ + int isView; /* True if attempting to delete from a view */ + AuthContext sContext; /* Authorization context */ + + int row_triggers_exist = 0; /* True if any triggers exist */ + int before_triggers; /* True if there are BEFORE triggers */ + int after_triggers; /* True if there are AFTER triggers */ + int oldIdx = -1; /* Cursor for the OLD table of AFTER triggers */ + + sContext.pParse = 0; + if( pParse->nErr || sqlite_malloc_failed ){ + pTabList = 0; + goto delete_from_cleanup; + } + db = pParse->db; + assert( pTabList->nSrc==1 ); + + /* Locate the table which we want to delete. This table has to be + ** put in an SrcList structure because some of the subroutines we + ** will be calling are designed to work with multiple tables and expect + ** an SrcList* parameter instead of just a Table* parameter. + */ + pTab = sqliteSrcListLookup(pParse, pTabList); + if( pTab==0 ) goto delete_from_cleanup; + before_triggers = sqliteTriggersExist(pParse, pTab->pTrigger, + TK_DELETE, TK_BEFORE, TK_ROW, 0); + after_triggers = sqliteTriggersExist(pParse, pTab->pTrigger, + TK_DELETE, TK_AFTER, TK_ROW, 0); + row_triggers_exist = before_triggers || after_triggers; + isView = pTab->pSelect!=0; + if( sqliteIsReadOnly(pParse, pTab, before_triggers) ){ + goto delete_from_cleanup; + } + assert( pTab->iDb<db->nDb ); + zDb = db->aDb[pTab->iDb].zName; + if( sqliteAuthCheck(pParse, SQLITE_DELETE, pTab->zName, 0, zDb) ){ + goto delete_from_cleanup; + } + + /* If pTab is really a view, make sure it has been initialized. + */ + if( isView && sqliteViewGetColumnNames(pParse, pTab) ){ + goto delete_from_cleanup; + } + + /* Allocate a cursor used to store the old.* data for a trigger. + */ + if( row_triggers_exist ){ + oldIdx = pParse->nTab++; + } + + /* Resolve the column names in all the expressions. + */ + assert( pTabList->nSrc==1 ); + iCur = pTabList->a[0].iCursor = pParse->nTab++; + if( pWhere ){ + if( sqliteExprResolveIds(pParse, pTabList, 0, pWhere) ){ + goto delete_from_cleanup; + } + if( sqliteExprCheck(pParse, pWhere, 0, 0) ){ + goto delete_from_cleanup; + } + } + + /* Start the view context + */ + if( isView ){ + sqliteAuthContextPush(pParse, &sContext, pTab->zName); + } + + /* Begin generating code. + */ + v = sqliteGetVdbe(pParse); + if( v==0 ){ + goto delete_from_cleanup; + } + sqliteBeginWriteOperation(pParse, row_triggers_exist, pTab->iDb); + + /* If we are trying to delete from a view, construct that view into + ** a temporary table. + */ + if( isView ){ + Select *pView = sqliteSelectDup(pTab->pSelect); + sqliteSelect(pParse, pView, SRT_TempTable, iCur, 0, 0, 0); + sqliteSelectDelete(pView); + } + + /* Initialize the counter of the number of rows deleted, if + ** we are counting rows. + */ + if( db->flags & SQLITE_CountRows ){ + sqliteVdbeAddOp(v, OP_Integer, 0, 0); + } + + /* Special case: A DELETE without a WHERE clause deletes everything. + ** It is easier just to erase the whole table. Note, however, that + ** this means that the row change count will be incorrect. + */ + if( pWhere==0 && !row_triggers_exist ){ + if( db->flags & SQLITE_CountRows ){ + /* If counting rows deleted, just count the total number of + ** entries in the table. */ + int endOfLoop = sqliteVdbeMakeLabel(v); + int addr; + if( !isView ){ + sqliteVdbeAddOp(v, OP_Integer, pTab->iDb, 0); + sqliteVdbeAddOp(v, OP_OpenRead, iCur, pTab->tnum); + } + sqliteVdbeAddOp(v, OP_Rewind, iCur, sqliteVdbeCurrentAddr(v)+2); + addr = sqliteVdbeAddOp(v, OP_AddImm, 1, 0); + sqliteVdbeAddOp(v, OP_Next, iCur, addr); + sqliteVdbeResolveLabel(v, endOfLoop); + sqliteVdbeAddOp(v, OP_Close, iCur, 0); + } + if( !isView ){ + sqliteVdbeAddOp(v, OP_Clear, pTab->tnum, pTab->iDb); + for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){ + sqliteVdbeAddOp(v, OP_Clear, pIdx->tnum, pIdx->iDb); + } + } + } + + /* The usual case: There is a WHERE clause so we have to scan through + ** the table and pick which records to delete. + */ + else{ + /* Begin the database scan + */ + pWInfo = sqliteWhereBegin(pParse, pTabList, pWhere, 1, 0); + if( pWInfo==0 ) goto delete_from_cleanup; + + /* Remember the key of every item to be deleted. + */ + sqliteVdbeAddOp(v, OP_ListWrite, 0, 0); + if( db->flags & SQLITE_CountRows ){ + sqliteVdbeAddOp(v, OP_AddImm, 1, 0); + } + + /* End the database scan loop. + */ + sqliteWhereEnd(pWInfo); + + /* Open the pseudo-table used to store OLD if there are triggers. + */ + if( row_triggers_exist ){ + sqliteVdbeAddOp(v, OP_OpenPseudo, oldIdx, 0); + } + + /* Delete every item whose key was written to the list during the + ** database scan. We have to delete items after the scan is complete + ** because deleting an item can change the scan order. + */ + sqliteVdbeAddOp(v, OP_ListRewind, 0, 0); + end = sqliteVdbeMakeLabel(v); + + /* This is the beginning of the delete loop when there are + ** row triggers. + */ + if( row_triggers_exist ){ + addr = sqliteVdbeAddOp(v, OP_ListRead, 0, end); + sqliteVdbeAddOp(v, OP_Dup, 0, 0); + if( !isView ){ + sqliteVdbeAddOp(v, OP_Integer, pTab->iDb, 0); + sqliteVdbeAddOp(v, OP_OpenRead, iCur, pTab->tnum); + } + sqliteVdbeAddOp(v, OP_MoveTo, iCur, 0); + + sqliteVdbeAddOp(v, OP_Recno, iCur, 0); + sqliteVdbeAddOp(v, OP_RowData, iCur, 0); + sqliteVdbeAddOp(v, OP_PutIntKey, oldIdx, 0); + if( !isView ){ + sqliteVdbeAddOp(v, OP_Close, iCur, 0); + } + + sqliteCodeRowTrigger(pParse, TK_DELETE, 0, TK_BEFORE, pTab, -1, + oldIdx, (pParse->trigStack)?pParse->trigStack->orconf:OE_Default, + addr); + } + + if( !isView ){ + /* Open cursors for the table we are deleting from and all its + ** indices. If there are row triggers, this happens inside the + ** OP_ListRead loop because the cursor have to all be closed + ** before the trigger fires. If there are no row triggers, the + ** cursors are opened only once on the outside the loop. + */ + pParse->nTab = iCur + 1; + sqliteOpenTableAndIndices(pParse, pTab, iCur); + + /* This is the beginning of the delete loop when there are no + ** row triggers */ + if( !row_triggers_exist ){ + addr = sqliteVdbeAddOp(v, OP_ListRead, 0, end); + } + + /* Delete the row */ + sqliteGenerateRowDelete(db, v, pTab, iCur, pParse->trigStack==0); + } + + /* If there are row triggers, close all cursors then invoke + ** the AFTER triggers + */ + if( row_triggers_exist ){ + if( !isView ){ + for(i=1, pIdx=pTab->pIndex; pIdx; i++, pIdx=pIdx->pNext){ + sqliteVdbeAddOp(v, OP_Close, iCur + i, pIdx->tnum); + } + sqliteVdbeAddOp(v, OP_Close, iCur, 0); + } + sqliteCodeRowTrigger(pParse, TK_DELETE, 0, TK_AFTER, pTab, -1, + oldIdx, (pParse->trigStack)?pParse->trigStack->orconf:OE_Default, + addr); + } + + /* End of the delete loop */ + sqliteVdbeAddOp(v, OP_Goto, 0, addr); + sqliteVdbeResolveLabel(v, end); + sqliteVdbeAddOp(v, OP_ListReset, 0, 0); + + /* Close the cursors after the loop if there are no row triggers */ + if( !row_triggers_exist ){ + for(i=1, pIdx=pTab->pIndex; pIdx; i++, pIdx=pIdx->pNext){ + sqliteVdbeAddOp(v, OP_Close, iCur + i, pIdx->tnum); + } + sqliteVdbeAddOp(v, OP_Close, iCur, 0); + pParse->nTab = iCur; + } + } + sqliteVdbeAddOp(v, OP_SetCounts, 0, 0); + sqliteEndWriteOperation(pParse); + + /* + ** Return the number of rows that were deleted. + */ + if( db->flags & SQLITE_CountRows ){ + sqliteVdbeAddOp(v, OP_ColumnName, 0, 1); + sqliteVdbeChangeP3(v, -1, "rows deleted", P3_STATIC); + sqliteVdbeAddOp(v, OP_Callback, 1, 0); + } + +delete_from_cleanup: + sqliteAuthContextPop(&sContext); + sqliteSrcListDelete(pTabList); + sqliteExprDelete(pWhere); + return; +} + +/* +** This routine generates VDBE code that causes a single row of a +** single table to be deleted. +** +** The VDBE must be in a particular state when this routine is called. +** These are the requirements: +** +** 1. A read/write cursor pointing to pTab, the table containing the row +** to be deleted, must be opened as cursor number "base". +** +** 2. Read/write cursors for all indices of pTab must be open as +** cursor number base+i for the i-th index. +** +** 3. The record number of the row to be deleted must be on the top +** of the stack. +** +** This routine pops the top of the stack to remove the record number +** and then generates code to remove both the table record and all index +** entries that point to that record. +*/ +void sqliteGenerateRowDelete( + sqlite *db, /* The database containing the index */ + Vdbe *v, /* Generate code into this VDBE */ + Table *pTab, /* Table containing the row to be deleted */ + int iCur, /* Cursor number for the table */ + int count /* Increment the row change counter */ +){ + int addr; + addr = sqliteVdbeAddOp(v, OP_NotExists, iCur, 0); + sqliteGenerateRowIndexDelete(db, v, pTab, iCur, 0); + sqliteVdbeAddOp(v, OP_Delete, iCur, + (count?OPFLAG_NCHANGE:0) | OPFLAG_CSCHANGE); + sqliteVdbeChangeP2(v, addr, sqliteVdbeCurrentAddr(v)); +} + +/* +** This routine generates VDBE code that causes the deletion of all +** index entries associated with a single row of a single table. +** +** The VDBE must be in a particular state when this routine is called. +** These are the requirements: +** +** 1. A read/write cursor pointing to pTab, the table containing the row +** to be deleted, must be opened as cursor number "iCur". +** +** 2. Read/write cursors for all indices of pTab must be open as +** cursor number iCur+i for the i-th index. +** +** 3. The "iCur" cursor must be pointing to the row that is to be +** deleted. +*/ +void sqliteGenerateRowIndexDelete( + sqlite *db, /* The database containing the index */ + Vdbe *v, /* Generate code into this VDBE */ + Table *pTab, /* Table containing the row to be deleted */ + int iCur, /* Cursor number for the table */ + char *aIdxUsed /* Only delete if aIdxUsed!=0 && aIdxUsed[i]!=0 */ +){ + int i; + Index *pIdx; + + for(i=1, pIdx=pTab->pIndex; pIdx; i++, pIdx=pIdx->pNext){ + int j; + if( aIdxUsed!=0 && aIdxUsed[i-1]==0 ) continue; + sqliteVdbeAddOp(v, OP_Recno, iCur, 0); + for(j=0; j<pIdx->nColumn; 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); + } +} diff --git a/kexi/3rdparty/kexisql/src/encode.c b/kexi/3rdparty/kexisql/src/encode.c new file mode 100644 index 00000000..899901b5 --- /dev/null +++ b/kexi/3rdparty/kexisql/src/encode.c @@ -0,0 +1,254 @@ +/* +** 2002 April 25 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains helper routines used to translate binary data into +** a null-terminated string (suitable for use in SQLite) and back again. +** These are convenience routines for use by people who want to store binary +** data in an SQLite database. The code in this file is not used by any other +** part of the SQLite library. +** +** $Id: encode.c 410099 2005-05-06 17:52:07Z staniek $ +*/ +#include <string.h> +#include <assert.h> + +/* +** How This Encoder Works +** +** The output is allowed to contain any character except 0x27 (') and +** 0x00. This is accomplished by using an escape character to encode +** 0x27 and 0x00 as a two-byte sequence. The escape character is always +** 0x01. An 0x00 is encoded as the two byte sequence 0x01 0x01. The +** 0x27 character is encoded as the two byte sequence 0x01 0x28. Finally, +** the escape character itself is encoded as the two-character sequence +** 0x01 0x02. +** +** To summarize, the encoder works by using an escape sequences as follows: +** +** 0x00 -> 0x01 0x01 +** 0x01 -> 0x01 0x02 +** 0x27 -> 0x01 0x28 +** +** If that were all the encoder did, it would work, but in certain cases +** it could double the size of the encoded string. For example, to +** encode a string of 100 0x27 characters would require 100 instances of +** the 0x01 0x03 escape sequence resulting in a 200-character output. +** We would prefer to keep the size of the encoded string smaller than +** this. +** +** To minimize the encoding size, we first add a fixed offset value to each +** byte in the sequence. The addition is modulo 256. (That is to say, if +** the sum of the original character value and the offset exceeds 256, then +** the higher order bits are truncated.) The offset is chosen to minimize +** the number of characters in the string that need to be escaped. For +** example, in the case above where the string was composed of 100 0x27 +** characters, the offset might be 0x01. Each of the 0x27 characters would +** then be converted into an 0x28 character which would not need to be +** escaped at all and so the 100 character input string would be converted +** into just 100 characters of output. Actually 101 characters of output - +** we have to record the offset used as the first byte in the sequence so +** that the string can be decoded. Since the offset value is stored as +** part of the output string and the output string is not allowed to contain +** characters 0x00 or 0x27, the offset cannot be 0x00 or 0x27. +** +** Here, then, are the encoding steps: +** +** (1) Choose an offset value and make it the first character of +** output. +** +** (2) Copy each input character into the output buffer, one by +** one, adding the offset value as you copy. +** +** (3) If the value of an input character plus offset is 0x00, replace +** that one character by the two-character sequence 0x01 0x01. +** If the sum is 0x01, replace it with 0x01 0x02. If the sum +** is 0x27, replace it with 0x01 0x03. +** +** (4) Put a 0x00 terminator at the end of the output. +** +** Decoding is obvious: +** +** (5) Copy encoded characters except the first into the decode +** buffer. Set the first encoded character aside for use as +** the offset in step 7 below. +** +** (6) Convert each 0x01 0x01 sequence into a single character 0x00. +** Convert 0x01 0x02 into 0x01. Convert 0x01 0x28 into 0x27. +** +** (7) Subtract the offset value that was the first character of +** the encoded buffer from all characters in the output buffer. +** +** The only tricky part is step (1) - how to compute an offset value to +** minimize the size of the output buffer. This is accomplished by testing +** all offset values and picking the one that results in the fewest number +** of escapes. To do that, we first scan the entire input and count the +** number of occurances of each character value in the input. Suppose +** the number of 0x00 characters is N(0), the number of occurances of 0x01 +** is N(1), and so forth up to the number of occurances of 0xff is N(255). +** An offset of 0 is not allowed so we don't have to test it. The number +** of escapes required for an offset of 1 is N(1)+N(2)+N(40). The number +** of escapes required for an offset of 2 is N(2)+N(3)+N(41). And so forth. +** In this way we find the offset that gives the minimum number of escapes, +** and thus minimizes the length of the output string. +*/ + +/* +** Encode a binary buffer "in" of size n bytes so that it contains +** no instances of characters '\'' or '\000'. The output is +** null-terminated and can be used as a string value in an INSERT +** or UPDATE statement. Use sqlite_decode_binary() to convert the +** string back into its original binary. +** +** The result is written into a preallocated output buffer "out". +** "out" must be able to hold at least 2 +(257*n)/254 bytes. +** In other words, the output will be expanded by as much as 3 +** bytes for every 254 bytes of input plus 2 bytes of fixed overhead. +** (This is approximately 2 + 1.0118*n or about a 1.2% size increase.) +** +** The return value is the number of characters in the encoded +** string, excluding the "\000" terminator. +** +** If out==NULL then no output is generated but the routine still returns +** the number of characters that would have been generated if out had +** not been NULL. +*/ +int sqlite_encode_binary(const unsigned char *in, int n, unsigned char *out){ + int i, j, e, m; + unsigned char x; + int cnt[256]; + if( n<=0 ){ + if( out ){ + out[0] = 'x'; + out[1] = 0; + } + return 1; + } + memset(cnt, 0, sizeof(cnt)); + for(i=n-1; i>=0; i--){ cnt[in[i]]++; } + m = n; + for(i=1; i<256; i++){ + int sum; + if( i=='\'' ) continue; + sum = cnt[i] + cnt[(i+1)&0xff] + cnt[(i+'\'')&0xff]; + if( sum<m ){ + m = sum; + e = i; + if( m==0 ) break; + } + } + if( out==0 ){ + return n+m+1; + } + out[0] = e; + j = 1; + for(i=0; i<n; i++){ + x = in[i] - e; + if( x==0 || x==1 || x=='\''){ + out[j++] = 1; + x++; + } + out[j++] = x; + } + out[j] = 0; + assert( j==n+m+1 ); + return j; +} + +/* +** Decode the string "in" into binary data and write it into "out". +** This routine reverses the encoding created by sqlite_encode_binary(). +** The output will always be a few bytes less than the input. The number +** of bytes of output is returned. If the input is not a well-formed +** encoding, -1 is returned. +** +** The "in" and "out" parameters may point to the same buffer in order +** to decode a string in place. +*/ +int sqlite_decode_binary(const unsigned char *in, unsigned char *out){ + int i, e; + unsigned char c; + e = *(in++); + i = 0; + while( (c = *(in++))!=0 ){ + if( c==1 ){ + c = *(in++) - 1; + } + out[i++] = c + e; + } + return i; +} + +#ifdef ENCODER_TEST +#include <stdio.h> +/* +** The subroutines above are not tested by the usual test suite. To test +** these routines, compile just this one file with a -DENCODER_TEST=1 option +** and run the result. +*/ +int main(int argc, char **argv){ + int i, j, n, m, nOut, nByteIn, nByteOut; + unsigned char in[30000]; + unsigned char out[33000]; + + nByteIn = nByteOut = 0; + for(i=0; i<sizeof(in); i++){ + printf("Test %d: ", i+1); + n = rand() % (i+1); + if( i%100==0 ){ + int k; + for(j=k=0; j<n; j++){ + /* if( k==0 || k=='\'' ) k++; */ + in[j] = k; + k = (k+1)&0xff; + } + }else{ + for(j=0; j<n; j++) in[j] = rand() & 0xff; + } + nByteIn += n; + nOut = sqlite_encode_binary(in, n, out); + nByteOut += nOut; + if( nOut!=strlen(out) ){ + printf(" ERROR return value is %d instead of %d\n", nOut, strlen(out)); + exit(1); + } + if( nOut!=sqlite_encode_binary(in, n, 0) ){ + printf(" ERROR actual output size disagrees with predicted size\n"); + exit(1); + } + m = (256*n + 1262)/253; + printf("size %d->%d (max %d)", n, strlen(out)+1, m); + if( strlen(out)+1>m ){ + printf(" ERROR output too big\n"); + exit(1); + } + for(j=0; out[j]; j++){ + if( out[j]=='\'' ){ + printf(" ERROR contains (')\n"); + exit(1); + } + } + j = sqlite_decode_binary(out, out); + if( j!=n ){ + printf(" ERROR decode size %d\n", j); + exit(1); + } + if( memcmp(in, out, n)!=0 ){ + printf(" ERROR decode mismatch\n"); + exit(1); + } + printf(" OK\n"); + } + fprintf(stderr,"Finished. Total encoding: %d->%d bytes\n", + nByteIn, nByteOut); + fprintf(stderr,"Avg size increase: %.3f%%\n", + (nByteOut-nByteIn)*100.0/(double)nByteIn); +} +#endif /* ENCODER_TEST */ diff --git a/kexi/3rdparty/kexisql/src/expr.c b/kexi/3rdparty/kexisql/src/expr.c new file mode 100644 index 00000000..b4fb936d --- /dev/null +++ b/kexi/3rdparty/kexisql/src/expr.c @@ -0,0 +1,1662 @@ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains routines used for analyzing expressions and +** for generating VDBE code that evaluates expressions in SQLite. +** +** $Id: expr.c 410099 2005-05-06 17:52:07Z staniek $ +*/ +#include "sqliteInt.h" +#include <ctype.h> + +/* +** Construct a new expression node and return a pointer to it. Memory +** for this node is obtained from sqliteMalloc(). The calling function +** is responsible for making sure the node eventually gets freed. +*/ +Expr *sqliteExpr(int op, Expr *pLeft, Expr *pRight, Token *pToken){ + Expr *pNew; + pNew = sqliteMalloc( sizeof(Expr) ); + if( pNew==0 ){ + /* When malloc fails, we leak memory from pLeft and pRight */ + return 0; + } + pNew->op = op; + pNew->pLeft = pLeft; + pNew->pRight = pRight; + if( pToken ){ + assert( pToken->dyn==0 ); + pNew->token = *pToken; + pNew->span = *pToken; + }else{ + assert( pNew->token.dyn==0 ); + assert( pNew->token.z==0 ); + assert( pNew->token.n==0 ); + if( pLeft && pRight ){ + sqliteExprSpan(pNew, &pLeft->span, &pRight->span); + }else{ + pNew->span = pNew->token; + } + } + return pNew; +} + +/* +** Set the Expr.span field of the given expression to span all +** text between the two given tokens. +*/ +void sqliteExprSpan(Expr *pExpr, Token *pLeft, Token *pRight){ + assert( pRight!=0 ); + assert( pLeft!=0 ); + /* Note: pExpr might be NULL due to a prior malloc failure */ + if( pExpr && pRight->z && pLeft->z ){ + if( pLeft->dyn==0 && pRight->dyn==0 ){ + pExpr->span.z = pLeft->z; + pExpr->span.n = pRight->n + Addr(pRight->z) - Addr(pLeft->z); + }else{ + pExpr->span.z = 0; + } + } +} + +/* +** Construct a new expression node for a function with multiple +** arguments. +*/ +Expr *sqliteExprFunction(ExprList *pList, Token *pToken){ + Expr *pNew; + pNew = sqliteMalloc( sizeof(Expr) ); + if( pNew==0 ){ + /* sqliteExprListDelete(pList); // Leak pList when malloc fails */ + return 0; + } + pNew->op = TK_FUNCTION; + pNew->pList = pList; + if( pToken ){ + assert( pToken->dyn==0 ); + pNew->token = *pToken; + }else{ + pNew->token.z = 0; + } + pNew->span = pNew->token; + return pNew; +} + +/* +** Recursively delete an expression tree. +*/ +void sqliteExprDelete(Expr *p){ + if( p==0 ) return; + if( p->span.dyn ) sqliteFree((char*)p->span.z); + if( p->token.dyn ) sqliteFree((char*)p->token.z); + sqliteExprDelete(p->pLeft); + sqliteExprDelete(p->pRight); + sqliteExprListDelete(p->pList); + sqliteSelectDelete(p->pSelect); + sqliteFree(p); +} + + +/* +** The following group of routines make deep copies of expressions, +** expression lists, ID lists, and select statements. The copies can +** be deleted (by being passed to their respective ...Delete() routines) +** without effecting the originals. +** +** The expression list, ID, and source lists return by sqliteExprListDup(), +** sqliteIdListDup(), and sqliteSrcListDup() can not be further expanded +** by subsequent calls to sqlite*ListAppend() routines. +** +** Any tables that the SrcList might point to are not duplicated. +*/ +Expr *sqliteExprDup(Expr *p){ + Expr *pNew; + if( p==0 ) return 0; + pNew = sqliteMallocRaw( sizeof(*p) ); + if( pNew==0 ) return 0; + memcpy(pNew, p, sizeof(*pNew)); + if( p->token.z!=0 ){ + pNew->token.z = sqliteStrDup(p->token.z); + pNew->token.dyn = 1; + }else{ + assert( pNew->token.z==0 ); + } + pNew->span.z = 0; + pNew->pLeft = sqliteExprDup(p->pLeft); + pNew->pRight = sqliteExprDup(p->pRight); + pNew->pList = sqliteExprListDup(p->pList); + pNew->pSelect = sqliteSelectDup(p->pSelect); + return pNew; +} +void sqliteTokenCopy(Token *pTo, Token *pFrom){ + if( pTo->dyn ) sqliteFree((char*)pTo->z); + if( pFrom->z ){ + pTo->n = pFrom->n; + pTo->z = sqliteStrNDup(pFrom->z, pFrom->n); + pTo->dyn = 1; + }else{ + pTo->z = 0; + } +} +ExprList *sqliteExprListDup(ExprList *p){ + ExprList *pNew; + struct ExprList_item *pItem; + int i; + if( p==0 ) return 0; + pNew = sqliteMalloc( sizeof(*pNew) ); + if( pNew==0 ) return 0; + pNew->nExpr = pNew->nAlloc = p->nExpr; + pNew->a = pItem = sqliteMalloc( p->nExpr*sizeof(p->a[0]) ); + if( pItem==0 ){ + sqliteFree(pNew); + return 0; + } + for(i=0; i<p->nExpr; i++, pItem++){ + Expr *pNewExpr, *pOldExpr; + pItem->pExpr = pNewExpr = sqliteExprDup(pOldExpr = p->a[i].pExpr); + if( pOldExpr->span.z!=0 && pNewExpr ){ + /* Always make a copy of the span for top-level expressions in the + ** expression list. The logic in SELECT processing that determines + ** the names of columns in the result set needs this information */ + sqliteTokenCopy(&pNewExpr->span, &pOldExpr->span); + } + assert( pNewExpr==0 || pNewExpr->span.z!=0 + || pOldExpr->span.z==0 || sqlite_malloc_failed ); + pItem->zName = sqliteStrDup(p->a[i].zName); + pItem->sortOrder = p->a[i].sortOrder; + pItem->isAgg = p->a[i].isAgg; + pItem->done = 0; + } + return pNew; +} +SrcList *sqliteSrcListDup(SrcList *p){ + SrcList *pNew; + int i; + int nByte; + if( p==0 ) return 0; + nByte = sizeof(*p) + (p->nSrc>0 ? sizeof(p->a[0]) * (p->nSrc-1) : 0); + pNew = sqliteMallocRaw( nByte ); + if( pNew==0 ) return 0; + pNew->nSrc = pNew->nAlloc = p->nSrc; + for(i=0; i<p->nSrc; i++){ + struct SrcList_item *pNewItem = &pNew->a[i]; + struct SrcList_item *pOldItem = &p->a[i]; + pNewItem->zDatabase = sqliteStrDup(pOldItem->zDatabase); + pNewItem->zName = sqliteStrDup(pOldItem->zName); + pNewItem->zAlias = sqliteStrDup(pOldItem->zAlias); + pNewItem->jointype = pOldItem->jointype; + pNewItem->iCursor = pOldItem->iCursor; + pNewItem->pTab = 0; + pNewItem->pSelect = sqliteSelectDup(pOldItem->pSelect); + pNewItem->pOn = sqliteExprDup(pOldItem->pOn); + pNewItem->pUsing = sqliteIdListDup(pOldItem->pUsing); + } + return pNew; +} +IdList *sqliteIdListDup(IdList *p){ + IdList *pNew; + int i; + if( p==0 ) return 0; + pNew = sqliteMallocRaw( sizeof(*pNew) ); + if( pNew==0 ) return 0; + pNew->nId = pNew->nAlloc = p->nId; + pNew->a = sqliteMallocRaw( p->nId*sizeof(p->a[0]) ); + if( pNew->a==0 ) return 0; + for(i=0; i<p->nId; i++){ + struct IdList_item *pNewItem = &pNew->a[i]; + struct IdList_item *pOldItem = &p->a[i]; + pNewItem->zName = sqliteStrDup(pOldItem->zName); + pNewItem->idx = pOldItem->idx; + } + return pNew; +} +Select *sqliteSelectDup(Select *p){ + Select *pNew; + if( p==0 ) return 0; + pNew = sqliteMallocRaw( sizeof(*p) ); + if( pNew==0 ) return 0; + pNew->isDistinct = p->isDistinct; + pNew->pEList = sqliteExprListDup(p->pEList); + pNew->pSrc = sqliteSrcListDup(p->pSrc); + pNew->pWhere = sqliteExprDup(p->pWhere); + pNew->pGroupBy = sqliteExprListDup(p->pGroupBy); + pNew->pHaving = sqliteExprDup(p->pHaving); + pNew->pOrderBy = sqliteExprListDup(p->pOrderBy); + pNew->op = p->op; + pNew->pPrior = sqliteSelectDup(p->pPrior); + pNew->nLimit = p->nLimit; + pNew->nOffset = p->nOffset; + pNew->zSelect = 0; + pNew->iLimit = -1; + pNew->iOffset = -1; + return pNew; +} + + +/* +** Add a new element to the end of an expression list. If pList is +** initially NULL, then create a new expression list. +*/ +ExprList *sqliteExprListAppend(ExprList *pList, Expr *pExpr, Token *pName){ + if( pList==0 ){ + pList = sqliteMalloc( sizeof(ExprList) ); + if( pList==0 ){ + /* sqliteExprDelete(pExpr); // Leak memory if malloc fails */ + return 0; + } + assert( pList->nAlloc==0 ); + } + if( pList->nAlloc<=pList->nExpr ){ + pList->nAlloc = pList->nAlloc*2 + 4; + pList->a = sqliteRealloc(pList->a, pList->nAlloc*sizeof(pList->a[0])); + if( pList->a==0 ){ + /* sqliteExprDelete(pExpr); // Leak memory if malloc fails */ + pList->nExpr = pList->nAlloc = 0; + return pList; + } + } + assert( pList->a!=0 ); + if( pExpr || pName ){ + struct ExprList_item *pItem = &pList->a[pList->nExpr++]; + memset(pItem, 0, sizeof(*pItem)); + pItem->pExpr = pExpr; + if( pName ){ + sqliteSetNString(&pItem->zName, pName->z, pName->n, 0); + sqliteDequote(pItem->zName); + } + } + return pList; +} + +/* +** Delete an entire expression list. +*/ +void sqliteExprListDelete(ExprList *pList){ + int i; + if( pList==0 ) return; + assert( pList->a!=0 || (pList->nExpr==0 && pList->nAlloc==0) ); + assert( pList->nExpr<=pList->nAlloc ); + for(i=0; i<pList->nExpr; i++){ + sqliteExprDelete(pList->a[i].pExpr); + sqliteFree(pList->a[i].zName); + } + sqliteFree(pList->a); + sqliteFree(pList); +} + +/* +** Walk an expression tree. Return 1 if the expression is constant +** and 0 if it involves variables. +** +** For the purposes of this function, a double-quoted string (ex: "abc") +** is considered a variable but a single-quoted string (ex: 'abc') is +** a constant. +*/ +int sqliteExprIsConstant(Expr *p){ + switch( p->op ){ + case TK_ID: + case TK_COLUMN: + case TK_DOT: + case TK_FUNCTION: + return 0; + case TK_NULL: + case TK_STRING: + case TK_INTEGER: + case TK_FLOAT: + case TK_VARIABLE: + return 1; + default: { + if( p->pLeft && !sqliteExprIsConstant(p->pLeft) ) return 0; + if( p->pRight && !sqliteExprIsConstant(p->pRight) ) return 0; + if( p->pList ){ + int i; + for(i=0; i<p->pList->nExpr; i++){ + if( !sqliteExprIsConstant(p->pList->a[i].pExpr) ) return 0; + } + } + return p->pLeft!=0 || p->pRight!=0 || (p->pList && p->pList->nExpr>0); + } + } + return 0; +} + +/* +** If the given expression codes a constant integer that is small enough +** to fit in a 32-bit integer, return 1 and put the value of the integer +** in *pValue. If the expression is not an integer or if it is too big +** to fit in a signed 32-bit integer, return 0 and leave *pValue unchanged. +*/ +int sqliteExprIsInteger(Expr *p, int *pValue){ + switch( p->op ){ + case TK_INTEGER: { + if( sqliteFitsIn32Bits(p->token.z) ){ + *pValue = atoi(p->token.z); + return 1; + } + break; + } + case TK_STRING: { + const char *z = p->token.z; + int n = p->token.n; + if( n>0 && z[0]=='-' ){ z++; n--; } + while( n>0 && *z && isdigit(*z) ){ z++; n--; } + if( n==0 && sqliteFitsIn32Bits(p->token.z) ){ + *pValue = atoi(p->token.z); + return 1; + } + break; + } + case TK_UPLUS: { + return sqliteExprIsInteger(p->pLeft, pValue); + } + case TK_UMINUS: { + int v; + if( sqliteExprIsInteger(p->pLeft, &v) ){ + *pValue = -v; + return 1; + } + break; + } + default: break; + } + return 0; +} + +/* +** Return TRUE if the given string is a row-id column name. +*/ +int sqliteIsRowid(const char *z){ + if( sqliteStrICmp(z, "_ROWID_")==0 ) return 1; + if( sqliteStrICmp(z, "ROWID")==0 ) return 1; + if( sqliteStrICmp(z, "OID")==0 ) return 1; + return 0; +} + +/* +** Given the name of a column of the form X.Y.Z or Y.Z or just Z, look up +** that name in the set of source tables in pSrcList and make the pExpr +** expression node refer back to that source column. The following changes +** are made to pExpr: +** +** pExpr->iDb Set the index in db->aDb[] of the database holding +** the table. +** pExpr->iTable Set to the cursor number for the table obtained +** from pSrcList. +** pExpr->iColumn Set to the column number within the table. +** pExpr->dataType Set to the appropriate data type for the column. +** pExpr->op Set to TK_COLUMN. +** pExpr->pLeft Any expression this points to is deleted +** pExpr->pRight Any expression this points to is deleted. +** +** The pDbToken is the name of the database (the "X"). This value may be +** NULL meaning that name is of the form Y.Z or Z. Any available database +** can be used. The pTableToken is the name of the table (the "Y"). This +** value can be NULL if pDbToken is also NULL. If pTableToken is NULL it +** means that the form of the name is Z and that columns from any table +** can be used. +** +** If the name cannot be resolved unambiguously, leave an error message +** in pParse and return non-zero. Return zero on success. +*/ +static int lookupName( + Parse *pParse, /* The parsing context */ + Token *pDbToken, /* Name of the database containing table, or NULL */ + Token *pTableToken, /* Name of table containing column, or NULL */ + Token *pColumnToken, /* Name of the column. */ + SrcList *pSrcList, /* List of tables used to resolve column names */ + ExprList *pEList, /* List of expressions used to resolve "AS" */ + Expr *pExpr /* Make this EXPR node point to the selected column */ +){ + char *zDb = 0; /* Name of the database. The "X" in X.Y.Z */ + char *zTab = 0; /* Name of the table. The "Y" in X.Y.Z or Y.Z */ + char *zCol = 0; /* Name of the column. The "Z" */ + int i, j; /* Loop counters */ + int cnt = 0; /* Number of matching column names */ + int cntTab = 0; /* Number of matching table names */ + sqlite *db = pParse->db; /* The database */ + + assert( pColumnToken && pColumnToken->z ); /* The Z in X.Y.Z cannot be NULL */ + if( pDbToken && pDbToken->z ){ + zDb = sqliteStrNDup(pDbToken->z, pDbToken->n); + sqliteDequote(zDb); + }else{ + zDb = 0; + } + if( pTableToken && pTableToken->z ){ + zTab = sqliteStrNDup(pTableToken->z, pTableToken->n); + sqliteDequote(zTab); + }else{ + assert( zDb==0 ); + zTab = 0; + } + zCol = sqliteStrNDup(pColumnToken->z, pColumnToken->n); + sqliteDequote(zCol); + if( sqlite_malloc_failed ){ + return 1; /* Leak memory (zDb and zTab) if malloc fails */ + } + assert( zTab==0 || pEList==0 ); + + pExpr->iTable = -1; + for(i=0; i<pSrcList->nSrc; i++){ + struct SrcList_item *pItem = &pSrcList->a[i]; + Table *pTab = pItem->pTab; + Column *pCol; + + if( pTab==0 ) continue; + assert( pTab->nCol>0 ); + if( zTab ){ + if( pItem->zAlias ){ + char *zTabName = pItem->zAlias; + if( sqliteStrICmp(zTabName, zTab)!=0 ) continue; + }else{ + char *zTabName = pTab->zName; + if( zTabName==0 || sqliteStrICmp(zTabName, zTab)!=0 ) continue; + if( zDb!=0 && sqliteStrICmp(db->aDb[pTab->iDb].zName, zDb)!=0 ){ + continue; + } + } + } + if( 0==(cntTab++) ){ + pExpr->iTable = pItem->iCursor; + pExpr->iDb = pTab->iDb; + } + for(j=0, pCol=pTab->aCol; j<pTab->nCol; j++, pCol++){ + if( sqliteStrICmp(pCol->zName, zCol)==0 ){ + cnt++; + pExpr->iTable = pItem->iCursor; + pExpr->iDb = pTab->iDb; + /* Substitute the rowid (column -1) for the INTEGER PRIMARY KEY */ + pExpr->iColumn = j==pTab->iPKey ? -1 : j; + pExpr->dataType = pCol->sortOrder & SQLITE_SO_TYPEMASK; + break; + } + } + } + + /* If we have not already resolved the name, then maybe + ** it is a new.* or old.* trigger argument reference + */ + if( zDb==0 && zTab!=0 && cnt==0 && pParse->trigStack!=0 ){ + TriggerStack *pTriggerStack = pParse->trigStack; + Table *pTab = 0; + if( pTriggerStack->newIdx != -1 && sqliteStrICmp("new", zTab) == 0 ){ + pExpr->iTable = pTriggerStack->newIdx; + assert( pTriggerStack->pTab ); + pTab = pTriggerStack->pTab; + }else if( pTriggerStack->oldIdx != -1 && sqliteStrICmp("old", zTab) == 0 ){ + pExpr->iTable = pTriggerStack->oldIdx; + assert( pTriggerStack->pTab ); + pTab = pTriggerStack->pTab; + } + + if( pTab ){ + int j; + Column *pCol = pTab->aCol; + + pExpr->iDb = pTab->iDb; + cntTab++; + for(j=0; j < pTab->nCol; j++, pCol++) { + if( sqliteStrICmp(pCol->zName, zCol)==0 ){ + cnt++; + pExpr->iColumn = j==pTab->iPKey ? -1 : j; + pExpr->dataType = pCol->sortOrder & SQLITE_SO_TYPEMASK; + break; + } + } + } + } + + /* + ** Perhaps the name is a reference to the ROWID + */ + if( cnt==0 && cntTab==1 && sqliteIsRowid(zCol) ){ + cnt = 1; + pExpr->iColumn = -1; + pExpr->dataType = SQLITE_SO_NUM; + } + + /* + ** If the input is of the form Z (not Y.Z or X.Y.Z) then the name Z + ** might refer to an result-set alias. This happens, for example, when + ** we are resolving names in the WHERE clause of the following command: + ** + ** SELECT a+b AS x FROM table WHERE x<10; + ** + ** In cases like this, replace pExpr with a copy of the expression that + ** forms the result set entry ("a+b" in the example) and return immediately. + ** Note that the expression in the result set should have already been + ** resolved by the time the WHERE clause is resolved. + */ + if( cnt==0 && pEList!=0 ){ + for(j=0; j<pEList->nExpr; j++){ + char *zAs = pEList->a[j].zName; + if( zAs!=0 && sqliteStrICmp(zAs, zCol)==0 ){ + assert( pExpr->pLeft==0 && pExpr->pRight==0 ); + pExpr->op = TK_AS; + pExpr->iColumn = j; + pExpr->pLeft = sqliteExprDup(pEList->a[j].pExpr); + sqliteFree(zCol); + assert( zTab==0 && zDb==0 ); + return 0; + } + } + } + + /* + ** If X and Y are NULL (in other words if only the column name Z is + ** supplied) and the value of Z is enclosed in double-quotes, then + ** Z is a string literal if it doesn't match any column names. In that + ** case, we need to return right away and not make any changes to + ** pExpr. + */ + if( cnt==0 && zTab==0 && pColumnToken->z[0]=='"' ){ + sqliteFree(zCol); + return 0; + } + + /* + ** cnt==0 means there was not match. cnt>1 means there were two or + ** more matches. Either way, we have an error. + */ + if( cnt!=1 ){ + char *z = 0; + char *zErr; + zErr = cnt==0 ? "no such column: %s" : "ambiguous column name: %s"; + if( zDb ){ + sqliteSetString(&z, zDb, ".", zTab, ".", zCol, 0); + }else if( zTab ){ + sqliteSetString(&z, zTab, ".", zCol, 0); + }else{ + z = sqliteStrDup(zCol); + } + sqliteErrorMsg(pParse, zErr, z); + sqliteFree(z); + } + + /* Clean up and return + */ + sqliteFree(zDb); + sqliteFree(zTab); + sqliteFree(zCol); + sqliteExprDelete(pExpr->pLeft); + pExpr->pLeft = 0; + sqliteExprDelete(pExpr->pRight); + pExpr->pRight = 0; + pExpr->op = TK_COLUMN; + sqliteAuthRead(pParse, pExpr, pSrcList); + return cnt!=1; +} + +/* +** This routine walks an expression tree and resolves references to +** table columns. Nodes of the form ID.ID or ID resolve into an +** index to the table in the table list and a column offset. The +** Expr.opcode for such nodes is changed to TK_COLUMN. The Expr.iTable +** value is changed to the index of the referenced table in pTabList +** plus the "base" value. The base value will ultimately become the +** VDBE cursor number for a cursor that is pointing into the referenced +** table. The Expr.iColumn value is changed to the index of the column +** of the referenced table. The Expr.iColumn value for the special +** ROWID column is -1. Any INTEGER PRIMARY KEY column is tried as an +** alias for ROWID. +** +** We also check for instances of the IN operator. IN comes in two +** forms: +** +** expr IN (exprlist) +** and +** expr IN (SELECT ...) +** +** The first form is handled by creating a set holding the list +** of allowed values. The second form causes the SELECT to generate +** a temporary table. +** +** This routine also looks for scalar SELECTs that are part of an expression. +** If it finds any, it generates code to write the value of that select +** into a memory cell. +** +** Unknown columns or tables provoke an error. The function returns +** the number of errors seen and leaves an error message on pParse->zErrMsg. +*/ +int sqliteExprResolveIds( + Parse *pParse, /* The parser context */ + SrcList *pSrcList, /* List of tables used to resolve column names */ + ExprList *pEList, /* List of expressions used to resolve "AS" */ + Expr *pExpr /* The expression to be analyzed. */ +){ + int i; + + if( pExpr==0 || pSrcList==0 ) return 0; + for(i=0; i<pSrcList->nSrc; i++){ + assert( pSrcList->a[i].iCursor>=0 && pSrcList->a[i].iCursor<pParse->nTab ); + } + switch( pExpr->op ){ + /* Double-quoted strings (ex: "abc") are used as identifiers if + ** possible. Otherwise they remain as strings. Single-quoted + ** strings (ex: 'abc') are always string literals. + */ + case TK_STRING: { + if( pExpr->token.z[0]=='\'' ) break; + /* Fall thru into the TK_ID case if this is a double-quoted string */ + } + /* A lone identifier is the name of a columnd. + */ + case TK_ID: { + if( lookupName(pParse, 0, 0, &pExpr->token, pSrcList, pEList, pExpr) ){ + return 1; + } + break; + } + + /* A table name and column name: ID.ID + ** Or a database, table and column: ID.ID.ID + */ + case TK_DOT: { + Token *pColumn; + Token *pTable; + Token *pDb; + Expr *pRight; + + pRight = pExpr->pRight; + if( pRight->op==TK_ID ){ + pDb = 0; + pTable = &pExpr->pLeft->token; + pColumn = &pRight->token; + }else{ + assert( pRight->op==TK_DOT ); + pDb = &pExpr->pLeft->token; + pTable = &pRight->pLeft->token; + pColumn = &pRight->pRight->token; + } + if( lookupName(pParse, pDb, pTable, pColumn, pSrcList, 0, pExpr) ){ + return 1; + } + break; + } + + case TK_IN: { + Vdbe *v = sqliteGetVdbe(pParse); + if( v==0 ) return 1; + if( sqliteExprResolveIds(pParse, pSrcList, pEList, pExpr->pLeft) ){ + return 1; + } + if( pExpr->pSelect ){ + /* Case 1: expr IN (SELECT ...) + ** + ** Generate code to write the results of the select into a temporary + ** table. The cursor number of the temporary table has already + ** been put in iTable by sqliteExprResolveInSelect(). + */ + pExpr->iTable = pParse->nTab++; + sqliteVdbeAddOp(v, OP_OpenTemp, pExpr->iTable, 1); + sqliteSelect(pParse, pExpr->pSelect, SRT_Set, pExpr->iTable, 0,0,0); + }else if( pExpr->pList ){ + /* Case 2: expr IN (exprlist) + ** + ** Create a set to put the exprlist values in. The Set id is stored + ** in iTable. + */ + int i, iSet; + for(i=0; i<pExpr->pList->nExpr; i++){ + Expr *pE2 = pExpr->pList->a[i].pExpr; + if( !sqliteExprIsConstant(pE2) ){ + sqliteErrorMsg(pParse, + "right-hand side of IN operator must be constant"); + return 1; + } + if( sqliteExprCheck(pParse, pE2, 0, 0) ){ + return 1; + } + } + iSet = pExpr->iTable = pParse->nSet++; + for(i=0; i<pExpr->pList->nExpr; i++){ + Expr *pE2 = pExpr->pList->a[i].pExpr; + switch( pE2->op ){ + case TK_FLOAT: + case TK_INTEGER: + case TK_STRING: { + int addr; + assert( pE2->token.z ); + addr = sqliteVdbeOp3(v, OP_SetInsert, iSet, 0, + pE2->token.z, pE2->token.n); + sqliteVdbeDequoteP3(v, addr); + break; + } + default: { + sqliteExprCode(pParse, pE2); + sqliteVdbeAddOp(v, OP_SetInsert, iSet, 0); + break; + } + } + } + } + break; + } + + case TK_SELECT: { + /* This has to be a scalar SELECT. Generate code to put the + ** value of this select in a memory cell and record the number + ** of the memory cell in iColumn. + */ + pExpr->iColumn = pParse->nMem++; + if( sqliteSelect(pParse, pExpr->pSelect, SRT_Mem, pExpr->iColumn,0,0,0) ){ + return 1; + } + break; + } + + /* For all else, just recursively walk the tree */ + default: { + if( pExpr->pLeft + && sqliteExprResolveIds(pParse, pSrcList, pEList, pExpr->pLeft) ){ + return 1; + } + if( pExpr->pRight + && sqliteExprResolveIds(pParse, pSrcList, pEList, pExpr->pRight) ){ + return 1; + } + if( pExpr->pList ){ + int i; + ExprList *pList = pExpr->pList; + for(i=0; i<pList->nExpr; i++){ + Expr *pArg = pList->a[i].pExpr; + if( sqliteExprResolveIds(pParse, pSrcList, pEList, pArg) ){ + return 1; + } + } + } + } + } + return 0; +} + +/* +** pExpr is a node that defines a function of some kind. It might +** be a syntactic function like "count(x)" or it might be a function +** that implements an operator, like "a LIKE b". +** +** This routine makes *pzName point to the name of the function and +** *pnName hold the number of characters in the function name. +*/ +static void getFunctionName(Expr *pExpr, const char **pzName, int *pnName){ + switch( pExpr->op ){ + case TK_FUNCTION: { + *pzName = pExpr->token.z; + *pnName = pExpr->token.n; + break; + } + case TK_LIKE: { + *pzName = "like"; + *pnName = 4; + break; + } + case TK_GLOB: { + *pzName = "glob"; + *pnName = 4; + break; + } + default: { + *pzName = "can't happen"; + *pnName = 12; + break; + } + } +} + +/* +** Error check the functions in an expression. Make sure all +** function names are recognized and all functions have the correct +** number of arguments. Leave an error message in pParse->zErrMsg +** if anything is amiss. Return the number of errors. +** +** if pIsAgg is not null and this expression is an aggregate function +** (like count(*) or max(value)) then write a 1 into *pIsAgg. +*/ +int sqliteExprCheck(Parse *pParse, Expr *pExpr, int allowAgg, int *pIsAgg){ + int nErr = 0; + if( pExpr==0 ) return 0; + switch( pExpr->op ){ + case TK_GLOB: + case TK_LIKE: + case TK_FUNCTION: { + int n = pExpr->pList ? pExpr->pList->nExpr : 0; /* Number of arguments */ + int no_such_func = 0; /* True if no such function exists */ + int wrong_num_args = 0; /* True if wrong number of arguments */ + int is_agg = 0; /* True if is an aggregate function */ + int i; + int nId; /* Number of characters in function name */ + const char *zId; /* The function name. */ + FuncDef *pDef; + + getFunctionName(pExpr, &zId, &nId); + pDef = sqliteFindFunction(pParse->db, zId, nId, n, 0); + if( pDef==0 ){ + pDef = sqliteFindFunction(pParse->db, zId, nId, -1, 0); + if( pDef==0 ){ + no_such_func = 1; + }else{ + wrong_num_args = 1; + } + }else{ + is_agg = pDef->xFunc==0; + } + if( is_agg && !allowAgg ){ + sqliteErrorMsg(pParse, "misuse of aggregate function %.*s()", nId, zId); + nErr++; + is_agg = 0; + }else if( no_such_func ){ + sqliteErrorMsg(pParse, "no such function: %.*s", nId, zId); + nErr++; + }else if( wrong_num_args ){ + sqliteErrorMsg(pParse,"wrong number of arguments to function %.*s()", + nId, zId); + nErr++; + } + if( is_agg ){ + pExpr->op = TK_AGG_FUNCTION; + if( pIsAgg ) *pIsAgg = 1; + } + for(i=0; nErr==0 && i<n; i++){ + nErr = sqliteExprCheck(pParse, pExpr->pList->a[i].pExpr, + allowAgg && !is_agg, pIsAgg); + } + if( pDef==0 ){ + /* Already reported an error */ + }else if( pDef->dataType>=0 ){ + if( pDef->dataType<n ){ + pExpr->dataType = + 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; i<n; i++){ + if( sqliteExprType(pExpr->pList->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 && i<n; i++){ + Expr *pE2 = pExpr->pList->a[i].pExpr; + nErr = sqliteExprCheck(pParse, pE2, allowAgg, pIsAgg); + } + } + break; + } + } + return nErr; +} + +/* +** Return either SQLITE_SO_NUM or SQLITE_SO_TEXT to indicate whether the +** given expression should sort as numeric values or as text. +** +** The sqliteExprResolveIds() and sqliteExprCheck() routines must have +** both been called on the expression before it is passed to this routine. +*/ +int sqliteExprType(Expr *p){ + if( p==0 ) return SQLITE_SO_NUM; + while( p ) switch( p->op ){ + case TK_PLUS: + case TK_MINUS: + case TK_STAR: + case TK_SLASH: + case TK_AND: + case TK_OR: + case TK_ISNULL: + case TK_NOTNULL: + case TK_NOT: + case TK_UMINUS: + case TK_UPLUS: + case TK_BITAND: + case TK_BITOR: + case TK_BITNOT: + case TK_LSHIFT: + case TK_RSHIFT: + case TK_REM: + case TK_INTEGER: + case TK_FLOAT: + case TK_IN: + case TK_BETWEEN: + case TK_GLOB: + case TK_LIKE: + return SQLITE_SO_NUM; + + case TK_STRING: + case TK_NULL: + case TK_CONCAT: + case TK_VARIABLE: + return SQLITE_SO_TEXT; + + case TK_LT: + case TK_LE: + case TK_GT: + case TK_GE: + case TK_NE: + case TK_EQ: + if( sqliteExprType(p->pLeft)==SQLITE_SO_NUM ){ + return SQLITE_SO_NUM; + } + p = p->pRight; + break; + + case TK_AS: + p = p->pLeft; + break; + + case TK_COLUMN: + case TK_FUNCTION: + case TK_AGG_FUNCTION: + return p->dataType; + + case TK_SELECT: + assert( p->pSelect ); + assert( p->pSelect->pEList ); + assert( p->pSelect->pEList->nExpr>0 ); + p = p->pSelect->pEList->a[0].pExpr; + break; + + case TK_CASE: { + if( p->pRight && sqliteExprType(p->pRight)==SQLITE_SO_NUM ){ + return SQLITE_SO_NUM; + } + if( p->pList ){ + int i; + ExprList *pList = p->pList; + for(i=1; i<pList->nExpr; i+=2){ + if( sqliteExprType(pList->a[i].pExpr)==SQLITE_SO_NUM ){ + return SQLITE_SO_NUM; + } + } + } + return SQLITE_SO_TEXT; + } + + default: + assert( p->op==TK_ABORT ); /* Can't Happen */ + break; + } + return SQLITE_SO_NUM; +} + +/* +** Generate code into the current Vdbe to evaluate the given +** expression and leave the result on the top of stack. +*/ +void sqliteExprCode(Parse *pParse, Expr *pExpr){ + Vdbe *v = pParse->pVdbe; + int op; + if( v==0 || pExpr==0 ) return; + switch( pExpr->op ){ + case TK_PLUS: op = OP_Add; break; + case TK_MINUS: op = OP_Subtract; break; + case TK_STAR: op = OP_Multiply; break; + case TK_SLASH: op = OP_Divide; break; + case TK_AND: op = OP_And; break; + case TK_OR: op = OP_Or; break; + case TK_LT: op = OP_Lt; break; + case TK_LE: op = OP_Le; break; + case TK_GT: op = OP_Gt; break; + case TK_GE: op = OP_Ge; break; + case TK_NE: op = OP_Ne; break; + case TK_EQ: op = OP_Eq; break; + case TK_ISNULL: op = OP_IsNull; break; + case TK_NOTNULL: op = OP_NotNull; break; + case TK_NOT: op = OP_Not; break; + case TK_UMINUS: op = OP_Negative; break; + case TK_BITAND: op = OP_BitAnd; break; + case TK_BITOR: op = OP_BitOr; break; + case TK_BITNOT: op = OP_BitNot; break; + case TK_LSHIFT: op = OP_ShiftLeft; break; + case TK_RSHIFT: op = OP_ShiftRight; break; + case TK_REM: op = OP_Remainder; break; + default: break; + } + switch( pExpr->op ){ + case TK_COLUMN: { + if( pParse->useAgg ){ + sqliteVdbeAddOp(v, OP_AggGet, 0, pExpr->iAgg); + }else if( pExpr->iColumn>=0 ){ + sqliteVdbeAddOp(v, OP_Column, pExpr->iTable, pExpr->iColumn); + }else{ + sqliteVdbeAddOp(v, OP_Recno, pExpr->iTable, 0); + } + break; + } + case TK_STRING: + case TK_FLOAT: + case TK_INTEGER: { + if( pExpr->op==TK_INTEGER && sqliteFitsIn32Bits(pExpr->token.z) ){ + sqliteVdbeAddOp(v, OP_Integer, atoi(pExpr->token.z), 0); + }else{ + sqliteVdbeAddOp(v, OP_String, 0, 0); + } + assert( pExpr->token.z ); + sqliteVdbeChangeP3(v, -1, pExpr->token.z, pExpr->token.n); + sqliteVdbeDequoteP3(v, -1); + break; + } + case TK_NULL: { + sqliteVdbeAddOp(v, OP_String, 0, 0); + break; + } + case TK_VARIABLE: { + sqliteVdbeAddOp(v, OP_Variable, pExpr->iTable, 0); + break; + } + case TK_LT: + case TK_LE: + case TK_GT: + case TK_GE: + case TK_NE: + case TK_EQ: { + if( pParse->db->file_format>=4 && sqliteExprType(pExpr)==SQLITE_SO_TEXT ){ + op += 6; /* Convert numeric opcodes to text opcodes */ + } + /* Fall through into the next case */ + } + case TK_AND: + case TK_OR: + case TK_PLUS: + case TK_STAR: + case TK_MINUS: + case TK_REM: + case TK_BITAND: + case TK_BITOR: + case TK_SLASH: { + sqliteExprCode(pParse, pExpr->pLeft); + sqliteExprCode(pParse, pExpr->pRight); + sqliteVdbeAddOp(v, op, 0, 0); + break; + } + case TK_LSHIFT: + case TK_RSHIFT: { + sqliteExprCode(pParse, pExpr->pRight); + sqliteExprCode(pParse, pExpr->pLeft); + sqliteVdbeAddOp(v, op, 0, 0); + break; + } + case TK_CONCAT: { + sqliteExprCode(pParse, pExpr->pLeft); + sqliteExprCode(pParse, pExpr->pRight); + sqliteVdbeAddOp(v, OP_Concat, 2, 0); + break; + } + case TK_UMINUS: { + assert( pExpr->pLeft ); + if( pExpr->pLeft->op==TK_FLOAT || pExpr->pLeft->op==TK_INTEGER ){ + Token *p = &pExpr->pLeft->token; + char *z = sqliteMalloc( p->n + 2 ); + sprintf(z, "-%.*s", p->n, p->z); + if( pExpr->pLeft->op==TK_INTEGER && sqliteFitsIn32Bits(z) ){ + sqliteVdbeAddOp(v, OP_Integer, atoi(z), 0); + }else{ + sqliteVdbeAddOp(v, OP_String, 0, 0); + } + sqliteVdbeChangeP3(v, -1, z, p->n+1); + sqliteFree(z); + break; + } + /* Fall through into TK_NOT */ + } + case TK_BITNOT: + case TK_NOT: { + sqliteExprCode(pParse, pExpr->pLeft); + sqliteVdbeAddOp(v, op, 0, 0); + break; + } + case TK_ISNULL: + case TK_NOTNULL: { + int dest; + sqliteVdbeAddOp(v, OP_Integer, 1, 0); + sqliteExprCode(pParse, pExpr->pLeft); + dest = sqliteVdbeCurrentAddr(v) + 2; + sqliteVdbeAddOp(v, op, 1, dest); + sqliteVdbeAddOp(v, OP_AddImm, -1, 0); + break; + } + case TK_AGG_FUNCTION: { + sqliteVdbeAddOp(v, OP_AggGet, 0, pExpr->iAgg); + break; + } + case TK_GLOB: + case TK_LIKE: + case TK_FUNCTION: { + ExprList *pList = pExpr->pList; + int nExpr = pList ? pList->nExpr : 0; + FuncDef *pDef; + int nId; + const char *zId; + getFunctionName(pExpr, &zId, &nId); + pDef = sqliteFindFunction(pParse->db, zId, nId, nExpr, 0); + assert( pDef!=0 ); + nExpr = sqliteExprCodeExprList(pParse, pList, pDef->includeTypes); + sqliteVdbeOp3(v, OP_Function, nExpr, 0, (char*)pDef, P3_POINTER); + break; + } + case TK_SELECT: { + sqliteVdbeAddOp(v, OP_MemLoad, pExpr->iColumn, 0); + break; + } + case TK_IN: { + int addr; + sqliteVdbeAddOp(v, OP_Integer, 1, 0); + sqliteExprCode(pParse, pExpr->pLeft); + addr = sqliteVdbeCurrentAddr(v); + sqliteVdbeAddOp(v, OP_NotNull, -1, addr+4); + sqliteVdbeAddOp(v, OP_Pop, 2, 0); + sqliteVdbeAddOp(v, OP_String, 0, 0); + sqliteVdbeAddOp(v, OP_Goto, 0, addr+6); + if( pExpr->pSelect ){ + sqliteVdbeAddOp(v, OP_Found, pExpr->iTable, addr+6); + }else{ + sqliteVdbeAddOp(v, OP_SetFound, pExpr->iTable, addr+6); + } + sqliteVdbeAddOp(v, OP_AddImm, -1, 0); + break; + } + case TK_BETWEEN: { + sqliteExprCode(pParse, pExpr->pLeft); + sqliteVdbeAddOp(v, OP_Dup, 0, 0); + sqliteExprCode(pParse, pExpr->pList->a[0].pExpr); + sqliteVdbeAddOp(v, OP_Ge, 0, 0); + sqliteVdbeAddOp(v, OP_Pull, 1, 0); + sqliteExprCode(pParse, pExpr->pList->a[1].pExpr); + sqliteVdbeAddOp(v, OP_Le, 0, 0); + sqliteVdbeAddOp(v, OP_And, 0, 0); + break; + } + case TK_UPLUS: + case TK_AS: { + sqliteExprCode(pParse, pExpr->pLeft); + break; + } + case TK_CASE: { + int expr_end_label; + int jumpInst; + int addr; + int nExpr; + int i; + + assert(pExpr->pList); + assert((pExpr->pList->nExpr % 2) == 0); + assert(pExpr->pList->nExpr > 0); + nExpr = pExpr->pList->nExpr; + expr_end_label = sqliteVdbeMakeLabel(v); + if( pExpr->pLeft ){ + sqliteExprCode(pParse, pExpr->pLeft); + } + for(i=0; i<nExpr; i=i+2){ + sqliteExprCode(pParse, pExpr->pList->a[i].pExpr); + if( pExpr->pLeft ){ + sqliteVdbeAddOp(v, OP_Dup, 1, 1); + jumpInst = sqliteVdbeAddOp(v, OP_Ne, 1, 0); + sqliteVdbeAddOp(v, OP_Pop, 1, 0); + }else{ + jumpInst = sqliteVdbeAddOp(v, OP_IfNot, 1, 0); + } + sqliteExprCode(pParse, pExpr->pList->a[i+1].pExpr); + sqliteVdbeAddOp(v, OP_Goto, 0, expr_end_label); + addr = sqliteVdbeCurrentAddr(v); + sqliteVdbeChangeP2(v, jumpInst, addr); + } + if( pExpr->pLeft ){ + sqliteVdbeAddOp(v, OP_Pop, 1, 0); + } + if( pExpr->pRight ){ + sqliteExprCode(pParse, pExpr->pRight); + }else{ + sqliteVdbeAddOp(v, OP_String, 0, 0); + } + sqliteVdbeResolveLabel(v, expr_end_label); + break; + } + case TK_RAISE: { + if( !pParse->trigStack ){ + sqliteErrorMsg(pParse, + "RAISE() may only be used within a trigger-program"); + pParse->nErr++; + return; + } + if( pExpr->iColumn == OE_Rollback || + pExpr->iColumn == OE_Abort || + pExpr->iColumn == OE_Fail ){ + sqliteVdbeOp3(v, OP_Halt, SQLITE_CONSTRAINT, pExpr->iColumn, + pExpr->token.z, pExpr->token.n); + sqliteVdbeDequoteP3(v, -1); + } else { + assert( pExpr->iColumn == OE_Ignore ); + sqliteVdbeOp3(v, OP_Goto, 0, pParse->trigStack->ignoreJump, + "(IGNORE jump)", 0); + } + } + break; + } +} + +/* +** Generate code that pushes the value of every element of the given +** expression list onto the stack. If the includeTypes flag is true, +** then also push a string that is the datatype of each element onto +** the stack after the value. +** +** Return the number of elements pushed onto the stack. +*/ +int sqliteExprCodeExprList( + Parse *pParse, /* Parsing context */ + ExprList *pList, /* The expression list to be coded */ + int includeTypes /* TRUE to put datatypes on the stack too */ +){ + struct ExprList_item *pItem; + int i, n; + Vdbe *v; + if( pList==0 ) return 0; + v = sqliteGetVdbe(pParse); + n = pList->nExpr; + for(pItem=pList->a, i=0; i<n; i++, pItem++){ + sqliteExprCode(pParse, pItem->pExpr); + if( includeTypes ){ + sqliteVdbeOp3(v, OP_String, 0, 0, + sqliteExprType(pItem->pExpr)==SQLITE_SO_NUM ? "numeric" : "text", + P3_STATIC); + } + } + return includeTypes ? n*2 : n; +} + +/* +** Generate code for a boolean expression such that a jump is made +** to the label "dest" if the expression is true but execution +** continues straight thru if the expression is false. +** +** If the expression evaluates to NULL (neither true nor false), then +** take the jump if the jumpIfNull flag is true. +*/ +void sqliteExprIfTrue(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull){ + Vdbe *v = pParse->pVdbe; + int op = 0; + if( v==0 || pExpr==0 ) return; + switch( pExpr->op ){ + case TK_LT: op = OP_Lt; break; + case TK_LE: op = OP_Le; break; + case TK_GT: op = OP_Gt; break; + case TK_GE: op = OP_Ge; break; + case TK_NE: op = OP_Ne; break; + case TK_EQ: op = OP_Eq; break; + case TK_ISNULL: op = OP_IsNull; break; + case TK_NOTNULL: op = OP_NotNull; break; + default: break; + } + switch( pExpr->op ){ + case TK_AND: { + int d2 = sqliteVdbeMakeLabel(v); + sqliteExprIfFalse(pParse, pExpr->pLeft, d2, !jumpIfNull); + sqliteExprIfTrue(pParse, pExpr->pRight, dest, jumpIfNull); + sqliteVdbeResolveLabel(v, d2); + break; + } + case TK_OR: { + sqliteExprIfTrue(pParse, pExpr->pLeft, dest, jumpIfNull); + sqliteExprIfTrue(pParse, pExpr->pRight, dest, jumpIfNull); + break; + } + case TK_NOT: { + sqliteExprIfFalse(pParse, pExpr->pLeft, dest, jumpIfNull); + break; + } + case TK_LT: + case TK_LE: + case TK_GT: + case TK_GE: + case TK_NE: + case TK_EQ: { + sqliteExprCode(pParse, pExpr->pLeft); + sqliteExprCode(pParse, pExpr->pRight); + if( pParse->db->file_format>=4 && sqliteExprType(pExpr)==SQLITE_SO_TEXT ){ + op += 6; /* Convert numeric opcodes to text opcodes */ + } + sqliteVdbeAddOp(v, op, jumpIfNull, dest); + break; + } + case TK_ISNULL: + case TK_NOTNULL: { + sqliteExprCode(pParse, pExpr->pLeft); + sqliteVdbeAddOp(v, op, 1, dest); + break; + } + case TK_IN: { + int addr; + sqliteExprCode(pParse, pExpr->pLeft); + addr = sqliteVdbeCurrentAddr(v); + sqliteVdbeAddOp(v, OP_NotNull, -1, addr+3); + sqliteVdbeAddOp(v, OP_Pop, 1, 0); + sqliteVdbeAddOp(v, OP_Goto, 0, jumpIfNull ? dest : addr+4); + if( pExpr->pSelect ){ + sqliteVdbeAddOp(v, OP_Found, pExpr->iTable, dest); + }else{ + sqliteVdbeAddOp(v, OP_SetFound, pExpr->iTable, dest); + } + break; + } + case TK_BETWEEN: { + int addr; + sqliteExprCode(pParse, pExpr->pLeft); + sqliteVdbeAddOp(v, OP_Dup, 0, 0); + sqliteExprCode(pParse, pExpr->pList->a[0].pExpr); + addr = sqliteVdbeAddOp(v, OP_Lt, !jumpIfNull, 0); + sqliteExprCode(pParse, pExpr->pList->a[1].pExpr); + sqliteVdbeAddOp(v, OP_Le, jumpIfNull, dest); + sqliteVdbeAddOp(v, OP_Integer, 0, 0); + sqliteVdbeChangeP2(v, addr, sqliteVdbeCurrentAddr(v)); + sqliteVdbeAddOp(v, OP_Pop, 1, 0); + break; + } + default: { + sqliteExprCode(pParse, pExpr); + sqliteVdbeAddOp(v, OP_If, jumpIfNull, dest); + break; + } + } +} + +/* +** Generate code for a boolean expression such that a jump is made +** to the label "dest" if the expression is false but execution +** continues straight thru if the expression is true. +** +** If the expression evaluates to NULL (neither true nor false) then +** jump if jumpIfNull is true or fall through if jumpIfNull is false. +*/ +void sqliteExprIfFalse(Parse *pParse, Expr *pExpr, int dest, int jumpIfNull){ + Vdbe *v = pParse->pVdbe; + int op = 0; + if( v==0 || pExpr==0 ) return; + switch( pExpr->op ){ + case TK_LT: op = OP_Ge; break; + case TK_LE: op = OP_Gt; break; + case TK_GT: op = OP_Le; break; + case TK_GE: op = OP_Lt; break; + case TK_NE: op = OP_Eq; break; + case TK_EQ: op = OP_Ne; break; + case TK_ISNULL: op = OP_NotNull; break; + case TK_NOTNULL: op = OP_IsNull; break; + default: break; + } + switch( pExpr->op ){ + case TK_AND: { + sqliteExprIfFalse(pParse, pExpr->pLeft, dest, jumpIfNull); + sqliteExprIfFalse(pParse, pExpr->pRight, dest, jumpIfNull); + break; + } + case TK_OR: { + int d2 = sqliteVdbeMakeLabel(v); + sqliteExprIfTrue(pParse, pExpr->pLeft, d2, !jumpIfNull); + sqliteExprIfFalse(pParse, pExpr->pRight, dest, jumpIfNull); + sqliteVdbeResolveLabel(v, d2); + break; + } + case TK_NOT: { + sqliteExprIfTrue(pParse, pExpr->pLeft, dest, jumpIfNull); + break; + } + case TK_LT: + case TK_LE: + case TK_GT: + case TK_GE: + case TK_NE: + case TK_EQ: { + if( pParse->db->file_format>=4 && sqliteExprType(pExpr)==SQLITE_SO_TEXT ){ + /* Convert numeric comparison opcodes into text comparison opcodes. + ** This step depends on the fact that the text comparision opcodes are + ** always 6 greater than their corresponding numeric comparison + ** opcodes. + */ + assert( OP_Eq+6 == OP_StrEq ); + op += 6; + } + sqliteExprCode(pParse, pExpr->pLeft); + sqliteExprCode(pParse, pExpr->pRight); + sqliteVdbeAddOp(v, op, jumpIfNull, dest); + break; + } + case TK_ISNULL: + case TK_NOTNULL: { + sqliteExprCode(pParse, pExpr->pLeft); + sqliteVdbeAddOp(v, op, 1, dest); + break; + } + case TK_IN: { + int addr; + sqliteExprCode(pParse, pExpr->pLeft); + addr = sqliteVdbeCurrentAddr(v); + sqliteVdbeAddOp(v, OP_NotNull, -1, addr+3); + sqliteVdbeAddOp(v, OP_Pop, 1, 0); + sqliteVdbeAddOp(v, OP_Goto, 0, jumpIfNull ? dest : addr+4); + if( pExpr->pSelect ){ + sqliteVdbeAddOp(v, OP_NotFound, pExpr->iTable, dest); + }else{ + sqliteVdbeAddOp(v, OP_SetNotFound, pExpr->iTable, dest); + } + break; + } + case TK_BETWEEN: { + int addr; + sqliteExprCode(pParse, pExpr->pLeft); + sqliteVdbeAddOp(v, OP_Dup, 0, 0); + sqliteExprCode(pParse, pExpr->pList->a[0].pExpr); + addr = sqliteVdbeCurrentAddr(v); + sqliteVdbeAddOp(v, OP_Ge, !jumpIfNull, addr+3); + sqliteVdbeAddOp(v, OP_Pop, 1, 0); + sqliteVdbeAddOp(v, OP_Goto, 0, dest); + sqliteExprCode(pParse, pExpr->pList->a[1].pExpr); + sqliteVdbeAddOp(v, OP_Gt, jumpIfNull, dest); + break; + } + default: { + sqliteExprCode(pParse, pExpr); + sqliteVdbeAddOp(v, OP_IfNot, jumpIfNull, dest); + break; + } + } +} + +/* +** Do a deep comparison of two expression trees. Return TRUE (non-zero) +** if they are identical and return FALSE if they differ in any way. +*/ +int sqliteExprCompare(Expr *pA, Expr *pB){ + int i; + if( pA==0 ){ + return pB==0; + }else if( pB==0 ){ + return 0; + } + if( pA->op!=pB->op ) return 0; + if( !sqliteExprCompare(pA->pLeft, pB->pLeft) ) return 0; + if( !sqliteExprCompare(pA->pRight, pB->pRight) ) return 0; + if( pA->pList ){ + if( pB->pList==0 ) return 0; + if( pA->pList->nExpr!=pB->pList->nExpr ) return 0; + for(i=0; i<pA->pList->nExpr; i++){ + if( !sqliteExprCompare(pA->pList->a[i].pExpr, pB->pList->a[i].pExpr) ){ + return 0; + } + } + }else if( pB->pList ){ + return 0; + } + if( pA->pSelect || pB->pSelect ) return 0; + if( pA->iTable!=pB->iTable || pA->iColumn!=pB->iColumn ) return 0; + if( pA->token.z ){ + if( pB->token.z==0 ) return 0; + if( pB->token.n!=pA->token.n ) return 0; + if( sqliteStrNICmp(pA->token.z, pB->token.z, pB->token.n)!=0 ) return 0; + } + return 1; +} + +/* +** Add a new element to the pParse->aAgg[] array and return its index. +*/ +static int appendAggInfo(Parse *pParse){ + if( (pParse->nAgg & 0x7)==0 ){ + int amt = pParse->nAgg + 8; + AggExpr *aAgg = sqliteRealloc(pParse->aAgg, amt*sizeof(pParse->aAgg[0])); + if( aAgg==0 ){ + return -1; + } + pParse->aAgg = aAgg; + } + memset(&pParse->aAgg[pParse->nAgg], 0, sizeof(pParse->aAgg[0])); + return pParse->nAgg++; +} + +/* +** Analyze the given expression looking for aggregate functions and +** for variables that need to be added to the pParse->aAgg[] array. +** Make additional entries to the pParse->aAgg[] array as necessary. +** +** This routine should only be called after the expression has been +** analyzed by sqliteExprResolveIds() and sqliteExprCheck(). +** +** If errors are seen, leave an error message in zErrMsg and return +** the number of errors. +*/ +int sqliteExprAnalyzeAggregates(Parse *pParse, Expr *pExpr){ + int i; + AggExpr *aAgg; + int nErr = 0; + + if( pExpr==0 ) return 0; + switch( pExpr->op ){ + case TK_COLUMN: { + aAgg = pParse->aAgg; + for(i=0; i<pParse->nAgg; 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; i<pParse->nAgg; 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 && i<n; i++){ + nErr = sqliteExprAnalyzeAggregates(pParse, pExpr->pList->a[i].pExpr); + } + } + break; + } + } + return nErr; +} + +/* +** Locate a user function given a name and a number of arguments. +** Return a pointer to the FuncDef structure that defines that +** function, or return NULL if the function does not exist. +** +** If the createFlag argument is true, then a new (blank) FuncDef +** structure is created and liked into the "db" structure if a +** no matching function previously existed. When createFlag is true +** and the nArg parameter is -1, then only a function that accepts +** any number of arguments will be returned. +** +** If createFlag is false and nArg is -1, then the first valid +** function found is returned. A function is valid if either xFunc +** or xStep is non-zero. +*/ +FuncDef *sqliteFindFunction( + sqlite *db, /* An open database */ + const char *zName, /* Name of the function. Not null-terminated */ + int nName, /* Number of characters in the name */ + int nArg, /* Number of arguments. -1 means any number */ + int createFlag /* Create new entry if true and does not otherwise exist */ +){ + FuncDef *pFirst, *p, *pMaybe; + pFirst = p = (FuncDef*)sqliteHashFind(&db->aFunc, zName, nName); + if( p && !createFlag && nArg<0 ){ + while( p && p->xFunc==0 && p->xStep==0 ){ p = p->pNext; } + return p; + } + pMaybe = 0; + while( p && p->nArg!=nArg ){ + if( p->nArg<0 && !createFlag && (p->xFunc || p->xStep) ) pMaybe = p; + p = p->pNext; + } + if( p && !createFlag && p->xFunc==0 && p->xStep==0 ){ + return 0; + } + if( p==0 && pMaybe ){ + assert( createFlag==0 ); + return pMaybe; + } + if( p==0 && createFlag && (p = sqliteMalloc(sizeof(*p)))!=0 ){ + p->nArg = nArg; + p->pNext = pFirst; + p->dataType = pFirst ? pFirst->dataType : SQLITE_NUMERIC; + sqliteHashInsert(&db->aFunc, zName, nName, (void*)p); + } + return p; +} diff --git a/kexi/3rdparty/kexisql/src/func.c b/kexi/3rdparty/kexisql/src/func.c new file mode 100644 index 00000000..1e176258 --- /dev/null +++ b/kexi/3rdparty/kexisql/src/func.c @@ -0,0 +1,658 @@ +/* +** 2002 February 23 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains the C functions that implement various SQL +** functions of SQLite. +** +** There is only one exported symbol in this file - the function +** sqliteRegisterBuildinFunctions() found at the bottom of the file. +** All other code has file scope. +** +** $Id: func.c 410099 2005-05-06 17:52:07Z staniek $ +*/ +#include <ctype.h> +#include <math.h> +#include <stdlib.h> +#include <assert.h> +#include "sqliteInt.h" +#include "os.h" + +/* +** Implementation of the non-aggregate min() and max() functions +*/ +static void minmaxFunc(sqlite_func *context, int argc, const char **argv){ + const char *zBest; + int i; + int (*xCompare)(const char*, const char*); + int mask; /* 0 for min() or 0xffffffff for max() */ + + if( argc==0 ) return; + mask = (int)sqlite_user_data(context); + zBest = argv[0]; + if( zBest==0 ) return; + if( argv[1][0]=='n' ){ + xCompare = sqliteCompare; + }else{ + xCompare = strcmp; + } + for(i=2; i<argc; i+=2){ + if( argv[i]==0 ) return; + if( (xCompare(argv[i], zBest)^mask)<0 ){ + zBest = argv[i]; + } + } + sqlite_set_result_string(context, zBest, -1); +} + +/* +** 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); +} + +/* +** Implementation of the length() function +*/ +static void lengthFunc(sqlite_func *context, int argc, const char **argv){ + const char *z; + 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); +} + +/* +** Implementation of the abs() function +*/ +static void absFunc(sqlite_func *context, int argc, const char **argv){ + const char *z; + assert( argc==1 ); + z = argv[0]; + if( z==0 ) return; + if( z[0]=='-' && isdigit(z[1]) ) z++; + sqlite_set_result_string(context, z, -1); +} + +/* +** 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; + int i; +#endif + int p1, p2, len; + assert( argc==3 ); + z = argv[0]; + if( z==0 ) return; + p1 = atoi(argv[1]?argv[1]:0); + p2 = atoi(argv[2]?argv[2]:0); +#ifdef SQLITE_UTF8 + 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 ){ + p2 += p1; + p1 = 0; + } + }else if( p1>0 ){ + p1--; + } + if( p1+p2>len ){ + p2 = len-p1; + } +#ifdef SQLITE_UTF8 + for(i=0; i<p1 && z[i]; i++){ + if( (z[i]&0xc0)==0x80 ) p1++; + } + while( z[i] && (z[i]&0xc0)==0x80 ){ i++; p1++; } + for(; i<p1+p2 && z[i]; i++){ + if( (z[i]&0xc0)==0x80 ) p2++; + } + while( z[i] && (z[i]&0xc0)==0x80 ){ i++; p2++; } +#endif + if( p2<0 ) p2 = 0; + sqlite_set_result_string(context, &z[p1], p2); +} + +/* +** Implementation of the round() function +*/ +static void roundFunc(sqlite_func *context, int argc, const char **argv){ + int n; + double r; + char zBuf[100]; + assert( argc==1 || argc==2 ); + if( argv[0]==0 || (argc==2 && argv[1]==0) ) return; + n = argc==2 ? atoi(argv[1]) : 0; + if( n>30 ) n = 30; + if( n<0 ) n = 0; + r = sqliteAtoF(argv[0], 0); + sprintf(zBuf,"%.*f",n,r); + sqlite_set_result_string(context, zBuf, -1); +} + +/* +** Implementation of the upper() and lower() SQL functions. +*/ +static void upperFunc(sqlite_func *context, int argc, const char **argv){ + unsigned char *z; + int i; + if( argc<1 || argv[0]==0 ) return; + z = (unsigned char*)sqlite_set_result_string(context, argv[0], -1); + if( z==0 ) return; + for(i=0; z[i]; i++){ + if( islower(z[i]) ) z[i] = toupper(z[i]); + } +} +static void lowerFunc(sqlite_func *context, int argc, const char **argv){ + unsigned char *z; + int i; + if( argc<1 || argv[0]==0 ) return; + z = (unsigned char*)sqlite_set_result_string(context, argv[0], -1); + if( z==0 ) return; + for(i=0; z[i]; i++){ + if( isupper(z[i]) ) z[i] = tolower(z[i]); + } +} + +/* +** Implementation of the IFNULL(), NVL(), and COALESCE() functions. +** All three do the same thing. They return the first non-NULL +** argument. +*/ +static void ifnullFunc(sqlite_func *context, int argc, const char **argv){ + int i; + for(i=0; i<argc; i++){ + if( argv[i] ){ + sqlite_set_result_string(context, argv[i], -1); + break; + } + } +} + +/* +** Implementation of random(). Return a random integer. +*/ +static void randomFunc(sqlite_func *context, int argc, const char **argv){ + int r; + sqliteRandomness(sizeof(r), &r); + sqlite_set_result_int(context, r); +} + +/* +** Implementation of the last_insert_rowid() SQL function. The return +** value is the same as the sqlite_last_insert_rowid() API function. +*/ +static void last_insert_rowid(sqlite_func *context, int arg, const char **argv){ + sqlite *db = sqlite_user_data(context); + sqlite_set_result_int(context, sqlite_last_insert_rowid(db)); +} + +/* +** Implementation of the change_count() SQL function. The return +** value is the same as the sqlite_changes() API function. +*/ +static void change_count(sqlite_func *context, int arg, const char **argv){ + sqlite *db = sqlite_user_data(context); + sqlite_set_result_int(context, sqlite_changes(db)); +} + +/* +** Implementation of the last_statement_change_count() SQL function. The +** return value is the same as the sqlite_last_statement_changes() API function. +*/ +static void last_statement_change_count(sqlite_func *context, int arg, + const char **argv){ + sqlite *db = sqlite_user_data(context); + sqlite_set_result_int(context, sqlite_last_statement_changes(db)); +} + +/* +** 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: +** +** 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: +** +** A GLOB B +** +** is implemented as glob(A,B). +*/ +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])); +} + +/* +** Implementation of the NULLIF(x,y) function. The result is the first +** argument if the arguments are different. The result is NULL if the +** arguments are equal to each other. +*/ +static void nullifFunc(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); + } +} + +/* +** 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); +} + +/* +** EXPERIMENTAL - This is not an official function. The interface may +** change. This function may disappear. Do not write code that depends +** on this function. +** +** Implementation of the QUOTE() function. This function takes a single +** argument. If the argument is numeric, the return value is the same as +** the argument. If the argument is NULL, the return value is the string +** "NULL". Otherwise, the argument is enclosed in single quotes with +** single-quote escapes. +*/ +static void quoteFunc(sqlite_func *context, int argc, const char **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++] = '\''; + } + } + z[j++] = '\''; + z[j] = 0; + sqlite_set_result_string(context, z, j); + sqliteFree(z); + } +} + +#ifdef SQLITE_SOUNDEX +/* +** Compute the soundex encoding of a word. +*/ +static void soundexFunc(sqlite_func *context, int argc, const char **argv){ + char zResult[8]; + const char *zIn; + int i, j; + static const unsigned char iCode[] = { + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 2, 3, 0, 1, 2, 0, 0, 2, 2, 4, 5, 5, 0, + 1, 2, 6, 2, 3, 0, 1, 0, 2, 0, 2, 0, 0, 0, 0, 0, + 0, 0, 1, 2, 3, 0, 1, 2, 0, 0, 2, 2, 4, 5, 5, 0, + 1, 2, 6, 2, 3, 0, 1, 0, 2, 0, 2, 0, 0, 0, 0, 0, + }; + assert( argc==1 ); + zIn = argv[0]; + for(i=0; zIn[i] && !isalpha(zIn[i]); i++){} + if( zIn[i] ){ + zResult[0] = toupper(zIn[i]); + for(j=1; j<4 && zIn[i]; i++){ + int code = iCode[zIn[i]&0x7f]; + if( code>0 ){ + zResult[j++] = code + '0'; + } + } + while( j<4 ){ + zResult[j++] = '0'; + } + zResult[j] = 0; + sqlite_set_result_string(context, zResult, 4); + }else{ + sqlite_set_result_string(context, "?000", 4); + } +} +#endif + +#ifdef SQLITE_TEST +/* +** This function generates a string of random characters. Used for +** generating test data. +*/ +static void randStr(sqlite_func *context, int argc, const char **argv){ + static const unsigned char zSrc[] = + "abcdefghijklmnopqrstuvwxyz" + "ABCDEFGHIJKLMNOPQRSTUVWXYZ" + "0123456789" + ".-!,:*^+=_|?/<> "; + int iMin, iMax, n, r, i; + unsigned char zBuf[1000]; + if( argc>=1 ){ + iMin = atoi(argv[0]); + if( iMin<0 ) iMin = 0; + if( iMin>=sizeof(zBuf) ) iMin = sizeof(zBuf)-1; + }else{ + iMin = 1; + } + if( argc>=2 ){ + iMax = atoi(argv[1]); + if( iMax<iMin ) iMax = iMin; + if( iMax>=sizeof(zBuf) ) iMax = sizeof(zBuf)-1; + }else{ + iMax = 50; + } + n = iMin; + if( iMax>iMin ){ + sqliteRandomness(sizeof(r), &r); + r &= 0x7fffffff; + n += r%(iMax + 1 - iMin); + } + assert( n<sizeof(zBuf) ); + sqliteRandomness(n, zBuf); + for(i=0; i<n; i++){ + zBuf[i] = zSrc[zBuf[i]%(sizeof(zSrc)-1)]; + } + zBuf[n] = 0; + sqlite_set_result_string(context, zBuf, n); +} +#endif + +/* +** An instance of the following structure holds the context of a +** sum() or avg() aggregate computation. +*/ +typedef struct SumCtx SumCtx; +struct SumCtx { + double sum; /* Sum of terms */ + int cnt; /* Number of elements summed */ +}; + +/* +** Routines used to compute the sum or average. +*/ +static void sumStep(sqlite_func *context, int argc, const char **argv){ + SumCtx *p; + if( argc<1 ) return; + p = sqlite_aggregate_context(context, sizeof(*p)); + if( p && argv[0] ){ + p->sum += sqliteAtoF(argv[0], 0); + p->cnt++; + } +} +static void sumFinalize(sqlite_func *context){ + SumCtx *p; + p = sqlite_aggregate_context(context, sizeof(*p)); + sqlite_set_result_double(context, p ? p->sum : 0.0); +} +static void avgFinalize(sqlite_func *context){ + SumCtx *p; + p = sqlite_aggregate_context(context, sizeof(*p)); + if( p && p->cnt>0 ){ + sqlite_set_result_double(context, p->sum/(double)p->cnt); + } +} + +/* +** An instance of the following structure holds the context of a +** variance or standard deviation computation. +*/ +typedef struct StdDevCtx StdDevCtx; +struct StdDevCtx { + double sum; /* Sum of terms */ + double sum2; /* Sum of the squares of terms */ + int cnt; /* Number of terms counted */ +}; + +#if 0 /* Omit because math library is required */ +/* +** Routines used to compute the standard deviation as an aggregate. +*/ +static void stdDevStep(sqlite_func *context, int argc, const char **argv){ + StdDevCtx *p; + double x; + if( argc<1 ) return; + p = sqlite_aggregate_context(context, sizeof(*p)); + if( p && argv[0] ){ + x = sqliteAtoF(argv[0], 0); + p->sum += x; + p->sum2 += x*x; + p->cnt++; + } +} +static void stdDevFinalize(sqlite_func *context){ + double rN = sqlite_aggregate_count(context); + StdDevCtx *p = sqlite_aggregate_context(context, sizeof(*p)); + if( p && p->cnt>1 ){ + double rCnt = cnt; + sqlite_set_result_double(context, + sqrt((p->sum2 - p->sum*p->sum/rCnt)/(rCnt-1.0))); + } +} +#endif + +/* +** The following structure keeps track of state information for the +** count() aggregate function. +*/ +typedef struct CountCtx CountCtx; +struct CountCtx { + int n; +}; + +/* +** Routines to implement the count() aggregate function. +*/ +static void countStep(sqlite_func *context, int argc, const char **argv){ + CountCtx *p; + p = sqlite_aggregate_context(context, sizeof(*p)); + if( (argc==0 || argv[0]) && p ){ + p->n++; + } +} +static void countFinalize(sqlite_func *context){ + CountCtx *p; + p = sqlite_aggregate_context(context, sizeof(*p)); + sqlite_set_result_int(context, p ? p->n : 0); +} + +/* +** This function tracks state information for the min() and max() +** aggregate functions. +*/ +typedef struct MinMaxCtx MinMaxCtx; +struct MinMaxCtx { + char *z; /* The best so far */ + char zBuf[28]; /* Space that can be used for storage */ +}; + +/* +** Routines to implement min() and max() aggregate functions. +*/ +static void minmaxStep(sqlite_func *context, int argc, const char **argv){ + MinMaxCtx *p; + int (*xCompare)(const char*, const char*); + int mask; /* 0 for min() or 0xffffffff for max() */ + + assert( argc==2 ); + if( argv[0]==0 ) return; /* Ignore NULL values */ + if( argv[1][0]=='n' ){ + xCompare = sqliteCompare; + }else{ + xCompare = strcmp; + } + mask = (int)sqlite_user_data(context); + assert( mask==0 || mask==-1 ); + p = sqlite_aggregate_context(context, sizeof(*p)); + if( p==0 || argc<1 ) return; + if( p->z==0 || (xCompare(argv[0],p->z)^mask)<0 ){ + int len; + if( p->zBuf[0] ){ + sqliteFree(p->z); + } + len = strlen(argv[0]); + if( len < sizeof(p->zBuf)-1 ){ + p->z = &p->zBuf[1]; + p->zBuf[0] = 0; + }else{ + p->z = sqliteMalloc( len+1 ); + p->zBuf[0] = 1; + if( p->z==0 ) return; + } + strcpy(p->z, argv[0]); + } +} +static void minMaxFinalize(sqlite_func *context){ + MinMaxCtx *p; + p = sqlite_aggregate_context(context, sizeof(*p)); + if( p && p->z && p->zBuf[0]<2 ){ + sqlite_set_result_string(context, p->z, strlen(p->z)); + } + if( p && p->zBuf[0] ){ + sqliteFree(p->z); + } +} + +/* +** This function registered all of the above C functions as SQL +** functions. This should be the only routine in this file with +** external linkage. +*/ +void sqliteRegisterBuiltinFunctions(sqlite *db){ + static struct { + char *zName; + signed char nArg; + signed char dataType; + u8 argType; /* 0: none. 1: db 2: (-1) */ + void (*xFunc)(sqlite_func*,int,const char**); + } aFuncs[] = { + { "min", -1, SQLITE_ARGS, 0, minmaxFunc }, + { "min", 0, 0, 0, 0 }, + { "max", -1, SQLITE_ARGS, 2, minmaxFunc }, + { "max", 0, 0, 2, 0 }, + { "typeof", 1, SQLITE_TEXT, 0, typeofFunc }, + { "length", 1, SQLITE_NUMERIC, 0, lengthFunc }, + { "substr", 3, SQLITE_TEXT, 0, substrFunc }, + { "abs", 1, SQLITE_NUMERIC, 0, absFunc }, + { "round", 1, SQLITE_NUMERIC, 0, roundFunc }, + { "round", 2, SQLITE_NUMERIC, 0, roundFunc }, + { "upper", 1, SQLITE_TEXT, 0, upperFunc }, + { "lower", 1, SQLITE_TEXT, 0, lowerFunc }, + { "coalesce", -1, SQLITE_ARGS, 0, ifnullFunc }, + { "coalesce", 0, 0, 0, 0 }, + { "coalesce", 1, 0, 0, 0 }, + { "ifnull", 2, SQLITE_ARGS, 0, ifnullFunc }, + { "random", -1, SQLITE_NUMERIC, 0, randomFunc }, + { "like", 2, SQLITE_NUMERIC, 0, likeFunc }, + { "glob", 2, SQLITE_NUMERIC, 0, globFunc }, + { "nullif", 2, SQLITE_ARGS, 0, nullifFunc }, + { "sqlite_version",0,SQLITE_TEXT, 0, versionFunc}, + { "quote", 1, SQLITE_ARGS, 0, quoteFunc }, + { "last_insert_rowid", 0, SQLITE_NUMERIC, 1, last_insert_rowid }, + { "change_count", 0, SQLITE_NUMERIC, 1, change_count }, + { "last_statement_change_count", + 0, SQLITE_NUMERIC, 1, last_statement_change_count }, +#ifdef SQLITE_SOUNDEX + { "soundex", 1, SQLITE_TEXT, 0, soundexFunc}, +#endif +#ifdef SQLITE_TEST + { "randstr", 2, SQLITE_TEXT, 0, randStr }, +#endif + }; + static struct { + char *zName; + signed char nArg; + signed char dataType; + u8 argType; + void (*xStep)(sqlite_func*,int,const char**); + void (*xFinalize)(sqlite_func*); + } aAggs[] = { + { "min", 1, 0, 0, minmaxStep, minMaxFinalize }, + { "max", 1, 0, 2, minmaxStep, minMaxFinalize }, + { "sum", 1, SQLITE_NUMERIC, 0, sumStep, sumFinalize }, + { "avg", 1, SQLITE_NUMERIC, 0, sumStep, avgFinalize }, + { "count", 0, SQLITE_NUMERIC, 0, countStep, countFinalize }, + { "count", 1, SQLITE_NUMERIC, 0, countStep, countFinalize }, +#if 0 + { "stddev", 1, SQLITE_NUMERIC, 0, stdDevStep, stdDevFinalize }, +#endif + }; + static const char *azTypeFuncs[] = { "min", "max", "typeof" }; + int i; + + for(i=0; i<sizeof(aFuncs)/sizeof(aFuncs[0]); i++){ + void *pArg; + switch( aFuncs[i].argType ){ + case 0: pArg = 0; break; + case 1: pArg = db; break; + case 2: pArg = (void*)(-1); break; + } + sqlite_create_function(db, aFuncs[i].zName, + aFuncs[i].nArg, aFuncs[i].xFunc, pArg); + if( aFuncs[i].xFunc ){ + sqlite_function_type(db, aFuncs[i].zName, aFuncs[i].dataType); + } + } + for(i=0; i<sizeof(aAggs)/sizeof(aAggs[0]); i++){ + void *pArg; + switch( aAggs[i].argType ){ + case 0: pArg = 0; break; + case 1: pArg = db; break; + case 2: pArg = (void*)(-1); break; + } + sqlite_create_aggregate(db, aAggs[i].zName, + aAggs[i].nArg, aAggs[i].xStep, aAggs[i].xFinalize, pArg); + sqlite_function_type(db, aAggs[i].zName, aAggs[i].dataType); + } + for(i=0; i<sizeof(azTypeFuncs)/sizeof(azTypeFuncs[0]); i++){ + int n = strlen(azTypeFuncs[i]); + FuncDef *p = sqliteHashFind(&db->aFunc, azTypeFuncs[i], n); + while( p ){ + p->includeTypes = 1; + p = p->pNext; + } + } + sqliteRegisterDateTimeFunctions(db); +} diff --git a/kexi/3rdparty/kexisql/src/hash.c b/kexi/3rdparty/kexisql/src/hash.c new file mode 100644 index 00000000..0aefe0ca --- /dev/null +++ b/kexi/3rdparty/kexisql/src/hash.c @@ -0,0 +1,356 @@ +/* +** 2001 September 22 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This is the implementation of generic hash-tables +** used in SQLite. +** +** $Id: hash.c 410099 2005-05-06 17:52:07Z staniek $ +*/ +#include "sqliteInt.h" +#include <assert.h> + +/* Turn bulk memory into a hash table object by initializing the +** fields of the Hash structure. +** +** "new" is a pointer to the hash table that is to be initialized. +** keyClass is one of the constants SQLITE_HASH_INT, SQLITE_HASH_POINTER, +** SQLITE_HASH_BINARY, or SQLITE_HASH_STRING. The value of keyClass +** determines what kind of key the hash table will use. "copyKey" is +** true if the hash table should make its own private copy of keys and +** false if it should just use the supplied pointer. CopyKey only makes +** sense for SQLITE_HASH_STRING and SQLITE_HASH_BINARY and is ignored +** for other key classes. +*/ +void sqliteHashInit(Hash *new, int keyClass, int copyKey){ + assert( new!=0 ); + assert( keyClass>=SQLITE_HASH_INT && keyClass<=SQLITE_HASH_BINARY ); + new->keyClass = keyClass; + new->copyKey = copyKey && + (keyClass==SQLITE_HASH_STRING || keyClass==SQLITE_HASH_BINARY); + new->first = 0; + new->count = 0; + new->htsize = 0; + new->ht = 0; +} + +/* Remove all entries from a hash table. Reclaim all memory. +** Call this routine to delete a hash table or to reset a hash table +** to the empty state. +*/ +void sqliteHashClear(Hash *pH){ + HashElem *elem; /* For looping over all elements of the table */ + + assert( pH!=0 ); + elem = pH->first; + pH->first = 0; + if( pH->ht ) sqliteFree(pH->ht); + pH->ht = 0; + pH->htsize = 0; + while( elem ){ + HashElem *next_elem = elem->next; + if( pH->copyKey && elem->pKey ){ + sqliteFree(elem->pKey); + } + sqliteFree(elem); + elem = next_elem; + } + pH->count = 0; +} + +/* +** Hash and comparison functions when the mode is SQLITE_HASH_INT +*/ +static int intHash(const void *pKey, int nKey){ + return nKey ^ (nKey<<8) ^ (nKey>>8); +} +static int intCompare(const void *pKey1, int n1, const void *pKey2, int n2){ + return n2 - n1; +} + +#if 0 /* NOT USED */ +/* +** Hash and comparison functions when the mode is SQLITE_HASH_POINTER +*/ +static int ptrHash(const void *pKey, int nKey){ + uptr x = Addr(pKey); + return x ^ (x<<8) ^ (x>>8); +} +static int ptrCompare(const void *pKey1, int n1, const void *pKey2, int n2){ + if( pKey1==pKey2 ) return 0; + if( pKey1<pKey2 ) return -1; + return 1; +} +#endif + +/* +** 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); +} +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); +} + +/* +** Hash and comparison functions when the mode is SQLITE_HASH_BINARY +*/ +static int binHash(const void *pKey, int nKey){ + int h = 0; + const char *z = (const char *)pKey; + while( nKey-- > 0 ){ + h = (h<<3) ^ h ^ *(z++); + } + return h & 0x7fffffff; +} +static int binCompare(const void *pKey1, int n1, const void *pKey2, int n2){ + if( n1!=n2 ) return n2-n1; + return memcmp(pKey1,pKey2,n1); +} + +/* +** Return a pointer to the appropriate hash function given the key class. +** +** The C syntax in this function definition may be unfamilar to some +** programmers, so we provide the following additional explanation: +** +** The name of the function is "hashFunction". The function takes a +** single parameter "keyClass". The return value of hashFunction() +** is a pointer to another function. Specifically, the return value +** of hashFunction() is a pointer to a function that takes two parameters +** with types "const void*" and "int" and returns an "int". +*/ +static int (*hashFunction(int keyClass))(const void*,int){ + switch( keyClass ){ + case SQLITE_HASH_INT: return &intHash; + /* case SQLITE_HASH_POINTER: return &ptrHash; // NOT USED */ + case SQLITE_HASH_STRING: return &strHash; + case SQLITE_HASH_BINARY: return &binHash;; + default: break; + } + return 0; +} + +/* +** Return a pointer to the appropriate hash function given the key class. +** +** For help in interpreted the obscure C code in the function definition, +** see the header comment on the previous function. +*/ +static int (*compareFunction(int keyClass))(const void*,int,const void*,int){ + switch( keyClass ){ + case SQLITE_HASH_INT: return &intCompare; + /* case SQLITE_HASH_POINTER: return &ptrCompare; // NOT USED */ + case SQLITE_HASH_STRING: return &strCompare; + case SQLITE_HASH_BINARY: return &binCompare; + default: break; + } + return 0; +} + + +/* Resize the hash table so that it cantains "new_size" buckets. +** "new_size" must be a power of 2. The hash table might fail +** to resize if sqliteMalloc() fails. +*/ +static void rehash(Hash *pH, int new_size){ + struct _ht *new_ht; /* The new hash table */ + HashElem *elem, *next_elem; /* For looping over existing elements */ + HashElem *x; /* Element being copied to new hash table */ + int (*xHash)(const void*,int); /* The hash function */ + + assert( (new_size & (new_size-1))==0 ); + new_ht = (struct _ht *)sqliteMalloc( new_size*sizeof(struct _ht) ); + if( new_ht==0 ) return; + if( pH->ht ) sqliteFree(pH->ht); + pH->ht = new_ht; + pH->htsize = new_size; + xHash = hashFunction(pH->keyClass); + for(elem=pH->first, pH->first=0; elem; elem = next_elem){ + int h = (*xHash)(elem->pKey, elem->nKey) & (new_size-1); + next_elem = elem->next; + x = new_ht[h].chain; + if( x ){ + elem->next = x; + elem->prev = x->prev; + if( x->prev ) x->prev->next = elem; + else pH->first = elem; + x->prev = elem; + }else{ + elem->next = pH->first; + if( pH->first ) pH->first->prev = elem; + elem->prev = 0; + pH->first = elem; + } + new_ht[h].chain = elem; + new_ht[h].count++; + } +} + +/* This function (for internal use only) locates an element in an +** hash table that matches the given key. The hash for this key has +** already been computed and is passed as the 4th parameter. +*/ +static HashElem *findElementGivenHash( + const Hash *pH, /* The pH to be searched */ + const void *pKey, /* The key we are searching for */ + int nKey, + int h /* The hash for this key. */ +){ + HashElem *elem; /* Used to loop thru the element list */ + int count; /* Number of elements left to test */ + int (*xCompare)(const void*,int,const void*,int); /* comparison function */ + + if( pH->ht ){ + elem = pH->ht[h].chain; + count = pH->ht[h].count; + xCompare = compareFunction(pH->keyClass); + while( count-- && elem ){ + if( (*xCompare)(elem->pKey,elem->nKey,pKey,nKey)==0 ){ + return elem; + } + elem = elem->next; + } + } + return 0; +} + +/* Remove a single entry from the hash table given a pointer to that +** element and a hash on the element's key. +*/ +static void removeElementGivenHash( + Hash *pH, /* The pH containing "elem" */ + HashElem* elem, /* The element to be removed from the pH */ + int h /* Hash value for the element */ +){ + if( elem->prev ){ + elem->prev->next = elem->next; + }else{ + pH->first = elem->next; + } + if( elem->next ){ + elem->next->prev = elem->prev; + } + if( pH->ht[h].chain==elem ){ + pH->ht[h].chain = elem->next; + } + pH->ht[h].count--; + if( pH->ht[h].count<=0 ){ + pH->ht[h].chain = 0; + } + if( pH->copyKey && elem->pKey ){ + sqliteFree(elem->pKey); + } + sqliteFree( elem ); + pH->count--; +} + +/* Attempt to locate an element of the hash table pH with a key +** that matches pKey,nKey. Return the data for this element if it is +** found, or NULL if there is no match. +*/ +void *sqliteHashFind(const Hash *pH, const void *pKey, int nKey){ + int h; /* A hash on key */ + HashElem *elem; /* The element that matches key */ + int (*xHash)(const void*,int); /* The hash function */ + + if( pH==0 || pH->ht==0 ) return 0; + xHash = hashFunction(pH->keyClass); + assert( xHash!=0 ); + h = (*xHash)(pKey,nKey); + assert( (pH->htsize & (pH->htsize-1))==0 ); + elem = findElementGivenHash(pH,pKey,nKey, h & (pH->htsize-1)); + return elem ? elem->data : 0; +} + +/* Insert an element into the hash table pH. The key is pKey,nKey +** and the data is "data". +** +** If no element exists with a matching key, then a new +** element is created. A copy of the key is made if the copyKey +** flag is set. NULL is returned. +** +** If another element already exists with the same key, then the +** new data replaces the old data and the old data is returned. +** The key is not copied in this instance. If a malloc fails, then +** the new data is returned and the hash table is unchanged. +** +** If the "data" parameter to this function is NULL, then the +** element corresponding to "key" is removed from the hash table. +*/ +void *sqliteHashInsert(Hash *pH, const void *pKey, int nKey, void *data){ + int hraw; /* Raw hash value of the key */ + int h; /* the hash of the key modulo hash table size */ + HashElem *elem; /* Used to loop thru the element list */ + HashElem *new_elem; /* New element added to the pH */ + int (*xHash)(const void*,int); /* The hash function */ + + assert( pH!=0 ); + xHash = hashFunction(pH->keyClass); + assert( xHash!=0 ); + hraw = (*xHash)(pKey, nKey); + assert( (pH->htsize & (pH->htsize-1))==0 ); + h = hraw & (pH->htsize-1); + elem = findElementGivenHash(pH,pKey,nKey,h); + if( elem ){ + void *old_data = elem->data; + if( data==0 ){ + removeElementGivenHash(pH,elem,h); + }else{ + elem->data = data; + } + return old_data; + } + if( data==0 ) return 0; + new_elem = (HashElem*)sqliteMalloc( sizeof(HashElem) ); + if( new_elem==0 ) return data; + if( pH->copyKey && pKey!=0 ){ + new_elem->pKey = sqliteMallocRaw( nKey ); + if( new_elem->pKey==0 ){ + sqliteFree(new_elem); + return data; + } + memcpy((void*)new_elem->pKey, pKey, nKey); + }else{ + new_elem->pKey = (void*)pKey; + } + new_elem->nKey = nKey; + pH->count++; + if( pH->htsize==0 ) rehash(pH,8); + if( pH->htsize==0 ){ + pH->count = 0; + sqliteFree(new_elem); + return data; + } + if( pH->count > pH->htsize ){ + rehash(pH,pH->htsize*2); + } + assert( (pH->htsize & (pH->htsize-1))==0 ); + h = hraw & (pH->htsize-1); + elem = pH->ht[h].chain; + if( elem ){ + new_elem->next = elem; + new_elem->prev = elem->prev; + if( elem->prev ){ elem->prev->next = new_elem; } + else { pH->first = new_elem; } + elem->prev = new_elem; + }else{ + new_elem->next = pH->first; + new_elem->prev = 0; + if( pH->first ){ pH->first->prev = new_elem; } + pH->first = new_elem; + } + pH->ht[h].count++; + pH->ht[h].chain = new_elem; + new_elem->data = data; + return 0; +} diff --git a/kexi/3rdparty/kexisql/src/hash.h b/kexi/3rdparty/kexisql/src/hash.h new file mode 100644 index 00000000..e1c1bb8e --- /dev/null +++ b/kexi/3rdparty/kexisql/src/hash.h @@ -0,0 +1,109 @@ +/* +** 2001 September 22 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This is the header file for the generic hash-table implemenation +** used in SQLite. +** +** $Id: hash.h 410099 2005-05-06 17:52:07Z staniek $ +*/ +#ifndef _SQLITE_HASH_H_ +#define _SQLITE_HASH_H_ + +/* Forward declarations of structures. */ +typedef struct Hash Hash; +typedef struct HashElem HashElem; + +/* A complete hash table is an instance of the following structure. +** The internals of this structure are intended to be opaque -- client +** code should not attempt to access or modify the fields of this structure +** directly. Change this structure only by using the routines below. +** However, many of the "procedures" and "functions" for modifying and +** accessing this structure are really macros, so we can't really make +** this structure opaque. +*/ +struct Hash { + char keyClass; /* SQLITE_HASH_INT, _POINTER, _STRING, _BINARY */ + char copyKey; /* True if copy of key made on insert */ + int count; /* Number of entries in this table */ + HashElem *first; /* The first element of the array */ + int htsize; /* Number of buckets in the hash table */ + struct _ht { /* the hash table */ + int count; /* Number of entries with this hash */ + HashElem *chain; /* Pointer to first entry with this hash */ + } *ht; +}; + +/* Each element in the hash table is an instance of the following +** structure. All elements are stored on a single doubly-linked list. +** +** Again, this structure is intended to be opaque, but it can't really +** be opaque because it is used by macros. +*/ +struct HashElem { + HashElem *next, *prev; /* Next and previous elements in the table */ + void *data; /* Data associated with this element */ + void *pKey; int nKey; /* Key associated with this element */ +}; + +/* +** There are 4 different modes of operation for a hash table: +** +** SQLITE_HASH_INT nKey is used as the key and pKey is ignored. +** +** SQLITE_HASH_POINTER pKey is used as the key and nKey is ignored. +** +** SQLITE_HASH_STRING pKey points to a string that is nKey bytes long +** (including the null-terminator, if any). Case +** is ignored in comparisons. +** +** SQLITE_HASH_BINARY pKey points to binary data nKey bytes long. +** memcmp() is used to compare keys. +** +** A copy of the key is made for SQLITE_HASH_STRING and SQLITE_HASH_BINARY +** if the copyKey parameter to HashInit is 1. +*/ +#define SQLITE_HASH_INT 1 +/* #define SQLITE_HASH_POINTER 2 // NOT USED */ +#define SQLITE_HASH_STRING 3 +#define SQLITE_HASH_BINARY 4 + +/* +** Access routines. To delete, insert a NULL pointer. +*/ +void sqliteHashInit(Hash*, int keytype, int copyKey); +void *sqliteHashInsert(Hash*, const void *pKey, int nKey, void *pData); +void *sqliteHashFind(const Hash*, const void *pKey, int nKey); +void sqliteHashClear(Hash*); + +/* +** Macros for looping over all elements of a hash table. The idiom is +** like this: +** +** Hash h; +** HashElem *p; +** ... +** for(p=sqliteHashFirst(&h); p; p=sqliteHashNext(p)){ +** SomeStructure *pData = sqliteHashData(p); +** // do something with pData +** } +*/ +#define sqliteHashFirst(H) ((H)->first) +#define sqliteHashNext(E) ((E)->next) +#define sqliteHashData(E) ((E)->data) +#define sqliteHashKey(E) ((E)->pKey) +#define sqliteHashKeysize(E) ((E)->nKey) + +/* +** Number of entries in a hash table +*/ +#define sqliteHashCount(H) ((H)->count) + +#endif /* _SQLITE_HASH_H_ */ diff --git a/kexi/3rdparty/kexisql/src/insert.c b/kexi/3rdparty/kexisql/src/insert.c new file mode 100644 index 00000000..660a2a56 --- /dev/null +++ b/kexi/3rdparty/kexisql/src/insert.c @@ -0,0 +1,919 @@ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains C code routines that are called by the parser +** to handle INSERT statements in SQLite. +** +** $Id: insert.c 410099 2005-05-06 17:52:07Z staniek $ +*/ +#include "sqliteInt.h" + +/* +** This routine is call to handle SQL of the following forms: +** +** insert into TABLE (IDLIST) values(EXPRLIST) +** insert into TABLE (IDLIST) select +** +** The IDLIST following the table name is always optional. If omitted, +** then a list of all columns for the table is substituted. The IDLIST +** appears in the pColumn parameter. pColumn is NULL if IDLIST is omitted. +** +** The pList parameter holds EXPRLIST in the first form of the INSERT +** statement above, and pSelect is NULL. For the second form, pList is +** NULL and pSelect is a pointer to the select statement used to generate +** data for the insert. +** +** The code generated follows one of three templates. For a simple +** select with data coming from a VALUES clause, the code executes +** once straight down through. The template looks like this: +** +** open write cursor to <table> and its indices +** puts VALUES clause expressions onto the stack +** write the resulting record into <table> +** cleanup +** +** If the statement is of the form +** +** INSERT INTO <table> SELECT ... +** +** And the SELECT clause does not read from <table> at any time, then +** the generated code follows this template: +** +** goto B +** A: setup for the SELECT +** loop over the tables in the SELECT +** gosub C +** end loop +** cleanup after the SELECT +** goto D +** B: open write cursor to <table> and its indices +** goto A +** C: insert the select result into <table> +** return +** D: cleanup +** +** The third template is used if the insert statement takes its +** values from a SELECT but the data is being inserted into a table +** that is also read as part of the SELECT. In the third form, +** we have to use a intermediate table to store the results of +** the select. The template is like this: +** +** goto B +** A: setup for the SELECT +** loop over the tables in the SELECT +** gosub C +** end loop +** cleanup after the SELECT +** goto D +** C: insert the select result into the intermediate table +** return +** B: open a cursor to an intermediate table +** goto A +** D: open write cursor to <table> and its indices +** loop over the intermediate table +** transfer values form intermediate table into <table> +** end the loop +** cleanup +*/ +void sqliteInsert( + Parse *pParse, /* Parser context */ + SrcList *pTabList, /* Name of table into which we are inserting */ + ExprList *pList, /* List of values to be inserted */ + Select *pSelect, /* A SELECT statement to use as the data source */ + IdList *pColumn, /* Column names corresponding to IDLIST. */ + int onError /* How to handle constraint errors */ +){ + Table *pTab; /* The table to insert into */ + char *zTab; /* Name of the table into which we are inserting */ + const char *zDb; /* Name of the database holding this table */ + int i, j, idx; /* Loop counters */ + Vdbe *v; /* Generate code into this virtual machine */ + Index *pIdx; /* For looping over indices of the table */ + int nColumn; /* Number of columns in the data */ + int base; /* VDBE Cursor number for pTab */ + int iCont, iBreak; /* Beginning and end of the loop over srcTab */ + sqlite *db; /* The main database structure */ + int keyColumn = -1; /* Column that is the INTEGER PRIMARY KEY */ + int endOfLoop; /* Label for the end of the insertion loop */ + int useTempTable; /* Store SELECT results in intermediate table */ + int srcTab; /* Data comes from this temporary cursor if >=0 */ + int iSelectLoop; /* Address of code that implements the SELECT */ + int iCleanup; /* Address of the cleanup code */ + int iInsertBlock; /* Address of the subroutine used to insert data */ + int iCntMem; /* Memory cell used for the row counter */ + int isView; /* True if attempting to insert into a view */ + + int row_triggers_exist = 0; /* True if there are FOR EACH ROW triggers */ + int before_triggers; /* True if there are BEFORE triggers */ + int after_triggers; /* True if there are AFTER triggers */ + int newIdx = -1; /* Cursor for the NEW table */ + + if( pParse->nErr || sqlite_malloc_failed ) goto insert_cleanup; + db = pParse->db; + + /* Locate the table into which we will be inserting new information. + */ + assert( pTabList->nSrc==1 ); + zTab = pTabList->a[0].zName; + if( zTab==0 ) goto insert_cleanup; + pTab = sqliteSrcListLookup(pParse, pTabList); + if( pTab==0 ){ + goto insert_cleanup; + } + assert( pTab->iDb<db->nDb ); + zDb = db->aDb[pTab->iDb].zName; + if( sqliteAuthCheck(pParse, SQLITE_INSERT, pTab->zName, 0, zDb) ){ + goto insert_cleanup; + } + + /* Ensure that: + * (a) the table is not read-only, + * (b) that if it is a view then ON INSERT triggers exist + */ + before_triggers = sqliteTriggersExist(pParse, pTab->pTrigger, TK_INSERT, + TK_BEFORE, TK_ROW, 0); + after_triggers = sqliteTriggersExist(pParse, pTab->pTrigger, TK_INSERT, + TK_AFTER, TK_ROW, 0); + row_triggers_exist = before_triggers || after_triggers; + isView = pTab->pSelect!=0; + if( sqliteIsReadOnly(pParse, pTab, before_triggers) ){ + goto insert_cleanup; + } + if( pTab==0 ) goto insert_cleanup; + + /* If pTab is really a view, make sure it has been initialized. + */ + if( isView && sqliteViewGetColumnNames(pParse, pTab) ){ + goto insert_cleanup; + } + + /* Allocate a VDBE + */ + v = sqliteGetVdbe(pParse); + if( v==0 ) goto insert_cleanup; + sqliteBeginWriteOperation(pParse, pSelect || row_triggers_exist, pTab->iDb); + + /* if there are row triggers, allocate a temp table for new.* references. */ + if( row_triggers_exist ){ + newIdx = pParse->nTab++; + } + + /* Figure out how many columns of data are supplied. If the data + ** is coming from a SELECT statement, then this step also generates + ** all the code to implement the SELECT statement and invoke a subroutine + ** to process each row of the result. (Template 2.) If the SELECT + ** statement uses the the table that is being inserted into, then the + ** subroutine is also coded here. That subroutine stores the SELECT + ** results in a temporary table. (Template 3.) + */ + if( pSelect ){ + /* Data is coming from a SELECT. Generate code to implement that SELECT + */ + int rc, iInitCode; + iInitCode = sqliteVdbeAddOp(v, OP_Goto, 0, 0); + iSelectLoop = sqliteVdbeCurrentAddr(v); + iInsertBlock = sqliteVdbeMakeLabel(v); + rc = sqliteSelect(pParse, pSelect, SRT_Subroutine, iInsertBlock, 0,0,0); + if( rc || pParse->nErr || sqlite_malloc_failed ) goto insert_cleanup; + iCleanup = sqliteVdbeMakeLabel(v); + sqliteVdbeAddOp(v, OP_Goto, 0, iCleanup); + assert( pSelect->pEList ); + nColumn = pSelect->pEList->nExpr; + + /* Set useTempTable to TRUE if the result of the SELECT statement + ** should be written into a temporary table. Set to FALSE if each + ** row of the SELECT can be written directly into the result table. + ** + ** A temp table must be used if the table being updated is also one + ** of the tables being read by the SELECT statement. Also use a + ** temp table in the case of row triggers. + */ + if( row_triggers_exist ){ + useTempTable = 1; + }else{ + int addr = sqliteVdbeFindOp(v, OP_OpenRead, pTab->tnum); + useTempTable = 0; + if( addr>0 ){ + VdbeOp *pOp = sqliteVdbeGetOp(v, addr-2); + if( pOp->opcode==OP_Integer && pOp->p1==pTab->iDb ){ + useTempTable = 1; + } + } + } + + if( useTempTable ){ + /* Generate the subroutine that SELECT calls to process each row of + ** the result. Store the result in a temporary table + */ + srcTab = pParse->nTab++; + sqliteVdbeResolveLabel(v, iInsertBlock); + sqliteVdbeAddOp(v, OP_MakeRecord, nColumn, 0); + sqliteVdbeAddOp(v, OP_NewRecno, srcTab, 0); + sqliteVdbeAddOp(v, OP_Pull, 1, 0); + sqliteVdbeAddOp(v, OP_PutIntKey, srcTab, 0); + sqliteVdbeAddOp(v, OP_Return, 0, 0); + + /* The following code runs first because the GOTO at the very top + ** of the program jumps to it. Create the temporary table, then jump + ** back up and execute the SELECT code above. + */ + sqliteVdbeChangeP2(v, iInitCode, sqliteVdbeCurrentAddr(v)); + sqliteVdbeAddOp(v, OP_OpenTemp, srcTab, 0); + sqliteVdbeAddOp(v, OP_Goto, 0, iSelectLoop); + sqliteVdbeResolveLabel(v, iCleanup); + }else{ + sqliteVdbeChangeP2(v, iInitCode, sqliteVdbeCurrentAddr(v)); + } + }else{ + /* This is the case if the data for the INSERT is coming from a VALUES + ** clause + */ + SrcList dummy; + assert( pList!=0 ); + srcTab = -1; + useTempTable = 0; + assert( pList ); + nColumn = pList->nExpr; + dummy.nSrc = 0; + for(i=0; i<nColumn; i++){ + if( sqliteExprResolveIds(pParse, &dummy, 0, pList->a[i].pExpr) ){ + goto insert_cleanup; + } + if( sqliteExprCheck(pParse, pList->a[i].pExpr, 0, 0) ){ + goto insert_cleanup; + } + } + } + + /* Make sure the number of columns in the source data matches the number + ** of columns to be inserted into the table. + */ + if( pColumn==0 && nColumn!=pTab->nCol ){ + sqliteErrorMsg(pParse, + "table %S has %d columns but %d values were supplied", + pTabList, 0, pTab->nCol, nColumn); + goto insert_cleanup; + } + if( pColumn!=0 && nColumn!=pColumn->nId ){ + sqliteErrorMsg(pParse, "%d values for %d columns", nColumn, pColumn->nId); + goto insert_cleanup; + } + + /* If the INSERT statement included an IDLIST term, then make sure + ** all elements of the IDLIST really are columns of the table and + ** remember the column indices. + ** + ** If the table has an INTEGER PRIMARY KEY column and that column + ** is named in the IDLIST, then record in the keyColumn variable + ** the index into IDLIST of the primary key column. keyColumn is + ** the index of the primary key as it appears in IDLIST, not as + ** is appears in the original table. (The index of the primary + ** key in the original table is pTab->iPKey.) + */ + if( pColumn ){ + for(i=0; i<pColumn->nId; i++){ + pColumn->a[i].idx = -1; + } + for(i=0; i<pColumn->nId; i++){ + for(j=0; j<pTab->nCol; j++){ + if( sqliteStrICmp(pColumn->a[i].zName, pTab->aCol[j].zName)==0 ){ + pColumn->a[i].idx = j; + if( j==pTab->iPKey ){ + keyColumn = i; + } + break; + } + } + if( j>=pTab->nCol ){ + if( sqliteIsRowid(pColumn->a[i].zName) ){ + keyColumn = i; + }else{ + sqliteErrorMsg(pParse, "table %S has no column named %s", + pTabList, 0, pColumn->a[i].zName); + pParse->nErr++; + goto insert_cleanup; + } + } + } + } + + /* If there is no IDLIST term but the table has an integer primary + ** key, the set the keyColumn variable to the primary key column index + ** in the original table definition. + */ + if( pColumn==0 ){ + keyColumn = pTab->iPKey; + } + + /* Open the temp table for FOR EACH ROW triggers + */ + if( row_triggers_exist ){ + sqliteVdbeAddOp(v, OP_OpenPseudo, newIdx, 0); + } + + /* Initialize the count of rows to be inserted + */ + if( db->flags & SQLITE_CountRows ){ + iCntMem = pParse->nMem++; + sqliteVdbeAddOp(v, OP_Integer, 0, 0); + sqliteVdbeAddOp(v, OP_MemStore, iCntMem, 1); + } + + /* Open tables and indices if there are no row triggers */ + if( !row_triggers_exist ){ + base = pParse->nTab; + idx = sqliteOpenTableAndIndices(pParse, pTab, base); + pParse->nTab += idx; + } + + /* If the data source is a temporary table, then we have to create + ** a loop because there might be multiple rows of data. If the data + ** source is a subroutine call from the SELECT statement, then we need + ** to launch the SELECT statement processing. + */ + if( useTempTable ){ + iBreak = sqliteVdbeMakeLabel(v); + sqliteVdbeAddOp(v, OP_Rewind, srcTab, iBreak); + iCont = sqliteVdbeCurrentAddr(v); + }else if( pSelect ){ + sqliteVdbeAddOp(v, OP_Goto, 0, iSelectLoop); + sqliteVdbeResolveLabel(v, iInsertBlock); + } + + /* Run the BEFORE and INSTEAD OF triggers, if there are any + */ + endOfLoop = sqliteVdbeMakeLabel(v); + if( before_triggers ){ + + /* build the NEW.* reference row. Note that if there is an INTEGER + ** PRIMARY KEY into which a NULL is being inserted, that NULL will be + ** translated into a unique ID for the row. But on a BEFORE trigger, + ** we do not know what the unique ID will be (because the insert has + ** not happened yet) so we substitute a rowid of -1 + */ + if( keyColumn<0 ){ + sqliteVdbeAddOp(v, OP_Integer, -1, 0); + }else if( useTempTable ){ + sqliteVdbeAddOp(v, OP_Column, srcTab, keyColumn); + }else if( pSelect ){ + sqliteVdbeAddOp(v, OP_Dup, nColumn - keyColumn - 1, 1); + }else{ + sqliteExprCode(pParse, pList->a[keyColumn].pExpr); + sqliteVdbeAddOp(v, OP_NotNull, -1, sqliteVdbeCurrentAddr(v)+3); + sqliteVdbeAddOp(v, OP_Pop, 1, 0); + sqliteVdbeAddOp(v, OP_Integer, -1, 0); + sqliteVdbeAddOp(v, OP_MustBeInt, 0, 0); + } + + /* Create the new column data + */ + for(i=0; i<pTab->nCol; i++){ + if( pColumn==0 ){ + j = i; + }else{ + for(j=0; j<pColumn->nId; j++){ + if( pColumn->a[j].idx==i ) break; + } + } + if( pColumn && j>=pColumn->nId ){ + sqliteVdbeOp3(v, OP_String, 0, 0, pTab->aCol[i].zDflt, P3_STATIC); + }else if( useTempTable ){ + sqliteVdbeAddOp(v, OP_Column, srcTab, j); + }else if( pSelect ){ + sqliteVdbeAddOp(v, OP_Dup, nColumn-j-1, 1); + }else{ + sqliteExprCode(pParse, pList->a[j].pExpr); + } + } + sqliteVdbeAddOp(v, OP_MakeRecord, pTab->nCol, 0); + sqliteVdbeAddOp(v, OP_PutIntKey, newIdx, 0); + + /* Fire BEFORE or INSTEAD OF triggers */ + if( sqliteCodeRowTrigger(pParse, TK_INSERT, 0, TK_BEFORE, pTab, + newIdx, -1, onError, endOfLoop) ){ + goto insert_cleanup; + } + } + + /* If any triggers exists, the opening of tables and indices is deferred + ** until now. + */ + if( row_triggers_exist && !isView ){ + base = pParse->nTab; + idx = sqliteOpenTableAndIndices(pParse, pTab, base); + pParse->nTab += idx; + } + + /* Push the record number for the new entry onto the stack. The + ** record number is a randomly generate integer created by NewRecno + ** except when the table has an INTEGER PRIMARY KEY column, in which + ** case the record number is the same as that column. + */ + if( !isView ){ + if( keyColumn>=0 ){ + if( useTempTable ){ + sqliteVdbeAddOp(v, OP_Column, srcTab, keyColumn); + }else if( pSelect ){ + sqliteVdbeAddOp(v, OP_Dup, nColumn - keyColumn - 1, 1); + }else{ + sqliteExprCode(pParse, pList->a[keyColumn].pExpr); + } + /* If the PRIMARY KEY expression is NULL, then use OP_NewRecno + ** to generate a unique primary key value. + */ + sqliteVdbeAddOp(v, OP_NotNull, -1, sqliteVdbeCurrentAddr(v)+3); + sqliteVdbeAddOp(v, OP_Pop, 1, 0); + sqliteVdbeAddOp(v, OP_NewRecno, base, 0); + sqliteVdbeAddOp(v, OP_MustBeInt, 0, 0); + }else{ + sqliteVdbeAddOp(v, OP_NewRecno, base, 0); + } + + /* Push onto the stack, data for all columns of the new entry, beginning + ** with the first column. + */ + for(i=0; i<pTab->nCol; i++){ + if( i==pTab->iPKey ){ + /* The value of the INTEGER PRIMARY KEY column is always a NULL. + ** Whenever this column is read, the record number will be substituted + ** in its place. So will fill this column with a NULL to avoid + ** taking up data space with information that will never be used. */ + sqliteVdbeAddOp(v, OP_String, 0, 0); + continue; + } + if( pColumn==0 ){ + j = i; + }else{ + for(j=0; j<pColumn->nId; j++){ + if( pColumn->a[j].idx==i ) break; + } + } + if( pColumn && j>=pColumn->nId ){ + sqliteVdbeOp3(v, OP_String, 0, 0, pTab->aCol[i].zDflt, P3_STATIC); + }else if( useTempTable ){ + sqliteVdbeAddOp(v, OP_Column, srcTab, j); + }else if( pSelect ){ + sqliteVdbeAddOp(v, OP_Dup, i+nColumn-j, 1); + }else{ + sqliteExprCode(pParse, pList->a[j].pExpr); + } + } + + /* Generate code to check constraints and generate index keys and + ** do the insertion. + */ + sqliteGenerateConstraintChecks(pParse, pTab, base, 0, keyColumn>=0, + 0, onError, endOfLoop); + sqliteCompleteInsertion(pParse, pTab, base, 0,0,0, + after_triggers ? newIdx : -1); + } + + /* Update the count of rows that are inserted + */ + if( (db->flags & SQLITE_CountRows)!=0 ){ + sqliteVdbeAddOp(v, OP_MemIncr, iCntMem, 0); + } + + if( row_triggers_exist ){ + /* Close all tables opened */ + if( !isView ){ + sqliteVdbeAddOp(v, OP_Close, base, 0); + for(idx=1, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, idx++){ + sqliteVdbeAddOp(v, OP_Close, idx+base, 0); + } + } + + /* Code AFTER triggers */ + if( sqliteCodeRowTrigger(pParse, TK_INSERT, 0, TK_AFTER, pTab, newIdx, -1, + onError, endOfLoop) ){ + goto insert_cleanup; + } + } + + /* The bottom of the loop, if the data source is a SELECT statement + */ + sqliteVdbeResolveLabel(v, endOfLoop); + if( useTempTable ){ + sqliteVdbeAddOp(v, OP_Next, srcTab, iCont); + sqliteVdbeResolveLabel(v, iBreak); + sqliteVdbeAddOp(v, OP_Close, srcTab, 0); + }else if( pSelect ){ + sqliteVdbeAddOp(v, OP_Pop, nColumn, 0); + sqliteVdbeAddOp(v, OP_Return, 0, 0); + sqliteVdbeResolveLabel(v, iCleanup); + } + + if( !row_triggers_exist ){ + /* Close all tables opened */ + sqliteVdbeAddOp(v, OP_Close, base, 0); + for(idx=1, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, idx++){ + sqliteVdbeAddOp(v, OP_Close, idx+base, 0); + } + } + + sqliteVdbeAddOp(v, OP_SetCounts, 0, 0); + sqliteEndWriteOperation(pParse); + + /* + ** Return the number of rows inserted. + */ + if( db->flags & SQLITE_CountRows ){ + sqliteVdbeOp3(v, OP_ColumnName, 0, 1, "rows inserted", P3_STATIC); + sqliteVdbeAddOp(v, OP_MemLoad, iCntMem, 0); + sqliteVdbeAddOp(v, OP_Callback, 1, 0); + } + +insert_cleanup: + sqliteSrcListDelete(pTabList); + if( pList ) sqliteExprListDelete(pList); + if( pSelect ) sqliteSelectDelete(pSelect); + sqliteIdListDelete(pColumn); +} + +/* +** Generate code to do a constraint check prior to an INSERT or an UPDATE. +** +** When this routine is called, the stack contains (from bottom to top) +** the following values: +** +** 1. The recno of the row to be updated before the update. This +** value is omitted unless we are doing an UPDATE that involves a +** change to the record number. +** +** 2. The recno of the row after the update. +** +** 3. The data in the first column of the entry after the update. +** +** i. Data from middle columns... +** +** N. The data in the last column of the entry after the update. +** +** The old recno shown as entry (1) above is omitted unless both isUpdate +** and recnoChng are 1. isUpdate is true for UPDATEs and false for +** INSERTs and recnoChng is true if the record number is being changed. +** +** The code generated by this routine pushes additional entries onto +** the stack which are the keys for new index entries for the new record. +** The order of index keys is the same as the order of the indices on +** the pTable->pIndex list. A key is only created for index i if +** aIdxUsed!=0 and aIdxUsed[i]!=0. +** +** This routine also generates code to check constraints. NOT NULL, +** CHECK, and UNIQUE constraints are all checked. If a constraint fails, +** then the appropriate action is performed. There are five possible +** actions: ROLLBACK, ABORT, FAIL, REPLACE, and IGNORE. +** +** Constraint type Action What Happens +** --------------- ---------- ---------------------------------------- +** any ROLLBACK The current transaction is rolled back and +** sqlite_exec() returns immediately with a +** return code of SQLITE_CONSTRAINT. +** +** any ABORT Back out changes from the current command +** only (do not do a complete rollback) then +** cause sqlite_exec() to return immediately +** with SQLITE_CONSTRAINT. +** +** any FAIL Sqlite_exec() returns immediately with a +** return code of SQLITE_CONSTRAINT. The +** transaction is not rolled back and any +** prior changes are retained. +** +** any IGNORE The record number and data is popped from +** the stack and there is an immediate jump +** to label ignoreDest. +** +** NOT NULL REPLACE The NULL value is replace by the default +** value for that column. If the default value +** is NULL, the action is the same as ABORT. +** +** UNIQUE REPLACE The other row that conflicts with the row +** being inserted is removed. +** +** CHECK REPLACE Illegal. The results in an exception. +** +** Which action to take is determined by the overrideError parameter. +** Or if overrideError==OE_Default, then the pParse->onError parameter +** is used. Or if pParse->onError==OE_Default then the onError value +** for the constraint is used. +** +** The calling routine must open a read/write cursor for pTab with +** cursor number "base". All indices of pTab must also have open +** read/write cursors with cursor number base+i for the i-th cursor. +** Except, if there is no possibility of a REPLACE action then +** cursors do not need to be open for indices where aIdxUsed[i]==0. +** +** If the isUpdate flag is true, it means that the "base" cursor is +** initially pointing to an entry that is being updated. The isUpdate +** flag causes extra code to be generated so that the "base" cursor +** is still pointing at the same entry after the routine returns. +** Without the isUpdate flag, the "base" cursor might be moved. +*/ +void sqliteGenerateConstraintChecks( + Parse *pParse, /* The parser context */ + Table *pTab, /* the table into which we are inserting */ + int base, /* Index of a read/write cursor pointing at pTab */ + char *aIdxUsed, /* Which indices are used. NULL means all are used */ + int recnoChng, /* True if the record number will change */ + int isUpdate, /* True for UPDATE, False for INSERT */ + int overrideError, /* Override onError to this if not OE_Default */ + int ignoreDest /* Jump to this label on an OE_Ignore resolution */ +){ + int i; + Vdbe *v; + int nCol; + int onError; + int addr; + int extra; + int iCur; + Index *pIdx; + int seenReplace = 0; + int jumpInst1, jumpInst2; + int contAddr; + int hasTwoRecnos = (isUpdate && recnoChng); + + v = sqliteGetVdbe(pParse); + assert( v!=0 ); + assert( pTab->pSelect==0 ); /* This table is not a VIEW */ + nCol = pTab->nCol; + + /* Test all NOT NULL constraints. + */ + for(i=0; i<nCol; i++){ + if( i==pTab->iPKey ){ + continue; + } + onError = pTab->aCol[i].notNull; + if( onError==OE_None ) continue; + if( overrideError!=OE_Default ){ + onError = overrideError; + }else if( pParse->db->onError!=OE_Default ){ + onError = pParse->db->onError; + }else if( onError==OE_Default ){ + onError = OE_Abort; + } + if( onError==OE_Replace && pTab->aCol[i].zDflt==0 ){ + onError = OE_Abort; + } + sqliteVdbeAddOp(v, OP_Dup, nCol-1-i, 1); + addr = sqliteVdbeAddOp(v, OP_NotNull, 1, 0); + switch( onError ){ + case OE_Rollback: + case OE_Abort: + case OE_Fail: { + char *zMsg = 0; + sqliteVdbeAddOp(v, OP_Halt, SQLITE_CONSTRAINT, onError); + sqliteSetString(&zMsg, pTab->zName, ".", pTab->aCol[i].zName, + " may not be NULL", (char*)0); + sqliteVdbeChangeP3(v, -1, zMsg, P3_DYNAMIC); + break; + } + case OE_Ignore: { + sqliteVdbeAddOp(v, OP_Pop, nCol+1+hasTwoRecnos, 0); + sqliteVdbeAddOp(v, OP_Goto, 0, ignoreDest); + break; + } + case OE_Replace: { + sqliteVdbeOp3(v, OP_String, 0, 0, pTab->aCol[i].zDflt, P3_STATIC); + sqliteVdbeAddOp(v, OP_Push, nCol-i, 0); + break; + } + default: assert(0); + } + sqliteVdbeChangeP2(v, addr, sqliteVdbeCurrentAddr(v)); + } + + /* Test all CHECK constraints + */ + /**** TBD ****/ + + /* If we have an INTEGER PRIMARY KEY, make sure the primary key + ** of the new record does not previously exist. Except, if this + ** is an UPDATE and the primary key is not changing, that is OK. + */ + if( recnoChng ){ + onError = pTab->keyConf; + if( overrideError!=OE_Default ){ + onError = overrideError; + }else if( pParse->db->onError!=OE_Default ){ + onError = pParse->db->onError; + }else if( onError==OE_Default ){ + onError = OE_Abort; + } + + if( isUpdate ){ + sqliteVdbeAddOp(v, OP_Dup, nCol+1, 1); + sqliteVdbeAddOp(v, OP_Dup, nCol+1, 1); + jumpInst1 = sqliteVdbeAddOp(v, OP_Eq, 0, 0); + } + sqliteVdbeAddOp(v, OP_Dup, nCol, 1); + jumpInst2 = sqliteVdbeAddOp(v, OP_NotExists, base, 0); + switch( onError ){ + default: { + onError = OE_Abort; + /* Fall thru into the next case */ + } + case OE_Rollback: + case OE_Abort: + case OE_Fail: { + sqliteVdbeOp3(v, OP_Halt, SQLITE_CONSTRAINT, onError, + "PRIMARY KEY must be unique", P3_STATIC); + break; + } + case OE_Replace: { + sqliteGenerateRowIndexDelete(pParse->db, v, pTab, base, 0); + if( isUpdate ){ + sqliteVdbeAddOp(v, OP_Dup, nCol+hasTwoRecnos, 1); + sqliteVdbeAddOp(v, OP_MoveTo, base, 0); + } + seenReplace = 1; + break; + } + case OE_Ignore: { + assert( seenReplace==0 ); + sqliteVdbeAddOp(v, OP_Pop, nCol+1+hasTwoRecnos, 0); + sqliteVdbeAddOp(v, OP_Goto, 0, ignoreDest); + break; + } + } + contAddr = sqliteVdbeCurrentAddr(v); + sqliteVdbeChangeP2(v, jumpInst2, contAddr); + if( isUpdate ){ + sqliteVdbeChangeP2(v, jumpInst1, contAddr); + sqliteVdbeAddOp(v, OP_Dup, nCol+1, 1); + sqliteVdbeAddOp(v, OP_MoveTo, base, 0); + } + } + + /* Test all UNIQUE constraints by creating entries for each UNIQUE + ** index and making sure that duplicate entries do not already exist. + ** Add the new records to the indices as we go. + */ + extra = -1; + for(iCur=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, iCur++){ + if( aIdxUsed && aIdxUsed[iCur]==0 ) continue; /* Skip unused indices */ + extra++; + + /* Create a key for accessing the index entry */ + sqliteVdbeAddOp(v, OP_Dup, nCol+extra, 1); + for(i=0; i<pIdx->nColumn; i++){ + int idx = pIdx->aiColumn[i]; + if( idx==pTab->iPKey ){ + sqliteVdbeAddOp(v, OP_Dup, i+extra+nCol+1, 1); + }else{ + sqliteVdbeAddOp(v, OP_Dup, i+extra+nCol-idx, 1); + } + } + jumpInst1 = sqliteVdbeAddOp(v, OP_MakeIdxKey, pIdx->nColumn, 0); + if( pParse->db->file_format>=4 ) sqliteAddIdxKeyType(v, pIdx); + + /* Find out what action to take in case there is an indexing conflict */ + onError = pIdx->onError; + if( onError==OE_None ) continue; /* pIdx is not a UNIQUE index */ + if( overrideError!=OE_Default ){ + onError = overrideError; + }else if( pParse->db->onError!=OE_Default ){ + onError = pParse->db->onError; + }else if( onError==OE_Default ){ + onError = OE_Abort; + } + if( seenReplace ){ + if( onError==OE_Ignore ) onError = OE_Replace; + else if( onError==OE_Fail ) onError = OE_Abort; + } + + + /* Check to see if the new index entry will be unique */ + sqliteVdbeAddOp(v, OP_Dup, extra+nCol+1+hasTwoRecnos, 1); + jumpInst2 = sqliteVdbeAddOp(v, OP_IsUnique, base+iCur+1, 0); + + /* Generate code that executes if the new index entry is not unique */ + switch( onError ){ + case OE_Rollback: + case OE_Abort: + case OE_Fail: { + int j, n1, n2; + char zErrMsg[200]; + strcpy(zErrMsg, pIdx->nColumn>1 ? "columns " : "column "); + n1 = strlen(zErrMsg); + for(j=0; j<pIdx->nColumn && n1<sizeof(zErrMsg)-30; j++){ + char *zCol = pTab->aCol[pIdx->aiColumn[j]].zName; + n2 = strlen(zCol); + if( j>0 ){ + strcpy(&zErrMsg[n1], ", "); + n1 += 2; + } + if( n1+n2>sizeof(zErrMsg)-30 ){ + strcpy(&zErrMsg[n1], "..."); + n1 += 3; + break; + }else{ + strcpy(&zErrMsg[n1], zCol); + n1 += n2; + } + } + strcpy(&zErrMsg[n1], + pIdx->nColumn>1 ? " are not unique" : " is not unique"); + sqliteVdbeOp3(v, OP_Halt, SQLITE_CONSTRAINT, onError, zErrMsg, 0); + break; + } + case OE_Ignore: { + assert( seenReplace==0 ); + sqliteVdbeAddOp(v, OP_Pop, nCol+extra+3+hasTwoRecnos, 0); + sqliteVdbeAddOp(v, OP_Goto, 0, ignoreDest); + break; + } + case OE_Replace: { + sqliteGenerateRowDelete(pParse->db, v, pTab, base, 0); + if( isUpdate ){ + sqliteVdbeAddOp(v, OP_Dup, nCol+extra+1+hasTwoRecnos, 1); + sqliteVdbeAddOp(v, OP_MoveTo, base, 0); + } + seenReplace = 1; + break; + } + default: assert(0); + } + contAddr = sqliteVdbeCurrentAddr(v); +#if NULL_DISTINCT_FOR_UNIQUE + sqliteVdbeChangeP2(v, jumpInst1, contAddr); +#endif + sqliteVdbeChangeP2(v, jumpInst2, contAddr); + } +} + +/* +** This routine generates code to finish the INSERT or UPDATE operation +** that was started by a prior call to sqliteGenerateConstraintChecks. +** The stack must contain keys for all active indices followed by data +** and the recno for the new entry. This routine creates the new +** entries in all indices and in the main table. +** +** The arguments to this routine should be the same as the first six +** arguments to sqliteGenerateConstraintChecks. +*/ +void sqliteCompleteInsertion( + Parse *pParse, /* The parser context */ + Table *pTab, /* the table into which we are inserting */ + int base, /* Index of a read/write cursor pointing at pTab */ + char *aIdxUsed, /* Which indices are used. NULL means all are used */ + int recnoChng, /* True if the record number will change */ + int isUpdate, /* True for UPDATE, False for INSERT */ + int newIdx /* Index of NEW table for triggers. -1 if none */ +){ + int i; + Vdbe *v; + int nIdx; + Index *pIdx; + + v = sqliteGetVdbe(pParse); + assert( v!=0 ); + assert( pTab->pSelect==0 ); /* This table is not a VIEW */ + for(nIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdx++){} + for(i=nIdx-1; i>=0; i--){ + if( aIdxUsed && aIdxUsed[i]==0 ) continue; + sqliteVdbeAddOp(v, OP_IdxPut, base+i+1, 0); + } + sqliteVdbeAddOp(v, OP_MakeRecord, pTab->nCol, 0); + if( newIdx>=0 ){ + sqliteVdbeAddOp(v, OP_Dup, 1, 0); + sqliteVdbeAddOp(v, OP_Dup, 1, 0); + sqliteVdbeAddOp(v, OP_PutIntKey, newIdx, 0); + } + sqliteVdbeAddOp(v, OP_PutIntKey, base, + (pParse->trigStack?0:OPFLAG_NCHANGE) | + (isUpdate?0:OPFLAG_LASTROWID) | OPFLAG_CSCHANGE); + if( isUpdate && recnoChng ){ + sqliteVdbeAddOp(v, OP_Pop, 1, 0); + } +} + +/* +** Generate code that will open write cursors for a table and for all +** indices of that table. The "base" parameter is the cursor number used +** for the table. Indices are opened on subsequent cursors. +** +** Return the total number of cursors opened. This is always at least +** 1 (for the main table) plus more for each cursor. +*/ +int sqliteOpenTableAndIndices(Parse *pParse, Table *pTab, int base){ + int i; + Index *pIdx; + Vdbe *v = sqliteGetVdbe(pParse); + assert( v!=0 ); + sqliteVdbeAddOp(v, OP_Integer, pTab->iDb, 0); + sqliteVdbeOp3(v, OP_OpenWrite, base, pTab->tnum, pTab->zName, P3_STATIC); + for(i=1, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){ + sqliteVdbeAddOp(v, OP_Integer, pIdx->iDb, 0); + sqliteVdbeOp3(v, OP_OpenWrite, i+base, pIdx->tnum, pIdx->zName, P3_STATIC); + } + return i; +} diff --git a/kexi/3rdparty/kexisql/src/main.c b/kexi/3rdparty/kexisql/src/main.c new file mode 100644 index 00000000..c883f2ea --- /dev/null +++ b/kexi/3rdparty/kexisql/src/main.c @@ -0,0 +1,1143 @@ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** Main file for the SQLite library. The routines in this file +** implement the programmer interface to the library. Routines in +** other files are for internal use by SQLite and should not be +** accessed by users of the library. +** +** $Id: main.c 410099 2005-05-06 17:52:07Z staniek $ +*/ +#include "sqliteInt.h" +#include "os.h" +#include <ctype.h> + +/* +** A pointer to this structure is used to communicate information +** from sqliteInit into the sqliteInitCallback. +*/ +typedef struct { + sqlite *db; /* The database being initialized */ + char **pzErrMsg; /* Error message stored here */ +} InitData; + +/* +** Fill the InitData structure with an error message that indicates +** that the database is corrupt. +*/ +static void corruptSchema(InitData *pData, const char *zExtra){ + sqliteSetString(pData->pzErrMsg, "malformed database schema", + zExtra!=0 && zExtra[0]!=0 ? " - " : (char*)0, zExtra, (char*)0); +} + +/* +** This is the callback routine for the code that initializes the +** database. See sqliteInit() below for additional information. +** +** Each callback contains the following information: +** +** argv[0] = "file-format" or "schema-cookie" or "table" or "index" +** argv[1] = table or index name or meta statement type. +** argv[2] = root page number for table or index. NULL for meta. +** argv[3] = SQL text for a CREATE TABLE or CREATE INDEX statement. +** argv[4] = "1" for temporary files, "0" for main database, "2" or more +** for auxiliary database files. +** +*/ +static +int sqliteInitCallback(void *pInit, int argc, char **argv, char **azColName){ + InitData *pData = (InitData*)pInit; + int nErr = 0; + + assert( argc==5 ); + if( argv==0 ) return 0; /* Might happen if EMPTY_RESULT_CALLBACKS are on */ + if( argv[0]==0 ){ + corruptSchema(pData, 0); + return 1; + } + switch( argv[0][0] ){ + case 'v': + case 'i': + case 't': { /* CREATE TABLE, CREATE INDEX, or CREATE VIEW statements */ + sqlite *db = pData->db; + if( argv[2]==0 || argv[4]==0 ){ + corruptSchema(pData, 0); + return 1; + } + if( argv[3] && argv[3][0] ){ + /* Call the parser to process a CREATE TABLE, INDEX or VIEW. + ** But because db->init.busy is set to 1, no VDBE code is generated + ** or executed. All the parser does is build the internal data + ** structures that describe the table, index, or view. + */ + char *zErr; + assert( db->init.busy ); + db->init.iDb = atoi(argv[4]); + assert( db->init.iDb>=0 && db->init.iDb<db->nDb ); + 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 && iDb<db->nDb ); + pIndex = sqliteFindIndex(db, argv[1], db->aDb[iDb].zName); + if( pIndex==0 || pIndex->tnum!=0 ){ + /* This can occur if there exists an index on a TEMP table which + ** has the same name as another index on a permanent index. Since + ** the permanent table is hidden by the TEMP table, we can also + ** safely ignore the index on the permanent table. + */ + /* Do Nothing */; + }else{ + pIndex->tnum = atoi(argv[2]); + } + } + break; + } + default: { + /* This can not happen! */ + nErr = 1; + assert( nErr==0 ); + } + } + return nErr; +} + +/* +** This is a callback procedure used to reconstruct a table. The +** name of the table to be reconstructed is passed in as argv[0]. +** +** This routine is used to automatically upgrade a database from +** format version 1 or 2 to version 3. The correct operation of +** this routine relys on the fact that no indices are used when +** copying a table out to a temporary file. +** +** The change from version 2 to version 3 occurred between SQLite +** version 2.5.6 and 2.6.0 on 2002-July-18. +*/ +static +int upgrade_3_callback(void *pInit, int argc, char **argv, char **NotUsed){ + InitData *pData = (InitData*)pInit; + int rc; + Table *pTab; + Trigger *pTrig; + char *zErr = 0; + + pTab = sqliteFindTable(pData->db, argv[0], 0); + assert( pTab!=0 ); + assert( sqliteStrICmp(pTab->zName, argv[0])==0 ); + if( pTab ){ + pTrig = pTab->pTrigger; + pTab->pTrigger = 0; /* Disable all triggers before rebuilding the table */ + } + rc = sqlite_exec_printf(pData->db, + "CREATE TEMP TABLE sqlite_x AS SELECT * FROM '%q'; " + "DELETE FROM '%q'; " + "INSERT INTO '%q' SELECT * FROM sqlite_x; " + "DROP TABLE sqlite_x;", + 0, 0, &zErr, argv[0], argv[0], argv[0]); + if( zErr ){ + if( *pData->pzErrMsg ) sqlite_freemem(*pData->pzErrMsg); + *pData->pzErrMsg = zErr; + } + + /* If an error occurred in the SQL above, then the transaction will + ** rollback which will delete the internal symbol tables. This will + ** cause the structure that pTab points to be deleted. In case that + ** happened, we need to refetch pTab. + */ + pTab = sqliteFindTable(pData->db, argv[0], 0); + if( pTab ){ + assert( sqliteStrICmp(pTab->zName, argv[0])==0 ); + pTab->pTrigger = pTrig; /* Re-enable triggers */ + } + return rc!=SQLITE_OK; +} + + + +/* +** Attempt to read the database schema and initialize internal +** data structures for a single database file. The index of the +** database file is given by iDb. iDb==0 is used for the main +** database. iDb==1 should never be used. iDb>=2 is used for +** auxiliary databases. Return one of the SQLITE_ error codes to +** indicate success or failure. +*/ +static int sqliteInitOne(sqlite *db, int iDb, char **pzErrMsg){ + int rc; + BtCursor *curMain; + int size; + Table *pTab; + char const *azArg[6]; + char zDbNum[30]; + int meta[SQLITE_N_BTREE_META]; + InitData initData; + char const *zMasterSchema; + char const *zMasterName; + char *zSql = 0; + + /* + ** The master database table has a structure like this + */ + static char master_schema[] = + "CREATE TABLE sqlite_master(\n" + " type text,\n" + " name text,\n" + " tbl_name text,\n" + " rootpage integer,\n" + " sql text\n" + ")" + ; + static char temp_master_schema[] = + "CREATE TEMP TABLE sqlite_temp_master(\n" + " type text,\n" + " name text,\n" + " tbl_name text,\n" + " rootpage integer,\n" + " sql text\n" + ")" + ; + + assert( iDb>=0 && iDb<db->nDb ); + + /* zMasterSchema and zInitScript are set to point at the master schema + ** and initialisation script appropriate for the database being + ** initialised. zMasterName is the name of the master table. + */ + if( iDb==1 ){ + zMasterSchema = temp_master_schema; + zMasterName = TEMP_MASTER_NAME; + }else{ + zMasterSchema = master_schema; + zMasterName = MASTER_NAME; + } + + /* Construct the schema table. + */ + sqliteSafetyOff(db); + azArg[0] = "table"; + azArg[1] = zMasterName; + azArg[2] = "2"; + azArg[3] = zMasterSchema; + sprintf(zDbNum, "%d", iDb); + azArg[4] = zDbNum; + azArg[5] = 0; + initData.db = db; + initData.pzErrMsg = pzErrMsg; + sqliteInitCallback(&initData, 5, (char **)azArg, 0); + pTab = sqliteFindTable(db, zMasterName, db->aDb[iDb].zName); + if( pTab ){ + pTab->readOnly = 1; + }else{ + return SQLITE_NOMEM; + } + sqliteSafetyOn(db); + + /* Create a cursor to hold the database open + */ + if( db->aDb[iDb].pBt==0 ) return SQLITE_OK; + rc = sqliteBtreeCursor(db->aDb[iDb].pBt, 2, 0, &curMain); + if( rc ){ + sqliteSetString(pzErrMsg, sqlite_error_string(rc), (char*)0); + return rc; + } + + /* Get the database meta information + */ + rc = sqliteBtreeGetMeta(db->aDb[iDb].pBt, meta); + if( rc ){ + sqliteSetString(pzErrMsg, sqlite_error_string(rc), (char*)0); + sqliteBtreeCloseCursor(curMain); + return rc; + } + db->aDb[iDb].schema_cookie = meta[1]; + if( iDb==0 ){ + db->next_cookie = meta[1]; + db->file_format = meta[2]; + size = meta[3]; + if( size==0 ){ size = MAX_PAGES; } + db->cache_size = size; + db->safety_level = meta[4]; + if( meta[6]>0 && meta[6]<=2 && db->temp_store==0 ){ + db->temp_store = meta[6]; + } + if( db->safety_level==0 ) db->safety_level = 2; + + /* + ** file_format==1 Version 2.1.0. + ** file_format==2 Version 2.2.0. Add support for INTEGER PRIMARY KEY. + ** file_format==3 Version 2.6.0. Fix empty-string index bug. + ** file_format==4 Version 2.7.0. Add support for separate numeric and + ** text datatypes. + */ + if( db->file_format==0 ){ + /* This happens if the database was initially empty */ + db->file_format = 4; + }else if( db->file_format>4 ){ + sqliteBtreeCloseCursor(curMain); + sqliteSetString(pzErrMsg, "unsupported file format", (char*)0); + return SQLITE_ERROR; + } + }else if( iDb!=1 && (db->file_format!=meta[2] || db->file_format<4) ){ + assert( db->file_format>=4 ); + if( meta[2]==0 ){ + sqliteSetString(pzErrMsg, "cannot attach empty database: ", + db->aDb[iDb].zName, (char*)0); + }else{ + sqliteSetString(pzErrMsg, "incompatible file format in auxiliary " + "database: ", db->aDb[iDb].zName, (char*)0); + } + sqliteBtreeClose(db->aDb[iDb].pBt); + db->aDb[iDb].pBt = 0; + return SQLITE_FORMAT; + } + sqliteBtreeSetCacheSize(db->aDb[iDb].pBt, db->cache_size); + sqliteBtreeSetSafetyLevel(db->aDb[iDb].pBt, meta[4]==0 ? 2 : meta[4]); + + /* Read the schema information out of the schema tables + */ + assert( db->init.busy ); + sqliteSafetyOff(db); + + /* The following SQL will read the schema from the master tables. + ** The first version works with SQLite file formats 2 or greater. + ** The second version is for format 1 files. + ** + ** Beginning with file format 2, the rowid for new table entries + ** (including entries in sqlite_master) is an increasing integer. + ** So for file format 2 and later, we can play back sqlite_master + ** and all the CREATE statements will appear in the right order. + ** But with file format 1, table entries were random and so we + ** have to make sure the CREATE TABLEs occur before their corresponding + ** CREATE INDEXs. (We don't have to deal with CREATE VIEW or + ** CREATE TRIGGER in file format 1 because those constructs did + ** not exist then.) + */ + if( db->file_format>=2 ){ + sqliteSetString(&zSql, + "SELECT type, name, rootpage, sql, ", zDbNum, " FROM \"", + db->aDb[iDb].zName, "\".", zMasterName, (char*)0); + }else{ + sqliteSetString(&zSql, + "SELECT type, name, rootpage, sql, ", zDbNum, " FROM \"", + db->aDb[iDb].zName, "\".", zMasterName, + " WHERE type IN ('table', 'index')" + " ORDER BY CASE type WHEN 'table' THEN 0 ELSE 1 END", (char*)0); + } + rc = sqlite_exec(db, zSql, sqliteInitCallback, &initData, 0); + + sqliteFree(zSql); + sqliteSafetyOn(db); + sqliteBtreeCloseCursor(curMain); + if( sqlite_malloc_failed ){ + sqliteSetString(pzErrMsg, "out of memory", (char*)0); + rc = SQLITE_NOMEM; + sqliteResetInternalSchema(db, 0); + } + if( rc==SQLITE_OK ){ + DbSetProperty(db, iDb, DB_SchemaLoaded); + }else{ + sqliteResetInternalSchema(db, iDb); + } + return rc; +} + +/* +** Initialize all database files - the main database file, the file +** used to store temporary tables, and any additional database files +** created using ATTACH statements. Return a success code. If an +** error occurs, write an error message into *pzErrMsg. +** +** After the database is initialized, the SQLITE_Initialized +** bit is set in the flags field of the sqlite structure. An +** attempt is made to initialize the database as soon as it +** is opened. If that fails (perhaps because another process +** has the sqlite_master table locked) than another attempt +** is made the first time the database is accessed. +*/ +int sqliteInit(sqlite *db, char **pzErrMsg){ + int i, rc; + + if( db->init.busy ) return SQLITE_OK; + assert( (db->flags & SQLITE_Initialized)==0 ); + rc = SQLITE_OK; + db->init.busy = 1; + for(i=0; rc==SQLITE_OK && i<db->nDb; i++){ + if( DbHasProperty(db, i, DB_SchemaLoaded) || i==1 ) continue; + rc = sqliteInitOne(db, i, pzErrMsg); + if( rc ){ + sqliteResetInternalSchema(db, i); + } + } + + /* Once all the other databases have been initialised, load the schema + ** for the TEMP database. This is loaded last, as the TEMP database + ** schema may contain references to objects in other databases. + */ + if( rc==SQLITE_OK && db->nDb>1 && !DbHasProperty(db, 1, DB_SchemaLoaded) ){ + rc = sqliteInitOne(db, 1, pzErrMsg); + if( rc ){ + sqliteResetInternalSchema(db, 1); + } + } + + db->init.busy = 0; + if( rc==SQLITE_OK ){ + db->flags |= SQLITE_Initialized; + sqliteCommitInternalChanges(db); + } + + /* If the database is in formats 1 or 2, then upgrade it to + ** version 3. This will reconstruct all indices. If the + ** upgrade fails for any reason (ex: out of disk space, database + ** is read only, interrupt received, etc.) then fail the init. + */ + if( rc==SQLITE_OK && db->file_format<3 ){ + char *zErr = 0; + InitData initData; + int meta[SQLITE_N_BTREE_META]; + + db->magic = SQLITE_MAGIC_OPEN; + initData.db = db; + initData.pzErrMsg = &zErr; + db->file_format = 3; + rc = sqlite_exec(db, + "BEGIN; SELECT name FROM sqlite_master WHERE type='table';", + upgrade_3_callback, + &initData, + &zErr); + if( rc==SQLITE_OK ){ + sqliteBtreeGetMeta(db->aDb[0].pBt, meta); + meta[2] = 4; + sqliteBtreeUpdateMeta(db->aDb[0].pBt, meta); + sqlite_exec(db, "COMMIT", 0, 0, 0); + } + if( rc!=SQLITE_OK ){ + sqliteSetString(pzErrMsg, + "unable to upgrade database to the version 2.6 format", + zErr ? ": " : 0, zErr, (char*)0); + } + sqlite_freemem(zErr); + } + + if( rc!=SQLITE_OK ){ + db->flags &= ~SQLITE_Initialized; + } + return rc; +} + +/* +** The version of the library +*/ +const char rcsid[] = "@(#) \044Id: SQLite version " SQLITE_VERSION " $"; +const char sqlite_version[] = SQLITE_VERSION; + +/* +** Does the library expect data to be encoded as UTF-8 or iso8859? The +** following global constant always lets us know. +*/ +#ifdef SQLITE_UTF8 +const char sqlite_encoding[] = "UTF-8"; +#else +const char sqlite_encoding[] = "iso8859"; +#endif + +/* +** Open a new SQLite database. Construct an "sqlite" structure to define +** the state of this database and return a pointer to that structure. +** +** An attempt is made to initialize the in-memory data structures that +** hold the database schema. But if this fails (because the schema file +** is locked) then that step is deferred until the first call to +** sqlite_exec(). +*/ +sqlite *sqlite_open(const char *zFilename, int mode, char **pzErrMsg){ + sqlite *db; + int rc, i; + + /* Allocate the sqlite data structure */ + db = sqliteMalloc( sizeof(sqlite) ); + if( pzErrMsg ) *pzErrMsg = 0; + if( db==0 ) goto no_mem_on_open; + db->onError = OE_Default; + db->priorNewRowid = 0; + db->magic = SQLITE_MAGIC_BUSY; + db->nDb = 2; + db->aDb = db->aDbStatic; + /* db->flags |= SQLITE_ShortColNames; */ + sqliteHashInit(&db->aFunc, SQLITE_HASH_STRING, 1); + for(i=0; i<db->nDb; i++){ + sqliteHashInit(&db->aDb[i].tblHash, SQLITE_HASH_STRING, 0); + sqliteHashInit(&db->aDb[i].idxHash, SQLITE_HASH_STRING, 0); + sqliteHashInit(&db->aDb[i].trigHash, SQLITE_HASH_STRING, 0); + sqliteHashInit(&db->aDb[i].aFKey, SQLITE_HASH_STRING, 1); + } + + /* Open the backend database driver */ + if( zFilename[0]==':' && strcmp(zFilename,":memory:")==0 ){ + db->temp_store = 2; + } + rc = sqliteBtreeFactory(db, zFilename, 0, MAX_PAGES, &db->aDb[0].pBt); + if( rc!=SQLITE_OK ){ + switch( rc ){ + default: { + sqliteSetString(pzErrMsg, "unable to open database: ", + zFilename, (char*)0); + } + } + sqliteFree(db); + sqliteStrRealloc(pzErrMsg); + return 0; + } + db->aDb[0].zName = "main"; + db->aDb[1].zName = "temp"; + + /* Attempt to read the schema */ + sqliteRegisterBuiltinFunctions(db); + rc = sqliteInit(db, pzErrMsg); + db->magic = SQLITE_MAGIC_OPEN; + if( sqlite_malloc_failed ){ + sqlite_close(db); + goto no_mem_on_open; + }else if( rc!=SQLITE_OK && rc!=SQLITE_BUSY ){ + sqlite_close(db); + sqliteStrRealloc(pzErrMsg); + return 0; + }else if( pzErrMsg ){ + sqliteFree(*pzErrMsg); + *pzErrMsg = 0; + } + + /* Return a pointer to the newly opened database structure */ + return db; + +no_mem_on_open: + sqliteSetString(pzErrMsg, "out of memory", (char*)0); + sqliteStrRealloc(pzErrMsg); + return 0; +} + +/* +** Return the ROWID of the most recent insert +*/ +int sqlite_last_insert_rowid(sqlite *db){ + return db->lastRowid; +} + +/* +** Return the number of changes in the most recent call to sqlite_exec(). +*/ +int sqlite_changes(sqlite *db){ + return db->nChange; +} + +/* +** Return the number of changes produced by the last INSERT, UPDATE, or +** DELETE statement to complete execution. The count does not include +** changes due to SQL statements executed in trigger programs that were +** triggered by that statement +*/ +int sqlite_last_statement_changes(sqlite *db){ + return db->lsChange; +} + +/* +** Close an existing SQLite database +*/ +void sqlite_close(sqlite *db){ + HashElem *i; + int j; + db->want_to_close = 1; + if( sqliteSafetyCheck(db) || sqliteSafetyOn(db) ){ + /* printf("DID NOT CLOSE\n"); fflush(stdout); */ + return; + } + db->magic = SQLITE_MAGIC_CLOSED; + for(j=0; j<db->nDb; j++){ + struct Db *pDb = &db->aDb[j]; + if( pDb->pBt ){ + sqliteBtreeClose(pDb->pBt); + pDb->pBt = 0; + } + } + sqliteResetInternalSchema(db, 0); + assert( db->nDb<=2 ); + assert( db->aDb==db->aDbStatic ); + for(i=sqliteHashFirst(&db->aFunc); i; i=sqliteHashNext(i)){ + FuncDef *pFunc, *pNext; + for(pFunc = (FuncDef*)sqliteHashData(i); pFunc; pFunc=pNext){ + pNext = pFunc->pNext; + sqliteFree(pFunc); + } + } + sqliteHashClear(&db->aFunc); + sqliteFree(db); +} + +/* +** Rollback all database files. +*/ +void sqliteRollbackAll(sqlite *db){ + int i; + for(i=0; i<db->nDb; i++){ + if( db->aDb[i].pBt ){ + sqliteBtreeRollback(db->aDb[i].pBt); + db->aDb[i].inTrans = 0; + } + } + sqliteResetInternalSchema(db, 0); + /* sqliteRollbackInternalChanges(db); */ +} + +/* +** Execute SQL code. Return one of the SQLITE_ success/failure +** codes. Also write an error message into memory obtained from +** malloc() and make *pzErrMsg point to that message. +** +** If the SQL is a query, then for each row in the query result +** the xCallback() function is called. pArg becomes the first +** argument to xCallback(). If xCallback=NULL then no callback +** is invoked, even for queries. +*/ +int sqlite_exec( + sqlite *db, /* The database on which the SQL executes */ + const char *zSql, /* The SQL to be executed */ + sqlite_callback xCallback, /* Invoke this callback routine */ + void *pArg, /* First argument to xCallback() */ + char **pzErrMsg /* Write error messages here */ +){ + int rc = SQLITE_OK; + const char *zLeftover; + sqlite_vm *pVm; + int nRetry = 0; + int nChange = 0; + int nCallback; + + if( zSql==0 ) return SQLITE_OK; + while( rc==SQLITE_OK && zSql[0] ){ + pVm = 0; + rc = sqlite_compile(db, zSql, &zLeftover, &pVm, pzErrMsg); + if( rc!=SQLITE_OK ){ + assert( pVm==0 || sqlite_malloc_failed ); + return rc; + } + if( pVm==0 ){ + /* This happens if the zSql input contained only whitespace */ + break; + } + db->nChange += nChange; + nCallback = 0; + while(1){ + int nArg; + char **azArg, **azCol; + rc = sqlite_step(pVm, &nArg, (const char***)&azArg,(const char***)&azCol); + if( rc==SQLITE_ROW ){ + if( xCallback!=0 && xCallback(pArg, nArg, azArg, azCol) ){ + sqlite_finalize(pVm, 0); + return SQLITE_ABORT; + } + nCallback++; + }else{ + if( rc==SQLITE_DONE && nCallback==0 + && (db->flags & SQLITE_NullCallback)!=0 && xCallback!=0 ){ + xCallback(pArg, nArg, azArg, azCol); + } + rc = sqlite_finalize(pVm, pzErrMsg); + if( rc==SQLITE_SCHEMA && nRetry<2 ){ + nRetry++; + rc = SQLITE_OK; + break; + } + if( db->pVdbe==0 ){ + nChange = db->nChange; + } + nRetry = 0; + zSql = zLeftover; + while( isspace(zSql[0]) ) zSql++; + break; + } + } + } + return rc; +} + + +/* +** Compile a single statement of SQL into a virtual machine. Return one +** of the SQLITE_ success/failure codes. Also write an error message into +** memory obtained from malloc() and make *pzErrMsg point to that message. +*/ +int sqlite_compile( + sqlite *db, /* The database on which the SQL executes */ + const char *zSql, /* The SQL to be executed */ + const char **pzTail, /* OUT: Next statement after the first */ + sqlite_vm **ppVm, /* OUT: The virtual machine */ + char **pzErrMsg /* OUT: Write error messages here */ +){ + Parse sParse; + + if( pzErrMsg ) *pzErrMsg = 0; + if( sqliteSafetyOn(db) ) goto exec_misuse; + if( !db->init.busy ){ + if( (db->flags & SQLITE_Initialized)==0 ){ + int rc, cnt = 1; + while( (rc = sqliteInit(db, pzErrMsg))==SQLITE_BUSY + && db->xBusyCallback + && db->xBusyCallback(db->pBusyArg, "", cnt++)!=0 ){} + if( rc!=SQLITE_OK ){ + sqliteStrRealloc(pzErrMsg); + sqliteSafetyOff(db); + return rc; + } + if( pzErrMsg ){ + sqliteFree(*pzErrMsg); + *pzErrMsg = 0; + } + } + if( db->file_format<3 ){ + sqliteSafetyOff(db); + sqliteSetString(pzErrMsg, "obsolete database file format", (char*)0); + return SQLITE_ERROR; + } + } + assert( (db->flags & SQLITE_Initialized)!=0 || db->init.busy ); + if( db->pVdbe==0 ){ db->nChange = 0; } + memset(&sParse, 0, sizeof(sParse)); + sParse.db = db; + sqliteRunParser(&sParse, zSql, pzErrMsg); + if( db->xTrace && !db->init.busy ){ + /* Trace only the statment that was compiled. + ** Make a copy of that part of the SQL string since zSQL is const + ** and we must pass a zero terminated string to the trace function + ** The copy is unnecessary if the tail pointer is pointing at the + ** beginnig or end of the SQL string. + */ + if( sParse.zTail && sParse.zTail!=zSql && *sParse.zTail ){ + char *tmpSql = sqliteStrNDup(zSql, sParse.zTail - zSql); + if( tmpSql ){ + db->xTrace(db->pTraceArg, tmpSql); + free(tmpSql); + }else{ + /* If a memory error occurred during the copy, + ** trace entire SQL string and fall through to the + ** sqlite_malloc_failed test to report the error. + */ + db->xTrace(db->pTraceArg, zSql); + } + }else{ + db->xTrace(db->pTraceArg, zSql); + } + } + if( sqlite_malloc_failed ){ + sqliteSetString(pzErrMsg, "out of memory", (char*)0); + sParse.rc = SQLITE_NOMEM; + sqliteRollbackAll(db); + sqliteResetInternalSchema(db, 0); + db->flags &= ~SQLITE_InTrans; + } + if( sParse.rc==SQLITE_DONE ) sParse.rc = SQLITE_OK; + if( sParse.rc!=SQLITE_OK && pzErrMsg && *pzErrMsg==0 ){ + sqliteSetString(pzErrMsg, sqlite_error_string(sParse.rc), (char*)0); + } + sqliteStrRealloc(pzErrMsg); + if( sParse.rc==SQLITE_SCHEMA ){ + sqliteResetInternalSchema(db, 0); + } + assert( ppVm ); + *ppVm = (sqlite_vm*)sParse.pVdbe; + if( pzTail ) *pzTail = sParse.zTail; + if( sqliteSafetyOff(db) ) goto exec_misuse; + return sParse.rc; + +exec_misuse: + if( pzErrMsg ){ + *pzErrMsg = 0; + sqliteSetString(pzErrMsg, sqlite_error_string(SQLITE_MISUSE), (char*)0); + sqliteStrRealloc(pzErrMsg); + } + return SQLITE_MISUSE; +} + + +/* +** The following routine destroys a virtual machine that is created by +** the sqlite_compile() routine. +** +** The integer returned is an SQLITE_ success/failure code that describes +** the result of executing the virtual machine. An error message is +** written into memory obtained from malloc and *pzErrMsg is made to +** point to that error if pzErrMsg is not NULL. The calling routine +** should use sqlite_freemem() to delete the message when it has finished +** with it. +*/ +int sqlite_finalize( + sqlite_vm *pVm, /* The virtual machine to be destroyed */ + char **pzErrMsg /* OUT: Write error messages here */ +){ + int rc = sqliteVdbeFinalize((Vdbe*)pVm, pzErrMsg); + sqliteStrRealloc(pzErrMsg); + return rc; +} + +/* +** Terminate the current execution of a virtual machine then +** reset the virtual machine back to its starting state so that it +** can be reused. Any error message resulting from the prior execution +** is written into *pzErrMsg. A success code from the prior execution +** is returned. +*/ +int sqlite_reset( + sqlite_vm *pVm, /* The virtual machine to be destroyed */ + char **pzErrMsg /* OUT: Write error messages here */ +){ + int rc = sqliteVdbeReset((Vdbe*)pVm, pzErrMsg); + sqliteVdbeMakeReady((Vdbe*)pVm, -1, 0); + sqliteStrRealloc(pzErrMsg); + return rc; +} + +/* +** Return a static string that describes the kind of error specified in the +** argument. +*/ +const char *sqlite_error_string(int rc){ + const char *z; + switch( rc ){ + case SQLITE_OK: z = "not an error"; break; + case SQLITE_ERROR: z = "SQL logic error or missing database"; break; + case SQLITE_INTERNAL: z = "internal SQLite implementation flaw"; break; + case SQLITE_PERM: z = "access permission denied"; break; + case SQLITE_ABORT: z = "callback requested query abort"; break; + case SQLITE_BUSY: z = "database is locked"; break; + case SQLITE_LOCKED: z = "database table is locked"; break; + case SQLITE_NOMEM: z = "out of memory"; break; + case SQLITE_READONLY: z = "attempt to write a readonly database"; break; + case SQLITE_INTERRUPT: z = "interrupted"; break; + case SQLITE_IOERR: z = "disk I/O error"; break; + case SQLITE_CORRUPT: z = "database disk image is malformed"; break; + case SQLITE_NOTFOUND: z = "table or record not found"; break; + case SQLITE_FULL: z = "database is full"; break; + case SQLITE_CANTOPEN: z = "unable to open database file"; break; + case SQLITE_PROTOCOL: z = "database locking protocol failure"; break; + case SQLITE_EMPTY: z = "table contains no data"; break; + case SQLITE_SCHEMA: z = "database schema has changed"; break; + case SQLITE_TOOBIG: z = "too much data for one table row"; break; + case SQLITE_CONSTRAINT: z = "constraint failed"; break; + case SQLITE_MISMATCH: z = "datatype mismatch"; break; + case SQLITE_MISUSE: z = "library routine called out of sequence";break; + case SQLITE_NOLFS: z = "kernel lacks large file support"; break; + case SQLITE_AUTH: z = "authorization denied"; break; + case SQLITE_FORMAT: z = "auxiliary database format error"; break; + case SQLITE_RANGE: z = "bind index out of range"; break; + case SQLITE_NOTADB: z = "file is encrypted or is not a database";break; + default: z = "unknown error"; break; + } + return z; +} + +/* +** This routine implements a busy callback that sleeps and tries +** again until a timeout value is reached. The timeout value is +** an integer number of milliseconds passed in as the first +** argument. +*/ +static int sqliteDefaultBusyCallback( + void *Timeout, /* Maximum amount of time to wait */ + const char *NotUsed, /* The name of the table that is busy */ + int count /* Number of times table has been busy */ +){ +#if SQLITE_MIN_SLEEP_MS==1 + static const char delays[] = + { 1, 2, 5, 10, 15, 20, 25, 25, 25, 50, 50, 50, 100}; + static const short int totals[] = + { 0, 1, 3, 8, 18, 33, 53, 78, 103, 128, 178, 228, 287}; +# define NDELAY (sizeof(delays)/sizeof(delays[0])) + int timeout = (int)(long)Timeout; + int delay, prior; + + if( count <= NDELAY ){ + delay = delays[count-1]; + prior = totals[count-1]; + }else{ + delay = delays[NDELAY-1]; + prior = totals[NDELAY-1] + delay*(count-NDELAY-1); + } + if( prior + delay > timeout ){ + delay = timeout - prior; + if( delay<=0 ) return 0; + } + sqliteOsSleep(delay); + return 1; +#else + int timeout = (int)(long)Timeout; + if( (count+1)*1000 > timeout ){ + return 0; + } + sqliteOsSleep(1000); + return 1; +#endif +} + +/* +** This routine sets the busy callback for an Sqlite database to the +** given callback function with the given argument. +*/ +void sqlite_busy_handler( + sqlite *db, + int (*xBusy)(void*,const char*,int), + void *pArg +){ + db->xBusyCallback = xBusy; + db->pBusyArg = pArg; +} + +#ifndef SQLITE_OMIT_PROGRESS_CALLBACK +/* +** This routine sets the progress callback for an Sqlite database to the +** given callback function with the given argument. The progress callback will +** be invoked every nOps opcodes. +*/ +void sqlite_progress_handler( + sqlite *db, + int nOps, + int (*xProgress)(void*), + void *pArg +){ + if( nOps>0 ){ + db->xProgress = xProgress; + db->nProgressOps = nOps; + db->pProgressArg = pArg; + }else{ + db->xProgress = 0; + db->nProgressOps = 0; + db->pProgressArg = 0; + } +} +#endif + + +/* +** This routine installs a default busy handler that waits for the +** specified number of milliseconds before returning 0. +*/ +void sqlite_busy_timeout(sqlite *db, int ms){ + if( ms>0 ){ + sqlite_busy_handler(db, sqliteDefaultBusyCallback, (void*)(long)ms); + }else{ + sqlite_busy_handler(db, 0, 0); + } +} + +/* +** Cause any pending operation to stop at its earliest opportunity. +*/ +void sqlite_interrupt(sqlite *db){ + db->flags |= SQLITE_Interrupt; +} + +/* +** Windows systems should call this routine to free memory that +** is returned in the in the errmsg parameter of sqlite_open() when +** SQLite is a DLL. For some reason, it does not work to call free() +** directly. +** +** Note that we need to call free() not sqliteFree() here, since every +** string that is exported from SQLite should have already passed through +** sqliteStrRealloc(). +*/ +void sqlite_freemem(void *p){ free(p); } + +/* +** Windows systems need functions to call to return the sqlite_version +** and sqlite_encoding strings since they are unable to access constants +** within DLLs. +*/ +const char *sqlite_libversion(void){ return sqlite_version; } +const char *sqlite_libencoding(void){ return sqlite_encoding; } + +/* +** Create new user-defined functions. The sqlite_create_function() +** routine creates a regular function and sqlite_create_aggregate() +** creates an aggregate function. +** +** Passing a NULL xFunc argument or NULL xStep and xFinalize arguments +** disables the function. Calling sqlite_create_function() with the +** same name and number of arguments as a prior call to +** sqlite_create_aggregate() disables the prior call to +** sqlite_create_aggregate(), and vice versa. +** +** If nArg is -1 it means that this function will accept any number +** of arguments, including 0. The maximum allowed value of nArg is 127. +*/ +int sqlite_create_function( + sqlite *db, /* Add the function to this database connection */ + const char *zName, /* Name of the function to add */ + int nArg, /* Number of arguments */ + void (*xFunc)(sqlite_func*,int,const char**), /* The implementation */ + void *pUserData /* User data */ +){ + FuncDef *p; + int nName; + if( db==0 || zName==0 || sqliteSafetyCheck(db) ) return 1; + if( nArg<-1 || nArg>127 ) return 1; + nName = strlen(zName); + if( nName>255 ) return 1; + p = sqliteFindFunction(db, zName, nName, nArg, 1); + if( p==0 ) return 1; + p->xFunc = xFunc; + p->xStep = 0; + p->xFinalize = 0; + p->pUserData = pUserData; + return 0; +} +int sqlite_create_aggregate( + sqlite *db, /* Add the function to this database connection */ + const char *zName, /* Name of the function to add */ + int nArg, /* Number of arguments */ + void (*xStep)(sqlite_func*,int,const char**), /* The step function */ + void (*xFinalize)(sqlite_func*), /* The finalizer */ + void *pUserData /* User data */ +){ + FuncDef *p; + int nName; + if( db==0 || zName==0 || sqliteSafetyCheck(db) ) return 1; + if( nArg<-1 || nArg>127 ) return 1; + nName = strlen(zName); + if( nName>255 ) return 1; + p = sqliteFindFunction(db, zName, nName, nArg, 1); + if( p==0 ) return 1; + p->xFunc = 0; + p->xStep = xStep; + p->xFinalize = xFinalize; + p->pUserData = pUserData; + return 0; +} + +/* +** Change the datatype for all functions with a given name. See the +** header comment for the prototype of this function in sqlite.h for +** additional information. +*/ +int sqlite_function_type(sqlite *db, const char *zName, int dataType){ + FuncDef *p = (FuncDef*)sqliteHashFind(&db->aFunc, zName, strlen(zName)); + while( p ){ + p->dataType = dataType; + p = p->pNext; + } + return SQLITE_OK; +} + +/* +** Register a trace function. The pArg from the previously registered trace +** is returned. +** +** A NULL trace function means that no tracing is executes. A non-NULL +** trace is a pointer to a function that is invoked at the start of each +** sqlite_exec(). +*/ +void *sqlite_trace(sqlite *db, void (*xTrace)(void*,const char*), void *pArg){ + void *pOld = db->pTraceArg; + db->xTrace = xTrace; + db->pTraceArg = pArg; + return pOld; +} + +/*** EXPERIMENTAL *** +** +** Register a function to be invoked when a transaction comments. +** If either function returns non-zero, then the commit becomes a +** rollback. +*/ +void *sqlite_commit_hook( + sqlite *db, /* Attach the hook to this database */ + int (*xCallback)(void*), /* Function to invoke on each commit */ + void *pArg /* Argument to the function */ +){ + void *pOld = db->pCommitArg; + db->xCommitCallback = xCallback; + db->pCommitArg = pArg; + return pOld; +} + + +/* +** This routine is called to create a connection to a database BTree +** driver. If zFilename is the name of a file, then that file is +** opened and used. If zFilename is the magic name ":memory:" then +** the database is stored in memory (and is thus forgotten as soon as +** the connection is closed.) If zFilename is NULL then the database +** is for temporary use only and is deleted as soon as the connection +** is closed. +** +** A temporary database can be either a disk file (that is automatically +** deleted when the file is closed) or a set of red-black trees held in memory, +** depending on the values of the TEMP_STORE compile-time macro and the +** db->temp_store variable, according to the following chart: +** +** TEMP_STORE db->temp_store Location of temporary database +** ---------- -------------- ------------------------------ +** 0 any file +** 1 1 file +** 1 2 memory +** 1 0 file +** 2 1 file +** 2 2 memory +** 2 0 memory +** 3 any memory +*/ +int sqliteBtreeFactory( + const sqlite *db, /* Main database when opening aux otherwise 0 */ + const char *zFilename, /* Name of the file containing the BTree database */ + int omitJournal, /* if TRUE then do not journal this file */ + int nCache, /* How many pages in the page cache */ + Btree **ppBtree){ /* Pointer to new Btree object written here */ + + assert( ppBtree != 0); + +#ifndef SQLITE_OMIT_INMEMORYDB + if( zFilename==0 ){ + if (TEMP_STORE == 0) { + /* Always use file based temporary DB */ + return sqliteBtreeOpen(0, omitJournal, nCache, ppBtree); + } else if (TEMP_STORE == 1 || TEMP_STORE == 2) { + /* Switch depending on compile-time and/or runtime settings. */ + int location = db->temp_store==0 ? TEMP_STORE : db->temp_store; + + if (location == 1) { + return sqliteBtreeOpen(zFilename, omitJournal, nCache, ppBtree); + } else { + return sqliteRbtreeOpen(0, 0, 0, ppBtree); + } + } else { + /* Always use in-core DB */ + return sqliteRbtreeOpen(0, 0, 0, ppBtree); + } + }else if( zFilename[0]==':' && strcmp(zFilename,":memory:")==0 ){ + return sqliteRbtreeOpen(0, 0, 0, ppBtree); + }else +#endif + { + return sqliteBtreeOpen(zFilename, omitJournal, nCache, ppBtree); + } +} diff --git a/kexi/3rdparty/kexisql/src/opcodes.c b/kexi/3rdparty/kexisql/src/opcodes.c new file mode 100644 index 00000000..0907e0e7 --- /dev/null +++ b/kexi/3rdparty/kexisql/src/opcodes.c @@ -0,0 +1,140 @@ +/* Automatically generated file. Do not edit */ +char *sqliteOpcodeNames[] = { "???", + "Goto", + "Gosub", + "Return", + "Halt", + "Integer", + "String", + "Variable", + "Pop", + "Dup", + "Pull", + "Push", + "ColumnName", + "Callback", + "Concat", + "Add", + "Subtract", + "Multiply", + "Divide", + "Remainder", + "Function", + "BitAnd", + "BitOr", + "ShiftLeft", + "ShiftRight", + "AddImm", + "ForceInt", + "MustBeInt", + "Eq", + "Ne", + "Lt", + "Le", + "Gt", + "Ge", + "StrEq", + "StrNe", + "StrLt", + "StrLe", + "StrGt", + "StrGe", + "And", + "Or", + "Negative", + "AbsValue", + "Not", + "BitNot", + "Noop", + "If", + "IfNot", + "IsNull", + "NotNull", + "MakeRecord", + "MakeIdxKey", + "MakeKey", + "IncrKey", + "Checkpoint", + "Transaction", + "Commit", + "Rollback", + "ReadCookie", + "SetCookie", + "VerifyCookie", + "OpenRead", + "OpenWrite", + "OpenTemp", + "OpenPseudo", + "Close", + "MoveLt", + "MoveTo", + "Distinct", + "NotFound", + "Found", + "IsUnique", + "NotExists", + "NewRecno", + "PutIntKey", + "PutStrKey", + "Delete", + "SetCounts", + "KeyAsData", + "RowKey", + "RowData", + "Column", + "Recno", + "FullKey", + "NullRow", + "Last", + "Rewind", + "Prev", + "Next", + "IdxPut", + "IdxDelete", + "IdxRecno", + "IdxLT", + "IdxGT", + "IdxGE", + "IdxIsNull", + "Destroy", + "Clear", + "CreateIndex", + "CreateTable", + "IntegrityCk", + "ListWrite", + "ListRewind", + "ListRead", + "ListReset", + "ListPush", + "ListPop", + "ContextPush", + "ContextPop", + "SortPut", + "SortMakeRec", + "SortMakeKey", + "Sort", + "SortNext", + "SortCallback", + "SortReset", + "FileOpen", + "FileRead", + "FileColumn", + "MemStore", + "MemLoad", + "MemIncr", + "AggReset", + "AggInit", + "AggFunc", + "AggFocus", + "AggSet", + "AggGet", + "AggNext", + "SetInsert", + "SetFound", + "SetNotFound", + "SetFirst", + "SetNext", + "Vacuum", + "StackDepth", + "StackReset", +}; diff --git a/kexi/3rdparty/kexisql/src/opcodes.h b/kexi/3rdparty/kexisql/src/opcodes.h new file mode 100644 index 00000000..35e05069 --- /dev/null +++ b/kexi/3rdparty/kexisql/src/opcodes.h @@ -0,0 +1,138 @@ +/* Automatically generated file. Do not edit */ +#define OP_Goto 1 +#define OP_Gosub 2 +#define OP_Return 3 +#define OP_Halt 4 +#define OP_Integer 5 +#define OP_String 6 +#define OP_Variable 7 +#define OP_Pop 8 +#define OP_Dup 9 +#define OP_Pull 10 +#define OP_Push 11 +#define OP_ColumnName 12 +#define OP_Callback 13 +#define OP_Concat 14 +#define OP_Add 15 +#define OP_Subtract 16 +#define OP_Multiply 17 +#define OP_Divide 18 +#define OP_Remainder 19 +#define OP_Function 20 +#define OP_BitAnd 21 +#define OP_BitOr 22 +#define OP_ShiftLeft 23 +#define OP_ShiftRight 24 +#define OP_AddImm 25 +#define OP_ForceInt 26 +#define OP_MustBeInt 27 +#define OP_Eq 28 +#define OP_Ne 29 +#define OP_Lt 30 +#define OP_Le 31 +#define OP_Gt 32 +#define OP_Ge 33 +#define OP_StrEq 34 +#define OP_StrNe 35 +#define OP_StrLt 36 +#define OP_StrLe 37 +#define OP_StrGt 38 +#define OP_StrGe 39 +#define OP_And 40 +#define OP_Or 41 +#define OP_Negative 42 +#define OP_AbsValue 43 +#define OP_Not 44 +#define OP_BitNot 45 +#define OP_Noop 46 +#define OP_If 47 +#define OP_IfNot 48 +#define OP_IsNull 49 +#define OP_NotNull 50 +#define OP_MakeRecord 51 +#define OP_MakeIdxKey 52 +#define OP_MakeKey 53 +#define OP_IncrKey 54 +#define OP_Checkpoint 55 +#define OP_Transaction 56 +#define OP_Commit 57 +#define OP_Rollback 58 +#define OP_ReadCookie 59 +#define OP_SetCookie 60 +#define OP_VerifyCookie 61 +#define OP_OpenRead 62 +#define OP_OpenWrite 63 +#define OP_OpenTemp 64 +#define OP_OpenPseudo 65 +#define OP_Close 66 +#define OP_MoveLt 67 +#define OP_MoveTo 68 +#define OP_Distinct 69 +#define OP_NotFound 70 +#define OP_Found 71 +#define OP_IsUnique 72 +#define OP_NotExists 73 +#define OP_NewRecno 74 +#define OP_PutIntKey 75 +#define OP_PutStrKey 76 +#define OP_Delete 77 +#define OP_SetCounts 78 +#define OP_KeyAsData 79 +#define OP_RowKey 80 +#define OP_RowData 81 +#define OP_Column 82 +#define OP_Recno 83 +#define OP_FullKey 84 +#define OP_NullRow 85 +#define OP_Last 86 +#define OP_Rewind 87 +#define OP_Prev 88 +#define OP_Next 89 +#define OP_IdxPut 90 +#define OP_IdxDelete 91 +#define OP_IdxRecno 92 +#define OP_IdxLT 93 +#define OP_IdxGT 94 +#define OP_IdxGE 95 +#define OP_IdxIsNull 96 +#define OP_Destroy 97 +#define OP_Clear 98 +#define OP_CreateIndex 99 +#define OP_CreateTable 100 +#define OP_IntegrityCk 101 +#define OP_ListWrite 102 +#define OP_ListRewind 103 +#define OP_ListRead 104 +#define OP_ListReset 105 +#define OP_ListPush 106 +#define OP_ListPop 107 +#define OP_ContextPush 108 +#define OP_ContextPop 109 +#define OP_SortPut 110 +#define OP_SortMakeRec 111 +#define OP_SortMakeKey 112 +#define OP_Sort 113 +#define OP_SortNext 114 +#define OP_SortCallback 115 +#define OP_SortReset 116 +#define OP_FileOpen 117 +#define OP_FileRead 118 +#define OP_FileColumn 119 +#define OP_MemStore 120 +#define OP_MemLoad 121 +#define OP_MemIncr 122 +#define OP_AggReset 123 +#define OP_AggInit 124 +#define OP_AggFunc 125 +#define OP_AggFocus 126 +#define OP_AggSet 127 +#define OP_AggGet 128 +#define OP_AggNext 129 +#define OP_SetInsert 130 +#define OP_SetFound 131 +#define OP_SetNotFound 132 +#define OP_SetFirst 133 +#define OP_SetNext 134 +#define OP_Vacuum 135 +#define OP_StackDepth 136 +#define OP_StackReset 137 diff --git a/kexi/3rdparty/kexisql/src/os.c b/kexi/3rdparty/kexisql/src/os.c new file mode 100644 index 00000000..16576924 --- /dev/null +++ b/kexi/3rdparty/kexisql/src/os.c @@ -0,0 +1,1845 @@ +/* +** 2001 September 16 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +****************************************************************************** +** +** This file contains code that is specific to particular operating +** systems. The purpose of this file is to provide a uniform abstraction +** on which the rest of SQLite can operate. +*/ +#include "os.h" /* Must be first to enable large file support */ +#include "sqliteInt.h" + +#if OS_UNIX +# include <time.h> +# include <errno.h> +# include <unistd.h> +# 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 <winbase.h> +#endif + +#if OS_MAC +# include <extras.h> +# include <path2fss.h> +# include <TextUtils.h> +# include <FinderRegistry.h> +# include <Folders.h> +# include <Timer.h> +# include <OSUtils.h> +#endif + +/* +** The DJGPP compiler environment looks mostly like Unix, but it +** lacks the fcntl() system call. So redefine fcntl() to be something +** that always succeeds. This means that locking does not occur under +** DJGPP. But its DOS - what did you expect? +*/ +#ifdef __DJGPP__ +# define fcntl(A,B,C) 0 +#endif + +/* +** Macros used to determine whether or not to use threads. The +** SQLITE_UNIX_THREADS macro is defined if we are synchronizing for +** Posix threads and SQLITE_W32_THREADS is defined if we are +** synchronizing using Win32 threads. +*/ +#if OS_UNIX && defined(THREADSAFE) && THREADSAFE +# include <pthread.h> +# 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 <Multiprocessing.h> +# define SQLITE_MACOS_MULTITASKING 1 +#endif + +/* +** Macros for performance tracing. Normally turned off +*/ +#if 0 +static int last_page = 0; +__inline__ unsigned long long int hwtime(void){ + unsigned long long int x; + __asm__("rdtsc\n\t" + "mov %%edx, %%ecx\n\t" + :"=A" (x)); + return x; +} +static unsigned long long int g_start; +static unsigned int elapse; +#define TIMER_START g_start=hwtime() +#define TIMER_END elapse=hwtime()-g_start +#define SEEK(X) last_page=(X) +#define TRACE1(X) fprintf(stderr,X) +#define TRACE2(X,Y) fprintf(stderr,X,Y) +#define TRACE3(X,Y,Z) fprintf(stderr,X,Y,Z) +#define TRACE4(X,Y,Z,A) fprintf(stderr,X,Y,Z,A) +#define TRACE5(X,Y,Z,A,B) fprintf(stderr,X,Y,Z,A,B) +#else +#define TIMER_START +#define TIMER_END +#define SEEK(X) +#define TRACE1(X) +#define TRACE2(X,Y) +#define TRACE3(X,Y,Z) +#define TRACE4(X,Y,Z,A) +#define TRACE5(X,Y,Z,A,B) +#endif + + +#if OS_UNIX +/* +** Here is the dirt on POSIX advisory locks: ANSI STD 1003.1 (1996) +** section 6.5.2.2 lines 483 through 490 specify that when a process +** sets or clears a lock, that operation overrides any prior locks set +** by the same process. It does not explicitly say so, but this implies +** that it overrides locks set by the same process using a different +** file descriptor. Consider this test case: +** +** int fd1 = open("./file1", O_RDWR|O_CREAT, 0644); +** int fd2 = open("./file2", O_RDWR|O_CREAT, 0644); +** +** Suppose ./file1 and ./file2 are really the same file (because +** one is a hard or symbolic link to the other) then if you set +** an exclusive lock on fd1, then try to get an exclusive lock +** on fd2, it works. I would have expected the second lock to +** fail since there was already a lock on the file due to fd1. +** But not so. Since both locks came from the same process, the +** second overrides the first, even though they were on different +** file descriptors opened on different file names. +** +** Bummer. If you ask me, this is broken. Badly broken. It means +** that we cannot use POSIX locks to synchronize file access among +** competing threads of the same process. POSIX locks will work fine +** to synchronize access for threads in separate processes, but not +** threads within the same process. +** +** To work around the problem, SQLite has to manage file locks internally +** on its own. Whenever a new database is opened, we have to find the +** specific inode of the database file (the inode is determined by the +** st_dev and st_ino fields of the stat structure that fstat() fills in) +** and check for locks already existing on that inode. When locks are +** created or removed, we have to look at our own internal record of the +** locks to see if another thread has previously set a lock on that same +** inode. +** +** The OsFile structure for POSIX is no longer just an integer file +** descriptor. It is now a structure that holds the integer file +** descriptor and a pointer to a structure that describes the internal +** locks on the corresponding inode. There is one locking structure +** per inode, so if the same inode is opened twice, both OsFile structures +** point to the same locking structure. The locking structure keeps +** a reference count (so we will know when to delete it) and a "cnt" +** field that tells us its internal lock status. cnt==0 means the +** file is unlocked. cnt==-1 means the file has an exclusive lock. +** cnt>0 means there are cnt shared locks on the file. +** +** Any attempt to lock or unlock a file first checks the locking +** structure. The fcntl() system call is only invoked to set a +** POSIX lock if the internal lock structure transitions between +** a locked and an unlocked state. +** +** 2004-Jan-11: +** More recent discoveries about POSIX advisory locks. (The more +** I discover, the more I realize the a POSIX advisory locks are +** an abomination.) +** +** If you close a file descriptor that points to a file that has locks, +** all locks on that file that are owned by the current process are +** released. To work around this problem, each OsFile structure contains +** a pointer to an openCnt structure. There is one openCnt structure +** per open inode, which means that multiple OsFiles can point to a single +** openCnt. When an attempt is made to close an OsFile, if there are +** other OsFiles open on the same inode that are holding locks, the call +** to close() the file descriptor is deferred until all of the locks clear. +** The openCnt structure keeps a list of file descriptors that need to +** be closed and that list is walked (and cleared) when the last lock +** clears. +** +** First, under Linux threads, because each thread has a separate +** process ID, lock operations in one thread do not override locks +** to the same file in other threads. Linux threads behave like +** separate processes in this respect. But, if you close a file +** descriptor in linux threads, all locks are cleared, even locks +** on other threads and even though the other threads have different +** process IDs. Linux threads is inconsistent in this respect. +** (I'm beginning to think that linux threads is an abomination too.) +** The consequence of this all is that the hash table for the lockInfo +** structure has to include the process id as part of its key because +** locks in different threads are treated as distinct. But the +** openCnt structure should not include the process id in its +** key because close() clears lock on all threads, not just the current +** thread. Were it not for this goofiness in linux threads, we could +** combine the lockInfo and openCnt structures into a single structure. +*/ + +/* +** An instance of the following structure serves as the key used +** to locate a particular lockInfo structure given its inode. Note +** that we have to include the process ID as part of the key. On some +** threading implementations (ex: linux), each thread has a separate +** process ID. +*/ +struct lockKey { + dev_t dev; /* Device number */ + ino_t ino; /* Inode number */ + pid_t pid; /* Process ID */ +}; + +/* +** An instance of the following structure is allocated for each open +** inode on each thread with a different process ID. (Threads have +** different process IDs on linux, but not on most other unixes.) +** +** A single inode can have multiple file descriptors, so each OsFile +** structure contains a pointer to an instance of this object and this +** object keeps a count of the number of OsFiles pointing to it. +*/ +struct lockInfo { + struct lockKey key; /* The lookup key */ + int cnt; /* 0: unlocked. -1: write lock. 1...: read lock. */ + int nRef; /* Number of pointers to this structure */ +}; + +/* +** An instance of the following structure serves as the key used +** to locate a particular openCnt structure given its inode. This +** is the same as the lockKey except that the process ID is omitted. +*/ +struct openKey { + dev_t dev; /* Device number */ + ino_t ino; /* Inode number */ +}; + +/* +** An instance of the following structure is allocated for each open +** inode. This structure keeps track of the number of locks on that +** inode. If a close is attempted against an inode that is holding +** locks, the close is deferred until all locks clear by adding the +** file descriptor to be closed to the pending list. +*/ +struct openCnt { + struct openKey key; /* The lookup key */ + int nRef; /* Number of pointers to this structure */ + int nLock; /* Number of outstanding locks */ + int nPending; /* Number of pending close() operations */ + int *aPending; /* Malloced space holding fd's awaiting a close() */ +}; + +/* +** These hash table maps inodes and process IDs into lockInfo and openCnt +** structures. Access to these hash tables must be protected by a mutex. +*/ +static Hash lockHash = { SQLITE_HASH_BINARY, 0, 0, 0, 0, 0 }; +static Hash openHash = { SQLITE_HASH_BINARY, 0, 0, 0, 0, 0 }; + +/* +** Release a lockInfo structure previously allocated by findLockInfo(). +*/ +static void releaseLockInfo(struct lockInfo *pLock){ + pLock->nRef--; + if( pLock->nRef==0 ){ + sqliteHashInsert(&lockHash, &pLock->key, sizeof(pLock->key), 0); + sqliteFree(pLock); + } +} + +/* +** Release a openCnt structure previously allocated by findLockInfo(). +*/ +static void releaseOpenCnt(struct openCnt *pOpen){ + pOpen->nRef--; + if( pOpen->nRef==0 ){ + sqliteHashInsert(&openHash, &pOpen->key, sizeof(pOpen->key), 0); + sqliteFree(pOpen->aPending); + sqliteFree(pOpen); + } +} + +/* +** Given a file descriptor, locate lockInfo and openCnt structures that +** describes that file descriptor. Create a new ones if necessary. The +** return values might be unset if an error occurs. +** +** Return the number of errors. +*/ +int findLockInfo( + int fd, /* The file descriptor used in the key */ + struct lockInfo **ppLock, /* Return the lockInfo structure here */ + struct openCnt **ppOpen /* Return the openCnt structure here */ +){ + int rc; + struct lockKey key1; + struct openKey key2; + struct stat statbuf; + struct lockInfo *pLock; + struct openCnt *pOpen; + rc = fstat(fd, &statbuf); + if( rc!=0 ) return 1; + memset(&key1, 0, sizeof(key1)); + key1.dev = statbuf.st_dev; + key1.ino = statbuf.st_ino; + key1.pid = getpid(); + memset(&key2, 0, sizeof(key2)); + key2.dev = statbuf.st_dev; + key2.ino = statbuf.st_ino; + pLock = (struct lockInfo*)sqliteHashFind(&lockHash, &key1, sizeof(key1)); + if( pLock==0 ){ + struct lockInfo *pOld; + pLock = sqliteMallocRaw( sizeof(*pLock) ); + if( pLock==0 ) return 1; + pLock->key = key1; + pLock->nRef = 1; + pLock->cnt = 0; + pOld = sqliteHashInsert(&lockHash, &pLock->key, sizeof(key1), pLock); + if( pOld!=0 ){ + assert( pOld==pLock ); + sqliteFree(pLock); + return 1; + } + }else{ + pLock->nRef++; + } + *ppLock = pLock; + pOpen = (struct openCnt*)sqliteHashFind(&openHash, &key2, sizeof(key2)); + if( pOpen==0 ){ + struct openCnt *pOld; + pOpen = sqliteMallocRaw( sizeof(*pOpen) ); + if( pOpen==0 ){ + releaseLockInfo(pLock); + return 1; + } + pOpen->key = key2; + pOpen->nRef = 1; + pOpen->nLock = 0; + pOpen->nPending = 0; + pOpen->aPending = 0; + pOld = sqliteHashInsert(&openHash, &pOpen->key, sizeof(key2), pOpen); + if( pOld!=0 ){ + assert( pOld==pOpen ); + sqliteFree(pOpen); + releaseLockInfo(pLock); + return 1; + } + }else{ + pOpen->nRef++; + } + *ppOpen = pOpen; + return 0; +} + +#endif /** POSIX advisory lock work-around **/ + +/* +** If we compile with the SQLITE_TEST macro set, then the following block +** of code will give us the ability to simulate a disk I/O error. This +** is used for testing the I/O recovery logic. +*/ +#ifdef SQLITE_TEST +int sqlite_io_error_pending = 0; +#define SimulateIOError(A) \ + if( sqlite_io_error_pending ) \ + if( sqlite_io_error_pending-- == 1 ){ local_ioerr(); return A; } +static void local_ioerr(){ + sqlite_io_error_pending = 0; /* Really just a place to set a breakpoint */ +} +#else +#define SimulateIOError(A) +#endif + +/* +** When testing, keep a count of the number of open files. +*/ +#ifdef SQLITE_TEST +int sqlite_open_file_count = 0; +#define OpenCounter(X) sqlite_open_file_count+=(X) +#else +#define OpenCounter(X) +#endif + + +/* +** Delete the named file +*/ +int sqliteOsDelete(const char *zFilename){ +#if OS_UNIX + unlink(zFilename); +#endif +#if OS_WIN + DeleteFile(zFilename); +#endif +#if OS_MAC + unlink(zFilename); +#endif + return SQLITE_OK; +} + +/* +** Return TRUE if the named file exists. +*/ +int sqliteOsFileExists(const char *zFilename){ +#if OS_UNIX + return access(zFilename, 0)==0; +#endif +#if OS_WIN + return GetFileAttributes(zFilename) != 0xffffffff; +#endif +#if OS_MAC + return access(zFilename, 0)==0; +#endif +} + + +#if 0 /* NOT USED */ +/* +** Change the name of an existing file. +*/ +int sqliteOsFileRename(const char *zOldName, const char *zNewName){ +#if OS_UNIX + if( link(zOldName, zNewName) ){ + return SQLITE_ERROR; + } + unlink(zOldName); + return SQLITE_OK; +#endif +#if OS_WIN + if( !MoveFile(zOldName, zNewName) ){ + return SQLITE_ERROR; + } + return SQLITE_OK; +#endif +#if OS_MAC + /**** FIX ME ***/ + return SQLITE_ERROR; +#endif +} +#endif /* NOT USED */ + +/* +** Attempt to open a file for both reading and writing. If that +** fails, try opening it read-only. If the file does not exist, +** try to create it. +** +** On success, a handle for the open file is written to *id +** and *pReadonly is set to 0 if the file was opened for reading and +** writing or 1 if the file was opened read-only. The function returns +** SQLITE_OK. +** +** On failure, the function returns SQLITE_CANTOPEN and leaves +** *id and *pReadonly unchanged. +*/ +int sqliteOsOpenReadWrite( + const char *zFilename, + OsFile *id, + int *pReadonly +){ +#if OS_UNIX + int rc; + id->dirfd = -1; + id->fd = open(zFilename, O_RDWR|O_CREAT|O_LARGEFILE|O_BINARY, 0644); + if( id->fd<0 ){ +#ifdef EISDIR + if( errno==EISDIR ){ + return SQLITE_CANTOPEN; + } +#endif + id->fd = open(zFilename, O_RDONLY|O_LARGEFILE|O_BINARY); + if( id->fd<0 ){ + return SQLITE_CANTOPEN; + } + *pReadonly = 1; + }else{ + *pReadonly = 0; + } + sqliteOsEnterMutex(); + rc = findLockInfo(id->fd, &id->pLock, &id->pOpen); + sqliteOsLeaveMutex(); + if( rc ){ + close(id->fd); + return SQLITE_NOMEM; + } + id->locked = 0; + TRACE3("OPEN %-3d %s\n", id->fd, zFilename); + OpenCounter(+1); + return SQLITE_OK; +#endif +#if OS_WIN + HANDLE h = CreateFile(zFilename, + GENERIC_READ | GENERIC_WRITE, + FILE_SHARE_READ | FILE_SHARE_WRITE, + NULL, + OPEN_ALWAYS, + FILE_ATTRIBUTE_NORMAL | FILE_FLAG_RANDOM_ACCESS, + NULL + ); + if( h==INVALID_HANDLE_VALUE ){ + h = CreateFile(zFilename, + GENERIC_READ, + FILE_SHARE_READ, + NULL, + OPEN_ALWAYS, + FILE_ATTRIBUTE_NORMAL | FILE_FLAG_RANDOM_ACCESS, + NULL + ); + if( h==INVALID_HANDLE_VALUE ){ + return SQLITE_CANTOPEN; + } + *pReadonly = 1; + }else{ + *pReadonly = 0; + } + id->h = h; + id->locked = 0; + OpenCounter(+1); + return SQLITE_OK; +#endif +#if OS_MAC + FSSpec fsSpec; +# ifdef _LARGE_FILE + HFSUniStr255 dfName; + FSRef fsRef; + if( __path2fss(zFilename, &fsSpec) != noErr ){ + if( HCreate(fsSpec.vRefNum, fsSpec.parID, fsSpec.name, 'SQLI', cDocumentFile) != noErr ) + return SQLITE_CANTOPEN; + } + if( FSpMakeFSRef(&fsSpec, &fsRef) != noErr ) + return SQLITE_CANTOPEN; + FSGetDataForkName(&dfName); + if( FSOpenFork(&fsRef, dfName.length, dfName.unicode, + fsRdWrShPerm, &(id->refNum)) != noErr ){ + if( FSOpenFork(&fsRef, dfName.length, dfName.unicode, + fsRdWrPerm, &(id->refNum)) != noErr ){ + if (FSOpenFork(&fsRef, dfName.length, dfName.unicode, + fsRdPerm, &(id->refNum)) != noErr ) + return SQLITE_CANTOPEN; + else + *pReadonly = 1; + } else + *pReadonly = 0; + } else + *pReadonly = 0; +# else + __path2fss(zFilename, &fsSpec); + if( !sqliteOsFileExists(zFilename) ){ + if( HCreate(fsSpec.vRefNum, fsSpec.parID, fsSpec.name, 'SQLI', cDocumentFile) != noErr ) + return SQLITE_CANTOPEN; + } + if( HOpenDF(fsSpec.vRefNum, fsSpec.parID, fsSpec.name, fsRdWrShPerm, &(id->refNum)) != noErr ){ + if( HOpenDF(fsSpec.vRefNum, fsSpec.parID, fsSpec.name, fsRdWrPerm, &(id->refNum)) != noErr ){ + if( HOpenDF(fsSpec.vRefNum, fsSpec.parID, fsSpec.name, fsRdPerm, &(id->refNum)) != noErr ) + return SQLITE_CANTOPEN; + else + *pReadonly = 1; + } else + *pReadonly = 0; + } else + *pReadonly = 0; +# endif + if( HOpenRF(fsSpec.vRefNum, fsSpec.parID, fsSpec.name, fsRdWrShPerm, &(id->refNumRF)) != noErr){ + id->refNumRF = -1; + } + id->locked = 0; + id->delOnClose = 0; + OpenCounter(+1); + return SQLITE_OK; +#endif +} + + +/* +** Attempt to open a new file for exclusive access by this process. +** The file will be opened for both reading and writing. To avoid +** a potential security problem, we do not allow the file to have +** previously existed. Nor do we allow the file to be a symbolic +** link. +** +** If delFlag is true, then make arrangements to automatically delete +** the file when it is closed. +** +** On success, write the file handle into *id and return SQLITE_OK. +** +** On failure, return SQLITE_CANTOPEN. +*/ +int sqliteOsOpenExclusive(const char *zFilename, OsFile *id, int delFlag){ +#if OS_UNIX + int rc; + if( access(zFilename, 0)==0 ){ + return SQLITE_CANTOPEN; + } + id->dirfd = -1; + id->fd = open(zFilename, + O_RDWR|O_CREAT|O_EXCL|O_NOFOLLOW|O_LARGEFILE|O_BINARY, 0600); + if( id->fd<0 ){ + return SQLITE_CANTOPEN; + } + sqliteOsEnterMutex(); + rc = findLockInfo(id->fd, &id->pLock, &id->pOpen); + sqliteOsLeaveMutex(); + if( rc ){ + close(id->fd); + unlink(zFilename); + return SQLITE_NOMEM; + } + id->locked = 0; + if( delFlag ){ + unlink(zFilename); + } + TRACE3("OPEN-EX %-3d %s\n", id->fd, zFilename); + OpenCounter(+1); + return SQLITE_OK; +#endif +#if OS_WIN + HANDLE h; + int fileflags; + if( delFlag ){ + fileflags = FILE_ATTRIBUTE_TEMPORARY | FILE_FLAG_RANDOM_ACCESS + | FILE_FLAG_DELETE_ON_CLOSE; + }else{ + fileflags = FILE_FLAG_RANDOM_ACCESS; + } + h = CreateFile(zFilename, + GENERIC_READ | GENERIC_WRITE, + 0, + NULL, + CREATE_ALWAYS, + fileflags, + NULL + ); + if( h==INVALID_HANDLE_VALUE ){ + return SQLITE_CANTOPEN; + } + id->h = h; + id->locked = 0; + OpenCounter(+1); + return SQLITE_OK; +#endif +#if OS_MAC + FSSpec fsSpec; +# ifdef _LARGE_FILE + HFSUniStr255 dfName; + FSRef fsRef; + __path2fss(zFilename, &fsSpec); + if( HCreate(fsSpec.vRefNum, fsSpec.parID, fsSpec.name, 'SQLI', cDocumentFile) != noErr ) + return SQLITE_CANTOPEN; + if( FSpMakeFSRef(&fsSpec, &fsRef) != noErr ) + return SQLITE_CANTOPEN; + FSGetDataForkName(&dfName); + if( FSOpenFork(&fsRef, dfName.length, dfName.unicode, + fsRdWrPerm, &(id->refNum)) != noErr ) + return SQLITE_CANTOPEN; +# else + __path2fss(zFilename, &fsSpec); + if( HCreate(fsSpec.vRefNum, fsSpec.parID, fsSpec.name, 'SQLI', cDocumentFile) != noErr ) + return SQLITE_CANTOPEN; + if( HOpenDF(fsSpec.vRefNum, fsSpec.parID, fsSpec.name, fsRdWrPerm, &(id->refNum)) != noErr ) + return SQLITE_CANTOPEN; +# endif + id->refNumRF = -1; + id->locked = 0; + id->delOnClose = delFlag; + if (delFlag) + id->pathToDel = sqliteOsFullPathname(zFilename); + OpenCounter(+1); + return SQLITE_OK; +#endif +} + +/* +** Attempt to open a new file for read-only access. +** +** On success, write the file handle into *id and return SQLITE_OK. +** +** On failure, return SQLITE_CANTOPEN. +*/ +int sqliteOsOpenReadOnly(const char *zFilename, OsFile *id){ +#if OS_UNIX + int rc; + id->dirfd = -1; + id->fd = open(zFilename, O_RDONLY|O_LARGEFILE|O_BINARY); + if( id->fd<0 ){ + return SQLITE_CANTOPEN; + } + sqliteOsEnterMutex(); + rc = findLockInfo(id->fd, &id->pLock, &id->pOpen); + sqliteOsLeaveMutex(); + if( rc ){ + close(id->fd); + return SQLITE_NOMEM; + } + id->locked = 0; + TRACE3("OPEN-RO %-3d %s\n", id->fd, zFilename); + OpenCounter(+1); + return SQLITE_OK; +#endif +#if OS_WIN + HANDLE h = CreateFile(zFilename, + GENERIC_READ, + 0, + NULL, + OPEN_EXISTING, + FILE_ATTRIBUTE_NORMAL | FILE_FLAG_RANDOM_ACCESS, + NULL + ); + if( h==INVALID_HANDLE_VALUE ){ + return SQLITE_CANTOPEN; + } + id->h = h; + id->locked = 0; + OpenCounter(+1); + return SQLITE_OK; +#endif +#if OS_MAC + FSSpec fsSpec; +# ifdef _LARGE_FILE + HFSUniStr255 dfName; + FSRef fsRef; + if( __path2fss(zFilename, &fsSpec) != noErr ) + return SQLITE_CANTOPEN; + if( FSpMakeFSRef(&fsSpec, &fsRef) != noErr ) + return SQLITE_CANTOPEN; + FSGetDataForkName(&dfName); + if( FSOpenFork(&fsRef, dfName.length, dfName.unicode, + fsRdPerm, &(id->refNum)) != noErr ) + return SQLITE_CANTOPEN; +# else + __path2fss(zFilename, &fsSpec); + if( HOpenDF(fsSpec.vRefNum, fsSpec.parID, fsSpec.name, fsRdPerm, &(id->refNum)) != noErr ) + return SQLITE_CANTOPEN; +# endif + if( HOpenRF(fsSpec.vRefNum, fsSpec.parID, fsSpec.name, fsRdWrShPerm, &(id->refNumRF)) != noErr){ + id->refNumRF = -1; + } + id->locked = 0; + id->delOnClose = 0; + OpenCounter(+1); + return SQLITE_OK; +#endif +} + +/* +** Attempt to open a file descriptor for the directory that contains a +** file. This file descriptor can be used to fsync() the directory +** in order to make sure the creation of a new file is actually written +** to disk. +** +** This routine is only meaningful for Unix. It is a no-op under +** windows since windows does not support hard links. +** +** On success, a handle for a previously open file is at *id is +** updated with the new directory file descriptor and SQLITE_OK is +** returned. +** +** On failure, the function returns SQLITE_CANTOPEN and leaves +** *id unchanged. +*/ +int sqliteOsOpenDirectory( + const char *zDirname, + OsFile *id +){ +#if OS_UNIX + if( id->fd<0 ){ + /* Do not open the directory if the corresponding file is not already + ** open. */ + return SQLITE_CANTOPEN; + } + assert( id->dirfd<0 ); + id->dirfd = open(zDirname, O_RDONLY|O_BINARY, 0644); + if( id->dirfd<0 ){ + return SQLITE_CANTOPEN; + } + TRACE3("OPENDIR %-3d %s\n", id->dirfd, zDirname); +#endif + return SQLITE_OK; +} + +/* +** If the following global variable points to a string which is the +** name of a directory, then that directory will be used to store +** temporary files. +*/ +const char *sqlite_temp_directory = 0; + +/* +** Create a temporary file name in zBuf. zBuf must be big enough to +** hold at least SQLITE_TEMPNAME_SIZE characters. +*/ +int sqliteOsTempFileName(char *zBuf){ +#if OS_UNIX + static const char *azDirs[] = { + 0, + "/var/tmp", + "/usr/tmp", + "/tmp", + ".", + }; + static unsigned char zChars[] = + "abcdefghijklmnopqrstuvwxyz" + "ABCDEFGHIJKLMNOPQRSTUVWXYZ" + "0123456789"; + int i, j; + struct stat buf; + const char *zDir = "."; + azDirs[0] = sqlite_temp_directory; + for(i=0; i<sizeof(azDirs)/sizeof(azDirs[0]); i++){ + if( azDirs[i]==0 ) continue; + if( stat(azDirs[i], &buf) ) continue; + if( !S_ISDIR(buf.st_mode) ) continue; + if( access(azDirs[i], 07) ) continue; + zDir = azDirs[i]; + break; + } + do{ + sprintf(zBuf, "%s/"TEMP_FILE_PREFIX, zDir); + j = strlen(zBuf); + sqliteRandomness(15, &zBuf[j]); + for(i=0; i<15; i++, j++){ + zBuf[j] = (char)zChars[ ((unsigned char)zBuf[j])%(sizeof(zChars)-1) ]; + } + zBuf[j] = 0; + }while( access(zBuf,0)==0 ); +#endif +#if OS_WIN + static char zChars[] = + "abcdefghijklmnopqrstuvwxyz" + "ABCDEFGHIJKLMNOPQRSTUVWXYZ" + "0123456789"; + int i, j; + const char *zDir; + char zTempPath[SQLITE_TEMPNAME_SIZE]; + if( sqlite_temp_directory==0 ){ + GetTempPath(SQLITE_TEMPNAME_SIZE-30, zTempPath); + for(i=strlen(zTempPath); i>0 && zTempPath[i-1]=='\\'; i--){} + zTempPath[i] = 0; + zDir = zTempPath; + }else{ + zDir = sqlite_temp_directory; + } + for(;;){ + sprintf(zBuf, "%s\\"TEMP_FILE_PREFIX, zDir); + j = strlen(zBuf); + sqliteRandomness(15, &zBuf[j]); + for(i=0; i<15; i++, j++){ + zBuf[j] = (char)zChars[ ((unsigned char)zBuf[j])%(sizeof(zChars)-1) ]; + } + zBuf[j] = 0; + if( !sqliteOsFileExists(zBuf) ) break; + } +#endif +#if OS_MAC + static char zChars[] = + "abcdefghijklmnopqrstuvwxyz" + "ABCDEFGHIJKLMNOPQRSTUVWXYZ" + "0123456789"; + int i, j; + char *zDir; + char zTempPath[SQLITE_TEMPNAME_SIZE]; + char zdirName[32]; + CInfoPBRec infoRec; + Str31 dirName; + memset(&infoRec, 0, sizeof(infoRec)); + memset(zTempPath, 0, SQLITE_TEMPNAME_SIZE); + if( sqlite_temp_directory!=0 ){ + zDir = sqlite_temp_directory; + }else if( FindFolder(kOnSystemDisk, kTemporaryFolderType, kCreateFolder, + &(infoRec.dirInfo.ioVRefNum), &(infoRec.dirInfo.ioDrParID)) == noErr ){ + infoRec.dirInfo.ioNamePtr = dirName; + do{ + infoRec.dirInfo.ioFDirIndex = -1; + infoRec.dirInfo.ioDrDirID = infoRec.dirInfo.ioDrParID; + if( PBGetCatInfoSync(&infoRec) == noErr ){ + CopyPascalStringToC(dirName, zdirName); + i = strlen(zdirName); + memmove(&(zTempPath[i+1]), zTempPath, strlen(zTempPath)); + strcpy(zTempPath, zdirName); + zTempPath[i] = ':'; + }else{ + *zTempPath = 0; + break; + } + } while( infoRec.dirInfo.ioDrDirID != fsRtDirID ); + zDir = zTempPath; + } + if( zDir[0]==0 ){ + getcwd(zTempPath, SQLITE_TEMPNAME_SIZE-24); + zDir = zTempPath; + } + for(;;){ + sprintf(zBuf, "%s"TEMP_FILE_PREFIX, zDir); + j = strlen(zBuf); + sqliteRandomness(15, &zBuf[j]); + for(i=0; i<15; i++, j++){ + zBuf[j] = (char)zChars[ ((unsigned char)zBuf[j])%(sizeof(zChars)-1) ]; + } + zBuf[j] = 0; + if( !sqliteOsFileExists(zBuf) ) break; + } +#endif + return SQLITE_OK; +} + +/* +** Close a file. +*/ +int sqliteOsClose(OsFile *id){ +#if OS_UNIX + sqliteOsUnlock(id); + if( id->dirfd>=0 ) close(id->dirfd); + id->dirfd = -1; + sqliteOsEnterMutex(); + if( id->pOpen->nLock ){ + /* If there are outstanding locks, do not actually close the file just + ** yet because that would clear those locks. Instead, add the file + ** descriptor to pOpen->aPending. It will be automatically closed when + ** the last lock is cleared. + */ + int *aNew; + struct openCnt *pOpen = id->pOpen; + pOpen->nPending++; + aNew = sqliteRealloc( pOpen->aPending, pOpen->nPending*sizeof(int) ); + if( aNew==0 ){ + /* If a malloc fails, just leak the file descriptor */ + }else{ + pOpen->aPending = aNew; + pOpen->aPending[pOpen->nPending-1] = id->fd; + } + }else{ + /* There are no outstanding locks so we can close the file immediately */ + close(id->fd); + } + releaseLockInfo(id->pLock); + releaseOpenCnt(id->pOpen); + sqliteOsLeaveMutex(); + TRACE2("CLOSE %-3d\n", id->fd); + OpenCounter(-1); + return SQLITE_OK; +#endif +#if OS_WIN + CloseHandle(id->h); + OpenCounter(-1); + return SQLITE_OK; +#endif +#if OS_MAC + if( id->refNumRF!=-1 ) + FSClose(id->refNumRF); +# ifdef _LARGE_FILE + FSCloseFork(id->refNum); +# else + FSClose(id->refNum); +# endif + if( id->delOnClose ){ + unlink(id->pathToDel); + sqliteFree(id->pathToDel); + } + OpenCounter(-1); + return SQLITE_OK; +#endif +} + +/* +** Read data from a file into a buffer. Return SQLITE_OK if all +** bytes were read successfully and SQLITE_IOERR if anything goes +** wrong. +*/ +int sqliteOsRead(OsFile *id, void *pBuf, int amt){ +#if OS_UNIX + int got; + SimulateIOError(SQLITE_IOERR); + TIMER_START; + got = read(id->fd, pBuf, amt); + TIMER_END; + TRACE4("READ %-3d %7d %d\n", id->fd, last_page, elapse); + SEEK(0); + /* if( got<0 ) got = 0; */ + if( got==amt ){ + return SQLITE_OK; + }else{ + return SQLITE_IOERR; + } +#endif +#if OS_WIN + DWORD got; + SimulateIOError(SQLITE_IOERR); + TRACE2("READ %d\n", last_page); + if( !ReadFile(id->h, pBuf, amt, &got, 0) ){ + got = 0; + } + if( got==(DWORD)amt ){ + return SQLITE_OK; + }else{ + return SQLITE_IOERR; + } +#endif +#if OS_MAC + int got; + SimulateIOError(SQLITE_IOERR); + TRACE2("READ %d\n", last_page); +# ifdef _LARGE_FILE + FSReadFork(id->refNum, fsAtMark, 0, (ByteCount)amt, pBuf, (ByteCount*)&got); +# else + got = amt; + FSRead(id->refNum, &got, pBuf); +# endif + if( got==amt ){ + return SQLITE_OK; + }else{ + return SQLITE_IOERR; + } +#endif +} + +/* +** Write data from a buffer into a file. Return SQLITE_OK on success +** or some other error code on failure. +*/ +int sqliteOsWrite(OsFile *id, const void *pBuf, int amt){ +#if OS_UNIX + int wrote = 0; + SimulateIOError(SQLITE_IOERR); + TIMER_START; + while( amt>0 && (wrote = write(id->fd, pBuf, amt))>0 ){ + amt -= wrote; + pBuf = &((char*)pBuf)[wrote]; + } + TIMER_END; + TRACE4("WRITE %-3d %7d %d\n", id->fd, last_page, elapse); + SEEK(0); + if( amt>0 ){ + return SQLITE_FULL; + } + return SQLITE_OK; +#endif +#if OS_WIN + int rc; + DWORD wrote; + SimulateIOError(SQLITE_IOERR); + TRACE2("WRITE %d\n", last_page); + while( amt>0 && (rc = WriteFile(id->h, pBuf, amt, &wrote, 0))!=0 && wrote>0 ){ + amt -= wrote; + pBuf = &((char*)pBuf)[wrote]; + } + if( !rc || amt>(int)wrote ){ + return SQLITE_FULL; + } + return SQLITE_OK; +#endif +#if OS_MAC + OSErr oserr; + int wrote = 0; + SimulateIOError(SQLITE_IOERR); + TRACE2("WRITE %d\n", last_page); + while( amt>0 ){ +# ifdef _LARGE_FILE + oserr = FSWriteFork(id->refNum, fsAtMark, 0, + (ByteCount)amt, pBuf, (ByteCount*)&wrote); +# else + wrote = amt; + oserr = FSWrite(id->refNum, &wrote, pBuf); +# endif + if( wrote == 0 || oserr != noErr) + break; + amt -= wrote; + pBuf = &((char*)pBuf)[wrote]; + } + if( oserr != noErr || amt>wrote ){ + return SQLITE_FULL; + } + return SQLITE_OK; +#endif +} + +/* +** Move the read/write pointer in a file. +*/ +int sqliteOsSeek(OsFile *id, off_t offset){ + SEEK(offset/1024 + 1); +#if OS_UNIX + lseek(id->fd, offset, SEEK_SET); + return SQLITE_OK; +#endif +#if OS_WIN + { + LONG upperBits = offset>>32; + LONG lowerBits = offset & 0xffffffff; + DWORD rc; + rc = SetFilePointer(id->h, lowerBits, &upperBits, FILE_BEGIN); + /* TRACE3("SEEK rc=0x%x upper=0x%x\n", rc, upperBits); */ + } + return SQLITE_OK; +#endif +#if OS_MAC + { + off_t curSize; + if( sqliteOsFileSize(id, &curSize) != SQLITE_OK ){ + return SQLITE_IOERR; + } + if( offset >= curSize ){ + if( sqliteOsTruncate(id, offset+1) != SQLITE_OK ){ + return SQLITE_IOERR; + } + } +# ifdef _LARGE_FILE + if( FSSetForkPosition(id->refNum, fsFromStart, offset) != noErr ){ +# else + if( SetFPos(id->refNum, fsFromStart, offset) != noErr ){ +# endif + return SQLITE_IOERR; + }else{ + return SQLITE_OK; + } + } +#endif +} + +/* +** Make sure all writes to a particular file are committed to disk. +** +** Under Unix, also make sure that the directory entry for the file +** has been created by fsync-ing the directory that contains the file. +** If we do not do this and we encounter a power failure, the directory +** entry for the journal might not exist after we reboot. The next +** SQLite to access the file will not know that the journal exists (because +** the directory entry for the journal was never created) and the transaction +** will not roll back - possibly leading to database corruption. +*/ +int sqliteOsSync(OsFile *id){ +#if OS_UNIX + SimulateIOError(SQLITE_IOERR); + TRACE2("SYNC %-3d\n", id->fd); + if( fsync(id->fd) ){ + return SQLITE_IOERR; + }else{ + if( id->dirfd>=0 ){ + TRACE2("DIRSYNC %-3d\n", id->dirfd); + fsync(id->dirfd); + close(id->dirfd); /* Only need to sync once, so close the directory */ + id->dirfd = -1; /* when we are done. */ + } + return SQLITE_OK; + } +#endif +#if OS_WIN + if( FlushFileBuffers(id->h) ){ + return SQLITE_OK; + }else{ + return SQLITE_IOERR; + } +#endif +#if OS_MAC +# ifdef _LARGE_FILE + if( FSFlushFork(id->refNum) != noErr ){ +# else + ParamBlockRec params; + memset(¶ms, 0, sizeof(ParamBlockRec)); + params.ioParam.ioRefNum = id->refNum; + if( PBFlushFileSync(¶ms) != noErr ){ +# endif + return SQLITE_IOERR; + }else{ + return SQLITE_OK; + } +#endif +} + +/* +** Truncate an open file to a specified size +*/ +int sqliteOsTruncate(OsFile *id, off_t nByte){ + SimulateIOError(SQLITE_IOERR); +#if OS_UNIX + return ftruncate(id->fd, nByte)==0 ? SQLITE_OK : SQLITE_IOERR; +#endif +#if OS_WIN + { + LONG upperBits = nByte>>32; + SetFilePointer(id->h, nByte, &upperBits, FILE_BEGIN); + SetEndOfFile(id->h); + } + return SQLITE_OK; +#endif +#if OS_MAC +# ifdef _LARGE_FILE + if( FSSetForkSize(id->refNum, fsFromStart, nByte) != noErr){ +# else + if( SetEOF(id->refNum, nByte) != noErr ){ +# endif + return SQLITE_IOERR; + }else{ + return SQLITE_OK; + } +#endif +} + +/* +** Determine the current size of a file in bytes +*/ +int sqliteOsFileSize(OsFile *id, off_t *pSize){ +#if OS_UNIX + struct stat buf; + SimulateIOError(SQLITE_IOERR); + if( fstat(id->fd, &buf)!=0 ){ + return SQLITE_IOERR; + } + *pSize = buf.st_size; + return SQLITE_OK; +#endif +#if OS_WIN + DWORD upperBits, lowerBits; + SimulateIOError(SQLITE_IOERR); + lowerBits = GetFileSize(id->h, &upperBits); + *pSize = (((off_t)upperBits)<<32) + lowerBits; + return SQLITE_OK; +#endif +#if OS_MAC +# ifdef _LARGE_FILE + if( FSGetForkSize(id->refNum, pSize) != noErr){ +# else + if( GetEOF(id->refNum, pSize) != noErr ){ +# endif + return SQLITE_IOERR; + }else{ + return SQLITE_OK; + } +#endif +} + +#if OS_WIN +/* +** Return true (non-zero) if we are running under WinNT, Win2K or WinXP. +** Return false (zero) for Win95, Win98, or WinME. +** +** Here is an interesting observation: Win95, Win98, and WinME lack +** the LockFileEx() API. But we can still statically link against that +** API as long as we don't call it win running Win95/98/ME. A call to +** this routine is used to determine if the host is Win95/98/ME or +** WinNT/2K/XP so that we will know whether or not we can safely call +** the LockFileEx() API. +*/ +int isNT(void){ + static int osType = 0; /* 0=unknown 1=win95 2=winNT */ + if( osType==0 ){ + OSVERSIONINFO sInfo; + sInfo.dwOSVersionInfoSize = sizeof(sInfo); + GetVersionEx(&sInfo); + osType = sInfo.dwPlatformId==VER_PLATFORM_WIN32_NT ? 2 : 1; + } + return osType==2; +} +#endif + +/* +** Windows file locking notes: [similar issues apply to MacOS] +** +** We cannot use LockFileEx() or UnlockFileEx() on Win95/98/ME because +** those functions are not available. So we use only LockFile() and +** UnlockFile(). +** +** LockFile() prevents not just writing but also reading by other processes. +** (This is a design error on the part of Windows, but there is nothing +** we can do about that.) So the region used for locking is at the +** end of the file where it is unlikely to ever interfere with an +** actual read attempt. +** +** A database read lock is obtained by locking a single randomly-chosen +** byte out of a specific range of bytes. The lock byte is obtained at +** random so two separate readers can probably access the file at the +** same time, unless they are unlucky and choose the same lock byte. +** A database write lock is obtained by locking all bytes in the range. +** There can only be one writer. +** +** A lock is obtained on the first byte of the lock range before acquiring +** either a read lock or a write lock. This prevents two processes from +** attempting to get a lock at a same time. The semantics of +** sqliteOsReadLock() require that if there is already a write lock, that +** lock is converted into a read lock atomically. The lock on the first +** byte allows us to drop the old write lock and get the read lock without +** another process jumping into the middle and messing us up. The same +** argument applies to sqliteOsWriteLock(). +** +** On WinNT/2K/XP systems, LockFileEx() and UnlockFileEx() are available, +** which means we can use reader/writer locks. When reader writer locks +** are used, the lock is placed on the same range of bytes that is used +** for probabilistic locking in Win95/98/ME. Hence, the locking scheme +** will support two or more Win95 readers or two or more WinNT readers. +** But a single Win95 reader will lock out all WinNT readers and a single +** WinNT reader will lock out all other Win95 readers. +** +** Note: On MacOS we use the resource fork for locking. +** +** The following #defines specify the range of bytes used for locking. +** N_LOCKBYTE is the number of bytes available for doing the locking. +** The first byte used to hold the lock while the lock is changing does +** not count toward this number. FIRST_LOCKBYTE is the address of +** the first byte in the range of bytes used for locking. +*/ +#define N_LOCKBYTE 10239 +#if OS_MAC +# define FIRST_LOCKBYTE (0x000fffff - N_LOCKBYTE) +#else +# define FIRST_LOCKBYTE (0xffffffff - N_LOCKBYTE) +#endif + +/* +** Change the status of the lock on the file "id" to be a readlock. +** If the file was write locked, then this reduces the lock to a read. +** If the file was read locked, then this acquires a new read lock. +** +** Return SQLITE_OK on success and SQLITE_BUSY on failure. If this +** library was compiled with large file support (LFS) but LFS is not +** available on the host, then an SQLITE_NOLFS is returned. +*/ +int sqliteOsReadLock(OsFile *id){ +#if OS_UNIX + int rc; + sqliteOsEnterMutex(); + if( id->pLock->cnt>0 ){ + if( !id->locked ){ + id->pLock->cnt++; + id->locked = 1; + id->pOpen->nLock++; + } + rc = SQLITE_OK; + }else if( id->locked || id->pLock->cnt==0 ){ + struct flock lock; + int s; + lock.l_type = F_RDLCK; + lock.l_whence = SEEK_SET; + lock.l_start = lock.l_len = 0L; + s = fcntl(id->fd, F_SETLK, &lock); + if( s!=0 ){ + rc = (errno==EINVAL) ? SQLITE_NOLFS : SQLITE_BUSY; + }else{ + rc = SQLITE_OK; + if( !id->locked ){ + id->pOpen->nLock++; + id->locked = 1; + } + id->pLock->cnt = 1; + } + }else{ + rc = SQLITE_BUSY; + } + sqliteOsLeaveMutex(); + return rc; +#endif +#if OS_WIN + int rc; + if( id->locked>0 ){ + rc = SQLITE_OK; + }else{ + int lk; + int res; + int cnt = 100; + sqliteRandomness(sizeof(lk), &lk); + lk = (lk & 0x7fffffff)%N_LOCKBYTE + 1; + while( cnt-->0 && (res = LockFile(id->h, FIRST_LOCKBYTE, 0, 1, 0))==0 ){ + Sleep(1); + } + if( res ){ + UnlockFile(id->h, FIRST_LOCKBYTE+1, 0, N_LOCKBYTE, 0); + if( isNT() ){ + OVERLAPPED ovlp; + ovlp.Offset = FIRST_LOCKBYTE+1; + ovlp.OffsetHigh = 0; + ovlp.hEvent = 0; + res = LockFileEx(id->h, LOCKFILE_FAIL_IMMEDIATELY, + 0, N_LOCKBYTE, 0, &ovlp); + }else{ + res = LockFile(id->h, FIRST_LOCKBYTE+lk, 0, 1, 0); + } + UnlockFile(id->h, FIRST_LOCKBYTE, 0, 1, 0); + } + if( res ){ + id->locked = lk; + rc = SQLITE_OK; + }else{ + rc = SQLITE_BUSY; + } + } + return rc; +#endif +#if OS_MAC + int rc; + if( id->locked>0 || id->refNumRF == -1 ){ + rc = SQLITE_OK; + }else{ + int lk; + OSErr res; + int cnt = 5; + ParamBlockRec params; + sqliteRandomness(sizeof(lk), &lk); + lk = (lk & 0x7fffffff)%N_LOCKBYTE + 1; + memset(¶ms, 0, sizeof(params)); + params.ioParam.ioRefNum = id->refNumRF; + params.ioParam.ioPosMode = fsFromStart; + params.ioParam.ioPosOffset = FIRST_LOCKBYTE; + params.ioParam.ioReqCount = 1; + while( cnt-->0 && (res = PBLockRangeSync(¶ms))!=noErr ){ + UInt32 finalTicks; + Delay(1, &finalTicks); /* 1/60 sec */ + } + if( res == noErr ){ + params.ioParam.ioPosOffset = FIRST_LOCKBYTE+1; + params.ioParam.ioReqCount = N_LOCKBYTE; + PBUnlockRangeSync(¶ms); + params.ioParam.ioPosOffset = FIRST_LOCKBYTE+lk; + params.ioParam.ioReqCount = 1; + res = PBLockRangeSync(¶ms); + params.ioParam.ioPosOffset = FIRST_LOCKBYTE; + params.ioParam.ioReqCount = 1; + PBUnlockRangeSync(¶ms); + } + if( res == noErr ){ + id->locked = lk; + rc = SQLITE_OK; + }else{ + rc = SQLITE_BUSY; + } + } + return rc; +#endif +} + +/* +** Change the lock status to be an exclusive or write lock. Return +** SQLITE_OK on success and SQLITE_BUSY on a failure. If this +** library was compiled with large file support (LFS) but LFS is not +** available on the host, then an SQLITE_NOLFS is returned. +*/ +int sqliteOsWriteLock(OsFile *id){ +#if OS_UNIX + int rc; + sqliteOsEnterMutex(); + if( id->pLock->cnt==0 || (id->pLock->cnt==1 && id->locked==1) ){ + struct flock lock; + int s; + lock.l_type = F_WRLCK; + lock.l_whence = SEEK_SET; + lock.l_start = lock.l_len = 0L; + s = fcntl(id->fd, F_SETLK, &lock); + if( s!=0 ){ + rc = (errno==EINVAL) ? SQLITE_NOLFS : SQLITE_BUSY; + }else{ + rc = SQLITE_OK; + if( !id->locked ){ + id->pOpen->nLock++; + id->locked = 1; + } + id->pLock->cnt = -1; + } + }else{ + rc = SQLITE_BUSY; + } + sqliteOsLeaveMutex(); + return rc; +#endif +#if OS_WIN + int rc; + if( id->locked<0 ){ + rc = SQLITE_OK; + }else{ + int res; + int cnt = 100; + while( cnt-->0 && (res = LockFile(id->h, FIRST_LOCKBYTE, 0, 1, 0))==0 ){ + Sleep(1); + } + if( res ){ + if( id->locked>0 ){ + if( isNT() ){ + UnlockFile(id->h, FIRST_LOCKBYTE+1, 0, N_LOCKBYTE, 0); + }else{ + res = UnlockFile(id->h, FIRST_LOCKBYTE + id->locked, 0, 1, 0); + } + } + if( res ){ + res = LockFile(id->h, FIRST_LOCKBYTE+1, 0, N_LOCKBYTE, 0); + }else{ + res = 0; + } + UnlockFile(id->h, FIRST_LOCKBYTE, 0, 1, 0); + } + if( res ){ + id->locked = -1; + rc = SQLITE_OK; + }else{ + rc = SQLITE_BUSY; + } + } + return rc; +#endif +#if OS_MAC + int rc; + if( id->locked<0 || id->refNumRF == -1 ){ + rc = SQLITE_OK; + }else{ + OSErr res; + int cnt = 5; + ParamBlockRec params; + memset(¶ms, 0, sizeof(params)); + params.ioParam.ioRefNum = id->refNumRF; + params.ioParam.ioPosMode = fsFromStart; + params.ioParam.ioPosOffset = FIRST_LOCKBYTE; + params.ioParam.ioReqCount = 1; + while( cnt-->0 && (res = PBLockRangeSync(¶ms))!=noErr ){ + UInt32 finalTicks; + Delay(1, &finalTicks); /* 1/60 sec */ + } + if( res == noErr ){ + params.ioParam.ioPosOffset = FIRST_LOCKBYTE + id->locked; + params.ioParam.ioReqCount = 1; + if( id->locked==0 + || PBUnlockRangeSync(¶ms)==noErr ){ + params.ioParam.ioPosOffset = FIRST_LOCKBYTE+1; + params.ioParam.ioReqCount = N_LOCKBYTE; + res = PBLockRangeSync(¶ms); + }else{ + res = afpRangeNotLocked; + } + params.ioParam.ioPosOffset = FIRST_LOCKBYTE; + params.ioParam.ioReqCount = 1; + PBUnlockRangeSync(¶ms); + } + if( res == noErr ){ + id->locked = -1; + rc = SQLITE_OK; + }else{ + rc = SQLITE_BUSY; + } + } + return rc; +#endif +} + +/* +** Unlock the given file descriptor. If the file descriptor was +** not previously locked, then this routine is a no-op. If this +** library was compiled with large file support (LFS) but LFS is not +** available on the host, then an SQLITE_NOLFS is returned. +*/ +int sqliteOsUnlock(OsFile *id){ +#if OS_UNIX + int rc; + if( !id->locked ) return SQLITE_OK; + sqliteOsEnterMutex(); + assert( id->pLock->cnt!=0 ); + if( id->pLock->cnt>1 ){ + id->pLock->cnt--; + rc = SQLITE_OK; + }else{ + struct flock lock; + int s; + lock.l_type = F_UNLCK; + lock.l_whence = SEEK_SET; + lock.l_start = lock.l_len = 0L; + s = fcntl(id->fd, F_SETLK, &lock); + if( s!=0 ){ + rc = (errno==EINVAL) ? SQLITE_NOLFS : SQLITE_BUSY; + }else{ + rc = SQLITE_OK; + id->pLock->cnt = 0; + } + } + if( rc==SQLITE_OK ){ + /* Decrement the count of locks against this same file. When the + ** count reaches zero, close any other file descriptors whose close + ** was deferred because of outstanding locks. + */ + struct openCnt *pOpen = id->pOpen; + pOpen->nLock--; + assert( pOpen->nLock>=0 ); + if( pOpen->nLock==0 && pOpen->nPending>0 ){ + int i; + for(i=0; i<pOpen->nPending; 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 non-zero value, becomes the result +** returned from sqliteOsCurrentTime(). This is used for testing. +*/ +#ifdef SQLITE_TEST +int sqlite_current_time = 0; +#endif + +/* +** Find the current time (in Universal Coordinated Time). Write the +** current time and date as a Julian Day number into *prNow and +** return 0. Return 1 if the time and date cannot be found. +*/ +int sqliteOsCurrentTime(double *prNow){ +#if OS_UNIX + time_t t; + time(&t); + *prNow = t/86400.0 + 2440587.5; +#endif +#if OS_WIN + FILETIME ft; + /* FILETIME structure is a 64-bit value representing the number of + 100-nanosecond intervals since January 1, 1601 (= JD 2305813.5). + */ + double now; + GetSystemTimeAsFileTime( &ft ); + now = ((double)ft.dwHighDateTime) * 4294967296.0; + *prNow = (now + ft.dwLowDateTime)/864000000000.0 + 2305813.5; +#endif +#ifdef SQLITE_TEST + if( sqlite_current_time ){ + *prNow = sqlite_current_time/86400.0 + 2440587.5; + } +#endif + return 0; +} diff --git a/kexi/3rdparty/kexisql/src/os.h b/kexi/3rdparty/kexisql/src/os.h new file mode 100644 index 00000000..d1395841 --- /dev/null +++ b/kexi/3rdparty/kexisql/src/os.h @@ -0,0 +1,191 @@ +/* +** 2001 September 16 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +****************************************************************************** +** +** This header file (together with is companion C source-code file +** "os.c") attempt to abstract the underlying operating system so that +** the SQLite library will work on both POSIX and windows systems. +*/ +#ifndef _SQLITE_OS_H_ +#define _SQLITE_OS_H_ + +/* +** Helpful hint: To get this to compile on HP/UX, add -D_INCLUDE_POSIX_SOURCE +** to the compiler command line. +*/ + +/* +** These #defines should enable >2GB file support on Posix if the +** underlying operating system supports it. If the OS lacks +** large file support, or if the OS is windows, these should be no-ops. +** +** Large file support can be disabled using the -DSQLITE_DISABLE_LFS switch +** on the compiler command line. This is necessary if you are compiling +** on a recent machine (ex: RedHat 7.2) but you want your code to work +** on an older machine (ex: RedHat 6.0). If you compile on RedHat 7.2 +** without this option, LFS is enable. But LFS does not exist in the kernel +** in RedHat 6.0, so the code won't work. Hence, for maximum binary +** portability you should omit LFS. +** +** Similar is true for MacOS. LFS is only supported on MacOS 9 and later. +*/ +#ifndef SQLITE_DISABLE_LFS +# define _LARGE_FILE 1 +# ifndef _FILE_OFFSET_BITS +# define _FILE_OFFSET_BITS 64 +# endif +# define _LARGEFILE_SOURCE 1 +#endif + +/* +** Temporary files are named starting with this prefix followed by 16 random +** alphanumeric characters, and no file extension. They are stored in the +** OS's standard temporary file directory, and are deleted prior to exit. +** If sqlite is being embedded in another program, you may wish to change the +** prefix to reflect your program's name, so that if your program exits +** prematurely, old temporary files can be easily identified. This can be done +** using -DTEMP_FILE_PREFIX=myprefix_ on the compiler command line. +*/ +#ifndef TEMP_FILE_PREFIX +# define TEMP_FILE_PREFIX "sqlite_" +#endif + +/* +** Figure out if we are dealing with Unix, Windows or MacOS. +** +** N.B. MacOS means Mac Classic (or Carbon). Treat Darwin (OS X) as Unix. +** The MacOS build is designed to use CodeWarrior (tested with v8) +*/ +#ifndef OS_UNIX +# ifndef OS_WIN +# ifndef OS_MAC +# if defined(__MACOS__) +# define OS_MAC 1 +# define OS_WIN 0 +# define OS_UNIX 0 +# elif defined(_WIN32) || defined(WIN32) || defined(__CYGWIN__) || defined(__MINGW32__) || defined(__BORLANDC__) +# define OS_MAC 0 +# define OS_WIN 1 +# define OS_UNIX 0 +# else +# define OS_MAC 0 +# define OS_WIN 0 +# define OS_UNIX 1 +# endif +# else +# define OS_WIN 0 +# define OS_UNIX 0 +# endif +# else +# define OS_MAC 0 +# define OS_UNIX 0 +# endif +#else +# define OS_MAC 0 +# ifndef OS_WIN +# define OS_WIN 0 +# endif +#endif + +/* +** A handle for an open file is stored in an OsFile object. +*/ +#if OS_UNIX +# include <sys/types.h> +# include <sys/stat.h> +# include <fcntl.h> +# include <unistd.h> + typedef struct OsFile OsFile; + struct OsFile { + struct openCnt *pOpen; /* Info about all open fd's on this inode */ + struct lockInfo *pLock; /* Info about locks on this inode */ + int fd; /* The file descriptor */ + int locked; /* True if this instance holds the lock */ + int dirfd; /* File descriptor for the directory */ + }; +# define SQLITE_TEMPNAME_SIZE 200 +# if defined(HAVE_USLEEP) && HAVE_USLEEP +# define SQLITE_MIN_SLEEP_MS 1 +# else +# define SQLITE_MIN_SLEEP_MS 1000 +# endif +#endif + +#if OS_WIN +#include <windows.h> +#include <winbase.h> + typedef struct OsFile OsFile; + struct OsFile { + HANDLE h; /* Handle for accessing the file */ + int locked; /* 0: unlocked, <0: write lock, >0: read lock */ + }; +# if defined(_MSC_VER) || defined(__BORLANDC__) + typedef __int64 off_t; +# else +# if !defined(_CYGWIN_TYPES_H) + typedef long long off_t; +# if defined(__MINGW32__) +# define _OFF_T_ +# endif +# endif +# endif +# define SQLITE_TEMPNAME_SIZE (MAX_PATH+50) +# define SQLITE_MIN_SLEEP_MS 1 +#endif + +#if OS_MAC +# include <unistd.h> +# include <Files.h> + typedef struct OsFile OsFile; + struct OsFile { + SInt16 refNum; /* Data fork/file reference number */ + SInt16 refNumRF; /* Resource fork reference number (for locking) */ + int locked; /* 0: unlocked, <0: write lock, >0: read lock */ + int delOnClose; /* True if file is to be deleted on close */ + char *pathToDel; /* Name of file to delete on close */ + }; +# ifdef _LARGE_FILE + typedef SInt64 off_t; +# else + typedef SInt32 off_t; +# endif +# define SQLITE_TEMPNAME_SIZE _MAX_PATH +# define SQLITE_MIN_SLEEP_MS 17 +#endif + +int sqliteOsDelete(const char*); +int sqliteOsFileExists(const char*); +int sqliteOsFileRename(const char*, const char*); +int sqliteOsOpenReadWrite(const char*, OsFile*, int*); +int sqliteOsOpenExclusive(const char*, OsFile*, int); +int sqliteOsOpenReadOnly(const char*, OsFile*); +int sqliteOsOpenDirectory(const char*, OsFile*); +int sqliteOsTempFileName(char*); +int sqliteOsClose(OsFile*); +int sqliteOsRead(OsFile*, void*, int amt); +int sqliteOsWrite(OsFile*, const void*, int amt); +int sqliteOsSeek(OsFile*, off_t offset); +int sqliteOsSync(OsFile*); +int sqliteOsTruncate(OsFile*, off_t size); +int sqliteOsFileSize(OsFile*, off_t *pSize); +int sqliteOsReadLock(OsFile*); +int sqliteOsWriteLock(OsFile*); +int sqliteOsUnlock(OsFile*); +int sqliteOsRandomSeed(char*); +int sqliteOsSleep(int ms); +int sqliteOsCurrentTime(double*); +void sqliteOsEnterMutex(void); +void sqliteOsLeaveMutex(void); +char *sqliteOsFullPathname(const char*); + + + +#endif /* _SQLITE_OS_H_ */ diff --git a/kexi/3rdparty/kexisql/src/pager.c b/kexi/3rdparty/kexisql/src/pager.c new file mode 100644 index 00000000..0ce24086 --- /dev/null +++ b/kexi/3rdparty/kexisql/src/pager.c @@ -0,0 +1,2220 @@ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This is the implementation of the page cache subsystem or "pager". +** +** The pager is used to access a database disk file. It implements +** atomic commit and rollback through the use of a journal file that +** is separate from the database file. The pager also implements file +** locking to prevent two processes from writing the same database +** file simultaneously, or one process from reading the database while +** another is writing. +** +** @(#) $Id: pager.c 410099 2005-05-06 17:52:07Z staniek $ +*/ +#include "os.h" /* Must be first to enable large file support */ +#include "sqliteInt.h" +#include "pager.h" +#include <assert.h> +#include <string.h> + +/* +** Macros for troubleshooting. Normally turned off +*/ +#if 0 +static Pager *mainPager = 0; +#define SET_PAGER(X) if( mainPager==0 ) mainPager = (X) +#define CLR_PAGER(X) if( mainPager==(X) ) mainPager = 0 +#define TRACE1(X) if( pPager==mainPager ) fprintf(stderr,X) +#define TRACE2(X,Y) if( pPager==mainPager ) fprintf(stderr,X,Y) +#define TRACE3(X,Y,Z) if( pPager==mainPager ) fprintf(stderr,X,Y,Z) +#else +#define SET_PAGER(X) +#define CLR_PAGER(X) +#define TRACE1(X) +#define TRACE2(X,Y) +#define TRACE3(X,Y,Z) +#endif + + +/* +** The page cache as a whole is always in one of the following +** states: +** +** SQLITE_UNLOCK The page cache is not currently reading or +** writing the database file. There is no +** data held in memory. This is the initial +** state. +** +** SQLITE_READLOCK The page cache is reading the database. +** Writing is not permitted. There can be +** multiple readers accessing the same database +** file at the same time. +** +** SQLITE_WRITELOCK The page cache is writing the database. +** Access is exclusive. No other processes or +** threads can be reading or writing while one +** process is writing. +** +** The page cache comes up in SQLITE_UNLOCK. The first time a +** sqlite_page_get() occurs, the state transitions to SQLITE_READLOCK. +** After all pages have been released using sqlite_page_unref(), +** the state transitions back to SQLITE_UNLOCK. The first time +** that sqlite_page_write() is called, the state transitions to +** SQLITE_WRITELOCK. (Note that sqlite_page_write() can only be +** called on an outstanding page which means that the pager must +** be in SQLITE_READLOCK before it transitions to SQLITE_WRITELOCK.) +** The sqlite_page_rollback() and sqlite_page_commit() functions +** transition the state from SQLITE_WRITELOCK back to SQLITE_READLOCK. +*/ +#define SQLITE_UNLOCK 0 +#define SQLITE_READLOCK 1 +#define SQLITE_WRITELOCK 2 + + +/* +** Each in-memory image of a page begins with the following header. +** This header is only visible to this pager module. The client +** code that calls pager sees only the data that follows the header. +** +** Client code should call sqlitepager_write() on a page prior to making +** any modifications to that page. The first time sqlitepager_write() +** is called, the original page contents are written into the rollback +** journal and PgHdr.inJournal and PgHdr.needSync are set. Later, once +** the journal page has made it onto the disk surface, PgHdr.needSync +** is cleared. The modified page cannot be written back into the original +** database file until the journal pages has been synced to disk and the +** PgHdr.needSync has been cleared. +** +** The PgHdr.dirty flag is set when sqlitepager_write() is called and +** is cleared again when the page content is written back to the original +** database file. +*/ +typedef struct PgHdr PgHdr; +struct PgHdr { + Pager *pPager; /* The pager to which this page belongs */ + Pgno pgno; /* The page number for this page */ + PgHdr *pNextHash, *pPrevHash; /* Hash collision chain for PgHdr.pgno */ + int nRef; /* Number of users of this page */ + PgHdr *pNextFree, *pPrevFree; /* Freelist of pages where nRef==0 */ + PgHdr *pNextAll, *pPrevAll; /* A list of all pages */ + PgHdr *pNextCkpt, *pPrevCkpt; /* List of pages in the checkpoint journal */ + u8 inJournal; /* TRUE if has been written to journal */ + u8 inCkpt; /* TRUE if written to the checkpoint journal */ + u8 dirty; /* TRUE if we need to write back changes */ + u8 needSync; /* Sync journal before writing this page */ + u8 alwaysRollback; /* Disable dont_rollback() for this page */ + PgHdr *pDirty; /* Dirty pages sorted by PgHdr.pgno */ + /* SQLITE_PAGE_SIZE bytes of page data follow this header */ + /* Pager.nExtra bytes of local data follow the page data */ +}; + + +/* +** A macro used for invoking the codec if there is one +*/ +#ifdef SQLITE_HAS_CODEC +# define CODEC(P,D,N,X) if( P->xCodec ){ P->xCodec(P->pCodecArg,D,N,X); } +#else +# define CODEC(P,D,N,X) +#endif + +/* +** Convert a pointer to a PgHdr into a pointer to its data +** and back again. +*/ +#define PGHDR_TO_DATA(P) ((void*)(&(P)[1])) +#define DATA_TO_PGHDR(D) (&((PgHdr*)(D))[-1]) +#define PGHDR_TO_EXTRA(P) ((void*)&((char*)(&(P)[1]))[SQLITE_PAGE_SIZE]) + +/* +** How big to make the hash table used for locating in-memory pages +** by page number. +*/ +#define N_PG_HASH 2048 + +/* +** Hash a page number +*/ +#define pager_hash(PN) ((PN)&(N_PG_HASH-1)) + +/* +** A open page cache is an instance of the following structure. +*/ +struct Pager { + char *zFilename; /* Name of the database file */ + char *zJournal; /* Name of the journal file */ + char *zDirectory; /* Directory hold database and journal files */ + OsFile fd, jfd; /* File descriptors for database and journal */ + OsFile cpfd; /* File descriptor for the checkpoint journal */ + int dbSize; /* Number of pages in the file */ + int origDbSize; /* dbSize before the current change */ + int ckptSize; /* Size of database (in pages) at ckpt_begin() */ + off_t ckptJSize; /* Size of journal at ckpt_begin() */ + int nRec; /* Number of pages written to the journal */ + u32 cksumInit; /* Quasi-random value added to every checksum */ + int ckptNRec; /* Number of records in the checkpoint journal */ + int nExtra; /* Add this many bytes to each in-memory page */ + void (*xDestructor)(void*); /* Call this routine when freeing pages */ + int nPage; /* Total number of in-memory pages */ + int nRef; /* Number of in-memory pages with PgHdr.nRef>0 */ + int mxPage; /* Maximum number of pages to hold in cache */ + int nHit, nMiss, nOvfl; /* Cache hits, missing, and LRU overflows */ + void (*xCodec)(void*,void*,Pgno,int); /* Routine for en/decoding data */ + void *pCodecArg; /* First argument to xCodec() */ + u8 journalOpen; /* True if journal file descriptors is valid */ + u8 journalStarted; /* True if header of journal is synced */ + u8 useJournal; /* Use a rollback journal on this file */ + u8 ckptOpen; /* True if the checkpoint journal is open */ + u8 ckptInUse; /* True we are in a checkpoint */ + u8 ckptAutoopen; /* Open ckpt journal when main journal is opened*/ + u8 noSync; /* Do not sync the journal if true */ + u8 fullSync; /* Do extra syncs of the journal for robustness */ + u8 state; /* SQLITE_UNLOCK, _READLOCK or _WRITELOCK */ + u8 errMask; /* One of several kinds of errors */ + u8 tempFile; /* zFilename is a temporary file */ + u8 readOnly; /* True for a read-only database */ + u8 needSync; /* True if an fsync() is needed on the journal */ + u8 dirtyFile; /* True if database file has changed in any way */ + u8 alwaysRollback; /* Disable dont_rollback() for all pages */ + u8 *aInJournal; /* One bit for each page in the database file */ + u8 *aInCkpt; /* One bit for each page in the database */ + PgHdr *pFirst, *pLast; /* List of free pages */ + PgHdr *pFirstSynced; /* First free page with PgHdr.needSync==0 */ + PgHdr *pAll; /* List of all pages */ + PgHdr *pCkpt; /* List of pages in the checkpoint journal */ + PgHdr *aHash[N_PG_HASH]; /* Hash table to map page number of PgHdr */ +}; + +/* +** These are bits that can be set in Pager.errMask. +*/ +#define PAGER_ERR_FULL 0x01 /* a write() failed */ +#define PAGER_ERR_MEM 0x02 /* malloc() failed */ +#define PAGER_ERR_LOCK 0x04 /* error in the locking protocol */ +#define PAGER_ERR_CORRUPT 0x08 /* database or journal corruption */ +#define PAGER_ERR_DISK 0x10 /* general disk I/O error - bad hard drive? */ + +/* +** The journal file contains page records in the following +** format. +** +** Actually, this structure is the complete page record for pager +** formats less than 3. Beginning with format 3, this record is surrounded +** by two checksums. +*/ +typedef struct PageRecord PageRecord; +struct PageRecord { + Pgno pgno; /* The page number */ + char aData[SQLITE_PAGE_SIZE]; /* Original data for page pgno */ +}; + +/* +** Journal files begin with the following magic string. The data +** was obtained from /dev/random. It is used only as a sanity check. +** +** There are three journal formats (so far). The 1st journal format writes +** 32-bit integers in the byte-order of the host machine. New +** formats writes integers as big-endian. All new journals use the +** new format, but we have to be able to read an older journal in order +** to rollback journals created by older versions of the library. +** +** The 3rd journal format (added for 2.8.0) adds additional sanity +** checking information to the journal. If the power fails while the +** journal is being written, semi-random garbage data might appear in +** the journal file after power is restored. If an attempt is then made +** to roll the journal back, the database could be corrupted. The additional +** sanity checking data is an attempt to discover the garbage in the +** journal and ignore it. +** +** The sanity checking information for the 3rd journal format consists +** of a 32-bit checksum on each page of data. The checksum covers both +** the page number and the SQLITE_PAGE_SIZE bytes of data for the page. +** This cksum is initialized to a 32-bit random value that appears in the +** journal file right after the header. The random initializer is important, +** because garbage data that appears at the end of a journal is likely +** data that was once in other files that have now been deleted. If the +** garbage data came from an obsolete journal file, the checksums might +** be correct. But by initializing the checksum to random value which +** is different for every journal, we minimize that risk. +*/ +static const unsigned char aJournalMagic1[] = { + 0xd9, 0xd5, 0x05, 0xf9, 0x20, 0xa1, 0x63, 0xd4, +}; +static const unsigned char aJournalMagic2[] = { + 0xd9, 0xd5, 0x05, 0xf9, 0x20, 0xa1, 0x63, 0xd5, +}; +static const unsigned char aJournalMagic3[] = { + 0xd9, 0xd5, 0x05, 0xf9, 0x20, 0xa1, 0x63, 0xd6, +}; +#define JOURNAL_FORMAT_1 1 +#define JOURNAL_FORMAT_2 2 +#define JOURNAL_FORMAT_3 3 + +/* +** The following integer determines what format to use when creating +** new primary journal files. By default we always use format 3. +** When testing, we can set this value to older journal formats in order to +** make sure that newer versions of the library are able to rollback older +** journal files. +** +** Note that checkpoint journals always use format 2 and omit the header. +*/ +#ifdef SQLITE_TEST +int journal_format = 3; +#else +# define journal_format 3 +#endif + +/* +** The size of the header and of each page in the journal varies according +** to which journal format is being used. The following macros figure out +** the sizes based on format numbers. +*/ +#define JOURNAL_HDR_SZ(X) \ + (sizeof(aJournalMagic1) + sizeof(Pgno) + ((X)>=3)*2*sizeof(u32)) +#define JOURNAL_PG_SZ(X) \ + (SQLITE_PAGE_SIZE + sizeof(Pgno) + ((X)>=3)*sizeof(u32)) + +/* +** Enable reference count tracking here: +*/ +#ifdef SQLITE_TEST + int pager_refinfo_enable = 0; + static void pager_refinfo(PgHdr *p){ + static int cnt = 0; + if( !pager_refinfo_enable ) return; + printf( + "REFCNT: %4d addr=0x%08x nRef=%d\n", + p->pgno, (int)PGHDR_TO_DATA(p), p->nRef + ); + cnt++; /* Something to set a breakpoint on */ + } +# define REFINFO(X) pager_refinfo(X) +#else +# define REFINFO(X) +#endif + +/* +** Read a 32-bit integer from the given file descriptor. Store the integer +** that is read in *pRes. Return SQLITE_OK if everything worked, or an +** error code is something goes wrong. +** +** If the journal format is 2 or 3, read a big-endian integer. If the +** journal format is 1, read an integer in the native byte-order of the +** host machine. +*/ +static int read32bits(int format, OsFile *fd, u32 *pRes){ + u32 res; + int rc; + rc = sqliteOsRead(fd, &res, sizeof(res)); + if( rc==SQLITE_OK && format>JOURNAL_FORMAT_1 ){ + unsigned char ac[4]; + memcpy(ac, &res, 4); + res = (ac[0]<<24) | (ac[1]<<16) | (ac[2]<<8) | ac[3]; + } + *pRes = res; + return rc; +} + +/* +** Write a 32-bit integer into the given file descriptor. Return SQLITE_OK +** on success or an error code is something goes wrong. +** +** If the journal format is 2 or 3, write the integer as 4 big-endian +** bytes. If the journal format is 1, write the integer in the native +** byte order. In normal operation, only formats 2 and 3 are used. +** Journal format 1 is only used for testing. +*/ +static int write32bits(OsFile *fd, u32 val){ + unsigned char ac[4]; + if( journal_format<=1 ){ + return sqliteOsWrite(fd, &val, 4); + } + ac[0] = (val>>24) & 0xff; + ac[1] = (val>>16) & 0xff; + ac[2] = (val>>8) & 0xff; + ac[3] = val & 0xff; + return sqliteOsWrite(fd, ac, 4); +} + +/* +** Write a 32-bit integer into a page header right before the +** page data. This will overwrite the PgHdr.pDirty pointer. +** +** The integer is big-endian for formats 2 and 3 and native byte order +** for journal format 1. +*/ +static void store32bits(u32 val, PgHdr *p, int offset){ + unsigned char *ac; + ac = &((unsigned char*)PGHDR_TO_DATA(p))[offset]; + if( journal_format<=1 ){ + memcpy(ac, &val, 4); + }else{ + ac[0] = (val>>24) & 0xff; + ac[1] = (val>>16) & 0xff; + ac[2] = (val>>8) & 0xff; + ac[3] = val & 0xff; + } +} + + +/* +** Convert the bits in the pPager->errMask into an approprate +** return code. +*/ +static int pager_errcode(Pager *pPager){ + int rc = SQLITE_OK; + if( pPager->errMask & PAGER_ERR_LOCK ) rc = SQLITE_PROTOCOL; + if( pPager->errMask & PAGER_ERR_DISK ) rc = SQLITE_IOERR; + if( pPager->errMask & PAGER_ERR_FULL ) rc = SQLITE_FULL; + if( pPager->errMask & PAGER_ERR_MEM ) rc = SQLITE_NOMEM; + if( pPager->errMask & PAGER_ERR_CORRUPT ) rc = SQLITE_CORRUPT; + return rc; +} + +/* +** Add or remove a page from the list of all pages that are in the +** checkpoint journal. +** +** The Pager keeps a separate list of pages that are currently in +** the checkpoint journal. This helps the sqlitepager_ckpt_commit() +** routine run MUCH faster for the common case where there are many +** pages in memory but only a few are in the checkpoint journal. +*/ +static void page_add_to_ckpt_list(PgHdr *pPg){ + Pager *pPager = pPg->pPager; + if( pPg->inCkpt ) return; + assert( pPg->pPrevCkpt==0 && pPg->pNextCkpt==0 ); + pPg->pPrevCkpt = 0; + if( pPager->pCkpt ){ + pPager->pCkpt->pPrevCkpt = pPg; + } + pPg->pNextCkpt = pPager->pCkpt; + pPager->pCkpt = pPg; + pPg->inCkpt = 1; +} +static void page_remove_from_ckpt_list(PgHdr *pPg){ + if( !pPg->inCkpt ) return; + if( pPg->pPrevCkpt ){ + assert( pPg->pPrevCkpt->pNextCkpt==pPg ); + pPg->pPrevCkpt->pNextCkpt = pPg->pNextCkpt; + }else{ + assert( pPg->pPager->pCkpt==pPg ); + pPg->pPager->pCkpt = pPg->pNextCkpt; + } + if( pPg->pNextCkpt ){ + assert( pPg->pNextCkpt->pPrevCkpt==pPg ); + pPg->pNextCkpt->pPrevCkpt = pPg->pPrevCkpt; + } + pPg->pNextCkpt = 0; + pPg->pPrevCkpt = 0; + pPg->inCkpt = 0; +} + +/* +** Find a page in the hash table given its page number. Return +** a pointer to the page or NULL if not found. +*/ +static PgHdr *pager_lookup(Pager *pPager, Pgno pgno){ + PgHdr *p = pPager->aHash[pager_hash(pgno)]; + while( p && p->pgno!=pgno ){ + p = p->pNextHash; + } + return p; +} + +/* +** Unlock the database and clear the in-memory cache. This routine +** sets the state of the pager back to what it was when it was first +** opened. Any outstanding pages are invalidated and subsequent attempts +** to access those pages will likely result in a coredump. +*/ +static void pager_reset(Pager *pPager){ + PgHdr *pPg, *pNext; + for(pPg=pPager->pAll; pPg; pPg=pNext){ + pNext = pPg->pNextAll; + sqliteFree(pPg); + } + pPager->pFirst = 0; + pPager->pFirstSynced = 0; + pPager->pLast = 0; + pPager->pAll = 0; + memset(pPager->aHash, 0, sizeof(pPager->aHash)); + pPager->nPage = 0; + if( pPager->state>=SQLITE_WRITELOCK ){ + sqlitepager_rollback(pPager); + } + sqliteOsUnlock(&pPager->fd); + pPager->state = SQLITE_UNLOCK; + pPager->dbSize = -1; + pPager->nRef = 0; + assert( pPager->journalOpen==0 ); +} + +/* +** When this routine is called, the pager has the journal file open and +** a write lock on the database. This routine releases the database +** write lock and acquires a read lock in its place. The journal file +** is deleted and closed. +** +** TODO: Consider keeping the journal file open for temporary databases. +** This might give a performance improvement on windows where opening +** a file is an expensive operation. +*/ +static int pager_unwritelock(Pager *pPager){ + int rc; + PgHdr *pPg; + if( pPager->state<SQLITE_WRITELOCK ) return SQLITE_OK; + sqlitepager_ckpt_commit(pPager); + if( pPager->ckptOpen ){ + sqliteOsClose(&pPager->cpfd); + pPager->ckptOpen = 0; + } + if( pPager->journalOpen ){ + sqliteOsClose(&pPager->jfd); + pPager->journalOpen = 0; + sqliteOsDelete(pPager->zJournal); + sqliteFree( pPager->aInJournal ); + pPager->aInJournal = 0; + for(pPg=pPager->pAll; pPg; pPg=pPg->pNextAll){ + pPg->inJournal = 0; + pPg->dirty = 0; + pPg->needSync = 0; + } + }else{ + assert( pPager->dirtyFile==0 || pPager->useJournal==0 ); + } + rc = sqliteOsReadLock(&pPager->fd); + if( rc==SQLITE_OK ){ + pPager->state = SQLITE_READLOCK; + }else{ + /* This can only happen if a process does a BEGIN, then forks and the + ** child process does the COMMIT. Because of the semantics of unix + ** file locking, the unlock will fail. + */ + pPager->state = SQLITE_UNLOCK; + } + return rc; +} + +/* +** Compute and return a checksum for the page of data. +** +** This is not a real checksum. It is really just the sum of the +** random initial value and the page number. We considered do a checksum +** of the database, but that was found to be too slow. +*/ +static u32 pager_cksum(Pager *pPager, Pgno pgno, const char *aData){ + u32 cksum = pPager->cksumInit + pgno; + return cksum; +} + +/* +** Read a single page from the journal file opened on file descriptor +** jfd. Playback this one page. +** +** There are three different journal formats. The format parameter determines +** which format is used by the journal that is played back. +*/ +static int pager_playback_one_page(Pager *pPager, OsFile *jfd, int format){ + int rc; + PgHdr *pPg; /* An existing page in the cache */ + PageRecord pgRec; + u32 cksum; + + rc = read32bits(format, jfd, &pgRec.pgno); + if( rc!=SQLITE_OK ) return rc; + rc = sqliteOsRead(jfd, &pgRec.aData, sizeof(pgRec.aData)); + if( rc!=SQLITE_OK ) return rc; + + /* Sanity checking on the page. This is more important that I originally + ** thought. If a power failure occurs while the journal is being written, + ** it could cause invalid data to be written into the journal. We need to + ** detect this invalid data (with high probability) and ignore it. + */ + if( pgRec.pgno==0 ){ + return SQLITE_DONE; + } + if( pgRec.pgno>(unsigned)pPager->dbSize ){ + return SQLITE_OK; + } + if( format>=JOURNAL_FORMAT_3 ){ + rc = read32bits(format, jfd, &cksum); + if( rc ) return rc; + if( pager_cksum(pPager, pgRec.pgno, pgRec.aData)!=cksum ){ + return SQLITE_DONE; + } + } + + /* Playback the page. Update the in-memory copy of the page + ** at the same time, if there is one. + */ + pPg = pager_lookup(pPager, pgRec.pgno); + TRACE2("PLAYBACK %d\n", pgRec.pgno); + sqliteOsSeek(&pPager->fd, (pgRec.pgno-1)*(off_t)SQLITE_PAGE_SIZE); + rc = sqliteOsWrite(&pPager->fd, pgRec.aData, SQLITE_PAGE_SIZE); + if( pPg ){ + /* No page should ever be rolled back that is in use, except for page + ** 1 which is held in use in order to keep the lock on the database + ** active. + */ + assert( pPg->nRef==0 || pPg->pgno==1 ); + memcpy(PGHDR_TO_DATA(pPg), pgRec.aData, SQLITE_PAGE_SIZE); + memset(PGHDR_TO_EXTRA(pPg), 0, pPager->nExtra); + pPg->dirty = 0; + pPg->needSync = 0; + CODEC(pPager, PGHDR_TO_DATA(pPg), pPg->pgno, 3); + } + return rc; +} + +/* +** Playback the journal and thus restore the database file to +** the state it was in before we started making changes. +** +** The journal file format is as follows: +** +** * 8 byte prefix. One of the aJournalMagic123 vectors defined +** above. The format of the journal file is determined by which +** of the three prefix vectors is seen. +** * 4 byte big-endian integer which is the number of valid page records +** in the journal. If this value is 0xffffffff, then compute the +** number of page records from the journal size. This field appears +** in format 3 only. +** * 4 byte big-endian integer which is the initial value for the +** sanity checksum. This field appears in format 3 only. +** * 4 byte integer which is the number of pages to truncate the +** database to during a rollback. +** * Zero or more pages instances, each as follows: +** + 4 byte page number. +** + SQLITE_PAGE_SIZE bytes of data. +** + 4 byte checksum (format 3 only) +** +** When we speak of the journal header, we mean the first 4 bullets above. +** Each entry in the journal is an instance of the 5th bullet. Note that +** bullets 2 and 3 only appear in format-3 journals. +** +** Call the value from the second bullet "nRec". nRec is the number of +** valid page entries in the journal. In most cases, you can compute the +** value of nRec from the size of the journal file. But if a power +** failure occurred while the journal was being written, it could be the +** case that the size of the journal file had already been increased but +** the extra entries had not yet made it safely to disk. In such a case, +** the value of nRec computed from the file size would be too large. For +** that reason, we always use the nRec value in the header. +** +** If the nRec value is 0xffffffff it means that nRec should be computed +** from the file size. This value is used when the user selects the +** no-sync option for the journal. A power failure could lead to corruption +** in this case. But for things like temporary table (which will be +** deleted when the power is restored) we don't care. +** +** Journal formats 1 and 2 do not have an nRec value in the header so we +** have to compute nRec from the file size. This has risks (as described +** above) which is why all persistent tables have been changed to use +** format 3. +** +** If the file opened as the journal file is not a well-formed +** journal file then the database will likely already be +** corrupted, so the PAGER_ERR_CORRUPT bit is set in pPager->errMask +** and SQLITE_CORRUPT is returned. If it all works, then this routine +** returns SQLITE_OK. +*/ +static int pager_playback(Pager *pPager, int useJournalSize){ + off_t szJ; /* Size of the journal file in bytes */ + int nRec; /* Number of Records in the journal */ + int i; /* Loop counter */ + Pgno mxPg = 0; /* Size of the original file in pages */ + int format; /* Format of the journal file. */ + unsigned char aMagic[sizeof(aJournalMagic1)]; + int rc; + + /* Figure out how many records are in the journal. Abort early if + ** the journal is empty. + */ + assert( pPager->journalOpen ); + sqliteOsSeek(&pPager->jfd, 0); + rc = sqliteOsFileSize(&pPager->jfd, &szJ); + if( rc!=SQLITE_OK ){ + goto end_playback; + } + + /* If the journal file is too small to contain a complete header, + ** it must mean that the process that created the journal was just + ** beginning to write the journal file when it died. In that case, + ** the database file should have still been completely unchanged. + ** Nothing needs to be rolled back. We can safely ignore this journal. + */ + if( szJ < sizeof(aMagic)+sizeof(Pgno) ){ + goto end_playback; + } + + /* Read the beginning of the journal and truncate the + ** database file back to its original size. + */ + rc = sqliteOsRead(&pPager->jfd, aMagic, sizeof(aMagic)); + if( rc!=SQLITE_OK ){ + rc = SQLITE_PROTOCOL; + goto end_playback; + } + if( memcmp(aMagic, aJournalMagic3, sizeof(aMagic))==0 ){ + format = JOURNAL_FORMAT_3; + }else if( memcmp(aMagic, aJournalMagic2, sizeof(aMagic))==0 ){ + format = JOURNAL_FORMAT_2; + }else if( memcmp(aMagic, aJournalMagic1, sizeof(aMagic))==0 ){ + format = JOURNAL_FORMAT_1; + }else{ + rc = SQLITE_PROTOCOL; + goto end_playback; + } + if( format>=JOURNAL_FORMAT_3 ){ + if( szJ < sizeof(aMagic) + 3*sizeof(u32) ){ + /* Ignore the journal if it is too small to contain a complete + ** header. We already did this test once above, but at the prior + ** test, we did not know the journal format and so we had to assume + ** the smallest possible header. Now we know the header is bigger + ** than the minimum so we test again. + */ + goto end_playback; + } + rc = read32bits(format, &pPager->jfd, (u32*)&nRec); + if( rc ) goto end_playback; + rc = read32bits(format, &pPager->jfd, &pPager->cksumInit); + if( rc ) goto end_playback; + if( nRec==0xffffffff || useJournalSize ){ + nRec = (szJ - JOURNAL_HDR_SZ(3))/JOURNAL_PG_SZ(3); + } + }else{ + nRec = (szJ - JOURNAL_HDR_SZ(2))/JOURNAL_PG_SZ(2); + assert( nRec*JOURNAL_PG_SZ(2)+JOURNAL_HDR_SZ(2)==szJ ); + } + rc = read32bits(format, &pPager->jfd, &mxPg); + if( rc!=SQLITE_OK ){ + goto end_playback; + } + assert( pPager->origDbSize==0 || pPager->origDbSize==mxPg ); + rc = sqliteOsTruncate(&pPager->fd, SQLITE_PAGE_SIZE*(off_t)mxPg); + if( rc!=SQLITE_OK ){ + goto end_playback; + } + pPager->dbSize = mxPg; + + /* Copy original pages out of the journal and back into the database file. + */ + for(i=0; i<nRec; i++){ + rc = pager_playback_one_page(pPager, &pPager->jfd, format); + if( rc!=SQLITE_OK ){ + if( rc==SQLITE_DONE ){ + rc = SQLITE_OK; + } + break; + } + } + + /* Pages that have been written to the journal but never synced + ** where not restored by the loop above. We have to restore those + ** pages by reading them back from the original database. + */ + if( rc==SQLITE_OK ){ + PgHdr *pPg; + for(pPg=pPager->pAll; pPg; pPg=pPg->pNextAll){ + char zBuf[SQLITE_PAGE_SIZE]; + if( !pPg->dirty ) continue; + if( (int)pPg->pgno <= pPager->origDbSize ){ + sqliteOsSeek(&pPager->fd, SQLITE_PAGE_SIZE*(off_t)(pPg->pgno-1)); + rc = sqliteOsRead(&pPager->fd, zBuf, SQLITE_PAGE_SIZE); + TRACE2("REFETCH %d\n", pPg->pgno); + CODEC(pPager, zBuf, pPg->pgno, 2); + if( rc ) break; + }else{ + memset(zBuf, 0, SQLITE_PAGE_SIZE); + } + if( pPg->nRef==0 || memcmp(zBuf, PGHDR_TO_DATA(pPg), SQLITE_PAGE_SIZE) ){ + memcpy(PGHDR_TO_DATA(pPg), zBuf, SQLITE_PAGE_SIZE); + memset(PGHDR_TO_EXTRA(pPg), 0, pPager->nExtra); + } + pPg->needSync = 0; + pPg->dirty = 0; + } + } + +end_playback: + if( rc!=SQLITE_OK ){ + pager_unwritelock(pPager); + pPager->errMask |= PAGER_ERR_CORRUPT; + rc = SQLITE_CORRUPT; + }else{ + rc = pager_unwritelock(pPager); + } + return rc; +} + +/* +** Playback the checkpoint journal. +** +** This is similar to playing back the transaction journal but with +** a few extra twists. +** +** (1) The number of pages in the database file at the start of +** the checkpoint is stored in pPager->ckptSize, not in the +** journal file itself. +** +** (2) In addition to playing back the checkpoint journal, also +** playback all pages of the transaction journal beginning +** at offset pPager->ckptJSize. +*/ +static int pager_ckpt_playback(Pager *pPager){ + off_t szJ; /* Size of the full journal */ + int nRec; /* Number of Records */ + int i; /* Loop counter */ + int rc; + + /* Truncate the database back to its original size. + */ + rc = sqliteOsTruncate(&pPager->fd, SQLITE_PAGE_SIZE*(off_t)pPager->ckptSize); + pPager->dbSize = pPager->ckptSize; + + /* Figure out how many records are in the checkpoint journal. + */ + assert( pPager->ckptInUse && pPager->journalOpen ); + sqliteOsSeek(&pPager->cpfd, 0); + nRec = pPager->ckptNRec; + + /* Copy original pages out of the checkpoint journal and back into the + ** database file. Note that the checkpoint journal always uses format + ** 2 instead of format 3 since it does not need to be concerned with + ** power failures corrupting the journal and can thus omit the checksums. + */ + for(i=nRec-1; i>=0; i--){ + rc = pager_playback_one_page(pPager, &pPager->cpfd, 2); + assert( rc!=SQLITE_DONE ); + if( rc!=SQLITE_OK ) goto end_ckpt_playback; + } + + /* Figure out how many pages need to be copied out of the transaction + ** journal. + */ + rc = sqliteOsSeek(&pPager->jfd, pPager->ckptJSize); + if( rc!=SQLITE_OK ){ + goto end_ckpt_playback; + } + rc = sqliteOsFileSize(&pPager->jfd, &szJ); + if( rc!=SQLITE_OK ){ + goto end_ckpt_playback; + } + nRec = (szJ - pPager->ckptJSize)/JOURNAL_PG_SZ(journal_format); + for(i=nRec-1; i>=0; i--){ + rc = pager_playback_one_page(pPager, &pPager->jfd, journal_format); + if( rc!=SQLITE_OK ){ + assert( rc!=SQLITE_DONE ); + goto end_ckpt_playback; + } + } + +end_ckpt_playback: + if( rc!=SQLITE_OK ){ + pPager->errMask |= PAGER_ERR_CORRUPT; + rc = SQLITE_CORRUPT; + } + return rc; +} + +/* +** Change the maximum number of in-memory pages that are allowed. +** +** The maximum number is the absolute value of the mxPage parameter. +** If mxPage is negative, the noSync flag is also set. noSync bypasses +** calls to sqliteOsSync(). The pager runs much faster with noSync on, +** but if the operating system crashes or there is an abrupt power +** failure, the database file might be left in an inconsistent and +** unrepairable state. +*/ +void sqlitepager_set_cachesize(Pager *pPager, int mxPage){ + if( mxPage>=0 ){ + pPager->noSync = pPager->tempFile; + if( pPager->noSync==0 ) pPager->needSync = 0; + }else{ + pPager->noSync = 1; + mxPage = -mxPage; + } + if( mxPage>10 ){ + pPager->mxPage = mxPage; + } +} + +/* +** Adjust the robustness of the database to damage due to OS crashes +** or power failures by changing the number of syncs()s when writing +** the rollback journal. There are three levels: +** +** OFF sqliteOsSync() is never called. This is the default +** for temporary and transient files. +** +** NORMAL The journal is synced once before writes begin on the +** database. This is normally adequate protection, but +** it is theoretically possible, though very unlikely, +** that an inopertune power failure could leave the journal +** in a state which would cause damage to the database +** when it is rolled back. +** +** FULL The journal is synced twice before writes begin on the +** database (with some additional information - the nRec field +** of the journal header - being written in between the two +** syncs). If we assume that writing a +** single disk sector is atomic, then this mode provides +** assurance that the journal will not be corrupted to the +** point of causing damage to the database during rollback. +** +** Numeric values associated with these states are OFF==1, NORMAL=2, +** and FULL=3. +*/ +void sqlitepager_set_safety_level(Pager *pPager, int level){ + pPager->noSync = level==1 || pPager->tempFile; + pPager->fullSync = level==3 && !pPager->tempFile; + if( pPager->noSync==0 ) pPager->needSync = 0; +} + +/* +** Open a temporary file. Write the name of the file into zName +** (zName must be at least SQLITE_TEMPNAME_SIZE bytes long.) Write +** the file descriptor into *fd. Return SQLITE_OK on success or some +** other error code if we fail. +** +** The OS will automatically delete the temporary file when it is +** closed. +*/ +static int sqlitepager_opentemp(char *zFile, OsFile *fd){ + int cnt = 8; + int rc; + do{ + cnt--; + sqliteOsTempFileName(zFile); + rc = sqliteOsOpenExclusive(zFile, fd, 1); + }while( cnt>0 && rc!=SQLITE_OK ); + return rc; +} + +/* +** Create a new page cache and put a pointer to the page cache in *ppPager. +** The file to be cached need not exist. The file is not locked until +** the first call to sqlitepager_get() and is only held open until the +** last page is released using sqlitepager_unref(). +** +** If zFilename is NULL then a randomly-named temporary file is created +** and used as the file to be cached. The file will be deleted +** automatically when it is closed. +*/ +int sqlitepager_open( + Pager **ppPager, /* Return the Pager structure here */ + const char *zFilename, /* Name of the database file to open */ + int mxPage, /* Max number of in-memory cache pages */ + int nExtra, /* Extra bytes append to each in-memory page */ + int useJournal /* TRUE to use a rollback journal on this file */ +){ + Pager *pPager; + char *zFullPathname; + int nameLen; + OsFile fd; + int rc, i; + int tempFile; + int readOnly = 0; + char zTemp[SQLITE_TEMPNAME_SIZE]; + + *ppPager = 0; + if( sqlite_malloc_failed ){ + return SQLITE_NOMEM; + } + if( zFilename && zFilename[0] ){ + zFullPathname = sqliteOsFullPathname(zFilename); + rc = sqliteOsOpenReadWrite(zFullPathname, &fd, &readOnly); + tempFile = 0; + }else{ + rc = sqlitepager_opentemp(zTemp, &fd); + zFilename = zTemp; + zFullPathname = sqliteOsFullPathname(zFilename); + tempFile = 1; + } + if( sqlite_malloc_failed ){ + return SQLITE_NOMEM; + } + if( rc!=SQLITE_OK ){ + sqliteFree(zFullPathname); + return SQLITE_CANTOPEN; + } + nameLen = strlen(zFullPathname); + pPager = sqliteMalloc( sizeof(*pPager) + nameLen*3 + 30 ); + if( pPager==0 ){ + sqliteOsClose(&fd); + sqliteFree(zFullPathname); + return SQLITE_NOMEM; + } + SET_PAGER(pPager); + pPager->zFilename = (char*)&pPager[1]; + pPager->zDirectory = &pPager->zFilename[nameLen+1]; + pPager->zJournal = &pPager->zDirectory[nameLen+1]; + strcpy(pPager->zFilename, zFullPathname); + strcpy(pPager->zDirectory, zFullPathname); + for(i=nameLen; i>0 && pPager->zDirectory[i-1]!='/'; i--){} + if( i>0 ) pPager->zDirectory[i-1] = 0; + strcpy(pPager->zJournal, zFullPathname); + sqliteFree(zFullPathname); + strcpy(&pPager->zJournal[nameLen], "-journal"); + pPager->fd = fd; + pPager->journalOpen = 0; + pPager->useJournal = useJournal; + pPager->ckptOpen = 0; + pPager->ckptInUse = 0; + pPager->nRef = 0; + pPager->dbSize = -1; + pPager->ckptSize = 0; + pPager->ckptJSize = 0; + pPager->nPage = 0; + pPager->mxPage = mxPage>5 ? mxPage : 10; + pPager->state = SQLITE_UNLOCK; + pPager->errMask = 0; + pPager->tempFile = tempFile; + pPager->readOnly = readOnly; + pPager->needSync = 0; + pPager->noSync = pPager->tempFile || !useJournal; + pPager->pFirst = 0; + pPager->pFirstSynced = 0; + pPager->pLast = 0; + pPager->nExtra = nExtra; + memset(pPager->aHash, 0, sizeof(pPager->aHash)); + *ppPager = pPager; + return SQLITE_OK; +} + +/* +** Set the destructor for this pager. If not NULL, the destructor is called +** when the reference count on each page reaches zero. The destructor can +** be used to clean up information in the extra segment appended to each page. +** +** The destructor is not called as a result sqlitepager_close(). +** Destructors are only called by sqlitepager_unref(). +*/ +void sqlitepager_set_destructor(Pager *pPager, void (*xDesc)(void*)){ + pPager->xDestructor = xDesc; +} + +/* +** Return the total number of pages in the disk file associated with +** pPager. +*/ +int sqlitepager_pagecount(Pager *pPager){ + off_t n; + assert( pPager!=0 ); + if( pPager->dbSize>=0 ){ + return pPager->dbSize; + } + if( sqliteOsFileSize(&pPager->fd, &n)!=SQLITE_OK ){ + pPager->errMask |= PAGER_ERR_DISK; + return 0; + } + n /= SQLITE_PAGE_SIZE; + if( pPager->state!=SQLITE_UNLOCK ){ + pPager->dbSize = n; + } + return n; +} + +/* +** Forward declaration +*/ +static int syncJournal(Pager*); + +/* +** Truncate the file to the number of pages specified. +*/ +int sqlitepager_truncate(Pager *pPager, Pgno nPage){ + int rc; + if( pPager->dbSize<0 ){ + sqlitepager_pagecount(pPager); + } + if( pPager->errMask!=0 ){ + rc = pager_errcode(pPager); + return rc; + } + if( nPage>=(unsigned)pPager->dbSize ){ + return SQLITE_OK; + } + syncJournal(pPager); + rc = sqliteOsTruncate(&pPager->fd, SQLITE_PAGE_SIZE*(off_t)nPage); + if( rc==SQLITE_OK ){ + pPager->dbSize = nPage; + } + return rc; +} + +/* +** Shutdown the page cache. Free all memory and close all files. +** +** If a transaction was in progress when this routine is called, that +** transaction is rolled back. All outstanding pages are invalidated +** and their memory is freed. Any attempt to use a page associated +** with this page cache after this function returns will likely +** result in a coredump. +*/ +int sqlitepager_close(Pager *pPager){ + PgHdr *pPg, *pNext; + switch( pPager->state ){ + case SQLITE_WRITELOCK: { + sqlitepager_rollback(pPager); + sqliteOsUnlock(&pPager->fd); + assert( pPager->journalOpen==0 ); + break; + } + case SQLITE_READLOCK: { + sqliteOsUnlock(&pPager->fd); + break; + } + default: { + /* Do nothing */ + break; + } + } + for(pPg=pPager->pAll; pPg; pPg=pNext){ + pNext = pPg->pNextAll; + sqliteFree(pPg); + } + sqliteOsClose(&pPager->fd); + assert( pPager->journalOpen==0 ); + /* Temp files are automatically deleted by the OS + ** if( pPager->tempFile ){ + ** sqliteOsDelete(pPager->zFilename); + ** } + */ + CLR_PAGER(pPager); + if( pPager->zFilename!=(char*)&pPager[1] ){ + assert( 0 ); /* Cannot happen */ + sqliteFree(pPager->zFilename); + sqliteFree(pPager->zJournal); + sqliteFree(pPager->zDirectory); + } + sqliteFree(pPager); + return SQLITE_OK; +} + +/* +** Return the page number for the given page data. +*/ +Pgno sqlitepager_pagenumber(void *pData){ + PgHdr *p = DATA_TO_PGHDR(pData); + return p->pgno; +} + +/* +** Increment the reference count for a page. If the page is +** currently on the freelist (the reference count is zero) then +** remove it from the freelist. +*/ +#define page_ref(P) ((P)->nRef==0?_page_ref(P):(void)(P)->nRef++) +static void _page_ref(PgHdr *pPg){ + if( pPg->nRef==0 ){ + /* The page is currently on the freelist. Remove it. */ + if( pPg==pPg->pPager->pFirstSynced ){ + PgHdr *p = pPg->pNextFree; + while( p && p->needSync ){ p = p->pNextFree; } + pPg->pPager->pFirstSynced = p; + } + if( pPg->pPrevFree ){ + pPg->pPrevFree->pNextFree = pPg->pNextFree; + }else{ + pPg->pPager->pFirst = pPg->pNextFree; + } + if( pPg->pNextFree ){ + pPg->pNextFree->pPrevFree = pPg->pPrevFree; + }else{ + pPg->pPager->pLast = pPg->pPrevFree; + } + pPg->pPager->nRef++; + } + pPg->nRef++; + REFINFO(pPg); +} + +/* +** Increment the reference count for a page. The input pointer is +** a reference to the page data. +*/ +int sqlitepager_ref(void *pData){ + PgHdr *pPg = DATA_TO_PGHDR(pData); + page_ref(pPg); + return SQLITE_OK; +} + +/* +** Sync the journal. In other words, make sure all the pages that have +** been written to the journal have actually reached the surface of the +** disk. It is not safe to modify the original database file until after +** the journal has been synced. If the original database is modified before +** the journal is synced and a power failure occurs, the unsynced journal +** data would be lost and we would be unable to completely rollback the +** database changes. Database corruption would occur. +** +** This routine also updates the nRec field in the header of the journal. +** (See comments on the pager_playback() routine for additional information.) +** If the sync mode is FULL, two syncs will occur. First the whole journal +** is synced, then the nRec field is updated, then a second sync occurs. +** +** For temporary databases, we do not care if we are able to rollback +** after a power failure, so sync occurs. +** +** This routine clears the needSync field of every page current held in +** memory. +*/ +static int syncJournal(Pager *pPager){ + PgHdr *pPg; + int rc = SQLITE_OK; + + /* Sync the journal before modifying the main database + ** (assuming there is a journal and it needs to be synced.) + */ + if( pPager->needSync ){ + if( !pPager->tempFile ){ + assert( pPager->journalOpen ); + /* assert( !pPager->noSync ); // noSync might be set if synchronous + ** was turned off after the transaction was started. Ticket #615 */ +#ifndef NDEBUG + { + /* Make sure the pPager->nRec counter we are keeping agrees + ** with the nRec computed from the size of the journal file. + */ + off_t hdrSz, pgSz, jSz; + hdrSz = JOURNAL_HDR_SZ(journal_format); + pgSz = JOURNAL_PG_SZ(journal_format); + rc = sqliteOsFileSize(&pPager->jfd, &jSz); + if( rc!=0 ) return rc; + assert( pPager->nRec*pgSz+hdrSz==jSz ); + } +#endif + if( journal_format>=3 ){ + /* Write the nRec value into the journal file header */ + off_t szJ; + if( pPager->fullSync ){ + TRACE1("SYNC\n"); + rc = sqliteOsSync(&pPager->jfd); + if( rc!=0 ) return rc; + } + sqliteOsSeek(&pPager->jfd, sizeof(aJournalMagic1)); + rc = write32bits(&pPager->jfd, pPager->nRec); + if( rc ) return rc; + szJ = JOURNAL_HDR_SZ(journal_format) + + pPager->nRec*JOURNAL_PG_SZ(journal_format); + sqliteOsSeek(&pPager->jfd, szJ); + } + TRACE1("SYNC\n"); + rc = sqliteOsSync(&pPager->jfd); + if( rc!=0 ) return rc; + pPager->journalStarted = 1; + } + pPager->needSync = 0; + + /* Erase the needSync flag from every page. + */ + for(pPg=pPager->pAll; pPg; pPg=pPg->pNextAll){ + pPg->needSync = 0; + } + pPager->pFirstSynced = pPager->pFirst; + } + +#ifndef NDEBUG + /* If the Pager.needSync flag is clear then the PgHdr.needSync + ** flag must also be clear for all pages. Verify that this + ** invariant is true. + */ + else{ + for(pPg=pPager->pAll; pPg; pPg=pPg->pNextAll){ + assert( pPg->needSync==0 ); + } + assert( pPager->pFirstSynced==pPager->pFirst ); + } +#endif + + return rc; +} + +/* +** Given a list of pages (connected by the PgHdr.pDirty pointer) write +** every one of those pages out to the database file and mark them all +** as clean. +*/ +static int pager_write_pagelist(PgHdr *pList){ + Pager *pPager; + int rc; + + if( pList==0 ) return SQLITE_OK; + pPager = pList->pPager; + while( pList ){ + assert( pList->dirty ); + sqliteOsSeek(&pPager->fd, (pList->pgno-1)*(off_t)SQLITE_PAGE_SIZE); + CODEC(pPager, PGHDR_TO_DATA(pList), pList->pgno, 6); + TRACE2("STORE %d\n", pList->pgno); + rc = sqliteOsWrite(&pPager->fd, PGHDR_TO_DATA(pList), SQLITE_PAGE_SIZE); + CODEC(pPager, PGHDR_TO_DATA(pList), pList->pgno, 0); + if( rc ) return rc; + pList->dirty = 0; + pList = pList->pDirty; + } + return SQLITE_OK; +} + +/* +** Collect every dirty page into a dirty list and +** return a pointer to the head of that list. All pages are +** collected even if they are still in use. +*/ +static PgHdr *pager_get_all_dirty_pages(Pager *pPager){ + PgHdr *p, *pList; + pList = 0; + for(p=pPager->pAll; p; p=p->pNextAll){ + if( p->dirty ){ + p->pDirty = pList; + pList = p; + } + } + return pList; +} + +/* +** Acquire a page. +** +** A read lock on the disk file is obtained when the first page is acquired. +** This read lock is dropped when the last page is released. +** +** A _get works for any page number greater than 0. If the database +** file is smaller than the requested page, then no actual disk +** read occurs and the memory image of the page is initialized to +** all zeros. The extra data appended to a page is always initialized +** to zeros the first time a page is loaded into memory. +** +** The acquisition might fail for several reasons. In all cases, +** an appropriate error code is returned and *ppPage is set to NULL. +** +** See also sqlitepager_lookup(). Both this routine and _lookup() attempt +** to find a page in the in-memory cache first. If the page is not already +** in memory, this routine goes to disk to read it in whereas _lookup() +** just returns 0. This routine acquires a read-lock the first time it +** has to go to disk, and could also playback an old journal if necessary. +** Since _lookup() never goes to disk, it never has to deal with locks +** or journal files. +*/ +int sqlitepager_get(Pager *pPager, Pgno pgno, void **ppPage){ + PgHdr *pPg; + int rc; + + /* Make sure we have not hit any critical errors. + */ + assert( pPager!=0 ); + assert( pgno!=0 ); + *ppPage = 0; + if( pPager->errMask & ~(PAGER_ERR_FULL) ){ + return pager_errcode(pPager); + } + + /* If this is the first page accessed, then get a read lock + ** on the database file. + */ + if( pPager->nRef==0 ){ + rc = sqliteOsReadLock(&pPager->fd); + if( rc!=SQLITE_OK ){ + return rc; + } + pPager->state = SQLITE_READLOCK; + + /* If a journal file exists, try to play it back. + */ + if( pPager->useJournal && sqliteOsFileExists(pPager->zJournal) ){ + int rc; + + /* Get a write lock on the database + */ + rc = sqliteOsWriteLock(&pPager->fd); + if( rc!=SQLITE_OK ){ + if( sqliteOsUnlock(&pPager->fd)!=SQLITE_OK ){ + /* This should never happen! */ + rc = SQLITE_INTERNAL; + } + return rc; + } + pPager->state = SQLITE_WRITELOCK; + + /* Open the journal for reading only. Return SQLITE_BUSY if + ** we are unable to open the journal file. + ** + ** The journal file does not need to be locked itself. The + ** journal file is never open unless the main database file holds + ** a write lock, so there is never any chance of two or more + ** processes opening the journal at the same time. + */ + rc = sqliteOsOpenReadOnly(pPager->zJournal, &pPager->jfd); + if( rc!=SQLITE_OK ){ + rc = sqliteOsUnlock(&pPager->fd); + assert( rc==SQLITE_OK ); + return SQLITE_BUSY; + } + pPager->journalOpen = 1; + pPager->journalStarted = 0; + + /* Playback and delete the journal. Drop the database write + ** lock and reacquire the read lock. + */ + rc = pager_playback(pPager, 0); + if( rc!=SQLITE_OK ){ + return rc; + } + } + pPg = 0; + }else{ + /* Search for page in cache */ + pPg = pager_lookup(pPager, pgno); + } + if( pPg==0 ){ + /* The requested page is not in the page cache. */ + int h; + pPager->nMiss++; + if( pPager->nPage<pPager->mxPage || pPager->pFirst==0 ){ + /* Create a new page */ + pPg = sqliteMallocRaw( sizeof(*pPg) + SQLITE_PAGE_SIZE + + sizeof(u32) + pPager->nExtra ); + if( pPg==0 ){ + pager_unwritelock(pPager); + pPager->errMask |= PAGER_ERR_MEM; + return SQLITE_NOMEM; + } + memset(pPg, 0, sizeof(*pPg)); + pPg->pPager = pPager; + pPg->pNextAll = pPager->pAll; + if( pPager->pAll ){ + pPager->pAll->pPrevAll = pPg; + } + pPg->pPrevAll = 0; + pPager->pAll = pPg; + pPager->nPage++; + }else{ + /* Find a page to recycle. Try to locate a page that does not + ** require us to do an fsync() on the journal. + */ + pPg = pPager->pFirstSynced; + + /* If we could not find a page that does not require an fsync() + ** on the journal file then fsync the journal file. This is a + ** very slow operation, so we work hard to avoid it. But sometimes + ** it can't be helped. + */ + if( pPg==0 ){ + int rc = syncJournal(pPager); + if( rc!=0 ){ + sqlitepager_rollback(pPager); + return SQLITE_IOERR; + } + pPg = pPager->pFirst; + } + assert( pPg->nRef==0 ); + + /* Write the page to the database file if it is dirty. + */ + if( pPg->dirty ){ + assert( pPg->needSync==0 ); + pPg->pDirty = 0; + rc = pager_write_pagelist( pPg ); + if( rc!=SQLITE_OK ){ + sqlitepager_rollback(pPager); + return SQLITE_IOERR; + } + } + assert( pPg->dirty==0 ); + + /* If the page we are recycling is marked as alwaysRollback, then + ** set the global alwaysRollback flag, thus disabling the + ** sqlite_dont_rollback() optimization for the rest of this transaction. + ** It is necessary to do this because the page marked alwaysRollback + ** might be reloaded at a later time but at that point we won't remember + ** that is was marked alwaysRollback. This means that all pages must + ** be marked as alwaysRollback from here on out. + */ + if( pPg->alwaysRollback ){ + pPager->alwaysRollback = 1; + } + + /* Unlink the old page from the free list and the hash table + */ + if( pPg==pPager->pFirstSynced ){ + PgHdr *p = pPg->pNextFree; + while( p && p->needSync ){ p = p->pNextFree; } + pPager->pFirstSynced = p; + } + if( pPg->pPrevFree ){ + pPg->pPrevFree->pNextFree = pPg->pNextFree; + }else{ + assert( pPager->pFirst==pPg ); + pPager->pFirst = pPg->pNextFree; + } + if( pPg->pNextFree ){ + pPg->pNextFree->pPrevFree = pPg->pPrevFree; + }else{ + assert( pPager->pLast==pPg ); + pPager->pLast = pPg->pPrevFree; + } + pPg->pNextFree = pPg->pPrevFree = 0; + if( pPg->pNextHash ){ + pPg->pNextHash->pPrevHash = pPg->pPrevHash; + } + if( pPg->pPrevHash ){ + pPg->pPrevHash->pNextHash = pPg->pNextHash; + }else{ + h = pager_hash(pPg->pgno); + assert( pPager->aHash[h]==pPg ); + pPager->aHash[h] = pPg->pNextHash; + } + pPg->pNextHash = pPg->pPrevHash = 0; + pPager->nOvfl++; + } + pPg->pgno = pgno; + if( pPager->aInJournal && (int)pgno<=pPager->origDbSize ){ + sqliteCheckMemory(pPager->aInJournal, pgno/8); + assert( pPager->journalOpen ); + pPg->inJournal = (pPager->aInJournal[pgno/8] & (1<<(pgno&7)))!=0; + pPg->needSync = 0; + }else{ + pPg->inJournal = 0; + pPg->needSync = 0; + } + if( pPager->aInCkpt && (int)pgno<=pPager->ckptSize + && (pPager->aInCkpt[pgno/8] & (1<<(pgno&7)))!=0 ){ + page_add_to_ckpt_list(pPg); + }else{ + page_remove_from_ckpt_list(pPg); + } + pPg->dirty = 0; + pPg->nRef = 1; + REFINFO(pPg); + pPager->nRef++; + h = pager_hash(pgno); + pPg->pNextHash = pPager->aHash[h]; + pPager->aHash[h] = pPg; + if( pPg->pNextHash ){ + assert( pPg->pNextHash->pPrevHash==0 ); + pPg->pNextHash->pPrevHash = pPg; + } + if( pPager->nExtra>0 ){ + memset(PGHDR_TO_EXTRA(pPg), 0, pPager->nExtra); + } + if( pPager->dbSize<0 ) sqlitepager_pagecount(pPager); + if( pPager->errMask!=0 ){ + sqlitepager_unref(PGHDR_TO_DATA(pPg)); + rc = pager_errcode(pPager); + return rc; + } + if( pPager->dbSize<(int)pgno ){ + memset(PGHDR_TO_DATA(pPg), 0, SQLITE_PAGE_SIZE); + }else{ + int rc; + sqliteOsSeek(&pPager->fd, (pgno-1)*(off_t)SQLITE_PAGE_SIZE); + rc = sqliteOsRead(&pPager->fd, PGHDR_TO_DATA(pPg), SQLITE_PAGE_SIZE); + TRACE2("FETCH %d\n", pPg->pgno); + CODEC(pPager, PGHDR_TO_DATA(pPg), pPg->pgno, 3); + if( rc!=SQLITE_OK ){ + off_t fileSize; + if( sqliteOsFileSize(&pPager->fd,&fileSize)!=SQLITE_OK + || fileSize>=pgno*SQLITE_PAGE_SIZE ){ + sqlitepager_unref(PGHDR_TO_DATA(pPg)); + return rc; + }else{ + memset(PGHDR_TO_DATA(pPg), 0, SQLITE_PAGE_SIZE); + } + } + } + }else{ + /* The requested page is in the page cache. */ + pPager->nHit++; + page_ref(pPg); + } + *ppPage = PGHDR_TO_DATA(pPg); + return SQLITE_OK; +} + +/* +** Acquire a page if it is already in the in-memory cache. Do +** not read the page from disk. Return a pointer to the page, +** or 0 if the page is not in cache. +** +** See also sqlitepager_get(). The difference between this routine +** and sqlitepager_get() is that _get() will go to the disk and read +** in the page if the page is not already in cache. This routine +** returns NULL if the page is not in cache or if a disk I/O error +** has ever happened. +*/ +void *sqlitepager_lookup(Pager *pPager, Pgno pgno){ + PgHdr *pPg; + + assert( pPager!=0 ); + assert( pgno!=0 ); + if( pPager->errMask & ~(PAGER_ERR_FULL) ){ + return 0; + } + /* if( pPager->nRef==0 ){ + ** return 0; + ** } + */ + pPg = pager_lookup(pPager, pgno); + if( pPg==0 ) return 0; + page_ref(pPg); + return PGHDR_TO_DATA(pPg); +} + +/* +** Release a page. +** +** If the number of references to the page drop to zero, then the +** page is added to the LRU list. When all references to all pages +** are released, a rollback occurs and the lock on the database is +** removed. +*/ +int sqlitepager_unref(void *pData){ + PgHdr *pPg; + + /* Decrement the reference count for this page + */ + pPg = DATA_TO_PGHDR(pData); + assert( pPg->nRef>0 ); + pPg->nRef--; + REFINFO(pPg); + + /* When the number of references to a page reach 0, call the + ** destructor and add the page to the freelist. + */ + if( pPg->nRef==0 ){ + Pager *pPager; + pPager = pPg->pPager; + pPg->pNextFree = 0; + pPg->pPrevFree = pPager->pLast; + pPager->pLast = pPg; + if( pPg->pPrevFree ){ + pPg->pPrevFree->pNextFree = pPg; + }else{ + pPager->pFirst = pPg; + } + if( pPg->needSync==0 && pPager->pFirstSynced==0 ){ + pPager->pFirstSynced = pPg; + } + if( pPager->xDestructor ){ + pPager->xDestructor(pData); + } + + /* When all pages reach the freelist, drop the read lock from + ** the database file. + */ + pPager->nRef--; + assert( pPager->nRef>=0 ); + if( pPager->nRef==0 ){ + pager_reset(pPager); + } + } + return SQLITE_OK; +} + +/* +** Create a journal file for pPager. There should already be a write +** lock on the database file when this routine is called. +** +** Return SQLITE_OK if everything. Return an error code and release the +** write lock if anything goes wrong. +*/ +static int pager_open_journal(Pager *pPager){ + int rc; + assert( pPager->state==SQLITE_WRITELOCK ); + assert( pPager->journalOpen==0 ); + assert( pPager->useJournal ); + sqlitepager_pagecount(pPager); + pPager->aInJournal = sqliteMalloc( pPager->dbSize/8 + 1 ); + if( pPager->aInJournal==0 ){ + sqliteOsReadLock(&pPager->fd); + pPager->state = SQLITE_READLOCK; + return SQLITE_NOMEM; + } + rc = sqliteOsOpenExclusive(pPager->zJournal, &pPager->jfd,pPager->tempFile); + if( rc!=SQLITE_OK ){ + sqliteFree(pPager->aInJournal); + pPager->aInJournal = 0; + sqliteOsReadLock(&pPager->fd); + pPager->state = SQLITE_READLOCK; + return SQLITE_CANTOPEN; + } + sqliteOsOpenDirectory(pPager->zDirectory, &pPager->jfd); + pPager->journalOpen = 1; + pPager->journalStarted = 0; + pPager->needSync = 0; + pPager->alwaysRollback = 0; + pPager->nRec = 0; + if( pPager->errMask!=0 ){ + rc = pager_errcode(pPager); + return rc; + } + pPager->origDbSize = pPager->dbSize; + if( journal_format==JOURNAL_FORMAT_3 ){ + rc = sqliteOsWrite(&pPager->jfd, aJournalMagic3, sizeof(aJournalMagic3)); + if( rc==SQLITE_OK ){ + rc = write32bits(&pPager->jfd, pPager->noSync ? 0xffffffff : 0); + } + if( rc==SQLITE_OK ){ + sqliteRandomness(sizeof(pPager->cksumInit), &pPager->cksumInit); + rc = write32bits(&pPager->jfd, pPager->cksumInit); + } + }else if( journal_format==JOURNAL_FORMAT_2 ){ + rc = sqliteOsWrite(&pPager->jfd, aJournalMagic2, sizeof(aJournalMagic2)); + }else{ + assert( journal_format==JOURNAL_FORMAT_1 ); + rc = sqliteOsWrite(&pPager->jfd, aJournalMagic1, sizeof(aJournalMagic1)); + } + if( rc==SQLITE_OK ){ + rc = write32bits(&pPager->jfd, pPager->dbSize); + } + if( pPager->ckptAutoopen && rc==SQLITE_OK ){ + rc = sqlitepager_ckpt_begin(pPager); + } + if( rc!=SQLITE_OK ){ + rc = pager_unwritelock(pPager); + if( rc==SQLITE_OK ){ + rc = SQLITE_FULL; + } + } + return rc; +} + +/* +** Acquire a write-lock on the database. The lock is removed when +** the any of the following happen: +** +** * sqlitepager_commit() is called. +** * sqlitepager_rollback() is called. +** * sqlitepager_close() is called. +** * sqlitepager_unref() is called to on every outstanding page. +** +** The parameter to this routine is a pointer to any open page of the +** database file. Nothing changes about the page - it is used merely +** to acquire a pointer to the Pager structure and as proof that there +** is already a read-lock on the database. +** +** A journal file is opened if this is not a temporary file. For +** temporary files, the opening of the journal file is deferred until +** there is an actual need to write to the journal. +** +** If the database is already write-locked, this routine is a no-op. +*/ +int sqlitepager_begin(void *pData){ + PgHdr *pPg = DATA_TO_PGHDR(pData); + Pager *pPager = pPg->pPager; + int rc = SQLITE_OK; + assert( pPg->nRef>0 ); + assert( pPager->state!=SQLITE_UNLOCK ); + if( pPager->state==SQLITE_READLOCK ){ + assert( pPager->aInJournal==0 ); + rc = sqliteOsWriteLock(&pPager->fd); + if( rc!=SQLITE_OK ){ + return rc; + } + pPager->state = SQLITE_WRITELOCK; + pPager->dirtyFile = 0; + TRACE1("TRANSACTION\n"); + if( pPager->useJournal && !pPager->tempFile ){ + rc = pager_open_journal(pPager); + } + } + return rc; +} + +/* +** Mark a data page as writeable. The page is written into the journal +** if it is not there already. This routine must be called before making +** changes to a page. +** +** The first time this routine is called, the pager creates a new +** journal and acquires a write lock on the database. If the write +** lock could not be acquired, this routine returns SQLITE_BUSY. The +** calling routine must check for that return value and be careful not to +** change any page data until this routine returns SQLITE_OK. +** +** If the journal file could not be written because the disk is full, +** then this routine returns SQLITE_FULL and does an immediate rollback. +** All subsequent write attempts also return SQLITE_FULL until there +** is a call to sqlitepager_commit() or sqlitepager_rollback() to +** reset. +*/ +int sqlitepager_write(void *pData){ + PgHdr *pPg = DATA_TO_PGHDR(pData); + Pager *pPager = pPg->pPager; + int rc = SQLITE_OK; + + /* Check for errors + */ + if( pPager->errMask ){ + return pager_errcode(pPager); + } + if( pPager->readOnly ){ + return SQLITE_PERM; + } + + /* Mark the page as dirty. If the page has already been written + ** to the journal then we can return right away. + */ + pPg->dirty = 1; + if( pPg->inJournal && (pPg->inCkpt || pPager->ckptInUse==0) ){ + pPager->dirtyFile = 1; + return SQLITE_OK; + } + + /* If we get this far, it means that the page needs to be + ** written to the transaction journal or the ckeckpoint journal + ** or both. + ** + ** First check to see that the transaction journal exists and + ** create it if it does not. + */ + assert( pPager->state!=SQLITE_UNLOCK ); + rc = sqlitepager_begin(pData); + if( rc!=SQLITE_OK ){ + return rc; + } + assert( pPager->state==SQLITE_WRITELOCK ); + if( !pPager->journalOpen && pPager->useJournal ){ + rc = pager_open_journal(pPager); + if( rc!=SQLITE_OK ) return rc; + } + assert( pPager->journalOpen || !pPager->useJournal ); + pPager->dirtyFile = 1; + + /* The transaction journal now exists and we have a write lock on the + ** main database file. Write the current page to the transaction + ** journal if it is not there already. + */ + if( !pPg->inJournal && pPager->useJournal ){ + if( (int)pPg->pgno <= pPager->origDbSize ){ + int szPg; + u32 saved; + if( journal_format>=JOURNAL_FORMAT_3 ){ + u32 cksum = pager_cksum(pPager, pPg->pgno, pData); + saved = *(u32*)PGHDR_TO_EXTRA(pPg); + store32bits(cksum, pPg, SQLITE_PAGE_SIZE); + szPg = SQLITE_PAGE_SIZE+8; + }else{ + szPg = SQLITE_PAGE_SIZE+4; + } + store32bits(pPg->pgno, pPg, -4); + CODEC(pPager, pData, pPg->pgno, 7); + rc = sqliteOsWrite(&pPager->jfd, &((char*)pData)[-4], szPg); + TRACE3("JOURNAL %d %d\n", pPg->pgno, pPg->needSync); + CODEC(pPager, pData, pPg->pgno, 0); + if( journal_format>=JOURNAL_FORMAT_3 ){ + *(u32*)PGHDR_TO_EXTRA(pPg) = saved; + } + if( rc!=SQLITE_OK ){ + sqlitepager_rollback(pPager); + pPager->errMask |= PAGER_ERR_FULL; + return rc; + } + pPager->nRec++; + assert( pPager->aInJournal!=0 ); + pPager->aInJournal[pPg->pgno/8] |= 1<<(pPg->pgno&7); + pPg->needSync = !pPager->noSync; + pPg->inJournal = 1; + if( pPager->ckptInUse ){ + pPager->aInCkpt[pPg->pgno/8] |= 1<<(pPg->pgno&7); + page_add_to_ckpt_list(pPg); + } + }else{ + pPg->needSync = !pPager->journalStarted && !pPager->noSync; + TRACE3("APPEND %d %d\n", pPg->pgno, pPg->needSync); + } + if( pPg->needSync ){ + pPager->needSync = 1; + } + } + + /* If the checkpoint journal is open and the page is not in it, + ** then write the current page to the checkpoint journal. Note that + ** the checkpoint journal always uses the simplier format 2 that lacks + ** checksums. The header is also omitted from the checkpoint journal. + */ + if( pPager->ckptInUse && !pPg->inCkpt && (int)pPg->pgno<=pPager->ckptSize ){ + assert( pPg->inJournal || (int)pPg->pgno>pPager->origDbSize ); + store32bits(pPg->pgno, pPg, -4); + CODEC(pPager, pData, pPg->pgno, 7); + rc = sqliteOsWrite(&pPager->cpfd, &((char*)pData)[-4], SQLITE_PAGE_SIZE+4); + TRACE2("CKPT-JOURNAL %d\n", pPg->pgno); + CODEC(pPager, pData, pPg->pgno, 0); + if( rc!=SQLITE_OK ){ + sqlitepager_rollback(pPager); + pPager->errMask |= PAGER_ERR_FULL; + return rc; + } + pPager->ckptNRec++; + assert( pPager->aInCkpt!=0 ); + pPager->aInCkpt[pPg->pgno/8] |= 1<<(pPg->pgno&7); + page_add_to_ckpt_list(pPg); + } + + /* Update the database size and return. + */ + if( pPager->dbSize<(int)pPg->pgno ){ + pPager->dbSize = pPg->pgno; + } + return rc; +} + +/* +** Return TRUE if the page given in the argument was previously passed +** to sqlitepager_write(). In other words, return TRUE if it is ok +** to change the content of the page. +*/ +int sqlitepager_iswriteable(void *pData){ + PgHdr *pPg = DATA_TO_PGHDR(pData); + return pPg->dirty; +} + +/* +** Replace the content of a single page with the information in the third +** argument. +*/ +int sqlitepager_overwrite(Pager *pPager, Pgno pgno, void *pData){ + void *pPage; + int rc; + + rc = sqlitepager_get(pPager, pgno, &pPage); + if( rc==SQLITE_OK ){ + rc = sqlitepager_write(pPage); + if( rc==SQLITE_OK ){ + memcpy(pPage, pData, SQLITE_PAGE_SIZE); + } + sqlitepager_unref(pPage); + } + return rc; +} + +/* +** A call to this routine tells the pager that it is not necessary to +** write the information on page "pgno" back to the disk, even though +** that page might be marked as dirty. +** +** The overlying software layer calls this routine when all of the data +** on the given page is unused. The pager marks the page as clean so +** that it does not get written to disk. +** +** Tests show that this optimization, together with the +** sqlitepager_dont_rollback() below, more than double the speed +** of large INSERT operations and quadruple the speed of large DELETEs. +** +** When this routine is called, set the alwaysRollback flag to true. +** Subsequent calls to sqlitepager_dont_rollback() for the same page +** will thereafter be ignored. This is necessary to avoid a problem +** where a page with data is added to the freelist during one part of +** a transaction then removed from the freelist during a later part +** of the same transaction and reused for some other purpose. When it +** is first added to the freelist, this routine is called. When reused, +** the dont_rollback() routine is called. But because the page contains +** critical data, we still need to be sure it gets rolled back in spite +** of the dont_rollback() call. +*/ +void sqlitepager_dont_write(Pager *pPager, Pgno pgno){ + PgHdr *pPg; + + pPg = pager_lookup(pPager, pgno); + pPg->alwaysRollback = 1; + if( pPg && pPg->dirty ){ + if( pPager->dbSize==(int)pPg->pgno && pPager->origDbSize<pPager->dbSize ){ + /* If this pages is the last page in the file and the file has grown + ** during the current transaction, then do NOT mark the page as clean. + ** When the database file grows, we must make sure that the last page + ** gets written at least once so that the disk file will be the correct + ** size. If you do not write this page and the size of the file + ** on the disk ends up being too small, that can lead to database + ** corruption during the next transaction. + */ + }else{ + TRACE2("DONT_WRITE %d\n", pgno); + pPg->dirty = 0; + } + } +} + +/* +** A call to this routine tells the pager that if a rollback occurs, +** it is not necessary to restore the data on the given page. This +** means that the pager does not have to record the given page in the +** rollback journal. +*/ +void sqlitepager_dont_rollback(void *pData){ + PgHdr *pPg = DATA_TO_PGHDR(pData); + Pager *pPager = pPg->pPager; + + if( pPager->state!=SQLITE_WRITELOCK || pPager->journalOpen==0 ) return; + if( pPg->alwaysRollback || pPager->alwaysRollback ) return; + if( !pPg->inJournal && (int)pPg->pgno <= pPager->origDbSize ){ + assert( pPager->aInJournal!=0 ); + pPager->aInJournal[pPg->pgno/8] |= 1<<(pPg->pgno&7); + pPg->inJournal = 1; + if( pPager->ckptInUse ){ + pPager->aInCkpt[pPg->pgno/8] |= 1<<(pPg->pgno&7); + page_add_to_ckpt_list(pPg); + } + TRACE2("DONT_ROLLBACK %d\n", pPg->pgno); + } + if( pPager->ckptInUse && !pPg->inCkpt && (int)pPg->pgno<=pPager->ckptSize ){ + assert( pPg->inJournal || (int)pPg->pgno>pPager->origDbSize ); + assert( pPager->aInCkpt!=0 ); + pPager->aInCkpt[pPg->pgno/8] |= 1<<(pPg->pgno&7); + page_add_to_ckpt_list(pPg); + } +} + +/* +** Commit all changes to the database and release the write lock. +** +** If the commit fails for any reason, a rollback attempt is made +** and an error code is returned. If the commit worked, SQLITE_OK +** is returned. +*/ +int sqlitepager_commit(Pager *pPager){ + int rc; + PgHdr *pPg; + + if( pPager->errMask==PAGER_ERR_FULL ){ + rc = sqlitepager_rollback(pPager); + if( rc==SQLITE_OK ){ + rc = SQLITE_FULL; + } + return rc; + } + if( pPager->errMask!=0 ){ + rc = pager_errcode(pPager); + return rc; + } + if( pPager->state!=SQLITE_WRITELOCK ){ + return SQLITE_ERROR; + } + TRACE1("COMMIT\n"); + if( pPager->dirtyFile==0 ){ + /* Exit early (without doing the time-consuming sqliteOsSync() calls) + ** if there have been no changes to the database file. */ + assert( pPager->needSync==0 ); + rc = pager_unwritelock(pPager); + pPager->dbSize = -1; + return rc; + } + assert( pPager->journalOpen ); + rc = syncJournal(pPager); + if( rc!=SQLITE_OK ){ + goto commit_abort; + } + pPg = pager_get_all_dirty_pages(pPager); + if( pPg ){ + rc = pager_write_pagelist(pPg); + if( rc || (!pPager->noSync && sqliteOsSync(&pPager->fd)!=SQLITE_OK) ){ + goto commit_abort; + } + } + rc = pager_unwritelock(pPager); + pPager->dbSize = -1; + return rc; + + /* Jump here if anything goes wrong during the commit process. + */ +commit_abort: + rc = sqlitepager_rollback(pPager); + if( rc==SQLITE_OK ){ + rc = SQLITE_FULL; + } + return rc; +} + +/* +** Rollback all changes. The database falls back to read-only mode. +** All in-memory cache pages revert to their original data contents. +** The journal is deleted. +** +** This routine cannot fail unless some other process is not following +** the correct locking protocol (SQLITE_PROTOCOL) or unless some other +** process is writing trash into the journal file (SQLITE_CORRUPT) or +** unless a prior malloc() failed (SQLITE_NOMEM). Appropriate error +** codes are returned for all these occasions. Otherwise, +** SQLITE_OK is returned. +*/ +int sqlitepager_rollback(Pager *pPager){ + int rc; + TRACE1("ROLLBACK\n"); + if( !pPager->dirtyFile || !pPager->journalOpen ){ + rc = pager_unwritelock(pPager); + pPager->dbSize = -1; + return rc; + } + + if( pPager->errMask!=0 && pPager->errMask!=PAGER_ERR_FULL ){ + if( pPager->state>=SQLITE_WRITELOCK ){ + pager_playback(pPager, 1); + } + return pager_errcode(pPager); + } + if( pPager->state!=SQLITE_WRITELOCK ){ + return SQLITE_OK; + } + rc = pager_playback(pPager, 1); + if( rc!=SQLITE_OK ){ + rc = SQLITE_CORRUPT; + pPager->errMask |= PAGER_ERR_CORRUPT; + } + pPager->dbSize = -1; + return rc; +} + +/* +** Return TRUE if the database file is opened read-only. Return FALSE +** if the database is (in theory) writable. +*/ +int sqlitepager_isreadonly(Pager *pPager){ + return pPager->readOnly; +} + +/* +** This routine is used for testing and analysis only. +*/ +int *sqlitepager_stats(Pager *pPager){ + static int a[9]; + a[0] = pPager->nRef; + a[1] = pPager->nPage; + a[2] = pPager->mxPage; + a[3] = pPager->dbSize; + a[4] = pPager->state; + a[5] = pPager->errMask; + a[6] = pPager->nHit; + a[7] = pPager->nMiss; + a[8] = pPager->nOvfl; + return a; +} + +/* +** Set the checkpoint. +** +** This routine should be called with the transaction journal already +** open. A new checkpoint journal is created that can be used to rollback +** changes of a single SQL command within a larger transaction. +*/ +int sqlitepager_ckpt_begin(Pager *pPager){ + int rc; + char zTemp[SQLITE_TEMPNAME_SIZE]; + if( !pPager->journalOpen ){ + pPager->ckptAutoopen = 1; + return SQLITE_OK; + } + assert( pPager->journalOpen ); + assert( !pPager->ckptInUse ); + pPager->aInCkpt = sqliteMalloc( pPager->dbSize/8 + 1 ); + if( pPager->aInCkpt==0 ){ + sqliteOsReadLock(&pPager->fd); + return SQLITE_NOMEM; + } +#ifndef NDEBUG + rc = sqliteOsFileSize(&pPager->jfd, &pPager->ckptJSize); + if( rc ) goto ckpt_begin_failed; + assert( pPager->ckptJSize == + pPager->nRec*JOURNAL_PG_SZ(journal_format)+JOURNAL_HDR_SZ(journal_format) ); +#endif + pPager->ckptJSize = pPager->nRec*JOURNAL_PG_SZ(journal_format) + + JOURNAL_HDR_SZ(journal_format); + pPager->ckptSize = pPager->dbSize; + if( !pPager->ckptOpen ){ + rc = sqlitepager_opentemp(zTemp, &pPager->cpfd); + if( rc ) goto ckpt_begin_failed; + pPager->ckptOpen = 1; + pPager->ckptNRec = 0; + } + pPager->ckptInUse = 1; + return SQLITE_OK; + +ckpt_begin_failed: + if( pPager->aInCkpt ){ + sqliteFree(pPager->aInCkpt); + pPager->aInCkpt = 0; + } + return rc; +} + +/* +** Commit a checkpoint. +*/ +int sqlitepager_ckpt_commit(Pager *pPager){ + if( pPager->ckptInUse ){ + PgHdr *pPg, *pNext; + sqliteOsSeek(&pPager->cpfd, 0); + /* sqliteOsTruncate(&pPager->cpfd, 0); */ + pPager->ckptNRec = 0; + pPager->ckptInUse = 0; + sqliteFree( pPager->aInCkpt ); + pPager->aInCkpt = 0; + for(pPg=pPager->pCkpt; pPg; pPg=pNext){ + pNext = pPg->pNextCkpt; + assert( pPg->inCkpt ); + pPg->inCkpt = 0; + pPg->pPrevCkpt = pPg->pNextCkpt = 0; + } + pPager->pCkpt = 0; + } + pPager->ckptAutoopen = 0; + return SQLITE_OK; +} + +/* +** Rollback a checkpoint. +*/ +int sqlitepager_ckpt_rollback(Pager *pPager){ + int rc; + if( pPager->ckptInUse ){ + rc = pager_ckpt_playback(pPager); + sqlitepager_ckpt_commit(pPager); + }else{ + rc = SQLITE_OK; + } + pPager->ckptAutoopen = 0; + return rc; +} + +/* +** Return the full pathname of the database file. +*/ +const char *sqlitepager_filename(Pager *pPager){ + return pPager->zFilename; +} + +/* +** Set the codec for this pager +*/ +void sqlitepager_set_codec( + Pager *pPager, + void (*xCodec)(void*,void*,Pgno,int), + void *pCodecArg +){ + pPager->xCodec = xCodec; + pPager->pCodecArg = pCodecArg; +} + +#ifdef SQLITE_TEST +/* +** Print a listing of all referenced pages and their ref count. +*/ +void sqlitepager_refdump(Pager *pPager){ + PgHdr *pPg; + for(pPg=pPager->pAll; pPg; pPg=pPg->pNextAll){ + if( pPg->nRef<=0 ) continue; + printf("PAGE %3d addr=0x%08x nRef=%d\n", + pPg->pgno, (int)PGHDR_TO_DATA(pPg), pPg->nRef); + } +} +#endif diff --git a/kexi/3rdparty/kexisql/src/pager.h b/kexi/3rdparty/kexisql/src/pager.h new file mode 100644 index 00000000..b816a66f --- /dev/null +++ b/kexi/3rdparty/kexisql/src/pager.h @@ -0,0 +1,107 @@ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This header file defines the interface that the sqlite page cache +** subsystem. The page cache subsystem reads and writes a file a page +** at a time and provides a journal for rollback. +** +** @(#) $Id: pager.h 410099 2005-05-06 17:52:07Z staniek $ +*/ + +/* +** The size of one page +** +** You can change this value to another (reasonable) value you want. +** It need not be a power of two, though the interface to the disk +** will likely be faster if it is. +** +** Experiments show that a page size of 1024 gives the best speed +** for common usages. The speed differences for different sizes +** such as 512, 2048, 4096, an so forth, is minimal. Note, however, +** that changing the page size results in a completely imcompatible +** file format. +*/ +#ifndef SQLITE_PAGE_SIZE +#define SQLITE_PAGE_SIZE 1024 +#endif + +/* +** Number of extra bytes of data allocated at the end of each page and +** stored on disk but not used by the higher level btree layer. Changing +** this value results in a completely incompatible file format. +*/ +#ifndef SQLITE_PAGE_RESERVE +#define SQLITE_PAGE_RESERVE 0 +#endif + +/* +** The total number of usable bytes stored on disk for each page. +** The usable bytes come at the beginning of the page and the reserve +** bytes come at the end. +*/ +#define SQLITE_USABLE_SIZE (SQLITE_PAGE_SIZE-SQLITE_PAGE_RESERVE) + +/* +** Maximum number of pages in one database. (This is a limitation of +** imposed by 4GB files size limits.) +*/ +#define SQLITE_MAX_PAGE 1073741823 + +/* +** The type used to represent a page number. The first page in a file +** is called page 1. 0 is used to represent "not a page". +*/ +typedef unsigned int Pgno; + +/* +** Each open file is managed by a separate instance of the "Pager" structure. +*/ +typedef struct Pager Pager; + +/* +** See source code comments for a detailed description of the following +** routines: +*/ +int sqlitepager_open(Pager **ppPager, const char *zFilename, + int nPage, int nExtra, int useJournal); +void sqlitepager_set_destructor(Pager*, void(*)(void*)); +void sqlitepager_set_cachesize(Pager*, int); +int sqlitepager_close(Pager *pPager); +int sqlitepager_get(Pager *pPager, Pgno pgno, void **ppPage); +void *sqlitepager_lookup(Pager *pPager, Pgno pgno); +int sqlitepager_ref(void*); +int sqlitepager_unref(void*); +Pgno sqlitepager_pagenumber(void*); +int sqlitepager_write(void*); +int sqlitepager_iswriteable(void*); +int sqlitepager_overwrite(Pager *pPager, Pgno pgno, void*); +int sqlitepager_pagecount(Pager*); +int sqlitepager_truncate(Pager*,Pgno); +int sqlitepager_begin(void*); +int sqlitepager_commit(Pager*); +int sqlitepager_rollback(Pager*); +int sqlitepager_isreadonly(Pager*); +int sqlitepager_ckpt_begin(Pager*); +int sqlitepager_ckpt_commit(Pager*); +int sqlitepager_ckpt_rollback(Pager*); +void sqlitepager_dont_rollback(void*); +void sqlitepager_dont_write(Pager*, Pgno); +int *sqlitepager_stats(Pager*); +void sqlitepager_set_safety_level(Pager*,int); +const char *sqlitepager_filename(Pager*); +int sqlitepager_rename(Pager*, const char *zNewName); +void sqlitepager_set_codec(Pager*,void(*)(void*,void*,Pgno,int),void*); + +#ifdef SQLITE_TEST +void sqlitepager_refdump(Pager*); +int pager_refinfo_enable; +int journal_format; +#endif diff --git a/kexi/3rdparty/kexisql/src/parse.c b/kexi/3rdparty/kexisql/src/parse.c new file mode 100644 index 00000000..46353691 --- /dev/null +++ b/kexi/3rdparty/kexisql/src/parse.c @@ -0,0 +1,4035 @@ +/* Driver template for the LEMON parser generator. +** The author disclaims copyright to this source code. +*/ +/* First off, code is include which follows the "include" declaration +** in the input file. */ +#include <stdio.h> +#line 33 "parse.y" + +#include "sqliteInt.h" +#include "parse.h" + +/* +** An instance of this structure holds information about the +** LIMIT clause of a SELECT statement. +*/ +struct LimitVal { + int limit; /* The LIMIT value. -1 if there is no limit */ + int offset; /* The OFFSET. 0 if there is none */ +}; + +/* +** An instance of the following structure describes the event of a +** TRIGGER. "a" is the event type, one of TK_UPDATE, TK_INSERT, +** TK_DELETE, or TK_INSTEAD. If the event is of the form +** +** UPDATE ON (a,b,c) +** +** Then the "b" IdList records the list "a,b,c". +*/ +struct TrigEvent { int a; IdList * b; }; + + +#line 34 "parse.c" +/* Next is all token values, in a form suitable for use by makeheaders. +** This section will be null unless lemon is run with the -m switch. +*/ +/* +** These constants (all generated automatically by the parser generator) +** specify the various kinds of tokens (terminals) that the parser +** understands. +** +** Each symbol here is a terminal symbol in the grammar. +*/ +/* Make sure the INTERFACE macro is defined. +*/ +#ifndef INTERFACE +# define INTERFACE 1 +#endif +/* The next thing included is series of defines which control +** various aspects of the generated parser. +** YYCODETYPE is the data type used for storing terminal +** and nonterminal numbers. "unsigned char" is +** used if there are fewer than 250 terminals +** and nonterminals. "int" is used otherwise. +** YYNOCODE is a number of type YYCODETYPE which corresponds +** to no legal terminal or nonterminal number. This +** number is used to fill in empty slots of the hash +** table. +** YYFALLBACK If defined, this indicates that one or more tokens +** have fall-back values which should be used if the +** original value of the token will not parse. +** YYACTIONTYPE is the data type used for storing terminal +** and nonterminal numbers. "unsigned char" is +** used if there are fewer than 250 rules and +** states combined. "int" is used otherwise. +** sqliteParserTOKENTYPE is the data type used for minor tokens given +** directly to the parser from the tokenizer. +** YYMINORTYPE is the data type used for all minor tokens. +** This is typically a union of many types, one of +** which is sqliteParserTOKENTYPE. The entry in the union +** for base tokens is called "yy0". +** YYSTACKDEPTH is the maximum depth of the parser's stack. +** sqliteParserARG_SDECL A static variable declaration for the %extra_argument +** sqliteParserARG_PDECL A parameter declaration for the %extra_argument +** sqliteParserARG_STORE Code to store %extra_argument into yypParser +** sqliteParserARG_FETCH Code to extract %extra_argument from yypParser +** YYNSTATE the combined number of states. +** YYNRULE the number of rules in the grammar +** YYERRORSYMBOL is the code number of the error symbol. If not +** defined, then do no error processing. +*/ +/* */ +#define YYCODETYPE unsigned char +#define YYNOCODE 221 +#define YYACTIONTYPE unsigned short int +#define sqliteParserTOKENTYPE Token +typedef union { + 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; +} 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 YYFALLBACK 1 +#define YY_NO_ACTION (YYNSTATE+YYNRULE+2) +#define YY_ACCEPT_ACTION (YYNSTATE+YYNRULE+1) +#define YY_ERROR_ACTION (YYNSTATE+YYNRULE) + +/* Next are that tables used to determine what action to take based on the +** current state and lookahead token. These tables are used to implement +** functions that take a state number and lookahead value and return an +** action integer. +** +** Suppose the action integer is N. Then the action is determined as +** follows +** +** 0 <= N < YYNSTATE Shift N. That is, push the lookahead +** token onto the stack and goto state N. +** +** YYNSTATE <= N < YYNSTATE+YYNRULE Reduce by rule N-YYNSTATE. +** +** N == YYNSTATE+YYNRULE A syntax error has occurred. +** +** N == YYNSTATE+YYNRULE+1 The parser accepts its input. +** +** N == YYNSTATE+YYNRULE+2 No such action. Denotes unused +** slots in the yy_action[] table. +** +** The action table is constructed as a single large table named yy_action[]. +** Given state S and lookahead X, the action is computed as +** +** yy_action[ yy_shift_ofst[S] + X ] +** +** If the index value yy_shift_ofst[S]+X is out of range or if the value +** yy_lookahead[yy_shift_ofst[S]+X] is not equal to X or if yy_shift_ofst[S] +** is equal to YY_SHIFT_USE_DFLT, it means that the action is not in the table +** and that yy_default[S] should be used instead. +** +** The formula above is for computing the action when the lookahead is +** a terminal symbol. If the lookahead is a non-terminal (as occurs after +** a reduce action) then the yy_reduce_ofst[] array is used in place of +** the yy_shift_ofst[] array and YY_REDUCE_USE_DFLT is used in place of +** YY_SHIFT_USE_DFLT. +** +** The following are the tables generated in this section: +** +** yy_action[] A single table containing all actions. +** yy_lookahead[] A table containing the lookahead for each entry in +** yy_action. Used to detect hash collisions. +** yy_shift_ofst[] For each state, the offset into yy_action for +** shifting terminals. +** yy_reduce_ofst[] For each state, the offset into yy_action for +** shifting non-terminals after a reduce. +** yy_default[] Default action for each state. +*/ +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 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, +}; +#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_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, +}; +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, +}; +#define YY_SZ_ACTTAB (sizeof(yy_action)/sizeof(yy_action[0])) + +/* The next table maps tokens into fallback tokens. If a construct +** like the following: +** +** %fallback ID X Y Z. +** +** appears in the grammer, then ID becomes a fallback token for X, Y, +** and Z. Whenever one of the tokens X, Y, or Z is input to the parser +** but it does not parse, the type of the token is changed to ID and +** the parse is retried before an error is thrown. +*/ +#ifdef YYFALLBACK +static const YYCODETYPE yyFallback[] = { + 0, /* $ => nothing */ + 0, /* END_OF_FILE => nothing */ + 0, /* ILLEGAL => nothing */ + 0, /* SPACE => nothing */ + 0, /* UNCLOSED_STRING => nothing */ + 0, /* COMMENT => nothing */ + 0, /* FUNCTION => nothing */ + 0, /* COLUMN => nothing */ + 0, /* AGG_FUNCTION => nothing */ + 0, /* SEMI => nothing */ + 23, /* EXPLAIN => ID */ + 23, /* BEGIN => ID */ + 0, /* TRANSACTION => nothing */ + 0, /* COMMIT => nothing */ + 23, /* END => ID */ + 0, /* ROLLBACK => nothing */ + 0, /* CREATE => nothing */ + 0, /* TABLE => nothing */ + 23, /* TEMP => ID */ + 0, /* LP => nothing */ + 0, /* RP => nothing */ + 0, /* AS => nothing */ + 0, /* COMMA => nothing */ + 0, /* ID => nothing */ + 23, /* ABORT => ID */ + 23, /* AFTER => ID */ + 23, /* ASC => ID */ + 23, /* ATTACH => ID */ + 23, /* BEFORE => ID */ + 23, /* CASCADE => ID */ + 23, /* CLUSTER => ID */ + 23, /* CONFLICT => ID */ + 23, /* COPY => ID */ + 23, /* DATABASE => ID */ + 23, /* DEFERRED => ID */ + 23, /* DELIMITERS => ID */ + 23, /* DESC => ID */ + 23, /* DETACH => ID */ + 23, /* EACH => ID */ + 23, /* FAIL => ID */ + 23, /* FOR => ID */ + 23, /* GLOB => ID */ + 23, /* IGNORE => ID */ + 23, /* IMMEDIATE => ID */ + 23, /* INITIALLY => ID */ + 23, /* INSTEAD => ID */ + 23, /* LIKE => ID */ + 23, /* MATCH => ID */ + 23, /* KEY => ID */ + 23, /* OF => ID */ + 23, /* OFFSET => ID */ + 23, /* PRAGMA => ID */ + 23, /* RAISE => ID */ + 23, /* REPLACE => ID */ + 23, /* RESTRICT => ID */ + 23, /* ROW => ID */ + 23, /* STATEMENT => ID */ + 23, /* TRIGGER => ID */ + 23, /* VACUUM => ID */ + 23, /* VIEW => ID */ + 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, /* GT => nothing */ + 0, /* GE => nothing */ + 0, /* LT => nothing */ + 0, /* LE => nothing */ + 0, /* BITAND => nothing */ + 0, /* BITOR => nothing */ + 0, /* LSHIFT => nothing */ + 0, /* RSHIFT => nothing */ + 0, /* PLUS => nothing */ + 0, /* MINUS => nothing */ + 0, /* STAR => nothing */ + 0, /* SLASH => nothing */ + 0, /* REM => nothing */ + 0, /* CONCAT => nothing */ + 0, /* UMINUS => nothing */ + 0, /* UPLUS => nothing */ + 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, /* ON => nothing */ + 0, /* DELETE => nothing */ + 0, /* UPDATE => nothing */ + 0, /* INSERT => nothing */ + 0, /* SET => nothing */ + 0, /* DEFERRABLE => nothing */ + 0, /* FOREIGN => nothing */ + 0, /* DROP => nothing */ + 0, /* UNION => nothing */ + 0, /* ALL => nothing */ + 0, /* INTERSECT => nothing */ + 0, /* EXCEPT => nothing */ + 0, /* SELECT => nothing */ + 0, /* DISTINCT => nothing */ + 0, /* DOT => nothing */ + 0, /* FROM => nothing */ + 0, /* JOIN => nothing */ + 0, /* USING => nothing */ + 0, /* ORDER => nothing */ + 0, /* BY => nothing */ + 0, /* GROUP => nothing */ + 0, /* HAVING => nothing */ + 0, /* LIMIT => nothing */ + 0, /* WHERE => nothing */ + 0, /* INTO => nothing */ + 0, /* VALUES => nothing */ + 0, /* VARIABLE => nothing */ + 0, /* CASE => nothing */ + 0, /* WHEN => nothing */ + 0, /* THEN => nothing */ + 0, /* ELSE => nothing */ + 0, /* INDEX => nothing */ +}; +#endif /* YYFALLBACK */ + +/* The following structure represents a single element of the +** parser's stack. Information stored includes: +** +** + The state number for the parser at this level of the stack. +** +** + The value of the token stored at this level of the stack. +** (In other words, the "major" token.) +** +** + The semantic value stored at this level of the stack. This is +** the information used by the action routines in the grammar. +** It is sometimes called the "minor" token. +*/ +struct yyStackEntry { + int stateno; /* The state-number */ + int major; /* The major token value. This is the code + ** number for the token at this stack level */ + YYMINORTYPE minor; /* The user-supplied minor token value. This + ** is the value of the token */ +}; +typedef struct yyStackEntry yyStackEntry; + +/* The state of the parser is completely contained in an instance of +** the following structure */ +struct yyParser { + int yyidx; /* Index of top element in stack */ + int yyerrcnt; /* Shifts left before out of the error */ + sqliteParserARG_SDECL /* A place to hold %extra_argument */ + yyStackEntry yystack[YYSTACKDEPTH]; /* The parser's stack */ +}; +typedef struct yyParser yyParser; + +#ifndef NDEBUG +#include <stdio.h> +static FILE *yyTraceFILE = 0; +static char *yyTracePrompt = 0; +#endif /* NDEBUG */ + +#ifndef NDEBUG +/* +** Turn parser tracing on by giving a stream to which to write the trace +** and a prompt to preface each trace message. Tracing is turned off +** by making either argument NULL +** +** Inputs: +** <ul> +** <li> A FILE* to which trace output should be written. +** If NULL, then tracing is turned off. +** <li> A prefix string written at the beginning of every +** line of trace output. If NULL, then tracing is +** turned off. +** </ul> +** +** Outputs: +** None. +*/ +void sqliteParserTrace(FILE *TraceFILE, char *zTracePrompt){ + yyTraceFILE = TraceFILE; + yyTracePrompt = zTracePrompt; + if( yyTraceFILE==0 ) yyTracePrompt = 0; + else if( yyTracePrompt==0 ) yyTraceFILE = 0; +} +#endif /* NDEBUG */ + +#ifndef NDEBUG +/* For tracing shifts, the names of all terminals and nonterminals +** are required. The following table supplies these names */ +static const char *yyTokenName[] = { + "$", "END_OF_FILE", "ILLEGAL", "SPACE", + "UNCLOSED_STRING", "COMMENT", "FUNCTION", "COLUMN", + "AGG_FUNCTION", "SEMI", "EXPLAIN", "BEGIN", + "TRANSACTION", "COMMIT", "END", "ROLLBACK", + "CREATE", "TABLE", "TEMP", "LP", + "RP", "AS", "COMMA", "ID", + "ABORT", "AFTER", "ASC", "ATTACH", + "BEFORE", "CASCADE", "CLUSTER", "CONFLICT", + "COPY", "DATABASE", "DEFERRED", "DELIMITERS", + "DESC", "DETACH", "EACH", "FAIL", + "FOR", "GLOB", "IGNORE", "IMMEDIATE", + "INITIALLY", "INSTEAD", "LIKE", "MATCH", + "KEY", "OF", "OFFSET", "PRAGMA", + "RAISE", "REPLACE", "RESTRICT", "ROW", + "STATEMENT", "TRIGGER", "VACUUM", "VIEW", + "OR", "AND", "NOT", "EQ", + "NE", "ISNULL", "NOTNULL", "IS", + "BETWEEN", "IN", "GT", "GE", + "LT", "LE", "BITAND", "BITOR", + "LSHIFT", "RSHIFT", "PLUS", "MINUS", + "STAR", "SLASH", "REM", "CONCAT", + "UMINUS", "UPLUS", "BITNOT", "STRING", + "JOIN_KW", "INTEGER", "CONSTRAINT", "DEFAULT", + "FLOAT", "NULL", "PRIMARY", "UNIQUE", + "CHECK", "REFERENCES", "COLLATE", "ON", + "DELETE", "UPDATE", "INSERT", "SET", + "DEFERRABLE", "FOREIGN", "DROP", "UNION", + "ALL", "INTERSECT", "EXCEPT", "SELECT", + "DISTINCT", "DOT", "FROM", "JOIN", + "USING", "ORDER", "BY", "GROUP", + "HAVING", "LIMIT", "WHERE", "INTO", + "VALUES", "VARIABLE", "CASE", "WHEN", + "THEN", "ELSE", "INDEX", "error", + "input", "cmdlist", "ecmd", "explain", + "cmdx", "cmd", "trans_opt", "onconf", + "nm", "create_table", "create_table_args", "temp", + "columnlist", "conslist_opt", "select", "column", + "columnid", "type", "carglist", "id", + "ids", "typename", "signed", "carg", + "ccons", "sortorder", "expr", "idxlist_opt", + "refargs", "defer_subclause", "refarg", "refact", + "init_deferred_pred_opt", "conslist", "tcons", "idxlist", + "defer_subclause_opt", "orconf", "resolvetype", "oneselect", + "multiselect_op", "distinct", "selcollist", "from", + "where_opt", "groupby_opt", "having_opt", "orderby_opt", + "limit_opt", "sclp", "as", "seltablist", + "stl_prefix", "joinop", "dbnm", "on_opt", + "using_opt", "seltablist_paren", "joinop2", "sortlist", + "sortitem", "collate", "exprlist", "setlist", + "insert_cmd", "inscollist_opt", "itemlist", "inscollist", + "likeop", "case_operand", "case_exprlist", "case_else", + "expritem", "uniqueflag", "idxitem", "plus_num", + "minus_num", "plus_opt", "number", "trigger_decl", + "trigger_cmd_list", "trigger_time", "trigger_event", "foreach_clause", + "when_clause", "trigger_cmd", "database_kw_opt", "key_opt", +}; +#endif /* NDEBUG */ + +#ifndef NDEBUG +/* For tracing reduce actions, the names of all rules are required. +*/ +static const char *yyRuleName[] = { + /* 0 */ "input ::= cmdlist", + /* 1 */ "cmdlist ::= cmdlist ecmd", + /* 2 */ "cmdlist ::= ecmd", + /* 3 */ "ecmd ::= explain cmdx SEMI", + /* 4 */ "ecmd ::= SEMI", + /* 5 */ "cmdx ::= cmd", + /* 6 */ "explain ::= EXPLAIN", + /* 7 */ "explain ::=", + /* 8 */ "cmd ::= BEGIN trans_opt onconf", + /* 9 */ "trans_opt ::=", + /* 10 */ "trans_opt ::= TRANSACTION", + /* 11 */ "trans_opt ::= TRANSACTION nm", + /* 12 */ "cmd ::= COMMIT trans_opt", + /* 13 */ "cmd ::= END trans_opt", + /* 14 */ "cmd ::= ROLLBACK trans_opt", + /* 15 */ "cmd ::= create_table create_table_args", + /* 16 */ "create_table ::= CREATE temp TABLE nm", + /* 17 */ "temp ::= TEMP", + /* 18 */ "temp ::=", + /* 19 */ "create_table_args ::= LP columnlist conslist_opt RP", + /* 20 */ "create_table_args ::= AS select", + /* 21 */ "columnlist ::= columnlist COMMA column", + /* 22 */ "columnlist ::= column", + /* 23 */ "column ::= columnid type carglist", + /* 24 */ "columnid ::= nm", + /* 25 */ "id ::= ID", + /* 26 */ "ids ::= ID", + /* 27 */ "ids ::= STRING", + /* 28 */ "nm ::= ID", + /* 29 */ "nm ::= STRING", + /* 30 */ "nm ::= JOIN_KW", + /* 31 */ "type ::=", + /* 32 */ "type ::= typename", + /* 33 */ "type ::= typename LP signed RP", + /* 34 */ "type ::= typename LP signed COMMA signed RP", + /* 35 */ "typename ::= ids", + /* 36 */ "typename ::= typename ids", + /* 37 */ "signed ::= INTEGER", + /* 38 */ "signed ::= PLUS INTEGER", + /* 39 */ "signed ::= MINUS INTEGER", + /* 40 */ "carglist ::= carglist carg", + /* 41 */ "carglist ::=", + /* 42 */ "carg ::= CONSTRAINT nm ccons", + /* 43 */ "carg ::= ccons", + /* 44 */ "carg ::= DEFAULT STRING", + /* 45 */ "carg ::= DEFAULT ID", + /* 46 */ "carg ::= DEFAULT INTEGER", + /* 47 */ "carg ::= DEFAULT PLUS INTEGER", + /* 48 */ "carg ::= DEFAULT MINUS INTEGER", + /* 49 */ "carg ::= DEFAULT FLOAT", + /* 50 */ "carg ::= DEFAULT PLUS FLOAT", + /* 51 */ "carg ::= DEFAULT MINUS FLOAT", + /* 52 */ "carg ::= DEFAULT NULL", + /* 53 */ "ccons ::= NULL onconf", + /* 54 */ "ccons ::= NOT NULL onconf", + /* 55 */ "ccons ::= PRIMARY KEY sortorder onconf", + /* 56 */ "ccons ::= UNIQUE onconf", + /* 57 */ "ccons ::= CHECK LP expr RP onconf", + /* 58 */ "ccons ::= REFERENCES nm idxlist_opt refargs", + /* 59 */ "ccons ::= defer_subclause", + /* 60 */ "ccons ::= COLLATE id", + /* 61 */ "refargs ::=", + /* 62 */ "refargs ::= refargs refarg", + /* 63 */ "refarg ::= MATCH nm", + /* 64 */ "refarg ::= ON DELETE refact", + /* 65 */ "refarg ::= ON UPDATE refact", + /* 66 */ "refarg ::= ON INSERT refact", + /* 67 */ "refact ::= SET NULL", + /* 68 */ "refact ::= SET DEFAULT", + /* 69 */ "refact ::= CASCADE", + /* 70 */ "refact ::= RESTRICT", + /* 71 */ "defer_subclause ::= NOT DEFERRABLE init_deferred_pred_opt", + /* 72 */ "defer_subclause ::= DEFERRABLE init_deferred_pred_opt", + /* 73 */ "init_deferred_pred_opt ::=", + /* 74 */ "init_deferred_pred_opt ::= INITIALLY DEFERRED", + /* 75 */ "init_deferred_pred_opt ::= INITIALLY IMMEDIATE", + /* 76 */ "conslist_opt ::=", + /* 77 */ "conslist_opt ::= COMMA conslist", + /* 78 */ "conslist ::= conslist COMMA tcons", + /* 79 */ "conslist ::= conslist tcons", + /* 80 */ "conslist ::= tcons", + /* 81 */ "tcons ::= CONSTRAINT nm", + /* 82 */ "tcons ::= PRIMARY KEY LP idxlist RP onconf", + /* 83 */ "tcons ::= UNIQUE LP idxlist RP onconf", + /* 84 */ "tcons ::= CHECK expr onconf", + /* 85 */ "tcons ::= FOREIGN KEY LP idxlist RP REFERENCES nm idxlist_opt refargs defer_subclause_opt", + /* 86 */ "defer_subclause_opt ::=", + /* 87 */ "defer_subclause_opt ::= defer_subclause", + /* 88 */ "onconf ::=", + /* 89 */ "onconf ::= ON CONFLICT resolvetype", + /* 90 */ "orconf ::=", + /* 91 */ "orconf ::= OR resolvetype", + /* 92 */ "resolvetype ::= ROLLBACK", + /* 93 */ "resolvetype ::= ABORT", + /* 94 */ "resolvetype ::= FAIL", + /* 95 */ "resolvetype ::= IGNORE", + /* 96 */ "resolvetype ::= REPLACE", + /* 97 */ "cmd ::= DROP TABLE nm", + /* 98 */ "cmd ::= CREATE temp VIEW nm AS select", + /* 99 */ "cmd ::= DROP VIEW nm", + /* 100 */ "cmd ::= select", + /* 101 */ "select ::= oneselect", + /* 102 */ "select ::= select multiselect_op oneselect", + /* 103 */ "multiselect_op ::= UNION", + /* 104 */ "multiselect_op ::= UNION ALL", + /* 105 */ "multiselect_op ::= INTERSECT", + /* 106 */ "multiselect_op ::= EXCEPT", + /* 107 */ "oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt", + /* 108 */ "distinct ::= DISTINCT", + /* 109 */ "distinct ::= ALL", + /* 110 */ "distinct ::=", + /* 111 */ "sclp ::= selcollist COMMA", + /* 112 */ "sclp ::=", + /* 113 */ "selcollist ::= sclp expr as", + /* 114 */ "selcollist ::= sclp STAR", + /* 115 */ "selcollist ::= sclp nm DOT STAR", + /* 116 */ "as ::= AS nm", + /* 117 */ "as ::= ids", + /* 118 */ "as ::=", + /* 119 */ "from ::=", + /* 120 */ "from ::= FROM seltablist", + /* 121 */ "stl_prefix ::= seltablist joinop", + /* 122 */ "stl_prefix ::=", + /* 123 */ "seltablist ::= stl_prefix nm dbnm as on_opt using_opt", + /* 124 */ "seltablist ::= stl_prefix LP seltablist_paren RP as on_opt using_opt", + /* 125 */ "seltablist_paren ::= select", + /* 126 */ "seltablist_paren ::= seltablist", + /* 127 */ "dbnm ::=", + /* 128 */ "dbnm ::= DOT nm", + /* 129 */ "joinop ::= COMMA", + /* 130 */ "joinop ::= JOIN", + /* 131 */ "joinop ::= JOIN_KW JOIN", + /* 132 */ "joinop ::= JOIN_KW nm JOIN", + /* 133 */ "joinop ::= JOIN_KW nm nm JOIN", + /* 134 */ "on_opt ::= ON expr", + /* 135 */ "on_opt ::=", + /* 136 */ "using_opt ::= USING LP idxlist RP", + /* 137 */ "using_opt ::=", + /* 138 */ "orderby_opt ::=", + /* 139 */ "orderby_opt ::= ORDER BY sortlist", + /* 140 */ "sortlist ::= sortlist COMMA sortitem collate sortorder", + /* 141 */ "sortlist ::= sortitem collate sortorder", + /* 142 */ "sortitem ::= expr", + /* 143 */ "sortorder ::= ASC", + /* 144 */ "sortorder ::= DESC", + /* 145 */ "sortorder ::=", + /* 146 */ "collate ::=", + /* 147 */ "collate ::= COLLATE id", + /* 148 */ "groupby_opt ::=", + /* 149 */ "groupby_opt ::= GROUP BY exprlist", + /* 150 */ "having_opt ::=", + /* 151 */ "having_opt ::= HAVING expr", + /* 152 */ "limit_opt ::=", + /* 153 */ "limit_opt ::= LIMIT signed", + /* 154 */ "limit_opt ::= LIMIT signed OFFSET signed", + /* 155 */ "limit_opt ::= LIMIT signed COMMA signed", + /* 156 */ "cmd ::= DELETE FROM nm dbnm where_opt", + /* 157 */ "where_opt ::=", + /* 158 */ "where_opt ::= WHERE expr", + /* 159 */ "cmd ::= UPDATE orconf nm dbnm SET setlist where_opt", + /* 160 */ "setlist ::= setlist COMMA nm EQ expr", + /* 161 */ "setlist ::= nm EQ expr", + /* 162 */ "cmd ::= insert_cmd INTO nm dbnm inscollist_opt VALUES LP itemlist RP", + /* 163 */ "cmd ::= insert_cmd INTO nm dbnm inscollist_opt select", + /* 164 */ "insert_cmd ::= INSERT orconf", + /* 165 */ "insert_cmd ::= REPLACE", + /* 166 */ "itemlist ::= itemlist COMMA expr", + /* 167 */ "itemlist ::= expr", + /* 168 */ "inscollist_opt ::=", + /* 169 */ "inscollist_opt ::= LP inscollist RP", + /* 170 */ "inscollist ::= inscollist COMMA nm", + /* 171 */ "inscollist ::= nm", + /* 172 */ "expr ::= LP expr RP", + /* 173 */ "expr ::= NULL", + /* 174 */ "expr ::= ID", + /* 175 */ "expr ::= JOIN_KW", + /* 176 */ "expr ::= nm DOT nm", + /* 177 */ "expr ::= nm DOT nm DOT nm", + /* 178 */ "expr ::= INTEGER", + /* 179 */ "expr ::= FLOAT", + /* 180 */ "expr ::= STRING", + /* 181 */ "expr ::= VARIABLE", + /* 182 */ "expr ::= ID LP exprlist RP", + /* 183 */ "expr ::= ID LP STAR RP", + /* 184 */ "expr ::= expr AND expr", + /* 185 */ "expr ::= expr OR expr", + /* 186 */ "expr ::= expr LT expr", + /* 187 */ "expr ::= expr GT expr", + /* 188 */ "expr ::= expr LE expr", + /* 189 */ "expr ::= expr GE expr", + /* 190 */ "expr ::= expr NE expr", + /* 191 */ "expr ::= expr EQ expr", + /* 192 */ "expr ::= expr BITAND expr", + /* 193 */ "expr ::= expr BITOR expr", + /* 194 */ "expr ::= expr LSHIFT expr", + /* 195 */ "expr ::= expr RSHIFT expr", + /* 196 */ "expr ::= expr likeop expr", + /* 197 */ "expr ::= expr NOT likeop expr", + /* 198 */ "likeop ::= LIKE", + /* 199 */ "likeop ::= GLOB", + /* 200 */ "expr ::= expr PLUS expr", + /* 201 */ "expr ::= expr MINUS expr", + /* 202 */ "expr ::= expr STAR expr", + /* 203 */ "expr ::= expr SLASH expr", + /* 204 */ "expr ::= expr REM expr", + /* 205 */ "expr ::= expr CONCAT expr", + /* 206 */ "expr ::= expr ISNULL", + /* 207 */ "expr ::= expr IS NULL", + /* 208 */ "expr ::= expr NOTNULL", + /* 209 */ "expr ::= expr NOT NULL", + /* 210 */ "expr ::= expr IS NOT NULL", + /* 211 */ "expr ::= NOT expr", + /* 212 */ "expr ::= BITNOT expr", + /* 213 */ "expr ::= MINUS expr", + /* 214 */ "expr ::= PLUS expr", + /* 215 */ "expr ::= LP select RP", + /* 216 */ "expr ::= expr BETWEEN expr AND expr", + /* 217 */ "expr ::= expr NOT BETWEEN expr AND expr", + /* 218 */ "expr ::= expr IN LP exprlist RP", + /* 219 */ "expr ::= expr IN LP select RP", + /* 220 */ "expr ::= expr NOT IN LP exprlist RP", + /* 221 */ "expr ::= expr NOT IN LP select RP", + /* 222 */ "expr ::= expr IN nm dbnm", + /* 223 */ "expr ::= expr NOT IN nm dbnm", + /* 224 */ "expr ::= CASE case_operand case_exprlist case_else END", + /* 225 */ "case_exprlist ::= case_exprlist WHEN expr THEN expr", + /* 226 */ "case_exprlist ::= WHEN expr THEN expr", + /* 227 */ "case_else ::= ELSE expr", + /* 228 */ "case_else ::=", + /* 229 */ "case_operand ::= expr", + /* 230 */ "case_operand ::=", + /* 231 */ "exprlist ::= exprlist COMMA expritem", + /* 232 */ "exprlist ::= expritem", + /* 233 */ "expritem ::= expr", + /* 234 */ "expritem ::=", + /* 235 */ "cmd ::= CREATE uniqueflag INDEX nm ON nm dbnm LP idxlist RP onconf", + /* 236 */ "uniqueflag ::= UNIQUE", + /* 237 */ "uniqueflag ::=", + /* 238 */ "idxlist_opt ::=", + /* 239 */ "idxlist_opt ::= LP idxlist RP", + /* 240 */ "idxlist ::= idxlist COMMA idxitem", + /* 241 */ "idxlist ::= idxitem", + /* 242 */ "idxitem ::= nm sortorder", + /* 243 */ "cmd ::= DROP INDEX nm dbnm", + /* 244 */ "cmd ::= COPY orconf nm dbnm FROM nm USING DELIMITERS STRING", + /* 245 */ "cmd ::= COPY orconf nm dbnm FROM nm", + /* 246 */ "cmd ::= VACUUM", + /* 247 */ "cmd ::= VACUUM nm", + /* 248 */ "cmd ::= PRAGMA ids EQ nm", + /* 249 */ "cmd ::= PRAGMA ids EQ ON", + /* 250 */ "cmd ::= PRAGMA ids EQ plus_num", + /* 251 */ "cmd ::= PRAGMA ids EQ minus_num", + /* 252 */ "cmd ::= PRAGMA ids LP nm RP", + /* 253 */ "cmd ::= PRAGMA ids", + /* 254 */ "plus_num ::= plus_opt number", + /* 255 */ "minus_num ::= MINUS number", + /* 256 */ "number ::= INTEGER", + /* 257 */ "number ::= FLOAT", + /* 258 */ "plus_opt ::= PLUS", + /* 259 */ "plus_opt ::=", + /* 260 */ "cmd ::= CREATE trigger_decl BEGIN trigger_cmd_list END", + /* 261 */ "trigger_decl ::= temp TRIGGER nm trigger_time trigger_event ON nm dbnm foreach_clause when_clause", + /* 262 */ "trigger_time ::= BEFORE", + /* 263 */ "trigger_time ::= AFTER", + /* 264 */ "trigger_time ::= INSTEAD OF", + /* 265 */ "trigger_time ::=", + /* 266 */ "trigger_event ::= DELETE", + /* 267 */ "trigger_event ::= INSERT", + /* 268 */ "trigger_event ::= UPDATE", + /* 269 */ "trigger_event ::= UPDATE OF inscollist", + /* 270 */ "foreach_clause ::=", + /* 271 */ "foreach_clause ::= FOR EACH ROW", + /* 272 */ "foreach_clause ::= FOR EACH STATEMENT", + /* 273 */ "when_clause ::=", + /* 274 */ "when_clause ::= WHEN expr", + /* 275 */ "trigger_cmd_list ::= trigger_cmd SEMI trigger_cmd_list", + /* 276 */ "trigger_cmd_list ::=", + /* 277 */ "trigger_cmd ::= UPDATE orconf nm SET setlist where_opt", + /* 278 */ "trigger_cmd ::= insert_cmd INTO nm inscollist_opt VALUES LP itemlist RP", + /* 279 */ "trigger_cmd ::= insert_cmd INTO nm inscollist_opt select", + /* 280 */ "trigger_cmd ::= DELETE FROM nm where_opt", + /* 281 */ "trigger_cmd ::= select", + /* 282 */ "expr ::= RAISE LP IGNORE RP", + /* 283 */ "expr ::= RAISE LP ROLLBACK COMMA nm RP", + /* 284 */ "expr ::= RAISE LP ABORT COMMA nm RP", + /* 285 */ "expr ::= RAISE LP FAIL COMMA nm RP", + /* 286 */ "cmd ::= DROP TRIGGER nm dbnm", + /* 287 */ "cmd ::= ATTACH database_kw_opt ids AS nm key_opt", + /* 288 */ "key_opt ::= USING ids", + /* 289 */ "key_opt ::=", + /* 290 */ "database_kw_opt ::= DATABASE", + /* 291 */ "database_kw_opt ::=", + /* 292 */ "cmd ::= DETACH database_kw_opt nm", +}; +#endif /* NDEBUG */ + +/* +** This function returns the symbolic name associated with a token +** value. +*/ +const char *sqliteParserTokenName(int tokenType){ +#ifndef NDEBUG + if( tokenType>0 && tokenType<(sizeof(yyTokenName)/sizeof(yyTokenName[0])) ){ + return yyTokenName[tokenType]; + }else{ + return "Unknown"; + } +#else + return ""; +#endif +} + +/* +** This function allocates a new parser. +** The only argument is a pointer to a function which works like +** malloc. +** +** Inputs: +** A pointer to the function used to allocate memory. +** +** Outputs: +** A pointer to a parser. This pointer is used in subsequent calls +** to sqliteParser and sqliteParserFree. +*/ +void *sqliteParserAlloc(void *(*mallocProc)(size_t)){ + yyParser *pParser; + pParser = (yyParser*)(*mallocProc)( (size_t)sizeof(yyParser) ); + if( pParser ){ + pParser->yyidx = -1; + } + return pParser; +} + +/* The following function deletes the value associated with a +** symbol. The symbol can be either a terminal or nonterminal. +** "yymajor" is the symbol code, and "yypminor" is a pointer to +** the value. +*/ +static void yy_destructor(YYCODETYPE yymajor, YYMINORTYPE *yypminor){ + switch( yymajor ){ + /* Here is inserted the actions which take place when a + ** terminal or non-terminal is destroyed. This can happen + ** when the symbol is popped from the stack during a + ** reduce or during error processing or when a parser is + ** being destroyed before it is finished parsing. + ** + ** Note: during a reduce, the only symbols destroyed are those + ** which appear on the RHS of the rule, but which are not used + ** inside the C code. + */ + case 146: +#line 286 "parse.y" +{sqliteSelectDelete((yypminor->yy179));} +#line 1235 "parse.c" + break; + case 158: +#line 533 "parse.y" +{sqliteExprDelete((yypminor->yy242));} +#line 1240 "parse.c" + break; + case 159: +#line 746 "parse.y" +{sqliteIdListDelete((yypminor->yy320));} +#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" + 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" + 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 214: +#line 812 "parse.y" +{sqliteIdListDelete((yypminor->yy290).b);} +#line 1370 "parse.c" + break; + case 217: +#line 836 "parse.y" +{sqliteDeleteTriggerStep((yypminor->yy19));} +#line 1375 "parse.c" + break; + default: break; /* If no destructor action specified: do nothing */ + } +} + +/* +** Pop the parser's stack once. +** +** If there is a destructor routine associated with the token which +** is popped from the stack, then call it. +** +** Return the major token number for the symbol popped. +*/ +static int yy_pop_parser_stack(yyParser *pParser){ + YYCODETYPE yymajor; + yyStackEntry *yytos = &pParser->yystack[pParser->yyidx]; + + if( pParser->yyidx<0 ) return 0; +#ifndef NDEBUG + if( yyTraceFILE && pParser->yyidx>=0 ){ + fprintf(yyTraceFILE,"%sPopping %s\n", + yyTracePrompt, + yyTokenName[yytos->major]); + } +#endif + yymajor = yytos->major; + yy_destructor( yymajor, &yytos->minor); + pParser->yyidx--; + return yymajor; +} + +/* +** Deallocate and destroy a parser. Destructors are all called for +** all stack elements before shutting the parser down. +** +** Inputs: +** <ul> +** <li> A pointer to the parser. This should be a pointer +** obtained from sqliteParserAlloc. +** <li> A pointer to a function used to reclaim memory obtained +** from malloc. +** </ul> +*/ +void sqliteParserFree( + void *p, /* The parser to be deleted */ + void (*freeProc)(void*) /* Function used to reclaim memory */ +){ + yyParser *pParser = (yyParser*)p; + if( pParser==0 ) return; + while( pParser->yyidx>=0 ) yy_pop_parser_stack(pParser); + (*freeProc)((void*)pParser); +} + +/* +** Find the appropriate action for a parser given the terminal +** look-ahead token iLookAhead. +** +** If the look-ahead token is YYNOCODE, then check to see if the action is +** independent of the look-ahead. If it is, return the action, otherwise +** return YY_NO_ACTION. +*/ +static int yy_find_shift_action( + yyParser *pParser, /* The parser */ + int iLookAhead /* The look-ahead token */ +){ + 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 ){ + return yy_default[stateno]; + } + if( iLookAhead==YYNOCODE ){ + return YY_NO_ACTION; + } + i += iLookAhead; + if( i<0 || i>=YY_SZ_ACTTAB || yy_lookahead[i]!=iLookAhead ){ +#ifdef YYFALLBACK + int iFallback; /* Fallback token */ + if( iLookAhead<sizeof(yyFallback)/sizeof(yyFallback[0]) + && (iFallback = yyFallback[iLookAhead])!=0 ){ +#ifndef NDEBUG + if( yyTraceFILE ){ + fprintf(yyTraceFILE, "%sFALLBACK %s => %s\n", + yyTracePrompt, yyTokenName[iLookAhead], yyTokenName[iFallback]); + } +#endif + return yy_find_shift_action(pParser, iFallback); + } +#endif + return yy_default[stateno]; + }else{ + return yy_action[i]; + } +} + +/* +** Find the appropriate action for a parser given the non-terminal +** look-ahead token iLookAhead. +** +** If the look-ahead token is YYNOCODE, then check to see if the action is +** independent of the look-ahead. If it is, return the action, otherwise +** return YY_NO_ACTION. +*/ +static int yy_find_reduce_action( + yyParser *pParser, /* The parser */ + int iLookAhead /* The look-ahead token */ +){ + int i; + int stateno = pParser->yystack[pParser->yyidx].stateno; + + i = yy_reduce_ofst[stateno]; + if( i==YY_REDUCE_USE_DFLT ){ + return yy_default[stateno]; + } + if( iLookAhead==YYNOCODE ){ + return YY_NO_ACTION; + } + i += iLookAhead; + if( i<0 || i>=YY_SZ_ACTTAB || yy_lookahead[i]!=iLookAhead ){ + return yy_default[stateno]; + }else{ + return yy_action[i]; + } +} + +/* +** Perform a shift action. +*/ +static void yy_shift( + yyParser *yypParser, /* The parser to be shifted */ + int yyNewState, /* The new state to shift in */ + int yyMajor, /* The major token to shift in */ + YYMINORTYPE *yypMinor /* Pointer ot the minor token to shift in */ +){ + yyStackEntry *yytos; + yypParser->yyidx++; + if( yypParser->yyidx>=YYSTACKDEPTH ){ + sqliteParserARG_FETCH; + yypParser->yyidx--; +#ifndef NDEBUG + if( yyTraceFILE ){ + fprintf(yyTraceFILE,"%sStack Overflow!\n",yyTracePrompt); + } +#endif + while( yypParser->yyidx>=0 ) yy_pop_parser_stack(yypParser); + /* Here code is inserted which will execute if the parser + ** stack every overflows */ + sqliteParserARG_STORE; /* Suppress warning about unused %extra_argument var */ + return; + } + yytos = &yypParser->yystack[yypParser->yyidx]; + yytos->stateno = yyNewState; + yytos->major = yyMajor; + yytos->minor = *yypMinor; +#ifndef NDEBUG + if( yyTraceFILE && yypParser->yyidx>0 ){ + int i; + fprintf(yyTraceFILE,"%sShift %d\n",yyTracePrompt,yyNewState); + fprintf(yyTraceFILE,"%sStack:",yyTracePrompt); + for(i=1; i<=yypParser->yyidx; i++) + fprintf(yyTraceFILE," %s",yyTokenName[yypParser->yystack[i].major]); + fprintf(yyTraceFILE,"\n"); + } +#endif +} + +/* The following table contains information about every rule that +** is used during the reduce. +*/ +static struct { + YYCODETYPE lhs; /* Symbol on the left-hand side of the rule */ + unsigned char nrhs; /* Number of right-hand side symbols in the rule */ +} yyRuleInfo[] = { + { 132, 1 }, + { 133, 2 }, + { 133, 1 }, + { 134, 3 }, + { 134, 1 }, + { 136, 1 }, + { 135, 1 }, + { 135, 0 }, + { 137, 3 }, + { 138, 0 }, + { 138, 1 }, + { 138, 2 }, + { 137, 2 }, + { 137, 2 }, + { 137, 2 }, + { 137, 2 }, + { 141, 4 }, + { 143, 1 }, + { 143, 0 }, + { 142, 4 }, + { 142, 2 }, + { 144, 3 }, + { 144, 1 }, + { 147, 3 }, + { 148, 1 }, + { 151, 1 }, + { 152, 1 }, + { 152, 1 }, + { 140, 1 }, + { 140, 1 }, + { 140, 1 }, + { 149, 0 }, + { 149, 1 }, + { 149, 4 }, + { 149, 6 }, + { 153, 1 }, + { 153, 2 }, + { 154, 1 }, + { 154, 2 }, + { 154, 2 }, + { 150, 2 }, + { 150, 0 }, + { 155, 3 }, + { 155, 1 }, + { 155, 2 }, + { 155, 2 }, + { 155, 2 }, + { 155, 3 }, + { 155, 3 }, + { 155, 2 }, + { 155, 3 }, + { 155, 3 }, + { 155, 2 }, + { 156, 2 }, + { 156, 3 }, + { 156, 4 }, + { 156, 2 }, + { 156, 5 }, + { 156, 4 }, + { 156, 1 }, + { 156, 2 }, + { 160, 0 }, + { 160, 2 }, + { 162, 2 }, + { 162, 3 }, + { 162, 3 }, + { 162, 3 }, + { 163, 2 }, + { 163, 2 }, + { 163, 1 }, + { 163, 1 }, + { 161, 3 }, + { 161, 2 }, + { 164, 0 }, + { 164, 2 }, + { 164, 2 }, + { 145, 0 }, + { 145, 2 }, + { 165, 3 }, + { 165, 2 }, + { 165, 1 }, + { 166, 2 }, + { 166, 6 }, + { 166, 5 }, + { 166, 3 }, + { 166, 10 }, + { 168, 0 }, + { 168, 1 }, + { 139, 0 }, + { 139, 3 }, + { 169, 0 }, + { 169, 2 }, + { 170, 1 }, + { 170, 1 }, + { 170, 1 }, + { 170, 1 }, + { 170, 1 }, + { 137, 3 }, + { 137, 6 }, + { 137, 3 }, + { 137, 1 }, + { 146, 1 }, + { 146, 3 }, + { 172, 1 }, + { 172, 2 }, + { 172, 1 }, + { 172, 1 }, + { 171, 9 }, + { 173, 1 }, + { 173, 1 }, + { 173, 0 }, + { 181, 2 }, + { 181, 0 }, + { 174, 3 }, + { 174, 2 }, + { 174, 4 }, + { 182, 2 }, + { 182, 1 }, + { 182, 0 }, + { 175, 0 }, + { 175, 2 }, + { 184, 2 }, + { 184, 0 }, + { 183, 6 }, + { 183, 7 }, + { 189, 1 }, + { 189, 1 }, + { 186, 0 }, + { 186, 2 }, + { 185, 1 }, + { 185, 1 }, + { 185, 2 }, + { 185, 3 }, + { 185, 4 }, + { 187, 2 }, + { 187, 0 }, + { 188, 4 }, + { 188, 0 }, + { 179, 0 }, + { 179, 3 }, + { 191, 5 }, + { 191, 3 }, + { 192, 1 }, + { 157, 1 }, + { 157, 1 }, + { 157, 0 }, + { 193, 0 }, + { 193, 2 }, + { 177, 0 }, + { 177, 3 }, + { 178, 0 }, + { 178, 2 }, + { 180, 0 }, + { 180, 2 }, + { 180, 4 }, + { 180, 4 }, + { 137, 5 }, + { 176, 0 }, + { 176, 2 }, + { 137, 7 }, + { 195, 5 }, + { 195, 3 }, + { 137, 9 }, + { 137, 6 }, + { 196, 2 }, + { 196, 1 }, + { 198, 3 }, + { 198, 1 }, + { 197, 0 }, + { 197, 3 }, + { 199, 3 }, + { 199, 1 }, + { 158, 3 }, + { 158, 1 }, + { 158, 1 }, + { 158, 1 }, + { 158, 3 }, + { 158, 5 }, + { 158, 1 }, + { 158, 1 }, + { 158, 1 }, + { 158, 1 }, + { 158, 4 }, + { 158, 4 }, + { 158, 3 }, + { 158, 3 }, + { 158, 3 }, + { 158, 3 }, + { 158, 3 }, + { 158, 3 }, + { 158, 3 }, + { 158, 3 }, + { 158, 3 }, + { 158, 3 }, + { 158, 3 }, + { 158, 3 }, + { 158, 3 }, + { 158, 4 }, + { 200, 1 }, + { 200, 1 }, + { 158, 3 }, + { 158, 3 }, + { 158, 3 }, + { 158, 3 }, + { 158, 3 }, + { 158, 3 }, + { 158, 2 }, + { 158, 3 }, + { 158, 2 }, + { 158, 3 }, + { 158, 4 }, + { 158, 2 }, + { 158, 2 }, + { 158, 2 }, + { 158, 2 }, + { 158, 3 }, + { 158, 5 }, + { 158, 6 }, + { 158, 5 }, + { 158, 5 }, + { 158, 6 }, + { 158, 6 }, + { 158, 4 }, + { 158, 5 }, + { 158, 5 }, + { 202, 5 }, + { 202, 4 }, + { 203, 2 }, + { 203, 0 }, + { 201, 1 }, + { 201, 0 }, + { 194, 3 }, + { 194, 1 }, + { 204, 1 }, + { 204, 0 }, + { 137, 11 }, + { 205, 1 }, + { 205, 0 }, + { 159, 0 }, + { 159, 3 }, + { 167, 3 }, + { 167, 1 }, + { 206, 2 }, + { 137, 4 }, + { 137, 9 }, + { 137, 6 }, + { 137, 1 }, + { 137, 2 }, + { 137, 4 }, + { 137, 4 }, + { 137, 4 }, + { 137, 4 }, + { 137, 5 }, + { 137, 2 }, + { 207, 2 }, + { 208, 2 }, + { 210, 1 }, + { 210, 1 }, + { 209, 1 }, + { 209, 0 }, + { 137, 5 }, + { 211, 10 }, + { 213, 1 }, + { 213, 1 }, + { 213, 2 }, + { 213, 0 }, + { 214, 1 }, + { 214, 1 }, + { 214, 1 }, + { 214, 3 }, + { 215, 0 }, + { 215, 3 }, + { 215, 3 }, + { 216, 0 }, + { 216, 2 }, + { 212, 3 }, + { 212, 0 }, + { 217, 6 }, + { 217, 8 }, + { 217, 5 }, + { 217, 4 }, + { 217, 1 }, + { 158, 4 }, + { 158, 6 }, + { 158, 6 }, + { 158, 6 }, + { 137, 4 }, + { 137, 6 }, + { 219, 2 }, + { 219, 0 }, + { 218, 1 }, + { 218, 0 }, + { 137, 3 }, +}; + +static void yy_accept(yyParser*); /* Forward Declaration */ + +/* +** Perform a reduce action and the shift that must immediately +** follow the reduce. +*/ +static void yy_reduce( + yyParser *yypParser, /* The parser */ + int yyruleno /* Number of the rule by which to reduce */ +){ + int yygoto; /* The next state */ + int yyact; /* The next action */ + YYMINORTYPE yygotominor; /* The LHS of the rule reduced */ + yyStackEntry *yymsp; /* The top of the parser's stack */ + int yysize; /* Amount to pop the stack */ + sqliteParserARG_FETCH; + yymsp = &yypParser->yystack[yypParser->yyidx]; +#ifndef NDEBUG + if( yyTraceFILE && yyruleno>=0 + && yyruleno<sizeof(yyRuleName)/sizeof(yyRuleName[0]) ){ + fprintf(yyTraceFILE, "%sReduce [%s].\n", yyTracePrompt, + yyRuleName[yyruleno]); + } +#endif /* NDEBUG */ + + switch( yyruleno ){ + /* Beginning here are the reduction cases. A typical example + ** follows: + ** case 0: + ** #line <lineno> <grammarfile> + ** { ... } // User supplied code + ** #line <lineno> <thisfile> + ** 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 */ + break; + case 6: +#line 73 "parse.y" +{ sqliteBeginParse(pParse, 1); } +#line 1907 "parse.c" + /* No destructor defined for EXPLAIN */ + break; + case 7: +#line 74 "parse.y" +{ sqliteBeginParse(pParse, 0); } +#line 1913 "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 */ + 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 */ + break; + case 13: +#line 84 "parse.y" +{sqliteCommitTransaction(pParse);} +#line 1941 "parse.c" + /* No destructor defined for END */ + /* No destructor defined for trans_opt */ + 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 */ + 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" + 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 */ + break; + case 21: + /* No destructor defined for columnlist */ + /* No destructor defined for COMMA */ + /* No destructor defined for column */ + break; + case 22: + /* No destructor defined for column */ + 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" + break; + case 26: +#line 149 "parse.y" +{yygotominor.yy298 = yymsp[0].minor.yy0;} +#line 2020 "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" + break; + case 30: +#line 157 "parse.y" +{yygotominor.yy298 = yymsp[0].minor.yy0;} +#line 2040 "parse.c" + break; + case 31: + 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: +#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" + break; + case 38: +#line 169 "parse.y" +{ yygotominor.yy372 = atoi(yymsp[0].minor.yy0.z); } +#line 2084 "parse.c" + /* No destructor defined for PLUS */ + break; + case 39: +#line 170 "parse.y" +{ yygotominor.yy372 = -atoi(yymsp[0].minor.yy0.z); } +#line 2090 "parse.c" + /* No destructor defined for MINUS */ + break; + case 40: + /* No destructor defined for carglist */ + /* No destructor defined for carg */ + break; + case 41: + break; + case 42: + /* No destructor defined for CONSTRAINT */ + /* No destructor defined for nm */ + /* No destructor defined for ccons */ + break; + case 43: + /* No destructor defined for ccons */ + break; + case 44: +#line 175 "parse.y" +{sqliteAddDefaultValue(pParse,&yymsp[0].minor.yy0,0);} +#line 2110 "parse.c" + /* No destructor defined for DEFAULT */ + 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 */ + 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 */ + 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 */ + break; + case 53: + /* No destructor defined for NULL */ + /* No destructor defined for onconf */ + 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 */ + 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 */ + 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 */ + 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 */ + break; + case 59: +#line 195 "parse.y" +{sqliteDeferForeignKey(pParse,yymsp[0].minor.yy372);} +#line 2204 "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 */ + break; + case 61: +#line 206 "parse.y" +{ yygotominor.yy372 = OE_Restrict * 0x010101; } +#line 2217 "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 */ + 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 */ + 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 */ + 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 */ + 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 */ + break; + case 69: +#line 216 "parse.y" +{ yygotominor.yy372 = OE_Cascade; } +#line 2269 "parse.c" + /* No destructor defined for CASCADE */ + break; + case 70: +#line 217 "parse.y" +{ yygotominor.yy372 = OE_Restrict; } +#line 2275 "parse.c" + /* No destructor defined for RESTRICT */ + 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 */ + break; + case 72: +#line 220 "parse.y" +{yygotominor.yy372 = yymsp[0].minor.yy372;} +#line 2288 "parse.c" + /* No destructor defined for DEFERRABLE */ + break; + case 73: +#line 222 "parse.y" +{yygotominor.yy372 = 0;} +#line 2294 "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 */ + 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 */ + break; + case 80: + /* No destructor defined for tcons */ + 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 */ + break; + case 86: +#line 246 "parse.y" +{yygotominor.yy372 = 0;} +#line 2370 "parse.c" + break; + case 87: +#line 247 "parse.y" +{yygotominor.yy372 = yymsp[0].minor.yy372;} +#line 2375 "parse.c" + break; + case 88: +#line 255 "parse.y" +{ yygotominor.yy372 = OE_Default; } +#line 2380 "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 */ + 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 */ + 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 */ + 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 */ + break; + case 99: +#line 274 "parse.y" +{ + sqliteDropTable(pParse, &yymsp[0].minor.yy298, 1); +} +#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" + break; + case 102: +#line 291 "parse.y" +{ + if( yymsp[0].minor.yy179 ){ + yymsp[0].minor.yy179->op = yymsp[-1].minor.yy372; + yymsp[0].minor.yy179->pPrior = yymsp[-2].minor.yy179; + } + yygotominor.yy179 = yymsp[0].minor.yy179; +} +#line 2477 "parse.c" + break; + case 103: +#line 299 "parse.y" +{yygotominor.yy372 = TK_UNION;} +#line 2482 "parse.c" + /* No destructor defined for UNION */ + 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 */ + break; + case 105: +#line 301 "parse.y" +{yygotominor.yy372 = TK_INTERSECT;} +#line 2495 "parse.c" + /* No destructor defined for INTERSECT */ + 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" +{ + yygotominor.yy179 = sqliteSelectNew(yymsp[-6].minor.yy322,yymsp[-5].minor.yy307,yymsp[-4].minor.yy242,yymsp[-3].minor.yy322,yymsp[-2].minor.yy242,yymsp[-1].minor.yy322,yymsp[-7].minor.yy372,yymsp[0].minor.yy124.limit,yymsp[0].minor.yy124.offset); +} +#line 2509 "parse.c" + /* No destructor defined for SELECT */ + 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 */ + 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" +{ + yygotominor.yy322 = sqliteExprListAppend(yymsp[-2].minor.yy322,yymsp[-1].minor.yy242,yymsp[0].minor.yy298.n?&yymsp[0].minor.yy298:0); +} +#line 2545 "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 */ + 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 */ + break; + case 116: +#line 343 "parse.y" +{ yygotominor.yy298 = yymsp[0].minor.yy298; } +#line 2569 "parse.c" + /* No destructor defined for AS */ + break; + case 117: +#line 344 "parse.y" +{ yygotominor.yy298 = yymsp[0].minor.yy298; } +#line 2575 "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 */ + 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" + break; + case 122: +#line 367 "parse.y" +{yygotominor.yy307 = 0;} +#line 2604 "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" + break; + case 124: +#line 381 "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); } + } +} +#line 2637 "parse.c" + /* No destructor defined for LP */ + /* No destructor defined for RP */ + break; + case 125: +#line 401 "parse.y" +{yygotominor.yy179 = yymsp[0].minor.yy179;} +#line 2644 "parse.c" + break; + case 126: +#line 402 "parse.y" +{ + yygotominor.yy179 = sqliteSelectNew(0,yymsp[0].minor.yy307,0,0,0,0,0,-1,0); +} +#line 2651 "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 */ + break; + case 129: +#line 412 "parse.y" +{ yygotominor.yy372 = JT_INNER; } +#line 2667 "parse.c" + /* No destructor defined for COMMA */ + 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 */ + 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 */ + 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 */ + break; + case 134: +#line 421 "parse.y" +{yygotominor.yy242 = yymsp[0].minor.yy242;} +#line 2697 "parse.c" + /* No destructor defined for ON */ + break; + case 135: +#line 422 "parse.y" +{yygotominor.yy242 = 0;} +#line 2703 "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 */ + break; + case 137: +#line 427 "parse.y" +{yygotominor.yy320 = 0;} +#line 2716 "parse.c" + break; + case 138: +#line 437 "parse.y" +{yygotominor.yy322 = 0;} +#line 2721 "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 */ + 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" + break; + case 142: +#line 447 "parse.y" +{yygotominor.yy242 = yymsp[0].minor.yy242;} +#line 2750 "parse.c" + break; + case 143: +#line 452 "parse.y" +{yygotominor.yy372 = SQLITE_SO_ASC;} +#line 2755 "parse.c" + /* No destructor defined for ASC */ + 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" + break; + case 146: +#line 455 "parse.y" +{yygotominor.yy372 = SQLITE_SO_UNK;} +#line 2772 "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" + 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 */ + 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 */ + 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 */ + break; + case 157: +#line 485 "parse.y" +{yygotominor.yy242 = 0;} +#line 2840 "parse.c" + break; + case 158: +#line 486 "parse.y" +{yygotominor.yy242 = yymsp[0].minor.yy242;} +#line 2845 "parse.c" + /* No destructor defined for WHERE */ + 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 */ + 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 */ + 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 */ + break; + case 164: +#line 509 "parse.y" +{yygotominor.yy372 = yymsp[0].minor.yy372;} +#line 2886 "parse.c" + /* No destructor defined for INSERT */ + break; + case 165: +#line 510 "parse.y" +{yygotominor.yy372 = OE_Replace;} +#line 2892 "parse.c" + /* No destructor defined for REPLACE */ + 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" + 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 */ + 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" + break; + case 173: +#line 536 "parse.y" +{yygotominor.yy242 = sqliteExpr(TK_NULL, 0, 0, &yymsp[0].minor.yy0);} +#line 2937 "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" + 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 */ + 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 */ + 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" + break; + case 180: +#line 553 "parse.y" +{yygotominor.yy242 = sqliteExpr(TK_STRING, 0, 0, &yymsp[0].minor.yy0);} +#line 2985 "parse.c" + break; + case 181: +#line 554 "parse.y" +{ + yygotominor.yy242 = sqliteExpr(TK_VARIABLE, 0, 0, &yymsp[0].minor.yy0); + if( yygotominor.yy242 ) yygotominor.yy242->iTable = ++pParse->nVar; +} +#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 */ + 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 */ + 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); +} +#line 3266 "parse.c" + /* No destructor defined for NOT */ + /* No destructor defined for BETWEEN */ + /* No destructor defined for AND */ + break; + case 218: +#line 658 "parse.y" +{ + yygotominor.yy242 = sqliteExpr(TK_IN, yymsp[-4].minor.yy242, 0, 0); + if( yygotominor.yy242 ) yygotominor.yy242->pList = yymsp[-1].minor.yy322; + sqliteExprSpan(yygotominor.yy242,&yymsp[-4].minor.yy242->span,&yymsp[0].minor.yy0); +} +#line 3278 "parse.c" + /* No destructor defined for IN */ + /* No destructor defined for LP */ + break; + case 219: +#line 663 "parse.y" +{ + yygotominor.yy242 = sqliteExpr(TK_IN, yymsp[-4].minor.yy242, 0, 0); + if( yygotominor.yy242 ) yygotominor.yy242->pSelect = yymsp[-1].minor.yy179; + sqliteExprSpan(yygotominor.yy242,&yymsp[-4].minor.yy242->span,&yymsp[0].minor.yy0); +} +#line 3289 "parse.c" + /* No destructor defined for IN */ + /* No destructor defined for LP */ + break; + case 220: +#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); +} +#line 3301 "parse.c" + /* No destructor defined for NOT */ + /* No destructor defined for IN */ + /* No destructor defined for LP */ + break; + case 221: +#line 674 "parse.y" +{ + yygotominor.yy242 = sqliteExpr(TK_IN, yymsp[-5].minor.yy242, 0, 0); + if( yygotominor.yy242 ) yygotominor.yy242->pSelect = yymsp[-1].minor.yy179; + yygotominor.yy242 = sqliteExpr(TK_NOT, yygotominor.yy242, 0, 0); + sqliteExprSpan(yygotominor.yy242,&yymsp[-5].minor.yy242->span,&yymsp[0].minor.yy0); +} +#line 3314 "parse.c" + /* No destructor defined for NOT */ + /* No destructor defined for IN */ + /* No destructor defined for LP */ + break; + case 222: +#line 680 "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); +} +#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" + 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 */ + break; + case 232: +#line 725 "parse.y" +{yygotominor.yy322 = sqliteExprListAppend(0,yymsp[0].minor.yy242,0);} +#line 3402 "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 */ + break; + case 236: +#line 740 "parse.y" +{ yygotominor.yy372 = OE_Abort; } +#line 3430 "parse.c" + /* No destructor defined for UNIQUE */ + 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" + 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 */ + 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" + break; + case 242: +#line 753 "parse.y" +{yygotominor.yy298 = yymsp[-1].minor.yy298;} +#line 3464 "parse.c" + /* No destructor defined for sortorder */ + 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 */ + 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 */ + break; + case 246: +#line 772 "parse.y" +{sqliteVacuum(pParse,0);} +#line 3495 "parse.c" + /* No destructor defined for VACUUM */ + 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 */ + 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" +{ + Token all; + all.z = yymsp[-4].minor.yy0.z; + all.n = (yymsp[0].minor.yy0.z - yymsp[-4].minor.yy0.z) + yymsp[0].minor.yy0.n; + sqliteFinishTrigger(pParse, yymsp[-1].minor.yy19, &all); +} +#line 3581 "parse.c" + /* No destructor defined for trigger_decl */ + /* No destructor defined for BEGIN */ + 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 */ + 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 */ + 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 */ + break; + case 265: +#line 809 "parse.y" +{ yygotominor.yy372 = TK_BEFORE; } +#line 3617 "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 */ + 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 */ + 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 */ + 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 */ + break; + case 270: +#line 819 "parse.y" +{ yygotominor.yy372 = TK_ROW; } +#line 3647 "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 */ + 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 */ + break; + case 273: +#line 824 "parse.y" +{ yygotominor.yy182 = 0; } +#line 3668 "parse.c" + break; + case 274: +#line 825 "parse.y" +{ yygotominor.yy182 = yymsp[0].minor.yy242; } +#line 3673 "parse.c" + /* No destructor defined for WHEN */ + break; + case 275: +#line 829 "parse.y" +{ + yymsp[-2].minor.yy19->pNext = yymsp[0].minor.yy19; + yygotominor.yy19 = yymsp[-2].minor.yy19; +} +#line 3682 "parse.c" + /* No destructor defined for SEMI */ + 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 */ + 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 */ + 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 */ + 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 */ + break; + case 281: +#line 854 "parse.y" +{yygotominor.yy19 = sqliteTriggerSelectStep(yymsp[0].minor.yy179); } +#line 3722 "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 */ + break; + case 285: +#line 872 "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); +} +#line 3766 "parse.c" + /* No destructor defined for LP */ + /* No destructor defined for FAIL */ + /* No destructor defined for COMMA */ + 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 */ + 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 */ + break; + case 288: +#line 888 "parse.y" +{ yygotominor.yy298 = yymsp[0].minor.yy298; } +#line 3793 "parse.c" + /* No destructor defined for USING */ + break; + case 289: +#line 889 "parse.y" +{ yygotominor.yy298.z = 0; yygotominor.yy298.n = 0; } +#line 3799 "parse.c" + break; + case 290: + /* No destructor defined for DATABASE */ + break; + case 291: + break; + case 292: +#line 895 "parse.y" +{ + sqliteDetach(pParse, &yymsp[0].minor.yy298); +} +#line 3811 "parse.c" + /* No destructor defined for DETACH */ + /* No destructor defined for database_kw_opt */ + break; + }; + yygoto = yyRuleInfo[yyruleno].lhs; + yysize = yyRuleInfo[yyruleno].nrhs; + yypParser->yyidx -= yysize; + yyact = yy_find_reduce_action(yypParser,yygoto); + if( yyact < YYNSTATE ){ + yy_shift(yypParser,yyact,yygoto,&yygotominor); + }else if( yyact == YYNSTATE + YYNRULE + 1 ){ + yy_accept(yypParser); + } +} + +/* +** The following code executes when the parse fails +*/ +static void yy_parse_failed( + yyParser *yypParser /* The parser */ +){ + sqliteParserARG_FETCH; +#ifndef NDEBUG + if( yyTraceFILE ){ + fprintf(yyTraceFILE,"%sFail!\n",yyTracePrompt); + } +#endif + while( yypParser->yyidx>=0 ) yy_pop_parser_stack(yypParser); + /* Here code is inserted which will be executed whenever the + ** parser fails */ + sqliteParserARG_STORE; /* Suppress warning about unused %extra_argument variable */ +} + +/* +** The following code executes when a syntax error first occurs. +*/ +static void yy_syntax_error( + yyParser *yypParser, /* The parser */ + int yymajor, /* The major type of the error token */ + YYMINORTYPE yyminor /* The minor type of the error token */ +){ + sqliteParserARG_FETCH; +#define TOKEN (yyminor.yy0) +#line 23 "parse.y" + + if( pParse->zErrMsg==0 ){ + if( TOKEN.z[0] ){ + sqliteErrorMsg(pParse, "near \"%T\": syntax error", &TOKEN); + }else{ + sqliteErrorMsg(pParse, "incomplete SQL statement"); + } + } + +#line 3865 "parse.c" + sqliteParserARG_STORE; /* Suppress warning about unused %extra_argument variable */ +} + +/* +** The following is executed when the parser accepts +*/ +static void yy_accept( + yyParser *yypParser /* The parser */ +){ + sqliteParserARG_FETCH; +#ifndef NDEBUG + if( yyTraceFILE ){ + fprintf(yyTraceFILE,"%sAccept!\n",yyTracePrompt); + } +#endif + while( yypParser->yyidx>=0 ) yy_pop_parser_stack(yypParser); + /* Here code is inserted which will be executed whenever the + ** parser accepts */ + sqliteParserARG_STORE; /* Suppress warning about unused %extra_argument variable */ +} + +/* The main parser program. +** The first argument is a pointer to a structure obtained from +** "sqliteParserAlloc" which describes the current state of the parser. +** The second argument is the major token number. The third is +** the minor token. The fourth optional argument is whatever the +** user wants (and specified in the grammar) and is available for +** use by the action routines. +** +** Inputs: +** <ul> +** <li> A pointer to the parser (an opaque structure.) +** <li> The major token number. +** <li> The minor token number. +** <li> An option argument of a grammar-specified type. +** </ul> +** +** Outputs: +** None. +*/ +void sqliteParser( + void *yyp, /* The parser */ + int yymajor, /* The major token code number */ + sqliteParserTOKENTYPE yyminor /* The value for the token */ + sqliteParserARG_PDECL /* Optional %extra_argument parameter */ +){ + YYMINORTYPE yyminorunion; + int yyact; /* The parser action. */ + int yyendofinput; /* True if we are at the end of input */ + int yyerrorhit = 0; /* True if yymajor has invoked an error */ + yyParser *yypParser; /* The parser */ + + /* (re)initialize the parser, if necessary */ + yypParser = (yyParser*)yyp; + if( yypParser->yyidx<0 ){ + if( yymajor==0 ) return; + yypParser->yyidx = 0; + yypParser->yyerrcnt = -1; + yypParser->yystack[0].stateno = 0; + yypParser->yystack[0].major = 0; + } + yyminorunion.yy0 = yyminor; + yyendofinput = (yymajor==0); + sqliteParserARG_STORE; + +#ifndef NDEBUG + if( yyTraceFILE ){ + fprintf(yyTraceFILE,"%sInput %s\n",yyTracePrompt,yyTokenName[yymajor]); + } +#endif + + do{ + yyact = yy_find_shift_action(yypParser,yymajor); + if( yyact<YYNSTATE ){ + yy_shift(yypParser,yyact,yymajor,&yyminorunion); + yypParser->yyerrcnt--; + if( yyendofinput && yypParser->yyidx>=0 ){ + yymajor = 0; + }else{ + yymajor = YYNOCODE; + } + }else if( yyact < YYNSTATE + YYNRULE ){ + yy_reduce(yypParser,yyact-YYNSTATE); + }else if( yyact == YY_ERROR_ACTION ){ + int yymx; +#ifndef NDEBUG + if( yyTraceFILE ){ + fprintf(yyTraceFILE,"%sSyntax Error!\n",yyTracePrompt); + } +#endif +#ifdef YYERRORSYMBOL + /* A syntax error has occurred. + ** The response to an error depends upon whether or not the + ** grammar defines an error token "ERROR". + ** + ** This is what we do if the grammar does define ERROR: + ** + ** * Call the %syntax_error function. + ** + ** * Begin popping the stack until we enter a state where + ** it is legal to shift the error symbol, then shift + ** the error symbol. + ** + ** * Set the error count to three. + ** + ** * Begin accepting and shifting new tokens. No new error + ** processing will occur until three tokens have been + ** shifted successfully. + ** + */ + if( yypParser->yyerrcnt<0 ){ + yy_syntax_error(yypParser,yymajor,yyminorunion); + } + yymx = yypParser->yystack[yypParser->yyidx].major; + if( yymx==YYERRORSYMBOL || yyerrorhit ){ +#ifndef NDEBUG + if( yyTraceFILE ){ + fprintf(yyTraceFILE,"%sDiscard input token %s\n", + yyTracePrompt,yyTokenName[yymajor]); + } +#endif + yy_destructor(yymajor,&yyminorunion); + yymajor = YYNOCODE; + }else{ + while( + yypParser->yyidx >= 0 && + yymx != YYERRORSYMBOL && + (yyact = yy_find_shift_action(yypParser,YYERRORSYMBOL)) >= YYNSTATE + ){ + yy_pop_parser_stack(yypParser); + } + if( yypParser->yyidx < 0 || yymajor==0 ){ + yy_destructor(yymajor,&yyminorunion); + yy_parse_failed(yypParser); + yymajor = YYNOCODE; + }else if( yymx!=YYERRORSYMBOL ){ + YYMINORTYPE u2; + u2.YYERRSYMDT = 0; + yy_shift(yypParser,yyact,YYERRORSYMBOL,&u2); + } + } + yypParser->yyerrcnt = 3; + yyerrorhit = 1; +#else /* YYERRORSYMBOL is not defined */ + /* This is what we do if the grammar does not define ERROR: + ** + ** * Report an error message, and throw away the input token. + ** + ** * If the input token is $, then fail the parse. + ** + ** As before, subsequent error messages are suppressed until + ** three input tokens have been successfully shifted. + */ + if( yypParser->yyerrcnt<=0 ){ + yy_syntax_error(yypParser,yymajor,yyminorunion); + } + yypParser->yyerrcnt = 3; + yy_destructor(yymajor,&yyminorunion); + if( yyendofinput ){ + yy_parse_failed(yypParser); + } + yymajor = YYNOCODE; +#endif + }else{ + yy_accept(yypParser); + yymajor = YYNOCODE; + } + }while( yymajor!=YYNOCODE && yypParser->yyidx>=0 ); + return; +} diff --git a/kexi/3rdparty/kexisql/src/parse.h b/kexi/3rdparty/kexisql/src/parse.h new file mode 100644 index 00000000..188a336c --- /dev/null +++ b/kexi/3rdparty/kexisql/src/parse.h @@ -0,0 +1,130 @@ +#define TK_END_OF_FILE 1 +#define TK_ILLEGAL 2 +#define TK_SPACE 3 +#define TK_UNCLOSED_STRING 4 +#define TK_COMMENT 5 +#define TK_FUNCTION 6 +#define TK_COLUMN 7 +#define TK_AGG_FUNCTION 8 +#define TK_SEMI 9 +#define TK_EXPLAIN 10 +#define TK_BEGIN 11 +#define TK_TRANSACTION 12 +#define TK_COMMIT 13 +#define TK_END 14 +#define TK_ROLLBACK 15 +#define TK_CREATE 16 +#define TK_TABLE 17 +#define TK_TEMP 18 +#define TK_LP 19 +#define TK_RP 20 +#define TK_AS 21 +#define TK_COMMA 22 +#define TK_ID 23 +#define TK_ABORT 24 +#define TK_AFTER 25 +#define TK_ASC 26 +#define TK_ATTACH 27 +#define TK_BEFORE 28 +#define TK_CASCADE 29 +#define TK_CLUSTER 30 +#define TK_CONFLICT 31 +#define TK_COPY 32 +#define TK_DATABASE 33 +#define TK_DEFERRED 34 +#define TK_DELIMITERS 35 +#define TK_DESC 36 +#define TK_DETACH 37 +#define TK_EACH 38 +#define TK_FAIL 39 +#define TK_FOR 40 +#define TK_GLOB 41 +#define TK_IGNORE 42 +#define TK_IMMEDIATE 43 +#define TK_INITIALLY 44 +#define TK_INSTEAD 45 +#define TK_LIKE 46 +#define TK_MATCH 47 +#define TK_KEY 48 +#define TK_OF 49 +#define TK_OFFSET 50 +#define TK_PRAGMA 51 +#define TK_RAISE 52 +#define TK_REPLACE 53 +#define TK_RESTRICT 54 +#define TK_ROW 55 +#define TK_STATEMENT 56 +#define TK_TRIGGER 57 +#define TK_VACUUM 58 +#define TK_VIEW 59 +#define TK_OR 60 +#define TK_AND 61 +#define TK_NOT 62 +#define TK_EQ 63 +#define TK_NE 64 +#define TK_ISNULL 65 +#define TK_NOTNULL 66 +#define TK_IS 67 +#define TK_BETWEEN 68 +#define TK_IN 69 +#define TK_GT 70 +#define TK_GE 71 +#define TK_LT 72 +#define TK_LE 73 +#define TK_BITAND 74 +#define TK_BITOR 75 +#define TK_LSHIFT 76 +#define TK_RSHIFT 77 +#define TK_PLUS 78 +#define TK_MINUS 79 +#define TK_STAR 80 +#define TK_SLASH 81 +#define TK_REM 82 +#define TK_CONCAT 83 +#define TK_UMINUS 84 +#define TK_UPLUS 85 +#define TK_BITNOT 86 +#define TK_STRING 87 +#define TK_JOIN_KW 88 +#define TK_INTEGER 89 +#define TK_CONSTRAINT 90 +#define TK_DEFAULT 91 +#define TK_FLOAT 92 +#define TK_NULL 93 +#define TK_PRIMARY 94 +#define TK_UNIQUE 95 +#define TK_CHECK 96 +#define TK_REFERENCES 97 +#define TK_COLLATE 98 +#define TK_ON 99 +#define TK_DELETE 100 +#define TK_UPDATE 101 +#define TK_INSERT 102 +#define TK_SET 103 +#define TK_DEFERRABLE 104 +#define TK_FOREIGN 105 +#define TK_DROP 106 +#define TK_UNION 107 +#define TK_ALL 108 +#define TK_INTERSECT 109 +#define TK_EXCEPT 110 +#define TK_SELECT 111 +#define TK_DISTINCT 112 +#define TK_DOT 113 +#define TK_FROM 114 +#define TK_JOIN 115 +#define TK_USING 116 +#define TK_ORDER 117 +#define TK_BY 118 +#define TK_GROUP 119 +#define TK_HAVING 120 +#define TK_LIMIT 121 +#define TK_WHERE 122 +#define TK_INTO 123 +#define TK_VALUES 124 +#define TK_VARIABLE 125 +#define TK_CASE 126 +#define TK_WHEN 127 +#define TK_THEN 128 +#define TK_ELSE 129 +#define TK_INDEX 130 diff --git a/kexi/3rdparty/kexisql/src/parse.out b/kexi/3rdparty/kexisql/src/parse.out new file mode 100644 index 00000000..0f8b03c1 --- /dev/null +++ b/kexi/3rdparty/kexisql/src/parse.out @@ -0,0 +1,10575 @@ + State 0: + input ::= * cmdlist + cmdlist ::= * ecmd + cmdlist ::= * cmdlist ecmd + ecmd ::= * explain cmdx SEMI + ecmd ::= * SEMI + explain ::= * EXPLAIN + (7) explain ::= * + + EXPLAIN shift 553 + SEMI shift 552 + cmdlist shift 1 + ecmd shift 554 + explain shift 3 + input accept + {default} reduce 7 + +State 1: + (0) input ::= cmdlist * + cmdlist ::= cmdlist * ecmd + ecmd ::= * explain cmdx SEMI + ecmd ::= * SEMI + explain ::= * EXPLAIN + (7) explain ::= * + + $ reduce 0 + EXPLAIN shift 553 + SEMI shift 552 + ecmd shift 2 + explain shift 3 + {default} reduce 7 + +State 2: + (2) cmdlist ::= cmdlist ecmd * + + {default} reduce 2 + +State 3: + ecmd ::= explain * cmdx SEMI + cmdx ::= * cmd + cmd ::= * BEGIN trans_opt onconf + cmd ::= * COMMIT trans_opt + cmd ::= * END trans_opt + cmd ::= * ROLLBACK trans_opt + cmd ::= * create_table create_table_args + create_table ::= * CREATE temp TABLE nm + cmd ::= * DROP TABLE nm + cmd ::= * CREATE temp VIEW nm AS select + cmd ::= * DROP VIEW nm + cmd ::= * select + select ::= * oneselect + select ::= * select multiselect_op oneselect + oneselect ::= * SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt + cmd ::= * DELETE FROM nm dbnm where_opt + cmd ::= * UPDATE orconf nm dbnm SET setlist where_opt + cmd ::= * insert_cmd INTO nm dbnm inscollist_opt VALUES LP itemlist RP + cmd ::= * insert_cmd INTO nm dbnm inscollist_opt select + insert_cmd ::= * INSERT orconf + insert_cmd ::= * REPLACE + cmd ::= * CREATE temp uniqueflag INDEX nm ON nm dbnm LP idxlist RP onconf + cmd ::= * DROP INDEX nm dbnm + cmd ::= * COPY orconf nm dbnm FROM nm USING DELIMITERS STRING + cmd ::= * COPY orconf nm dbnm FROM nm + cmd ::= * VACUUM + cmd ::= * VACUUM nm + cmd ::= * PRAGMA ids EQ nm + cmd ::= * PRAGMA ids EQ ON + cmd ::= * PRAGMA ids EQ plus_num + cmd ::= * PRAGMA ids EQ minus_num + cmd ::= * PRAGMA ids LP nm RP + cmd ::= * PRAGMA ids + cmd ::= * CREATE trigger_decl BEGIN trigger_cmd_list END + cmd ::= * DROP TRIGGER nm dbnm + cmd ::= * ATTACH database_kw_opt ids AS nm + cmd ::= * DETACH database_kw_opt nm + + ATTACH shift 543 + BEGIN shift 7 + COMMIT shift 23 + COPY shift 515 + CREATE shift 388 + DELETE shift 490 + DETACH shift 549 + DROP shift 478 + END shift 25 + INSERT shift 512 + PRAGMA shift 526 + REPLACE shift 514 + ROLLBACK shift 27 + SELECT shift 73 + UPDATE shift 495 + VACUUM shift 524 + cmd shift 6 + cmdx shift 4 + create_table shift 29 + insert_cmd shift 502 + oneselect shift 69 + select shift 489 + +State 4: + ecmd ::= explain cmdx * SEMI + + SEMI shift 5 + +State 5: + (3) ecmd ::= explain cmdx SEMI * + + {default} reduce 3 + +State 6: + (5) cmdx ::= cmd * + + SEMI reduce 5 + +State 7: + cmd ::= BEGIN * trans_opt onconf + (9) trans_opt ::= * + trans_opt ::= * TRANSACTION + trans_opt ::= * TRANSACTION nm + + TRANSACTION shift 18 + trans_opt shift 8 + {default} reduce 9 + +State 8: + cmd ::= BEGIN trans_opt * onconf + (88) onconf ::= * + onconf ::= * ON CONFLICT resolvetype + + ON shift 10 + SEMI reduce 88 + onconf shift 9 + +State 9: + (8) cmd ::= BEGIN trans_opt onconf * + + SEMI reduce 8 + +State 10: + onconf ::= ON * CONFLICT resolvetype + + CONFLICT shift 11 + +State 11: + onconf ::= ON CONFLICT * resolvetype + resolvetype ::= * ROLLBACK + resolvetype ::= * ABORT + resolvetype ::= * FAIL + resolvetype ::= * IGNORE + resolvetype ::= * REPLACE + + ABORT shift 14 + FAIL shift 15 + IGNORE shift 16 + REPLACE shift 17 + ROLLBACK shift 13 + resolvetype shift 12 + +State 12: + (89) onconf ::= ON CONFLICT resolvetype * + + {default} reduce 89 + +State 13: + (92) resolvetype ::= ROLLBACK * + + {default} reduce 92 + +State 14: + (93) resolvetype ::= ABORT * + + {default} reduce 93 + +State 15: + (94) resolvetype ::= FAIL * + + {default} reduce 94 + +State 16: + (95) resolvetype ::= IGNORE * + + {default} reduce 95 + +State 17: + (96) resolvetype ::= REPLACE * + + {default} reduce 96 + +State 18: + (10) trans_opt ::= TRANSACTION * + trans_opt ::= TRANSACTION * nm + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + + ID shift 20 + JOIN_KW shift 22 + STRING shift 21 + nm shift 19 + {default} reduce 10 + +State 19: + (11) trans_opt ::= TRANSACTION nm * + + {default} reduce 11 + +State 20: + (28) nm ::= ID * + + {default} reduce 28 + +State 21: + (29) nm ::= STRING * + + {default} reduce 29 + +State 22: + (30) nm ::= JOIN_KW * + + {default} reduce 30 + +State 23: + (9) trans_opt ::= * + trans_opt ::= * TRANSACTION + trans_opt ::= * TRANSACTION nm + cmd ::= COMMIT * trans_opt + + SEMI reduce 9 + TRANSACTION shift 18 + trans_opt shift 24 + +State 24: + (12) cmd ::= COMMIT trans_opt * + + SEMI reduce 12 + +State 25: + (9) trans_opt ::= * + trans_opt ::= * TRANSACTION + trans_opt ::= * TRANSACTION nm + cmd ::= END * trans_opt + + SEMI reduce 9 + TRANSACTION shift 18 + trans_opt shift 26 + +State 26: + (13) cmd ::= END trans_opt * + + SEMI reduce 13 + +State 27: + (9) trans_opt ::= * + trans_opt ::= * TRANSACTION + trans_opt ::= * TRANSACTION nm + cmd ::= ROLLBACK * trans_opt + + SEMI reduce 9 + TRANSACTION shift 18 + trans_opt shift 28 + +State 28: + (14) cmd ::= ROLLBACK trans_opt * + + SEMI reduce 14 + +State 29: + cmd ::= create_table * create_table_args + create_table_args ::= * LP columnlist conslist_opt RP + create_table_args ::= * AS select + + AS shift 386 + LP shift 31 + create_table_args shift 30 + +State 30: + (15) cmd ::= create_table create_table_args * + + SEMI reduce 15 + +State 31: + create_table_args ::= LP * columnlist conslist_opt RP + columnlist ::= * columnlist COMMA column + columnlist ::= * column + column ::= * columnid type carglist + columnid ::= * nm + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + + ID shift 20 + JOIN_KW shift 22 + STRING shift 21 + column shift 385 + columnid shift 37 + columnlist shift 32 + nm shift 351 + +State 32: + create_table_args ::= LP columnlist * conslist_opt RP + columnlist ::= columnlist * COMMA column + (76) conslist_opt ::= * + conslist_opt ::= * COMMA conslist + + COMMA shift 35 + RP reduce 76 + conslist_opt shift 33 + +State 33: + create_table_args ::= LP columnlist conslist_opt * RP + + RP shift 34 + +State 34: + (19) create_table_args ::= LP columnlist conslist_opt RP * + + SEMI reduce 19 + +State 35: + columnlist ::= columnlist COMMA * column + column ::= * columnid type carglist + columnid ::= * nm + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + conslist_opt ::= COMMA * conslist + conslist ::= * conslist COMMA tcons + conslist ::= * conslist tcons + conslist ::= * tcons + tcons ::= * CONSTRAINT nm + tcons ::= * PRIMARY KEY LP idxlist RP onconf + tcons ::= * UNIQUE LP idxlist RP onconf + tcons ::= * CHECK expr onconf + tcons ::= * FOREIGN KEY LP idxlist RP REFERENCES nm idxlist_opt refargs defer_subclause_opt + + CHECK shift 368 + CONSTRAINT shift 355 + FOREIGN shift 371 + ID shift 20 + JOIN_KW shift 22 + PRIMARY shift 357 + STRING shift 21 + UNIQUE shift 363 + column shift 36 + columnid shift 37 + conslist shift 352 + nm shift 351 + tcons shift 384 + +State 36: + (21) columnlist ::= columnlist COMMA column * + + {default} reduce 21 + +State 37: + column ::= columnid * type carglist + ids ::= * ID + ids ::= * STRING + (31) type ::= * + type ::= * typename + type ::= * typename LP signed RP + type ::= * typename LP signed COMMA signed RP + typename ::= * ids + typename ::= * typename ids + + ID shift 256 + STRING shift 257 + ids shift 350 + type shift 38 + typename shift 342 + {default} reduce 31 + +State 38: + column ::= columnid type * carglist + carglist ::= * carglist carg + (41) carglist ::= * + + carglist shift 39 + {default} reduce 41 + +State 39: + (23) column ::= columnid type carglist * + carglist ::= carglist * carg + carg ::= * CONSTRAINT nm ccons + carg ::= * ccons + carg ::= * DEFAULT STRING + carg ::= * DEFAULT ID + carg ::= * DEFAULT INTEGER + carg ::= * DEFAULT PLUS INTEGER + carg ::= * DEFAULT MINUS INTEGER + carg ::= * DEFAULT FLOAT + carg ::= * DEFAULT PLUS FLOAT + carg ::= * DEFAULT MINUS FLOAT + carg ::= * DEFAULT NULL + ccons ::= * NULL onconf + ccons ::= * NOT NULL onconf + ccons ::= * PRIMARY KEY sortorder onconf + ccons ::= * UNIQUE onconf + ccons ::= * CHECK LP expr RP onconf + ccons ::= * REFERENCES nm idxlist_opt refargs + ccons ::= * defer_subclause + ccons ::= * COLLATE id + defer_subclause ::= * NOT DEFERRABLE init_deferred_pred_opt + defer_subclause ::= * DEFERRABLE init_deferred_pred_opt + + CHECK shift 62 + COLLATE shift 325 + CONSTRAINT shift 41 + DEFAULT shift 330 + DEFERRABLE shift 327 + NOT shift 46 + NULL shift 44 + PRIMARY shift 54 + REFERENCES shift 302 + UNIQUE shift 60 + carg shift 40 + ccons shift 329 + defer_subclause shift 324 + {default} reduce 23 + +State 40: + (40) carglist ::= carglist carg * + + {default} reduce 40 + +State 41: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + carg ::= CONSTRAINT * nm ccons + + ID shift 20 + JOIN_KW shift 22 + STRING shift 21 + nm shift 42 + +State 42: + carg ::= CONSTRAINT nm * ccons + ccons ::= * NULL onconf + ccons ::= * NOT NULL onconf + ccons ::= * PRIMARY KEY sortorder onconf + ccons ::= * UNIQUE onconf + ccons ::= * CHECK LP expr RP onconf + ccons ::= * REFERENCES nm idxlist_opt refargs + ccons ::= * defer_subclause + ccons ::= * COLLATE id + defer_subclause ::= * NOT DEFERRABLE init_deferred_pred_opt + defer_subclause ::= * DEFERRABLE init_deferred_pred_opt + + CHECK shift 62 + COLLATE shift 325 + DEFERRABLE shift 327 + NOT shift 46 + NULL shift 44 + PRIMARY shift 54 + REFERENCES shift 302 + UNIQUE shift 60 + ccons shift 43 + defer_subclause shift 324 + +State 43: + (42) carg ::= CONSTRAINT nm ccons * + + {default} reduce 42 + +State 44: + ccons ::= NULL * onconf + (88) onconf ::= * + onconf ::= * ON CONFLICT resolvetype + + ON shift 10 + onconf shift 45 + {default} reduce 88 + +State 45: + (53) ccons ::= NULL onconf * + + {default} reduce 53 + +State 46: + ccons ::= NOT * NULL onconf + defer_subclause ::= NOT * DEFERRABLE init_deferred_pred_opt + + DEFERRABLE shift 49 + NULL shift 47 + +State 47: + ccons ::= NOT NULL * onconf + (88) onconf ::= * + onconf ::= * ON CONFLICT resolvetype + + ON shift 10 + onconf shift 48 + {default} reduce 88 + +State 48: + (54) ccons ::= NOT NULL onconf * + + {default} reduce 54 + +State 49: + defer_subclause ::= NOT DEFERRABLE * init_deferred_pred_opt + (73) init_deferred_pred_opt ::= * + init_deferred_pred_opt ::= * INITIALLY DEFERRED + init_deferred_pred_opt ::= * INITIALLY IMMEDIATE + + INITIALLY shift 51 + init_deferred_pred_opt shift 50 + {default} reduce 73 + +State 50: + (71) defer_subclause ::= NOT DEFERRABLE init_deferred_pred_opt * + + {default} reduce 71 + +State 51: + init_deferred_pred_opt ::= INITIALLY * DEFERRED + init_deferred_pred_opt ::= INITIALLY * IMMEDIATE + + DEFERRED shift 52 + IMMEDIATE shift 53 + +State 52: + (74) init_deferred_pred_opt ::= INITIALLY DEFERRED * + + {default} reduce 74 + +State 53: + (75) init_deferred_pred_opt ::= INITIALLY IMMEDIATE * + + {default} reduce 75 + +State 54: + ccons ::= PRIMARY * KEY sortorder onconf + + KEY shift 55 + +State 55: + ccons ::= PRIMARY KEY * sortorder onconf + sortorder ::= * ASC + sortorder ::= * DESC + (143) sortorder ::= * + + ASC shift 58 + DESC shift 59 + sortorder shift 56 + {default} reduce 143 + +State 56: + ccons ::= PRIMARY KEY sortorder * onconf + (88) onconf ::= * + onconf ::= * ON CONFLICT resolvetype + + ON shift 10 + onconf shift 57 + {default} reduce 88 + +State 57: + (55) ccons ::= PRIMARY KEY sortorder onconf * + + {default} reduce 55 + +State 58: + (141) sortorder ::= ASC * + + {default} reduce 141 + +State 59: + (142) sortorder ::= DESC * + + {default} reduce 142 + +State 60: + ccons ::= UNIQUE * onconf + (88) onconf ::= * + onconf ::= * ON CONFLICT resolvetype + + ON shift 10 + onconf shift 61 + {default} reduce 88 + +State 61: + (56) ccons ::= UNIQUE onconf * + + {default} reduce 56 + +State 62: + ccons ::= CHECK * LP expr RP onconf + + LP shift 63 + +State 63: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + ccons ::= CHECK LP * expr RP onconf + expr ::= * LP expr RP + expr ::= * NULL + expr ::= * ID + expr ::= * JOIN_KW + expr ::= * nm DOT nm + expr ::= * nm DOT nm DOT nm + expr ::= * expr ORACLE_OUTER_JOIN + expr ::= * INTEGER + expr ::= * FLOAT + expr ::= * STRING + expr ::= * ID LP exprlist RP + expr ::= * ID LP STAR RP + expr ::= * expr AND expr + expr ::= * expr OR expr + expr ::= * expr LT expr + expr ::= * expr GT expr + expr ::= * expr LE expr + expr ::= * expr GE expr + expr ::= * expr NE expr + expr ::= * expr EQ expr + expr ::= * expr BITAND expr + expr ::= * expr BITOR expr + expr ::= * expr LSHIFT expr + expr ::= * expr RSHIFT expr + expr ::= * expr likeop expr + expr ::= * expr NOT likeop expr + expr ::= * expr PLUS expr + expr ::= * expr MINUS expr + expr ::= * expr STAR expr + expr ::= * expr SLASH expr + expr ::= * expr REM expr + expr ::= * expr CONCAT expr + expr ::= * expr ISNULL + expr ::= * expr IS NULL + expr ::= * expr NOTNULL + expr ::= * expr NOT NULL + expr ::= * expr IS NOT NULL + expr ::= * NOT expr + expr ::= * BITNOT expr + expr ::= * MINUS expr + expr ::= * PLUS expr + expr ::= * LP select RP + expr ::= * expr BETWEEN expr AND expr + expr ::= * expr NOT BETWEEN expr AND expr + expr ::= * expr IN LP exprlist RP + expr ::= * expr IN LP select RP + expr ::= * expr NOT IN LP exprlist RP + expr ::= * expr NOT IN LP select RP + expr ::= * CASE case_operand case_exprlist case_else END + expr ::= * RAISE LP IGNORE RP + expr ::= * RAISE LP ROLLBACK COMMA nm RP + expr ::= * RAISE LP ABORT COMMA nm RP + expr ::= * RAISE LP FAIL COMMA nm RP + + BITNOT shift 177 + CASE shift 183 + FLOAT shift 174 + ID shift 64 + INTEGER shift 173 + JOIN_KW shift 67 + LP shift 68 + MINUS shift 179 + NOT shift 175 + NULL shift 106 + PLUS shift 181 + RAISE shift 193 + STRING shift 66 + expr shift 299 + nm shift 107 + +State 64: + (28) nm ::= ID * + (172) expr ::= ID * + expr ::= ID * LP exprlist RP + expr ::= ID * LP STAR RP + + DOT reduce 28 + LP shift 65 + {default} reduce 172 + +State 65: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + expr ::= * LP expr RP + expr ::= * NULL + expr ::= * ID + expr ::= * JOIN_KW + expr ::= * nm DOT nm + expr ::= * nm DOT nm DOT nm + expr ::= * expr ORACLE_OUTER_JOIN + expr ::= * INTEGER + expr ::= * FLOAT + expr ::= * STRING + expr ::= * ID LP exprlist RP + expr ::= ID LP * exprlist RP + expr ::= * ID LP STAR RP + expr ::= ID LP * STAR RP + expr ::= * expr AND expr + expr ::= * expr OR expr + expr ::= * expr LT expr + expr ::= * expr GT expr + expr ::= * expr LE expr + expr ::= * expr GE expr + expr ::= * expr NE expr + expr ::= * expr EQ expr + expr ::= * expr BITAND expr + expr ::= * expr BITOR expr + expr ::= * expr LSHIFT expr + expr ::= * expr RSHIFT expr + expr ::= * expr likeop expr + expr ::= * expr NOT likeop expr + expr ::= * expr PLUS expr + expr ::= * expr MINUS expr + expr ::= * expr STAR expr + expr ::= * expr SLASH expr + expr ::= * expr REM expr + expr ::= * expr CONCAT expr + expr ::= * expr ISNULL + expr ::= * expr IS NULL + expr ::= * expr NOTNULL + expr ::= * expr NOT NULL + expr ::= * expr IS NOT NULL + expr ::= * NOT expr + expr ::= * BITNOT expr + expr ::= * MINUS expr + expr ::= * PLUS expr + expr ::= * LP select RP + expr ::= * expr BETWEEN expr AND expr + expr ::= * expr NOT BETWEEN expr AND expr + expr ::= * expr IN LP exprlist RP + expr ::= * expr IN LP select RP + expr ::= * expr NOT IN LP exprlist RP + expr ::= * expr NOT IN LP select RP + expr ::= * CASE case_operand case_exprlist case_else END + exprlist ::= * exprlist COMMA expritem + exprlist ::= * expritem + expritem ::= * expr + (230) expritem ::= * + expr ::= * RAISE LP IGNORE RP + expr ::= * RAISE LP ROLLBACK COMMA nm RP + expr ::= * RAISE LP ABORT COMMA nm RP + expr ::= * RAISE LP FAIL COMMA nm RP + + BITNOT shift 177 + CASE shift 183 + FLOAT shift 174 + ID shift 64 + INTEGER shift 173 + JOIN_KW shift 67 + LP shift 68 + MINUS shift 179 + NOT shift 175 + NULL shift 106 + PLUS shift 181 + RAISE shift 193 + STAR shift 297 + STRING shift 66 + expr shift 172 + expritem shift 219 + exprlist shift 295 + nm shift 107 + {default} reduce 230 + +State 66: + (29) nm ::= STRING * + (179) expr ::= STRING * + + DOT reduce 29 + {default} reduce 179 + +State 67: + (30) nm ::= JOIN_KW * + (173) expr ::= JOIN_KW * + + DOT reduce 30 + {default} reduce 173 + +State 68: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + select ::= * oneselect + select ::= * select multiselect_op oneselect + oneselect ::= * SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt + expr ::= * LP expr RP + expr ::= LP * expr RP + expr ::= * NULL + expr ::= * ID + expr ::= * JOIN_KW + expr ::= * nm DOT nm + expr ::= * nm DOT nm DOT nm + expr ::= * expr ORACLE_OUTER_JOIN + expr ::= * INTEGER + expr ::= * FLOAT + expr ::= * STRING + expr ::= * ID LP exprlist RP + expr ::= * ID LP STAR RP + expr ::= * expr AND expr + expr ::= * expr OR expr + expr ::= * expr LT expr + expr ::= * expr GT expr + expr ::= * expr LE expr + expr ::= * expr GE expr + expr ::= * expr NE expr + expr ::= * expr EQ expr + expr ::= * expr BITAND expr + expr ::= * expr BITOR expr + expr ::= * expr LSHIFT expr + expr ::= * expr RSHIFT expr + expr ::= * expr likeop expr + expr ::= * expr NOT likeop expr + expr ::= * expr PLUS expr + expr ::= * expr MINUS expr + expr ::= * expr STAR expr + expr ::= * expr SLASH expr + expr ::= * expr REM expr + expr ::= * expr CONCAT expr + expr ::= * expr ISNULL + expr ::= * expr IS NULL + expr ::= * expr NOTNULL + expr ::= * expr NOT NULL + expr ::= * expr IS NOT NULL + expr ::= * NOT expr + expr ::= * BITNOT expr + expr ::= * MINUS expr + expr ::= * PLUS expr + expr ::= * LP select RP + expr ::= LP * select RP + expr ::= * expr BETWEEN expr AND expr + expr ::= * expr NOT BETWEEN expr AND expr + expr ::= * expr IN LP exprlist RP + expr ::= * expr IN LP select RP + expr ::= * expr NOT IN LP exprlist RP + expr ::= * expr NOT IN LP select RP + expr ::= * CASE case_operand case_exprlist case_else END + expr ::= * RAISE LP IGNORE RP + expr ::= * RAISE LP ROLLBACK COMMA nm RP + expr ::= * RAISE LP ABORT COMMA nm RP + expr ::= * RAISE LP FAIL COMMA nm RP + + BITNOT shift 177 + CASE shift 183 + FLOAT shift 174 + ID shift 64 + INTEGER shift 173 + JOIN_KW shift 67 + LP shift 68 + MINUS shift 179 + NOT shift 175 + NULL shift 106 + PLUS shift 181 + RAISE shift 193 + SELECT shift 73 + STRING shift 66 + expr shift 293 + nm shift 107 + oneselect shift 69 + select shift 70 + +State 69: + (101) select ::= oneselect * + + {default} reduce 101 + +State 70: + select ::= select * multiselect_op oneselect + multiselect_op ::= * UNION + multiselect_op ::= * UNION ALL + multiselect_op ::= * INTERSECT + multiselect_op ::= * EXCEPT + expr ::= LP select * RP + + EXCEPT shift 170 + INTERSECT shift 169 + RP shift 292 + UNION shift 167 + multiselect_op shift 71 + +State 71: + select ::= select multiselect_op * oneselect + oneselect ::= * SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt + + SELECT shift 73 + oneselect shift 72 + +State 72: + (102) select ::= select multiselect_op oneselect * + + {default} reduce 102 + +State 73: + oneselect ::= SELECT * distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt + distinct ::= * DISTINCT + distinct ::= * ALL + (110) distinct ::= * + + ALL shift 291 + DISTINCT shift 290 + distinct shift 74 + {default} reduce 110 + +State 74: + oneselect ::= SELECT distinct * selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt + sclp ::= * selcollist COMMA + (112) sclp ::= * + selcollist ::= * sclp expr as + selcollist ::= * sclp STAR + selcollist ::= * sclp nm DOT STAR + + sclp shift 283 + selcollist shift 75 + {default} reduce 112 + +State 75: + oneselect ::= SELECT distinct selcollist * from where_opt groupby_opt having_opt orderby_opt limit_opt + sclp ::= selcollist * COMMA + (119) from ::= * + from ::= * FROM seltablist + + COMMA shift 241 + FROM shift 242 + from shift 76 + {default} reduce 119 + +State 76: + oneselect ::= SELECT distinct selcollist from * where_opt groupby_opt having_opt orderby_opt limit_opt + (155) where_opt ::= * + where_opt ::= * WHERE expr + + WHERE shift 239 + where_opt shift 77 + {default} reduce 155 + +State 77: + oneselect ::= SELECT distinct selcollist from where_opt * groupby_opt having_opt orderby_opt limit_opt + (146) groupby_opt ::= * + groupby_opt ::= * GROUP BY exprlist + + GROUP shift 236 + groupby_opt shift 78 + {default} reduce 146 + +State 78: + oneselect ::= SELECT distinct selcollist from where_opt groupby_opt * having_opt orderby_opt limit_opt + (148) having_opt ::= * + having_opt ::= * HAVING expr + + HAVING shift 234 + having_opt shift 79 + {default} reduce 148 + +State 79: + oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt * orderby_opt limit_opt + (136) orderby_opt ::= * + orderby_opt ::= * ORDER BY sortlist + + ORDER shift 93 + orderby_opt shift 80 + {default} reduce 136 + +State 80: + oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt * limit_opt + (150) limit_opt ::= * + limit_opt ::= * LIMIT signed + limit_opt ::= * LIMIT signed OFFSET signed + limit_opt ::= * LIMIT signed COMMA signed + + LIMIT shift 82 + limit_opt shift 81 + {default} reduce 150 + +State 81: + (107) oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt * + + {default} reduce 107 + +State 82: + signed ::= * INTEGER + signed ::= * PLUS INTEGER + signed ::= * MINUS INTEGER + limit_opt ::= LIMIT * signed + limit_opt ::= LIMIT * signed OFFSET signed + limit_opt ::= LIMIT * signed COMMA signed + + INTEGER shift 83 + MINUS shift 86 + PLUS shift 84 + signed shift 88 + +State 83: + (37) signed ::= INTEGER * + + {default} reduce 37 + +State 84: + signed ::= PLUS * INTEGER + + INTEGER shift 85 + +State 85: + (38) signed ::= PLUS INTEGER * + + {default} reduce 38 + +State 86: + signed ::= MINUS * INTEGER + + INTEGER shift 87 + +State 87: + (39) signed ::= MINUS INTEGER * + + {default} reduce 39 + +State 88: + (151) limit_opt ::= LIMIT signed * + limit_opt ::= LIMIT signed * OFFSET signed + limit_opt ::= LIMIT signed * COMMA signed + + COMMA shift 91 + OFFSET shift 89 + {default} reduce 151 + +State 89: + signed ::= * INTEGER + signed ::= * PLUS INTEGER + signed ::= * MINUS INTEGER + limit_opt ::= LIMIT signed OFFSET * signed + + INTEGER shift 83 + MINUS shift 86 + PLUS shift 84 + signed shift 90 + +State 90: + (152) limit_opt ::= LIMIT signed OFFSET signed * + + {default} reduce 152 + +State 91: + signed ::= * INTEGER + signed ::= * PLUS INTEGER + signed ::= * MINUS INTEGER + limit_opt ::= LIMIT signed COMMA * signed + + INTEGER shift 83 + MINUS shift 86 + PLUS shift 84 + signed shift 92 + +State 92: + (153) limit_opt ::= LIMIT signed COMMA signed * + + {default} reduce 153 + +State 93: + orderby_opt ::= ORDER * BY sortlist + + BY shift 94 + +State 94: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + orderby_opt ::= ORDER BY * sortlist + sortlist ::= * sortlist COMMA sortitem collate sortorder + sortlist ::= * sortitem collate sortorder + sortitem ::= * expr + expr ::= * LP expr RP + expr ::= * NULL + expr ::= * ID + expr ::= * JOIN_KW + expr ::= * nm DOT nm + expr ::= * nm DOT nm DOT nm + expr ::= * expr ORACLE_OUTER_JOIN + expr ::= * INTEGER + expr ::= * FLOAT + expr ::= * STRING + expr ::= * ID LP exprlist RP + expr ::= * ID LP STAR RP + expr ::= * expr AND expr + expr ::= * expr OR expr + expr ::= * expr LT expr + expr ::= * expr GT expr + expr ::= * expr LE expr + expr ::= * expr GE expr + expr ::= * expr NE expr + expr ::= * expr EQ expr + expr ::= * expr BITAND expr + expr ::= * expr BITOR expr + expr ::= * expr LSHIFT expr + expr ::= * expr RSHIFT expr + expr ::= * expr likeop expr + expr ::= * expr NOT likeop expr + expr ::= * expr PLUS expr + expr ::= * expr MINUS expr + expr ::= * expr STAR expr + expr ::= * expr SLASH expr + expr ::= * expr REM expr + expr ::= * expr CONCAT expr + expr ::= * expr ISNULL + expr ::= * expr IS NULL + expr ::= * expr NOTNULL + expr ::= * expr NOT NULL + expr ::= * expr IS NOT NULL + expr ::= * NOT expr + expr ::= * BITNOT expr + expr ::= * MINUS expr + expr ::= * PLUS expr + expr ::= * LP select RP + expr ::= * expr BETWEEN expr AND expr + expr ::= * expr NOT BETWEEN expr AND expr + expr ::= * expr IN LP exprlist RP + expr ::= * expr IN LP select RP + expr ::= * expr NOT IN LP exprlist RP + expr ::= * expr NOT IN LP select RP + expr ::= * CASE case_operand case_exprlist case_else END + expr ::= * RAISE LP IGNORE RP + expr ::= * RAISE LP ROLLBACK COMMA nm RP + expr ::= * RAISE LP ABORT COMMA nm RP + expr ::= * RAISE LP FAIL COMMA nm RP + + BITNOT shift 177 + CASE shift 183 + FLOAT shift 174 + ID shift 64 + INTEGER shift 173 + JOIN_KW shift 67 + LP shift 68 + MINUS shift 179 + NOT shift 175 + NULL shift 106 + PLUS shift 181 + RAISE shift 193 + STRING shift 66 + expr shift 103 + nm shift 107 + sortitem shift 231 + sortlist shift 95 + +State 95: + (137) orderby_opt ::= ORDER BY sortlist * + sortlist ::= sortlist * COMMA sortitem collate sortorder + + COMMA shift 96 + {default} reduce 137 + +State 96: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + sortlist ::= sortlist COMMA * sortitem collate sortorder + sortitem ::= * expr + expr ::= * LP expr RP + expr ::= * NULL + expr ::= * ID + expr ::= * JOIN_KW + expr ::= * nm DOT nm + expr ::= * nm DOT nm DOT nm + expr ::= * expr ORACLE_OUTER_JOIN + expr ::= * INTEGER + expr ::= * FLOAT + expr ::= * STRING + expr ::= * ID LP exprlist RP + expr ::= * ID LP STAR RP + expr ::= * expr AND expr + expr ::= * expr OR expr + expr ::= * expr LT expr + expr ::= * expr GT expr + expr ::= * expr LE expr + expr ::= * expr GE expr + expr ::= * expr NE expr + expr ::= * expr EQ expr + expr ::= * expr BITAND expr + expr ::= * expr BITOR expr + expr ::= * expr LSHIFT expr + expr ::= * expr RSHIFT expr + expr ::= * expr likeop expr + expr ::= * expr NOT likeop expr + expr ::= * expr PLUS expr + expr ::= * expr MINUS expr + expr ::= * expr STAR expr + expr ::= * expr SLASH expr + expr ::= * expr REM expr + expr ::= * expr CONCAT expr + expr ::= * expr ISNULL + expr ::= * expr IS NULL + expr ::= * expr NOTNULL + expr ::= * expr NOT NULL + expr ::= * expr IS NOT NULL + expr ::= * NOT expr + expr ::= * BITNOT expr + expr ::= * MINUS expr + expr ::= * PLUS expr + expr ::= * LP select RP + expr ::= * expr BETWEEN expr AND expr + expr ::= * expr NOT BETWEEN expr AND expr + expr ::= * expr IN LP exprlist RP + expr ::= * expr IN LP select RP + expr ::= * expr NOT IN LP exprlist RP + expr ::= * expr NOT IN LP select RP + expr ::= * CASE case_operand case_exprlist case_else END + expr ::= * RAISE LP IGNORE RP + expr ::= * RAISE LP ROLLBACK COMMA nm RP + expr ::= * RAISE LP ABORT COMMA nm RP + expr ::= * RAISE LP FAIL COMMA nm RP + + BITNOT shift 177 + CASE shift 183 + FLOAT shift 174 + ID shift 64 + INTEGER shift 173 + JOIN_KW shift 67 + LP shift 68 + MINUS shift 179 + NOT shift 175 + NULL shift 106 + PLUS shift 181 + RAISE shift 193 + STRING shift 66 + expr shift 103 + nm shift 107 + sortitem shift 97 + +State 97: + sortlist ::= sortlist COMMA sortitem * collate sortorder + (144) collate ::= * + collate ::= * COLLATE id + + COLLATE shift 100 + collate shift 98 + {default} reduce 144 + +State 98: + sortlist ::= sortlist COMMA sortitem collate * sortorder + sortorder ::= * ASC + sortorder ::= * DESC + (143) sortorder ::= * + + ASC shift 58 + DESC shift 59 + sortorder shift 99 + {default} reduce 143 + +State 99: + (138) sortlist ::= sortlist COMMA sortitem collate sortorder * + + {default} reduce 138 + +State 100: + id ::= * ID + collate ::= COLLATE * id + + ID shift 101 + id shift 102 + +State 101: + (25) id ::= ID * + + {default} reduce 25 + +State 102: + (145) collate ::= COLLATE id * + + {default} reduce 145 + +State 103: + (140) sortitem ::= expr * + expr ::= expr * ORACLE_OUTER_JOIN + expr ::= expr * AND expr + expr ::= expr * OR expr + expr ::= expr * LT expr + expr ::= expr * GT expr + expr ::= expr * LE expr + expr ::= expr * GE expr + expr ::= expr * NE expr + expr ::= expr * EQ expr + expr ::= expr * BITAND expr + expr ::= expr * BITOR expr + expr ::= expr * LSHIFT expr + expr ::= expr * RSHIFT expr + expr ::= expr * likeop expr + expr ::= expr * NOT likeop expr + likeop ::= * LIKE + likeop ::= * GLOB + expr ::= expr * PLUS expr + expr ::= expr * MINUS expr + expr ::= expr * STAR expr + expr ::= expr * SLASH expr + expr ::= expr * REM expr + expr ::= expr * CONCAT expr + expr ::= expr * ISNULL + expr ::= expr * IS NULL + expr ::= expr * NOTNULL + expr ::= expr * NOT NULL + expr ::= expr * IS NOT NULL + expr ::= expr * BETWEEN expr AND expr + expr ::= expr * NOT BETWEEN expr AND expr + expr ::= expr * IN LP exprlist RP + expr ::= expr * IN LP select RP + expr ::= expr * NOT IN LP exprlist RP + expr ::= expr * NOT IN LP select RP + + AND shift 105 + BETWEEN shift 160 + BITAND shift 127 + BITOR shift 129 + CONCAT shift 152 + EQ shift 125 + GE shift 121 + GLOB shift 141 + GT shift 117 + IN shift 164 + IS shift 155 + ISNULL shift 154 + LE shift 119 + LIKE shift 140 + LSHIFT shift 131 + LT shift 115 + MINUS shift 144 + NE shift 123 + NOT shift 137 + NOTNULL shift 159 + OR shift 113 + ORACLE_OUTER_JOIN shift 104 + PLUS shift 142 + REM shift 150 + RSHIFT shift 133 + SLASH shift 148 + STAR shift 146 + likeop shift 135 + {default} reduce 140 + +State 104: + (176) expr ::= expr ORACLE_OUTER_JOIN * + + {default} reduce 176 + +State 105: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + expr ::= * LP expr RP + expr ::= * NULL + expr ::= * ID + expr ::= * JOIN_KW + expr ::= * nm DOT nm + expr ::= * nm DOT nm DOT nm + expr ::= * expr ORACLE_OUTER_JOIN + expr ::= * INTEGER + expr ::= * FLOAT + expr ::= * STRING + expr ::= * ID LP exprlist RP + expr ::= * ID LP STAR RP + expr ::= * expr AND expr + expr ::= expr AND * expr + expr ::= * expr OR expr + expr ::= * expr LT expr + expr ::= * expr GT expr + expr ::= * expr LE expr + expr ::= * expr GE expr + expr ::= * expr NE expr + expr ::= * expr EQ expr + expr ::= * expr BITAND expr + expr ::= * expr BITOR expr + expr ::= * expr LSHIFT expr + expr ::= * expr RSHIFT expr + expr ::= * expr likeop expr + expr ::= * expr NOT likeop expr + expr ::= * expr PLUS expr + expr ::= * expr MINUS expr + expr ::= * expr STAR expr + expr ::= * expr SLASH expr + expr ::= * expr REM expr + expr ::= * expr CONCAT expr + expr ::= * expr ISNULL + expr ::= * expr IS NULL + expr ::= * expr NOTNULL + expr ::= * expr NOT NULL + expr ::= * expr IS NOT NULL + expr ::= * NOT expr + expr ::= * BITNOT expr + expr ::= * MINUS expr + expr ::= * PLUS expr + expr ::= * LP select RP + expr ::= * expr BETWEEN expr AND expr + expr ::= * expr NOT BETWEEN expr AND expr + expr ::= * expr IN LP exprlist RP + expr ::= * expr IN LP select RP + expr ::= * expr NOT IN LP exprlist RP + expr ::= * expr NOT IN LP select RP + expr ::= * CASE case_operand case_exprlist case_else END + expr ::= * RAISE LP IGNORE RP + expr ::= * RAISE LP ROLLBACK COMMA nm RP + expr ::= * RAISE LP ABORT COMMA nm RP + expr ::= * RAISE LP FAIL COMMA nm RP + + BITNOT shift 177 + CASE shift 183 + FLOAT shift 174 + ID shift 64 + INTEGER shift 173 + JOIN_KW shift 67 + LP shift 68 + MINUS shift 179 + NOT shift 175 + NULL shift 106 + PLUS shift 181 + RAISE shift 193 + STRING shift 66 + expr shift 112 + nm shift 107 + +State 106: + (171) expr ::= NULL * + + {default} reduce 171 + +State 107: + expr ::= nm * DOT nm + expr ::= nm * DOT nm DOT nm + + DOT shift 108 + +State 108: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + expr ::= nm DOT * nm + expr ::= nm DOT * nm DOT nm + + ID shift 20 + JOIN_KW shift 22 + STRING shift 21 + nm shift 109 + +State 109: + (174) expr ::= nm DOT nm * + expr ::= nm DOT nm * DOT nm + + DOT shift 110 + {default} reduce 174 + +State 110: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + expr ::= nm DOT nm DOT * nm + + ID shift 20 + JOIN_KW shift 22 + STRING shift 21 + nm shift 111 + +State 111: + (175) expr ::= nm DOT nm DOT nm * + + {default} reduce 175 + +State 112: + expr ::= expr * ORACLE_OUTER_JOIN + expr ::= expr * AND expr + (182) expr ::= expr AND expr * + expr ::= expr * OR expr + expr ::= expr * LT expr + expr ::= expr * GT expr + expr ::= expr * LE expr + expr ::= expr * GE expr + expr ::= expr * NE expr + expr ::= expr * EQ expr + expr ::= expr * BITAND expr + expr ::= expr * BITOR expr + expr ::= expr * LSHIFT expr + expr ::= expr * RSHIFT expr + expr ::= expr * likeop expr + expr ::= expr * NOT likeop expr + likeop ::= * LIKE + likeop ::= * GLOB + expr ::= expr * PLUS expr + expr ::= expr * MINUS expr + expr ::= expr * STAR expr + expr ::= expr * SLASH expr + expr ::= expr * REM expr + expr ::= expr * CONCAT expr + expr ::= expr * ISNULL + expr ::= expr * IS NULL + expr ::= expr * NOTNULL + expr ::= expr * NOT NULL + expr ::= expr * IS NOT NULL + expr ::= expr * BETWEEN expr AND expr + expr ::= expr * NOT BETWEEN expr AND expr + expr ::= expr * IN LP exprlist RP + expr ::= expr * IN LP select RP + expr ::= expr * NOT IN LP exprlist RP + expr ::= expr * NOT IN LP select RP + + BETWEEN shift 160 + BITAND shift 127 + BITOR shift 129 + CONCAT shift 152 + EQ shift 125 + GE shift 121 + GLOB shift 141 + GT shift 117 + IN shift 164 + IS shift 155 + ISNULL shift 154 + LE shift 119 + LIKE shift 140 + LSHIFT shift 131 + LT shift 115 + MINUS shift 144 + NE shift 123 + NOT shift 137 + NOTNULL shift 159 + ORACLE_OUTER_JOIN shift 104 + PLUS shift 142 + REM shift 150 + RSHIFT shift 133 + SLASH shift 148 + STAR shift 146 + likeop shift 135 + {default} reduce 182 + +State 113: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + expr ::= * LP expr RP + expr ::= * NULL + expr ::= * ID + expr ::= * JOIN_KW + expr ::= * nm DOT nm + expr ::= * nm DOT nm DOT nm + expr ::= * expr ORACLE_OUTER_JOIN + expr ::= * INTEGER + expr ::= * FLOAT + expr ::= * STRING + expr ::= * ID LP exprlist RP + expr ::= * ID LP STAR RP + expr ::= * expr AND expr + expr ::= * expr OR expr + expr ::= expr OR * expr + expr ::= * expr LT expr + expr ::= * expr GT expr + expr ::= * expr LE expr + expr ::= * expr GE expr + expr ::= * expr NE expr + expr ::= * expr EQ expr + expr ::= * expr BITAND expr + expr ::= * expr BITOR expr + expr ::= * expr LSHIFT expr + expr ::= * expr RSHIFT expr + expr ::= * expr likeop expr + expr ::= * expr NOT likeop expr + expr ::= * expr PLUS expr + expr ::= * expr MINUS expr + expr ::= * expr STAR expr + expr ::= * expr SLASH expr + expr ::= * expr REM expr + expr ::= * expr CONCAT expr + expr ::= * expr ISNULL + expr ::= * expr IS NULL + expr ::= * expr NOTNULL + expr ::= * expr NOT NULL + expr ::= * expr IS NOT NULL + expr ::= * NOT expr + expr ::= * BITNOT expr + expr ::= * MINUS expr + expr ::= * PLUS expr + expr ::= * LP select RP + expr ::= * expr BETWEEN expr AND expr + expr ::= * expr NOT BETWEEN expr AND expr + expr ::= * expr IN LP exprlist RP + expr ::= * expr IN LP select RP + expr ::= * expr NOT IN LP exprlist RP + expr ::= * expr NOT IN LP select RP + expr ::= * CASE case_operand case_exprlist case_else END + expr ::= * RAISE LP IGNORE RP + expr ::= * RAISE LP ROLLBACK COMMA nm RP + expr ::= * RAISE LP ABORT COMMA nm RP + expr ::= * RAISE LP FAIL COMMA nm RP + + BITNOT shift 177 + CASE shift 183 + FLOAT shift 174 + ID shift 64 + INTEGER shift 173 + JOIN_KW shift 67 + LP shift 68 + MINUS shift 179 + NOT shift 175 + NULL shift 106 + PLUS shift 181 + RAISE shift 193 + STRING shift 66 + expr shift 114 + nm shift 107 + +State 114: + expr ::= expr * ORACLE_OUTER_JOIN + expr ::= expr * AND expr + expr ::= expr * OR expr + (183) expr ::= expr OR expr * + expr ::= expr * LT expr + expr ::= expr * GT expr + expr ::= expr * LE expr + expr ::= expr * GE expr + expr ::= expr * NE expr + expr ::= expr * EQ expr + expr ::= expr * BITAND expr + expr ::= expr * BITOR expr + expr ::= expr * LSHIFT expr + expr ::= expr * RSHIFT expr + expr ::= expr * likeop expr + expr ::= expr * NOT likeop expr + likeop ::= * LIKE + likeop ::= * GLOB + expr ::= expr * PLUS expr + expr ::= expr * MINUS expr + expr ::= expr * STAR expr + expr ::= expr * SLASH expr + expr ::= expr * REM expr + expr ::= expr * CONCAT expr + expr ::= expr * ISNULL + expr ::= expr * IS NULL + expr ::= expr * NOTNULL + expr ::= expr * NOT NULL + expr ::= expr * IS NOT NULL + expr ::= expr * BETWEEN expr AND expr + expr ::= expr * NOT BETWEEN expr AND expr + expr ::= expr * IN LP exprlist RP + expr ::= expr * IN LP select RP + expr ::= expr * NOT IN LP exprlist RP + expr ::= expr * NOT IN LP select RP + + AND shift 105 + BETWEEN shift 160 + BITAND shift 127 + BITOR shift 129 + CONCAT shift 152 + EQ shift 125 + GE shift 121 + GLOB shift 141 + GT shift 117 + IN shift 164 + IS shift 155 + ISNULL shift 154 + LE shift 119 + LIKE shift 140 + LSHIFT shift 131 + LT shift 115 + MINUS shift 144 + NE shift 123 + NOT shift 137 + NOTNULL shift 159 + ORACLE_OUTER_JOIN shift 104 + PLUS shift 142 + REM shift 150 + RSHIFT shift 133 + SLASH shift 148 + STAR shift 146 + likeop shift 135 + {default} reduce 183 + +State 115: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + expr ::= * LP expr RP + expr ::= * NULL + expr ::= * ID + expr ::= * JOIN_KW + expr ::= * nm DOT nm + expr ::= * nm DOT nm DOT nm + expr ::= * expr ORACLE_OUTER_JOIN + expr ::= * INTEGER + expr ::= * FLOAT + expr ::= * STRING + expr ::= * ID LP exprlist RP + expr ::= * ID LP STAR RP + expr ::= * expr AND expr + expr ::= * expr OR expr + expr ::= * expr LT expr + expr ::= expr LT * expr + expr ::= * expr GT expr + expr ::= * expr LE expr + expr ::= * expr GE expr + expr ::= * expr NE expr + expr ::= * expr EQ expr + expr ::= * expr BITAND expr + expr ::= * expr BITOR expr + expr ::= * expr LSHIFT expr + expr ::= * expr RSHIFT expr + expr ::= * expr likeop expr + expr ::= * expr NOT likeop expr + expr ::= * expr PLUS expr + expr ::= * expr MINUS expr + expr ::= * expr STAR expr + expr ::= * expr SLASH expr + expr ::= * expr REM expr + expr ::= * expr CONCAT expr + expr ::= * expr ISNULL + expr ::= * expr IS NULL + expr ::= * expr NOTNULL + expr ::= * expr NOT NULL + expr ::= * expr IS NOT NULL + expr ::= * NOT expr + expr ::= * BITNOT expr + expr ::= * MINUS expr + expr ::= * PLUS expr + expr ::= * LP select RP + expr ::= * expr BETWEEN expr AND expr + expr ::= * expr NOT BETWEEN expr AND expr + expr ::= * expr IN LP exprlist RP + expr ::= * expr IN LP select RP + expr ::= * expr NOT IN LP exprlist RP + expr ::= * expr NOT IN LP select RP + expr ::= * CASE case_operand case_exprlist case_else END + expr ::= * RAISE LP IGNORE RP + expr ::= * RAISE LP ROLLBACK COMMA nm RP + expr ::= * RAISE LP ABORT COMMA nm RP + expr ::= * RAISE LP FAIL COMMA nm RP + + BITNOT shift 177 + CASE shift 183 + FLOAT shift 174 + ID shift 64 + INTEGER shift 173 + JOIN_KW shift 67 + LP shift 68 + MINUS shift 179 + NOT shift 175 + NULL shift 106 + PLUS shift 181 + RAISE shift 193 + STRING shift 66 + expr shift 116 + nm shift 107 + +State 116: + expr ::= expr * ORACLE_OUTER_JOIN + expr ::= expr * AND expr + expr ::= expr * OR expr + expr ::= expr * LT expr + (184) expr ::= expr LT expr * + expr ::= expr * GT expr + expr ::= expr * LE expr + expr ::= expr * GE expr + expr ::= expr * NE expr + expr ::= expr * EQ expr + expr ::= expr * BITAND expr + expr ::= expr * BITOR expr + expr ::= expr * LSHIFT expr + expr ::= expr * RSHIFT expr + expr ::= expr * likeop expr + expr ::= expr * NOT likeop expr + likeop ::= * LIKE + likeop ::= * GLOB + expr ::= expr * PLUS expr + expr ::= expr * MINUS expr + expr ::= expr * STAR expr + expr ::= expr * SLASH expr + expr ::= expr * REM expr + expr ::= expr * CONCAT expr + expr ::= expr * ISNULL + expr ::= expr * IS NULL + expr ::= expr * NOTNULL + expr ::= expr * NOT NULL + expr ::= expr * IS NOT NULL + expr ::= expr * BETWEEN expr AND expr + expr ::= expr * NOT BETWEEN expr AND expr + expr ::= expr * IN LP exprlist RP + expr ::= expr * IN LP select RP + expr ::= expr * NOT IN LP exprlist RP + expr ::= expr * NOT IN LP select RP + + BITAND shift 127 + BITOR shift 129 + CONCAT shift 152 + LSHIFT shift 131 + MINUS shift 144 + ORACLE_OUTER_JOIN shift 104 + PLUS shift 142 + REM shift 150 + RSHIFT shift 133 + SLASH shift 148 + STAR shift 146 + likeop shift 135 + {default} reduce 184 + +State 117: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + expr ::= * LP expr RP + expr ::= * NULL + expr ::= * ID + expr ::= * JOIN_KW + expr ::= * nm DOT nm + expr ::= * nm DOT nm DOT nm + expr ::= * expr ORACLE_OUTER_JOIN + expr ::= * INTEGER + expr ::= * FLOAT + expr ::= * STRING + expr ::= * ID LP exprlist RP + expr ::= * ID LP STAR RP + expr ::= * expr AND expr + expr ::= * expr OR expr + expr ::= * expr LT expr + expr ::= * expr GT expr + expr ::= expr GT * expr + expr ::= * expr LE expr + expr ::= * expr GE expr + expr ::= * expr NE expr + expr ::= * expr EQ expr + expr ::= * expr BITAND expr + expr ::= * expr BITOR expr + expr ::= * expr LSHIFT expr + expr ::= * expr RSHIFT expr + expr ::= * expr likeop expr + expr ::= * expr NOT likeop expr + expr ::= * expr PLUS expr + expr ::= * expr MINUS expr + expr ::= * expr STAR expr + expr ::= * expr SLASH expr + expr ::= * expr REM expr + expr ::= * expr CONCAT expr + expr ::= * expr ISNULL + expr ::= * expr IS NULL + expr ::= * expr NOTNULL + expr ::= * expr NOT NULL + expr ::= * expr IS NOT NULL + expr ::= * NOT expr + expr ::= * BITNOT expr + expr ::= * MINUS expr + expr ::= * PLUS expr + expr ::= * LP select RP + expr ::= * expr BETWEEN expr AND expr + expr ::= * expr NOT BETWEEN expr AND expr + expr ::= * expr IN LP exprlist RP + expr ::= * expr IN LP select RP + expr ::= * expr NOT IN LP exprlist RP + expr ::= * expr NOT IN LP select RP + expr ::= * CASE case_operand case_exprlist case_else END + expr ::= * RAISE LP IGNORE RP + expr ::= * RAISE LP ROLLBACK COMMA nm RP + expr ::= * RAISE LP ABORT COMMA nm RP + expr ::= * RAISE LP FAIL COMMA nm RP + + BITNOT shift 177 + CASE shift 183 + FLOAT shift 174 + ID shift 64 + INTEGER shift 173 + JOIN_KW shift 67 + LP shift 68 + MINUS shift 179 + NOT shift 175 + NULL shift 106 + PLUS shift 181 + RAISE shift 193 + STRING shift 66 + expr shift 118 + nm shift 107 + +State 118: + expr ::= expr * ORACLE_OUTER_JOIN + expr ::= expr * AND expr + expr ::= expr * OR expr + expr ::= expr * LT expr + expr ::= expr * GT expr + (185) expr ::= expr GT expr * + expr ::= expr * LE expr + expr ::= expr * GE expr + expr ::= expr * NE expr + expr ::= expr * EQ expr + expr ::= expr * BITAND expr + expr ::= expr * BITOR expr + expr ::= expr * LSHIFT expr + expr ::= expr * RSHIFT expr + expr ::= expr * likeop expr + expr ::= expr * NOT likeop expr + likeop ::= * LIKE + likeop ::= * GLOB + expr ::= expr * PLUS expr + expr ::= expr * MINUS expr + expr ::= expr * STAR expr + expr ::= expr * SLASH expr + expr ::= expr * REM expr + expr ::= expr * CONCAT expr + expr ::= expr * ISNULL + expr ::= expr * IS NULL + expr ::= expr * NOTNULL + expr ::= expr * NOT NULL + expr ::= expr * IS NOT NULL + expr ::= expr * BETWEEN expr AND expr + expr ::= expr * NOT BETWEEN expr AND expr + expr ::= expr * IN LP exprlist RP + expr ::= expr * IN LP select RP + expr ::= expr * NOT IN LP exprlist RP + expr ::= expr * NOT IN LP select RP + + BITAND shift 127 + BITOR shift 129 + CONCAT shift 152 + LSHIFT shift 131 + MINUS shift 144 + ORACLE_OUTER_JOIN shift 104 + PLUS shift 142 + REM shift 150 + RSHIFT shift 133 + SLASH shift 148 + STAR shift 146 + likeop shift 135 + {default} reduce 185 + +State 119: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + expr ::= * LP expr RP + expr ::= * NULL + expr ::= * ID + expr ::= * JOIN_KW + expr ::= * nm DOT nm + expr ::= * nm DOT nm DOT nm + expr ::= * expr ORACLE_OUTER_JOIN + expr ::= * INTEGER + expr ::= * FLOAT + expr ::= * STRING + expr ::= * ID LP exprlist RP + expr ::= * ID LP STAR RP + expr ::= * expr AND expr + expr ::= * expr OR expr + expr ::= * expr LT expr + expr ::= * expr GT expr + expr ::= * expr LE expr + expr ::= expr LE * expr + expr ::= * expr GE expr + expr ::= * expr NE expr + expr ::= * expr EQ expr + expr ::= * expr BITAND expr + expr ::= * expr BITOR expr + expr ::= * expr LSHIFT expr + expr ::= * expr RSHIFT expr + expr ::= * expr likeop expr + expr ::= * expr NOT likeop expr + expr ::= * expr PLUS expr + expr ::= * expr MINUS expr + expr ::= * expr STAR expr + expr ::= * expr SLASH expr + expr ::= * expr REM expr + expr ::= * expr CONCAT expr + expr ::= * expr ISNULL + expr ::= * expr IS NULL + expr ::= * expr NOTNULL + expr ::= * expr NOT NULL + expr ::= * expr IS NOT NULL + expr ::= * NOT expr + expr ::= * BITNOT expr + expr ::= * MINUS expr + expr ::= * PLUS expr + expr ::= * LP select RP + expr ::= * expr BETWEEN expr AND expr + expr ::= * expr NOT BETWEEN expr AND expr + expr ::= * expr IN LP exprlist RP + expr ::= * expr IN LP select RP + expr ::= * expr NOT IN LP exprlist RP + expr ::= * expr NOT IN LP select RP + expr ::= * CASE case_operand case_exprlist case_else END + expr ::= * RAISE LP IGNORE RP + expr ::= * RAISE LP ROLLBACK COMMA nm RP + expr ::= * RAISE LP ABORT COMMA nm RP + expr ::= * RAISE LP FAIL COMMA nm RP + + BITNOT shift 177 + CASE shift 183 + FLOAT shift 174 + ID shift 64 + INTEGER shift 173 + JOIN_KW shift 67 + LP shift 68 + MINUS shift 179 + NOT shift 175 + NULL shift 106 + PLUS shift 181 + RAISE shift 193 + STRING shift 66 + expr shift 120 + nm shift 107 + +State 120: + expr ::= expr * ORACLE_OUTER_JOIN + expr ::= expr * AND expr + expr ::= expr * OR expr + expr ::= expr * LT expr + expr ::= expr * GT expr + expr ::= expr * LE expr + (186) expr ::= expr LE expr * + expr ::= expr * GE expr + expr ::= expr * NE expr + expr ::= expr * EQ expr + expr ::= expr * BITAND expr + expr ::= expr * BITOR expr + expr ::= expr * LSHIFT expr + expr ::= expr * RSHIFT expr + expr ::= expr * likeop expr + expr ::= expr * NOT likeop expr + likeop ::= * LIKE + likeop ::= * GLOB + expr ::= expr * PLUS expr + expr ::= expr * MINUS expr + expr ::= expr * STAR expr + expr ::= expr * SLASH expr + expr ::= expr * REM expr + expr ::= expr * CONCAT expr + expr ::= expr * ISNULL + expr ::= expr * IS NULL + expr ::= expr * NOTNULL + expr ::= expr * NOT NULL + expr ::= expr * IS NOT NULL + expr ::= expr * BETWEEN expr AND expr + expr ::= expr * NOT BETWEEN expr AND expr + expr ::= expr * IN LP exprlist RP + expr ::= expr * IN LP select RP + expr ::= expr * NOT IN LP exprlist RP + expr ::= expr * NOT IN LP select RP + + BITAND shift 127 + BITOR shift 129 + CONCAT shift 152 + LSHIFT shift 131 + MINUS shift 144 + ORACLE_OUTER_JOIN shift 104 + PLUS shift 142 + REM shift 150 + RSHIFT shift 133 + SLASH shift 148 + STAR shift 146 + likeop shift 135 + {default} reduce 186 + +State 121: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + expr ::= * LP expr RP + expr ::= * NULL + expr ::= * ID + expr ::= * JOIN_KW + expr ::= * nm DOT nm + expr ::= * nm DOT nm DOT nm + expr ::= * expr ORACLE_OUTER_JOIN + expr ::= * INTEGER + expr ::= * FLOAT + expr ::= * STRING + expr ::= * ID LP exprlist RP + expr ::= * ID LP STAR RP + expr ::= * expr AND expr + expr ::= * expr OR expr + expr ::= * expr LT expr + expr ::= * expr GT expr + expr ::= * expr LE expr + expr ::= * expr GE expr + expr ::= expr GE * expr + expr ::= * expr NE expr + expr ::= * expr EQ expr + expr ::= * expr BITAND expr + expr ::= * expr BITOR expr + expr ::= * expr LSHIFT expr + expr ::= * expr RSHIFT expr + expr ::= * expr likeop expr + expr ::= * expr NOT likeop expr + expr ::= * expr PLUS expr + expr ::= * expr MINUS expr + expr ::= * expr STAR expr + expr ::= * expr SLASH expr + expr ::= * expr REM expr + expr ::= * expr CONCAT expr + expr ::= * expr ISNULL + expr ::= * expr IS NULL + expr ::= * expr NOTNULL + expr ::= * expr NOT NULL + expr ::= * expr IS NOT NULL + expr ::= * NOT expr + expr ::= * BITNOT expr + expr ::= * MINUS expr + expr ::= * PLUS expr + expr ::= * LP select RP + expr ::= * expr BETWEEN expr AND expr + expr ::= * expr NOT BETWEEN expr AND expr + expr ::= * expr IN LP exprlist RP + expr ::= * expr IN LP select RP + expr ::= * expr NOT IN LP exprlist RP + expr ::= * expr NOT IN LP select RP + expr ::= * CASE case_operand case_exprlist case_else END + expr ::= * RAISE LP IGNORE RP + expr ::= * RAISE LP ROLLBACK COMMA nm RP + expr ::= * RAISE LP ABORT COMMA nm RP + expr ::= * RAISE LP FAIL COMMA nm RP + + BITNOT shift 177 + CASE shift 183 + FLOAT shift 174 + ID shift 64 + INTEGER shift 173 + JOIN_KW shift 67 + LP shift 68 + MINUS shift 179 + NOT shift 175 + NULL shift 106 + PLUS shift 181 + RAISE shift 193 + STRING shift 66 + expr shift 122 + nm shift 107 + +State 122: + expr ::= expr * ORACLE_OUTER_JOIN + expr ::= expr * AND expr + expr ::= expr * OR expr + expr ::= expr * LT expr + expr ::= expr * GT expr + expr ::= expr * LE expr + expr ::= expr * GE expr + (187) expr ::= expr GE expr * + expr ::= expr * NE expr + expr ::= expr * EQ expr + expr ::= expr * BITAND expr + expr ::= expr * BITOR expr + expr ::= expr * LSHIFT expr + expr ::= expr * RSHIFT expr + expr ::= expr * likeop expr + expr ::= expr * NOT likeop expr + likeop ::= * LIKE + likeop ::= * GLOB + expr ::= expr * PLUS expr + expr ::= expr * MINUS expr + expr ::= expr * STAR expr + expr ::= expr * SLASH expr + expr ::= expr * REM expr + expr ::= expr * CONCAT expr + expr ::= expr * ISNULL + expr ::= expr * IS NULL + expr ::= expr * NOTNULL + expr ::= expr * NOT NULL + expr ::= expr * IS NOT NULL + expr ::= expr * BETWEEN expr AND expr + expr ::= expr * NOT BETWEEN expr AND expr + expr ::= expr * IN LP exprlist RP + expr ::= expr * IN LP select RP + expr ::= expr * NOT IN LP exprlist RP + expr ::= expr * NOT IN LP select RP + + BITAND shift 127 + BITOR shift 129 + CONCAT shift 152 + LSHIFT shift 131 + MINUS shift 144 + ORACLE_OUTER_JOIN shift 104 + PLUS shift 142 + REM shift 150 + RSHIFT shift 133 + SLASH shift 148 + STAR shift 146 + likeop shift 135 + {default} reduce 187 + +State 123: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + expr ::= * LP expr RP + expr ::= * NULL + expr ::= * ID + expr ::= * JOIN_KW + expr ::= * nm DOT nm + expr ::= * nm DOT nm DOT nm + expr ::= * expr ORACLE_OUTER_JOIN + expr ::= * INTEGER + expr ::= * FLOAT + expr ::= * STRING + expr ::= * ID LP exprlist RP + expr ::= * ID LP STAR RP + expr ::= * expr AND expr + expr ::= * expr OR expr + expr ::= * expr LT expr + expr ::= * expr GT expr + expr ::= * expr LE expr + expr ::= * expr GE expr + expr ::= * expr NE expr + expr ::= expr NE * expr + expr ::= * expr EQ expr + expr ::= * expr BITAND expr + expr ::= * expr BITOR expr + expr ::= * expr LSHIFT expr + expr ::= * expr RSHIFT expr + expr ::= * expr likeop expr + expr ::= * expr NOT likeop expr + expr ::= * expr PLUS expr + expr ::= * expr MINUS expr + expr ::= * expr STAR expr + expr ::= * expr SLASH expr + expr ::= * expr REM expr + expr ::= * expr CONCAT expr + expr ::= * expr ISNULL + expr ::= * expr IS NULL + expr ::= * expr NOTNULL + expr ::= * expr NOT NULL + expr ::= * expr IS NOT NULL + expr ::= * NOT expr + expr ::= * BITNOT expr + expr ::= * MINUS expr + expr ::= * PLUS expr + expr ::= * LP select RP + expr ::= * expr BETWEEN expr AND expr + expr ::= * expr NOT BETWEEN expr AND expr + expr ::= * expr IN LP exprlist RP + expr ::= * expr IN LP select RP + expr ::= * expr NOT IN LP exprlist RP + expr ::= * expr NOT IN LP select RP + expr ::= * CASE case_operand case_exprlist case_else END + expr ::= * RAISE LP IGNORE RP + expr ::= * RAISE LP ROLLBACK COMMA nm RP + expr ::= * RAISE LP ABORT COMMA nm RP + expr ::= * RAISE LP FAIL COMMA nm RP + + BITNOT shift 177 + CASE shift 183 + FLOAT shift 174 + ID shift 64 + INTEGER shift 173 + JOIN_KW shift 67 + LP shift 68 + MINUS shift 179 + NOT shift 175 + NULL shift 106 + PLUS shift 181 + RAISE shift 193 + STRING shift 66 + expr shift 124 + nm shift 107 + +State 124: + expr ::= expr * ORACLE_OUTER_JOIN + expr ::= expr * AND expr + expr ::= expr * OR expr + expr ::= expr * LT expr + expr ::= expr * GT expr + expr ::= expr * LE expr + expr ::= expr * GE expr + expr ::= expr * NE expr + (188) expr ::= expr NE expr * + expr ::= expr * EQ expr + expr ::= expr * BITAND expr + expr ::= expr * BITOR expr + expr ::= expr * LSHIFT expr + expr ::= expr * RSHIFT expr + expr ::= expr * likeop expr + expr ::= expr * NOT likeop expr + likeop ::= * LIKE + likeop ::= * GLOB + expr ::= expr * PLUS expr + expr ::= expr * MINUS expr + expr ::= expr * STAR expr + expr ::= expr * SLASH expr + expr ::= expr * REM expr + expr ::= expr * CONCAT expr + expr ::= expr * ISNULL + expr ::= expr * IS NULL + expr ::= expr * NOTNULL + expr ::= expr * NOT NULL + expr ::= expr * IS NOT NULL + expr ::= expr * BETWEEN expr AND expr + expr ::= expr * NOT BETWEEN expr AND expr + expr ::= expr * IN LP exprlist RP + expr ::= expr * IN LP select RP + expr ::= expr * NOT IN LP exprlist RP + expr ::= expr * NOT IN LP select RP + + BITAND shift 127 + BITOR shift 129 + CONCAT shift 152 + GE shift 121 + GT shift 117 + LE shift 119 + LSHIFT shift 131 + LT shift 115 + MINUS shift 144 + ORACLE_OUTER_JOIN shift 104 + PLUS shift 142 + REM shift 150 + RSHIFT shift 133 + SLASH shift 148 + STAR shift 146 + likeop shift 135 + {default} reduce 188 + +State 125: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + expr ::= * LP expr RP + expr ::= * NULL + expr ::= * ID + expr ::= * JOIN_KW + expr ::= * nm DOT nm + expr ::= * nm DOT nm DOT nm + expr ::= * expr ORACLE_OUTER_JOIN + expr ::= * INTEGER + expr ::= * FLOAT + expr ::= * STRING + expr ::= * ID LP exprlist RP + expr ::= * ID LP STAR RP + expr ::= * expr AND expr + expr ::= * expr OR expr + expr ::= * expr LT expr + expr ::= * expr GT expr + expr ::= * expr LE expr + expr ::= * expr GE expr + expr ::= * expr NE expr + expr ::= * expr EQ expr + expr ::= expr EQ * expr + expr ::= * expr BITAND expr + expr ::= * expr BITOR expr + expr ::= * expr LSHIFT expr + expr ::= * expr RSHIFT expr + expr ::= * expr likeop expr + expr ::= * expr NOT likeop expr + expr ::= * expr PLUS expr + expr ::= * expr MINUS expr + expr ::= * expr STAR expr + expr ::= * expr SLASH expr + expr ::= * expr REM expr + expr ::= * expr CONCAT expr + expr ::= * expr ISNULL + expr ::= * expr IS NULL + expr ::= * expr NOTNULL + expr ::= * expr NOT NULL + expr ::= * expr IS NOT NULL + expr ::= * NOT expr + expr ::= * BITNOT expr + expr ::= * MINUS expr + expr ::= * PLUS expr + expr ::= * LP select RP + expr ::= * expr BETWEEN expr AND expr + expr ::= * expr NOT BETWEEN expr AND expr + expr ::= * expr IN LP exprlist RP + expr ::= * expr IN LP select RP + expr ::= * expr NOT IN LP exprlist RP + expr ::= * expr NOT IN LP select RP + expr ::= * CASE case_operand case_exprlist case_else END + expr ::= * RAISE LP IGNORE RP + expr ::= * RAISE LP ROLLBACK COMMA nm RP + expr ::= * RAISE LP ABORT COMMA nm RP + expr ::= * RAISE LP FAIL COMMA nm RP + + BITNOT shift 177 + CASE shift 183 + FLOAT shift 174 + ID shift 64 + INTEGER shift 173 + JOIN_KW shift 67 + LP shift 68 + MINUS shift 179 + NOT shift 175 + NULL shift 106 + PLUS shift 181 + RAISE shift 193 + STRING shift 66 + expr shift 126 + nm shift 107 + +State 126: + expr ::= expr * ORACLE_OUTER_JOIN + expr ::= expr * AND expr + expr ::= expr * OR expr + expr ::= expr * LT expr + expr ::= expr * GT expr + expr ::= expr * LE expr + expr ::= expr * GE expr + expr ::= expr * NE expr + expr ::= expr * EQ expr + (189) expr ::= expr EQ expr * + expr ::= expr * BITAND expr + expr ::= expr * BITOR expr + expr ::= expr * LSHIFT expr + expr ::= expr * RSHIFT expr + expr ::= expr * likeop expr + expr ::= expr * NOT likeop expr + likeop ::= * LIKE + likeop ::= * GLOB + expr ::= expr * PLUS expr + expr ::= expr * MINUS expr + expr ::= expr * STAR expr + expr ::= expr * SLASH expr + expr ::= expr * REM expr + expr ::= expr * CONCAT expr + expr ::= expr * ISNULL + expr ::= expr * IS NULL + expr ::= expr * NOTNULL + expr ::= expr * NOT NULL + expr ::= expr * IS NOT NULL + expr ::= expr * BETWEEN expr AND expr + expr ::= expr * NOT BETWEEN expr AND expr + expr ::= expr * IN LP exprlist RP + expr ::= expr * IN LP select RP + expr ::= expr * NOT IN LP exprlist RP + expr ::= expr * NOT IN LP select RP + + BITAND shift 127 + BITOR shift 129 + CONCAT shift 152 + GE shift 121 + GT shift 117 + LE shift 119 + LSHIFT shift 131 + LT shift 115 + MINUS shift 144 + ORACLE_OUTER_JOIN shift 104 + PLUS shift 142 + REM shift 150 + RSHIFT shift 133 + SLASH shift 148 + STAR shift 146 + likeop shift 135 + {default} reduce 189 + +State 127: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + expr ::= * LP expr RP + expr ::= * NULL + expr ::= * ID + expr ::= * JOIN_KW + expr ::= * nm DOT nm + expr ::= * nm DOT nm DOT nm + expr ::= * expr ORACLE_OUTER_JOIN + expr ::= * INTEGER + expr ::= * FLOAT + expr ::= * STRING + expr ::= * ID LP exprlist RP + expr ::= * ID LP STAR RP + expr ::= * expr AND expr + expr ::= * expr OR expr + expr ::= * expr LT expr + expr ::= * expr GT expr + expr ::= * expr LE expr + expr ::= * expr GE expr + expr ::= * expr NE expr + expr ::= * expr EQ expr + expr ::= * expr BITAND expr + expr ::= expr BITAND * expr + expr ::= * expr BITOR expr + expr ::= * expr LSHIFT expr + expr ::= * expr RSHIFT expr + expr ::= * expr likeop expr + expr ::= * expr NOT likeop expr + expr ::= * expr PLUS expr + expr ::= * expr MINUS expr + expr ::= * expr STAR expr + expr ::= * expr SLASH expr + expr ::= * expr REM expr + expr ::= * expr CONCAT expr + expr ::= * expr ISNULL + expr ::= * expr IS NULL + expr ::= * expr NOTNULL + expr ::= * expr NOT NULL + expr ::= * expr IS NOT NULL + expr ::= * NOT expr + expr ::= * BITNOT expr + expr ::= * MINUS expr + expr ::= * PLUS expr + expr ::= * LP select RP + expr ::= * expr BETWEEN expr AND expr + expr ::= * expr NOT BETWEEN expr AND expr + expr ::= * expr IN LP exprlist RP + expr ::= * expr IN LP select RP + expr ::= * expr NOT IN LP exprlist RP + expr ::= * expr NOT IN LP select RP + expr ::= * CASE case_operand case_exprlist case_else END + expr ::= * RAISE LP IGNORE RP + expr ::= * RAISE LP ROLLBACK COMMA nm RP + expr ::= * RAISE LP ABORT COMMA nm RP + expr ::= * RAISE LP FAIL COMMA nm RP + + BITNOT shift 177 + CASE shift 183 + FLOAT shift 174 + ID shift 64 + INTEGER shift 173 + JOIN_KW shift 67 + LP shift 68 + MINUS shift 179 + NOT shift 175 + NULL shift 106 + PLUS shift 181 + RAISE shift 193 + STRING shift 66 + expr shift 128 + nm shift 107 + +State 128: + expr ::= expr * ORACLE_OUTER_JOIN + expr ::= expr * AND expr + expr ::= expr * OR expr + expr ::= expr * LT expr + expr ::= expr * GT expr + expr ::= expr * LE expr + expr ::= expr * GE expr + expr ::= expr * NE expr + expr ::= expr * EQ expr + expr ::= expr * BITAND expr + (190) expr ::= expr BITAND expr * + expr ::= expr * BITOR expr + expr ::= expr * LSHIFT expr + expr ::= expr * RSHIFT expr + expr ::= expr * likeop expr + expr ::= expr * NOT likeop expr + likeop ::= * LIKE + likeop ::= * GLOB + expr ::= expr * PLUS expr + expr ::= expr * MINUS expr + expr ::= expr * STAR expr + expr ::= expr * SLASH expr + expr ::= expr * REM expr + expr ::= expr * CONCAT expr + expr ::= expr * ISNULL + expr ::= expr * IS NULL + expr ::= expr * NOTNULL + expr ::= expr * NOT NULL + expr ::= expr * IS NOT NULL + expr ::= expr * BETWEEN expr AND expr + expr ::= expr * NOT BETWEEN expr AND expr + expr ::= expr * IN LP exprlist RP + expr ::= expr * IN LP select RP + expr ::= expr * NOT IN LP exprlist RP + expr ::= expr * NOT IN LP select RP + + CONCAT shift 152 + MINUS shift 144 + ORACLE_OUTER_JOIN shift 104 + PLUS shift 142 + REM shift 150 + SLASH shift 148 + STAR shift 146 + likeop shift 135 + {default} reduce 190 + +State 129: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + expr ::= * LP expr RP + expr ::= * NULL + expr ::= * ID + expr ::= * JOIN_KW + expr ::= * nm DOT nm + expr ::= * nm DOT nm DOT nm + expr ::= * expr ORACLE_OUTER_JOIN + expr ::= * INTEGER + expr ::= * FLOAT + expr ::= * STRING + expr ::= * ID LP exprlist RP + expr ::= * ID LP STAR RP + expr ::= * expr AND expr + expr ::= * expr OR expr + expr ::= * expr LT expr + expr ::= * expr GT expr + expr ::= * expr LE expr + expr ::= * expr GE expr + expr ::= * expr NE expr + expr ::= * expr EQ expr + expr ::= * expr BITAND expr + expr ::= * expr BITOR expr + expr ::= expr BITOR * expr + expr ::= * expr LSHIFT expr + expr ::= * expr RSHIFT expr + expr ::= * expr likeop expr + expr ::= * expr NOT likeop expr + expr ::= * expr PLUS expr + expr ::= * expr MINUS expr + expr ::= * expr STAR expr + expr ::= * expr SLASH expr + expr ::= * expr REM expr + expr ::= * expr CONCAT expr + expr ::= * expr ISNULL + expr ::= * expr IS NULL + expr ::= * expr NOTNULL + expr ::= * expr NOT NULL + expr ::= * expr IS NOT NULL + expr ::= * NOT expr + expr ::= * BITNOT expr + expr ::= * MINUS expr + expr ::= * PLUS expr + expr ::= * LP select RP + expr ::= * expr BETWEEN expr AND expr + expr ::= * expr NOT BETWEEN expr AND expr + expr ::= * expr IN LP exprlist RP + expr ::= * expr IN LP select RP + expr ::= * expr NOT IN LP exprlist RP + expr ::= * expr NOT IN LP select RP + expr ::= * CASE case_operand case_exprlist case_else END + expr ::= * RAISE LP IGNORE RP + expr ::= * RAISE LP ROLLBACK COMMA nm RP + expr ::= * RAISE LP ABORT COMMA nm RP + expr ::= * RAISE LP FAIL COMMA nm RP + + BITNOT shift 177 + CASE shift 183 + FLOAT shift 174 + ID shift 64 + INTEGER shift 173 + JOIN_KW shift 67 + LP shift 68 + MINUS shift 179 + NOT shift 175 + NULL shift 106 + PLUS shift 181 + RAISE shift 193 + STRING shift 66 + expr shift 130 + nm shift 107 + +State 130: + expr ::= expr * ORACLE_OUTER_JOIN + expr ::= expr * AND expr + expr ::= expr * OR expr + expr ::= expr * LT expr + expr ::= expr * GT expr + expr ::= expr * LE expr + expr ::= expr * GE expr + expr ::= expr * NE expr + expr ::= expr * EQ expr + expr ::= expr * BITAND expr + expr ::= expr * BITOR expr + (191) expr ::= expr BITOR expr * + expr ::= expr * LSHIFT expr + expr ::= expr * RSHIFT expr + expr ::= expr * likeop expr + expr ::= expr * NOT likeop expr + likeop ::= * LIKE + likeop ::= * GLOB + expr ::= expr * PLUS expr + expr ::= expr * MINUS expr + expr ::= expr * STAR expr + expr ::= expr * SLASH expr + expr ::= expr * REM expr + expr ::= expr * CONCAT expr + expr ::= expr * ISNULL + expr ::= expr * IS NULL + expr ::= expr * NOTNULL + expr ::= expr * NOT NULL + expr ::= expr * IS NOT NULL + expr ::= expr * BETWEEN expr AND expr + expr ::= expr * NOT BETWEEN expr AND expr + expr ::= expr * IN LP exprlist RP + expr ::= expr * IN LP select RP + expr ::= expr * NOT IN LP exprlist RP + expr ::= expr * NOT IN LP select RP + + CONCAT shift 152 + MINUS shift 144 + ORACLE_OUTER_JOIN shift 104 + PLUS shift 142 + REM shift 150 + SLASH shift 148 + STAR shift 146 + likeop shift 135 + {default} reduce 191 + +State 131: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + expr ::= * LP expr RP + expr ::= * NULL + expr ::= * ID + expr ::= * JOIN_KW + expr ::= * nm DOT nm + expr ::= * nm DOT nm DOT nm + expr ::= * expr ORACLE_OUTER_JOIN + expr ::= * INTEGER + expr ::= * FLOAT + expr ::= * STRING + expr ::= * ID LP exprlist RP + expr ::= * ID LP STAR RP + expr ::= * expr AND expr + expr ::= * expr OR expr + expr ::= * expr LT expr + expr ::= * expr GT expr + expr ::= * expr LE expr + expr ::= * expr GE expr + expr ::= * expr NE expr + expr ::= * expr EQ expr + expr ::= * expr BITAND expr + expr ::= * expr BITOR expr + expr ::= * expr LSHIFT expr + expr ::= expr LSHIFT * expr + expr ::= * expr RSHIFT expr + expr ::= * expr likeop expr + expr ::= * expr NOT likeop expr + expr ::= * expr PLUS expr + expr ::= * expr MINUS expr + expr ::= * expr STAR expr + expr ::= * expr SLASH expr + expr ::= * expr REM expr + expr ::= * expr CONCAT expr + expr ::= * expr ISNULL + expr ::= * expr IS NULL + expr ::= * expr NOTNULL + expr ::= * expr NOT NULL + expr ::= * expr IS NOT NULL + expr ::= * NOT expr + expr ::= * BITNOT expr + expr ::= * MINUS expr + expr ::= * PLUS expr + expr ::= * LP select RP + expr ::= * expr BETWEEN expr AND expr + expr ::= * expr NOT BETWEEN expr AND expr + expr ::= * expr IN LP exprlist RP + expr ::= * expr IN LP select RP + expr ::= * expr NOT IN LP exprlist RP + expr ::= * expr NOT IN LP select RP + expr ::= * CASE case_operand case_exprlist case_else END + expr ::= * RAISE LP IGNORE RP + expr ::= * RAISE LP ROLLBACK COMMA nm RP + expr ::= * RAISE LP ABORT COMMA nm RP + expr ::= * RAISE LP FAIL COMMA nm RP + + BITNOT shift 177 + CASE shift 183 + FLOAT shift 174 + ID shift 64 + INTEGER shift 173 + JOIN_KW shift 67 + LP shift 68 + MINUS shift 179 + NOT shift 175 + NULL shift 106 + PLUS shift 181 + RAISE shift 193 + STRING shift 66 + expr shift 132 + nm shift 107 + +State 132: + expr ::= expr * ORACLE_OUTER_JOIN + expr ::= expr * AND expr + expr ::= expr * OR expr + expr ::= expr * LT expr + expr ::= expr * GT expr + expr ::= expr * LE expr + expr ::= expr * GE expr + expr ::= expr * NE expr + expr ::= expr * EQ expr + expr ::= expr * BITAND expr + expr ::= expr * BITOR expr + expr ::= expr * LSHIFT expr + (192) expr ::= expr LSHIFT expr * + expr ::= expr * RSHIFT expr + expr ::= expr * likeop expr + expr ::= expr * NOT likeop expr + likeop ::= * LIKE + likeop ::= * GLOB + expr ::= expr * PLUS expr + expr ::= expr * MINUS expr + expr ::= expr * STAR expr + expr ::= expr * SLASH expr + expr ::= expr * REM expr + expr ::= expr * CONCAT expr + expr ::= expr * ISNULL + expr ::= expr * IS NULL + expr ::= expr * NOTNULL + expr ::= expr * NOT NULL + expr ::= expr * IS NOT NULL + expr ::= expr * BETWEEN expr AND expr + expr ::= expr * NOT BETWEEN expr AND expr + expr ::= expr * IN LP exprlist RP + expr ::= expr * IN LP select RP + expr ::= expr * NOT IN LP exprlist RP + expr ::= expr * NOT IN LP select RP + + CONCAT shift 152 + MINUS shift 144 + ORACLE_OUTER_JOIN shift 104 + PLUS shift 142 + REM shift 150 + SLASH shift 148 + STAR shift 146 + likeop shift 135 + {default} reduce 192 + +State 133: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + expr ::= * LP expr RP + expr ::= * NULL + expr ::= * ID + expr ::= * JOIN_KW + expr ::= * nm DOT nm + expr ::= * nm DOT nm DOT nm + expr ::= * expr ORACLE_OUTER_JOIN + expr ::= * INTEGER + expr ::= * FLOAT + expr ::= * STRING + expr ::= * ID LP exprlist RP + expr ::= * ID LP STAR RP + expr ::= * expr AND expr + expr ::= * expr OR expr + expr ::= * expr LT expr + expr ::= * expr GT expr + expr ::= * expr LE expr + expr ::= * expr GE expr + expr ::= * expr NE expr + expr ::= * expr EQ expr + expr ::= * expr BITAND expr + expr ::= * expr BITOR expr + expr ::= * expr LSHIFT expr + expr ::= * expr RSHIFT expr + expr ::= expr RSHIFT * expr + expr ::= * expr likeop expr + expr ::= * expr NOT likeop expr + expr ::= * expr PLUS expr + expr ::= * expr MINUS expr + expr ::= * expr STAR expr + expr ::= * expr SLASH expr + expr ::= * expr REM expr + expr ::= * expr CONCAT expr + expr ::= * expr ISNULL + expr ::= * expr IS NULL + expr ::= * expr NOTNULL + expr ::= * expr NOT NULL + expr ::= * expr IS NOT NULL + expr ::= * NOT expr + expr ::= * BITNOT expr + expr ::= * MINUS expr + expr ::= * PLUS expr + expr ::= * LP select RP + expr ::= * expr BETWEEN expr AND expr + expr ::= * expr NOT BETWEEN expr AND expr + expr ::= * expr IN LP exprlist RP + expr ::= * expr IN LP select RP + expr ::= * expr NOT IN LP exprlist RP + expr ::= * expr NOT IN LP select RP + expr ::= * CASE case_operand case_exprlist case_else END + expr ::= * RAISE LP IGNORE RP + expr ::= * RAISE LP ROLLBACK COMMA nm RP + expr ::= * RAISE LP ABORT COMMA nm RP + expr ::= * RAISE LP FAIL COMMA nm RP + + BITNOT shift 177 + CASE shift 183 + FLOAT shift 174 + ID shift 64 + INTEGER shift 173 + JOIN_KW shift 67 + LP shift 68 + MINUS shift 179 + NOT shift 175 + NULL shift 106 + PLUS shift 181 + RAISE shift 193 + STRING shift 66 + expr shift 134 + nm shift 107 + +State 134: + expr ::= expr * ORACLE_OUTER_JOIN + expr ::= expr * AND expr + expr ::= expr * OR expr + expr ::= expr * LT expr + expr ::= expr * GT expr + expr ::= expr * LE expr + expr ::= expr * GE expr + expr ::= expr * NE expr + expr ::= expr * EQ expr + expr ::= expr * BITAND expr + expr ::= expr * BITOR expr + expr ::= expr * LSHIFT expr + expr ::= expr * RSHIFT expr + (193) expr ::= expr RSHIFT expr * + expr ::= expr * likeop expr + expr ::= expr * NOT likeop expr + likeop ::= * LIKE + likeop ::= * GLOB + expr ::= expr * PLUS expr + expr ::= expr * MINUS expr + expr ::= expr * STAR expr + expr ::= expr * SLASH expr + expr ::= expr * REM expr + expr ::= expr * CONCAT expr + expr ::= expr * ISNULL + expr ::= expr * IS NULL + expr ::= expr * NOTNULL + expr ::= expr * NOT NULL + expr ::= expr * IS NOT NULL + expr ::= expr * BETWEEN expr AND expr + expr ::= expr * NOT BETWEEN expr AND expr + expr ::= expr * IN LP exprlist RP + expr ::= expr * IN LP select RP + expr ::= expr * NOT IN LP exprlist RP + expr ::= expr * NOT IN LP select RP + + CONCAT shift 152 + MINUS shift 144 + ORACLE_OUTER_JOIN shift 104 + PLUS shift 142 + REM shift 150 + SLASH shift 148 + STAR shift 146 + likeop shift 135 + {default} reduce 193 + +State 135: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + expr ::= * LP expr RP + expr ::= * NULL + expr ::= * ID + expr ::= * JOIN_KW + expr ::= * nm DOT nm + expr ::= * nm DOT nm DOT nm + expr ::= * expr ORACLE_OUTER_JOIN + expr ::= * INTEGER + expr ::= * FLOAT + expr ::= * STRING + expr ::= * ID LP exprlist RP + expr ::= * ID LP STAR RP + expr ::= * expr AND expr + expr ::= * expr OR expr + expr ::= * expr LT expr + expr ::= * expr GT expr + expr ::= * expr LE expr + expr ::= * expr GE expr + expr ::= * expr NE expr + expr ::= * expr EQ expr + expr ::= * expr BITAND expr + expr ::= * expr BITOR expr + expr ::= * expr LSHIFT expr + expr ::= * expr RSHIFT expr + expr ::= * expr likeop expr + expr ::= expr likeop * expr + expr ::= * expr NOT likeop expr + expr ::= * expr PLUS expr + expr ::= * expr MINUS expr + expr ::= * expr STAR expr + expr ::= * expr SLASH expr + expr ::= * expr REM expr + expr ::= * expr CONCAT expr + expr ::= * expr ISNULL + expr ::= * expr IS NULL + expr ::= * expr NOTNULL + expr ::= * expr NOT NULL + expr ::= * expr IS NOT NULL + expr ::= * NOT expr + expr ::= * BITNOT expr + expr ::= * MINUS expr + expr ::= * PLUS expr + expr ::= * LP select RP + expr ::= * expr BETWEEN expr AND expr + expr ::= * expr NOT BETWEEN expr AND expr + expr ::= * expr IN LP exprlist RP + expr ::= * expr IN LP select RP + expr ::= * expr NOT IN LP exprlist RP + expr ::= * expr NOT IN LP select RP + expr ::= * CASE case_operand case_exprlist case_else END + expr ::= * RAISE LP IGNORE RP + expr ::= * RAISE LP ROLLBACK COMMA nm RP + expr ::= * RAISE LP ABORT COMMA nm RP + expr ::= * RAISE LP FAIL COMMA nm RP + + BITNOT shift 177 + CASE shift 183 + FLOAT shift 174 + ID shift 64 + INTEGER shift 173 + JOIN_KW shift 67 + LP shift 68 + MINUS shift 179 + NOT shift 175 + NULL shift 106 + PLUS shift 181 + RAISE shift 193 + STRING shift 66 + expr shift 136 + nm shift 107 + +State 136: + expr ::= expr * ORACLE_OUTER_JOIN + expr ::= expr * AND expr + expr ::= expr * OR expr + expr ::= expr * LT expr + expr ::= expr * GT expr + expr ::= expr * LE expr + expr ::= expr * GE expr + expr ::= expr * NE expr + expr ::= expr * EQ expr + expr ::= expr * BITAND expr + expr ::= expr * BITOR expr + expr ::= expr * LSHIFT expr + expr ::= expr * RSHIFT expr + expr ::= expr * likeop expr + (194) expr ::= expr likeop expr * + expr ::= expr * NOT likeop expr + likeop ::= * LIKE + likeop ::= * GLOB + expr ::= expr * PLUS expr + expr ::= expr * MINUS expr + expr ::= expr * STAR expr + expr ::= expr * SLASH expr + expr ::= expr * REM expr + expr ::= expr * CONCAT expr + expr ::= expr * ISNULL + expr ::= expr * IS NULL + expr ::= expr * NOTNULL + expr ::= expr * NOT NULL + expr ::= expr * IS NOT NULL + expr ::= expr * BETWEEN expr AND expr + expr ::= expr * NOT BETWEEN expr AND expr + expr ::= expr * IN LP exprlist RP + expr ::= expr * IN LP select RP + expr ::= expr * NOT IN LP exprlist RP + expr ::= expr * NOT IN LP select RP + + BITAND shift 127 + BITOR shift 129 + CONCAT shift 152 + GE shift 121 + GT shift 117 + LE shift 119 + LSHIFT shift 131 + LT shift 115 + MINUS shift 144 + ORACLE_OUTER_JOIN shift 104 + PLUS shift 142 + REM shift 150 + RSHIFT shift 133 + SLASH shift 148 + STAR shift 146 + likeop shift 135 + {default} reduce 194 + +State 137: + expr ::= expr NOT * likeop expr + likeop ::= * LIKE + likeop ::= * GLOB + expr ::= expr NOT * NULL + expr ::= expr NOT * BETWEEN expr AND expr + expr ::= expr NOT * IN LP exprlist RP + expr ::= expr NOT * IN LP select RP + + BETWEEN shift 221 + GLOB shift 141 + IN shift 225 + LIKE shift 140 + NULL shift 220 + likeop shift 138 + +State 138: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + expr ::= * LP expr RP + expr ::= * NULL + expr ::= * ID + expr ::= * JOIN_KW + expr ::= * nm DOT nm + expr ::= * nm DOT nm DOT nm + expr ::= * expr ORACLE_OUTER_JOIN + expr ::= * INTEGER + expr ::= * FLOAT + expr ::= * STRING + expr ::= * ID LP exprlist RP + expr ::= * ID LP STAR RP + expr ::= * expr AND expr + expr ::= * expr OR expr + expr ::= * expr LT expr + expr ::= * expr GT expr + expr ::= * expr LE expr + expr ::= * expr GE expr + expr ::= * expr NE expr + expr ::= * expr EQ expr + expr ::= * expr BITAND expr + expr ::= * expr BITOR expr + expr ::= * expr LSHIFT expr + expr ::= * expr RSHIFT expr + expr ::= * expr likeop expr + expr ::= * expr NOT likeop expr + expr ::= expr NOT likeop * expr + expr ::= * expr PLUS expr + expr ::= * expr MINUS expr + expr ::= * expr STAR expr + expr ::= * expr SLASH expr + expr ::= * expr REM expr + expr ::= * expr CONCAT expr + expr ::= * expr ISNULL + expr ::= * expr IS NULL + expr ::= * expr NOTNULL + expr ::= * expr NOT NULL + expr ::= * expr IS NOT NULL + expr ::= * NOT expr + expr ::= * BITNOT expr + expr ::= * MINUS expr + expr ::= * PLUS expr + expr ::= * LP select RP + expr ::= * expr BETWEEN expr AND expr + expr ::= * expr NOT BETWEEN expr AND expr + expr ::= * expr IN LP exprlist RP + expr ::= * expr IN LP select RP + expr ::= * expr NOT IN LP exprlist RP + expr ::= * expr NOT IN LP select RP + expr ::= * CASE case_operand case_exprlist case_else END + expr ::= * RAISE LP IGNORE RP + expr ::= * RAISE LP ROLLBACK COMMA nm RP + expr ::= * RAISE LP ABORT COMMA nm RP + expr ::= * RAISE LP FAIL COMMA nm RP + + BITNOT shift 177 + CASE shift 183 + FLOAT shift 174 + ID shift 64 + INTEGER shift 173 + JOIN_KW shift 67 + LP shift 68 + MINUS shift 179 + NOT shift 175 + NULL shift 106 + PLUS shift 181 + RAISE shift 193 + STRING shift 66 + expr shift 139 + nm shift 107 + +State 139: + expr ::= expr * ORACLE_OUTER_JOIN + expr ::= expr * AND expr + expr ::= expr * OR expr + expr ::= expr * LT expr + expr ::= expr * GT expr + expr ::= expr * LE expr + expr ::= expr * GE expr + expr ::= expr * NE expr + expr ::= expr * EQ expr + expr ::= expr * BITAND expr + expr ::= expr * BITOR expr + expr ::= expr * LSHIFT expr + expr ::= expr * RSHIFT expr + expr ::= expr * likeop expr + expr ::= expr * NOT likeop expr + (195) expr ::= expr NOT likeop expr * + likeop ::= * LIKE + likeop ::= * GLOB + expr ::= expr * PLUS expr + expr ::= expr * MINUS expr + expr ::= expr * STAR expr + expr ::= expr * SLASH expr + expr ::= expr * REM expr + expr ::= expr * CONCAT expr + expr ::= expr * ISNULL + expr ::= expr * IS NULL + expr ::= expr * NOTNULL + expr ::= expr * NOT NULL + expr ::= expr * IS NOT NULL + expr ::= expr * BETWEEN expr AND expr + expr ::= expr * NOT BETWEEN expr AND expr + expr ::= expr * IN LP exprlist RP + expr ::= expr * IN LP select RP + expr ::= expr * NOT IN LP exprlist RP + expr ::= expr * NOT IN LP select RP + + BITAND shift 127 + BITOR shift 129 + CONCAT shift 152 + GE shift 121 + GT shift 117 + LE shift 119 + LSHIFT shift 131 + LT shift 115 + MINUS shift 144 + ORACLE_OUTER_JOIN shift 104 + PLUS shift 142 + REM shift 150 + RSHIFT shift 133 + SLASH shift 148 + STAR shift 146 + likeop shift 135 + {default} reduce 195 + +State 140: + (196) likeop ::= LIKE * + + {default} reduce 196 + +State 141: + (197) likeop ::= GLOB * + + {default} reduce 197 + +State 142: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + expr ::= * LP expr RP + expr ::= * NULL + expr ::= * ID + expr ::= * JOIN_KW + expr ::= * nm DOT nm + expr ::= * nm DOT nm DOT nm + expr ::= * expr ORACLE_OUTER_JOIN + expr ::= * INTEGER + expr ::= * FLOAT + expr ::= * STRING + expr ::= * ID LP exprlist RP + expr ::= * ID LP STAR RP + expr ::= * expr AND expr + expr ::= * expr OR expr + expr ::= * expr LT expr + expr ::= * expr GT expr + expr ::= * expr LE expr + expr ::= * expr GE expr + expr ::= * expr NE expr + expr ::= * expr EQ expr + expr ::= * expr BITAND expr + expr ::= * expr BITOR expr + expr ::= * expr LSHIFT expr + expr ::= * expr RSHIFT expr + expr ::= * expr likeop expr + expr ::= * expr NOT likeop expr + expr ::= * expr PLUS expr + expr ::= expr PLUS * expr + expr ::= * expr MINUS expr + expr ::= * expr STAR expr + expr ::= * expr SLASH expr + expr ::= * expr REM expr + expr ::= * expr CONCAT expr + expr ::= * expr ISNULL + expr ::= * expr IS NULL + expr ::= * expr NOTNULL + expr ::= * expr NOT NULL + expr ::= * expr IS NOT NULL + expr ::= * NOT expr + expr ::= * BITNOT expr + expr ::= * MINUS expr + expr ::= * PLUS expr + expr ::= * LP select RP + expr ::= * expr BETWEEN expr AND expr + expr ::= * expr NOT BETWEEN expr AND expr + expr ::= * expr IN LP exprlist RP + expr ::= * expr IN LP select RP + expr ::= * expr NOT IN LP exprlist RP + expr ::= * expr NOT IN LP select RP + expr ::= * CASE case_operand case_exprlist case_else END + expr ::= * RAISE LP IGNORE RP + expr ::= * RAISE LP ROLLBACK COMMA nm RP + expr ::= * RAISE LP ABORT COMMA nm RP + expr ::= * RAISE LP FAIL COMMA nm RP + + BITNOT shift 177 + CASE shift 183 + FLOAT shift 174 + ID shift 64 + INTEGER shift 173 + JOIN_KW shift 67 + LP shift 68 + MINUS shift 179 + NOT shift 175 + NULL shift 106 + PLUS shift 181 + RAISE shift 193 + STRING shift 66 + expr shift 143 + nm shift 107 + +State 143: + expr ::= expr * ORACLE_OUTER_JOIN + expr ::= expr * AND expr + expr ::= expr * OR expr + expr ::= expr * LT expr + expr ::= expr * GT expr + expr ::= expr * LE expr + expr ::= expr * GE expr + expr ::= expr * NE expr + expr ::= expr * EQ expr + expr ::= expr * BITAND expr + expr ::= expr * BITOR expr + expr ::= expr * LSHIFT expr + expr ::= expr * RSHIFT expr + expr ::= expr * likeop expr + expr ::= expr * NOT likeop expr + likeop ::= * LIKE + likeop ::= * GLOB + expr ::= expr * PLUS expr + (198) expr ::= expr PLUS expr * + expr ::= expr * MINUS expr + expr ::= expr * STAR expr + expr ::= expr * SLASH expr + expr ::= expr * REM expr + expr ::= expr * CONCAT expr + expr ::= expr * ISNULL + expr ::= expr * IS NULL + expr ::= expr * NOTNULL + expr ::= expr * NOT NULL + expr ::= expr * IS NOT NULL + expr ::= expr * BETWEEN expr AND expr + expr ::= expr * NOT BETWEEN expr AND expr + expr ::= expr * IN LP exprlist RP + expr ::= expr * IN LP select RP + expr ::= expr * NOT IN LP exprlist RP + expr ::= expr * NOT IN LP select RP + + CONCAT shift 152 + ORACLE_OUTER_JOIN shift 104 + REM shift 150 + SLASH shift 148 + STAR shift 146 + likeop shift 135 + {default} reduce 198 + +State 144: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + expr ::= * LP expr RP + expr ::= * NULL + expr ::= * ID + expr ::= * JOIN_KW + expr ::= * nm DOT nm + expr ::= * nm DOT nm DOT nm + expr ::= * expr ORACLE_OUTER_JOIN + expr ::= * INTEGER + expr ::= * FLOAT + expr ::= * STRING + expr ::= * ID LP exprlist RP + expr ::= * ID LP STAR RP + expr ::= * expr AND expr + expr ::= * expr OR expr + expr ::= * expr LT expr + expr ::= * expr GT expr + expr ::= * expr LE expr + expr ::= * expr GE expr + expr ::= * expr NE expr + expr ::= * expr EQ expr + expr ::= * expr BITAND expr + expr ::= * expr BITOR expr + expr ::= * expr LSHIFT expr + expr ::= * expr RSHIFT expr + expr ::= * expr likeop expr + expr ::= * expr NOT likeop expr + expr ::= * expr PLUS expr + expr ::= * expr MINUS expr + expr ::= expr MINUS * expr + expr ::= * expr STAR expr + expr ::= * expr SLASH expr + expr ::= * expr REM expr + expr ::= * expr CONCAT expr + expr ::= * expr ISNULL + expr ::= * expr IS NULL + expr ::= * expr NOTNULL + expr ::= * expr NOT NULL + expr ::= * expr IS NOT NULL + expr ::= * NOT expr + expr ::= * BITNOT expr + expr ::= * MINUS expr + expr ::= * PLUS expr + expr ::= * LP select RP + expr ::= * expr BETWEEN expr AND expr + expr ::= * expr NOT BETWEEN expr AND expr + expr ::= * expr IN LP exprlist RP + expr ::= * expr IN LP select RP + expr ::= * expr NOT IN LP exprlist RP + expr ::= * expr NOT IN LP select RP + expr ::= * CASE case_operand case_exprlist case_else END + expr ::= * RAISE LP IGNORE RP + expr ::= * RAISE LP ROLLBACK COMMA nm RP + expr ::= * RAISE LP ABORT COMMA nm RP + expr ::= * RAISE LP FAIL COMMA nm RP + + BITNOT shift 177 + CASE shift 183 + FLOAT shift 174 + ID shift 64 + INTEGER shift 173 + JOIN_KW shift 67 + LP shift 68 + MINUS shift 179 + NOT shift 175 + NULL shift 106 + PLUS shift 181 + RAISE shift 193 + STRING shift 66 + expr shift 145 + nm shift 107 + +State 145: + expr ::= expr * ORACLE_OUTER_JOIN + expr ::= expr * AND expr + expr ::= expr * OR expr + expr ::= expr * LT expr + expr ::= expr * GT expr + expr ::= expr * LE expr + expr ::= expr * GE expr + expr ::= expr * NE expr + expr ::= expr * EQ expr + expr ::= expr * BITAND expr + expr ::= expr * BITOR expr + expr ::= expr * LSHIFT expr + expr ::= expr * RSHIFT expr + expr ::= expr * likeop expr + expr ::= expr * NOT likeop expr + likeop ::= * LIKE + likeop ::= * GLOB + expr ::= expr * PLUS expr + expr ::= expr * MINUS expr + (199) expr ::= expr MINUS expr * + expr ::= expr * STAR expr + expr ::= expr * SLASH expr + expr ::= expr * REM expr + expr ::= expr * CONCAT expr + expr ::= expr * ISNULL + expr ::= expr * IS NULL + expr ::= expr * NOTNULL + expr ::= expr * NOT NULL + expr ::= expr * IS NOT NULL + expr ::= expr * BETWEEN expr AND expr + expr ::= expr * NOT BETWEEN expr AND expr + expr ::= expr * IN LP exprlist RP + expr ::= expr * IN LP select RP + expr ::= expr * NOT IN LP exprlist RP + expr ::= expr * NOT IN LP select RP + + CONCAT shift 152 + ORACLE_OUTER_JOIN shift 104 + REM shift 150 + SLASH shift 148 + STAR shift 146 + likeop shift 135 + {default} reduce 199 + +State 146: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + expr ::= * LP expr RP + expr ::= * NULL + expr ::= * ID + expr ::= * JOIN_KW + expr ::= * nm DOT nm + expr ::= * nm DOT nm DOT nm + expr ::= * expr ORACLE_OUTER_JOIN + expr ::= * INTEGER + expr ::= * FLOAT + expr ::= * STRING + expr ::= * ID LP exprlist RP + expr ::= * ID LP STAR RP + expr ::= * expr AND expr + expr ::= * expr OR expr + expr ::= * expr LT expr + expr ::= * expr GT expr + expr ::= * expr LE expr + expr ::= * expr GE expr + expr ::= * expr NE expr + expr ::= * expr EQ expr + expr ::= * expr BITAND expr + expr ::= * expr BITOR expr + expr ::= * expr LSHIFT expr + expr ::= * expr RSHIFT expr + expr ::= * expr likeop expr + expr ::= * expr NOT likeop expr + expr ::= * expr PLUS expr + expr ::= * expr MINUS expr + expr ::= * expr STAR expr + expr ::= expr STAR * expr + expr ::= * expr SLASH expr + expr ::= * expr REM expr + expr ::= * expr CONCAT expr + expr ::= * expr ISNULL + expr ::= * expr IS NULL + expr ::= * expr NOTNULL + expr ::= * expr NOT NULL + expr ::= * expr IS NOT NULL + expr ::= * NOT expr + expr ::= * BITNOT expr + expr ::= * MINUS expr + expr ::= * PLUS expr + expr ::= * LP select RP + expr ::= * expr BETWEEN expr AND expr + expr ::= * expr NOT BETWEEN expr AND expr + expr ::= * expr IN LP exprlist RP + expr ::= * expr IN LP select RP + expr ::= * expr NOT IN LP exprlist RP + expr ::= * expr NOT IN LP select RP + expr ::= * CASE case_operand case_exprlist case_else END + expr ::= * RAISE LP IGNORE RP + expr ::= * RAISE LP ROLLBACK COMMA nm RP + expr ::= * RAISE LP ABORT COMMA nm RP + expr ::= * RAISE LP FAIL COMMA nm RP + + BITNOT shift 177 + CASE shift 183 + FLOAT shift 174 + ID shift 64 + INTEGER shift 173 + JOIN_KW shift 67 + LP shift 68 + MINUS shift 179 + NOT shift 175 + NULL shift 106 + PLUS shift 181 + RAISE shift 193 + STRING shift 66 + expr shift 147 + nm shift 107 + +State 147: + expr ::= expr * ORACLE_OUTER_JOIN + expr ::= expr * AND expr + expr ::= expr * OR expr + expr ::= expr * LT expr + expr ::= expr * GT expr + expr ::= expr * LE expr + expr ::= expr * GE expr + expr ::= expr * NE expr + expr ::= expr * EQ expr + expr ::= expr * BITAND expr + expr ::= expr * BITOR expr + expr ::= expr * LSHIFT expr + expr ::= expr * RSHIFT expr + expr ::= expr * likeop expr + expr ::= expr * NOT likeop expr + likeop ::= * LIKE + likeop ::= * GLOB + expr ::= expr * PLUS expr + expr ::= expr * MINUS expr + expr ::= expr * STAR expr + (200) expr ::= expr STAR expr * + expr ::= expr * SLASH expr + expr ::= expr * REM expr + expr ::= expr * CONCAT expr + expr ::= expr * ISNULL + expr ::= expr * IS NULL + expr ::= expr * NOTNULL + expr ::= expr * NOT NULL + expr ::= expr * IS NOT NULL + expr ::= expr * BETWEEN expr AND expr + expr ::= expr * NOT BETWEEN expr AND expr + expr ::= expr * IN LP exprlist RP + expr ::= expr * IN LP select RP + expr ::= expr * NOT IN LP exprlist RP + expr ::= expr * NOT IN LP select RP + + CONCAT shift 152 + ORACLE_OUTER_JOIN shift 104 + likeop shift 135 + {default} reduce 200 + +State 148: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + expr ::= * LP expr RP + expr ::= * NULL + expr ::= * ID + expr ::= * JOIN_KW + expr ::= * nm DOT nm + expr ::= * nm DOT nm DOT nm + expr ::= * expr ORACLE_OUTER_JOIN + expr ::= * INTEGER + expr ::= * FLOAT + expr ::= * STRING + expr ::= * ID LP exprlist RP + expr ::= * ID LP STAR RP + expr ::= * expr AND expr + expr ::= * expr OR expr + expr ::= * expr LT expr + expr ::= * expr GT expr + expr ::= * expr LE expr + expr ::= * expr GE expr + expr ::= * expr NE expr + expr ::= * expr EQ expr + expr ::= * expr BITAND expr + expr ::= * expr BITOR expr + expr ::= * expr LSHIFT expr + expr ::= * expr RSHIFT expr + expr ::= * expr likeop expr + expr ::= * expr NOT likeop expr + expr ::= * expr PLUS expr + expr ::= * expr MINUS expr + expr ::= * expr STAR expr + expr ::= * expr SLASH expr + expr ::= expr SLASH * expr + expr ::= * expr REM expr + expr ::= * expr CONCAT expr + expr ::= * expr ISNULL + expr ::= * expr IS NULL + expr ::= * expr NOTNULL + expr ::= * expr NOT NULL + expr ::= * expr IS NOT NULL + expr ::= * NOT expr + expr ::= * BITNOT expr + expr ::= * MINUS expr + expr ::= * PLUS expr + expr ::= * LP select RP + expr ::= * expr BETWEEN expr AND expr + expr ::= * expr NOT BETWEEN expr AND expr + expr ::= * expr IN LP exprlist RP + expr ::= * expr IN LP select RP + expr ::= * expr NOT IN LP exprlist RP + expr ::= * expr NOT IN LP select RP + expr ::= * CASE case_operand case_exprlist case_else END + expr ::= * RAISE LP IGNORE RP + expr ::= * RAISE LP ROLLBACK COMMA nm RP + expr ::= * RAISE LP ABORT COMMA nm RP + expr ::= * RAISE LP FAIL COMMA nm RP + + BITNOT shift 177 + CASE shift 183 + FLOAT shift 174 + ID shift 64 + INTEGER shift 173 + JOIN_KW shift 67 + LP shift 68 + MINUS shift 179 + NOT shift 175 + NULL shift 106 + PLUS shift 181 + RAISE shift 193 + STRING shift 66 + expr shift 149 + nm shift 107 + +State 149: + expr ::= expr * ORACLE_OUTER_JOIN + expr ::= expr * AND expr + expr ::= expr * OR expr + expr ::= expr * LT expr + expr ::= expr * GT expr + expr ::= expr * LE expr + expr ::= expr * GE expr + expr ::= expr * NE expr + expr ::= expr * EQ expr + expr ::= expr * BITAND expr + expr ::= expr * BITOR expr + expr ::= expr * LSHIFT expr + expr ::= expr * RSHIFT expr + expr ::= expr * likeop expr + expr ::= expr * NOT likeop expr + likeop ::= * LIKE + likeop ::= * GLOB + expr ::= expr * PLUS expr + expr ::= expr * MINUS expr + expr ::= expr * STAR expr + expr ::= expr * SLASH expr + (201) expr ::= expr SLASH expr * + expr ::= expr * REM expr + expr ::= expr * CONCAT expr + expr ::= expr * ISNULL + expr ::= expr * IS NULL + expr ::= expr * NOTNULL + expr ::= expr * NOT NULL + expr ::= expr * IS NOT NULL + expr ::= expr * BETWEEN expr AND expr + expr ::= expr * NOT BETWEEN expr AND expr + expr ::= expr * IN LP exprlist RP + expr ::= expr * IN LP select RP + expr ::= expr * NOT IN LP exprlist RP + expr ::= expr * NOT IN LP select RP + + CONCAT shift 152 + ORACLE_OUTER_JOIN shift 104 + likeop shift 135 + {default} reduce 201 + +State 150: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + expr ::= * LP expr RP + expr ::= * NULL + expr ::= * ID + expr ::= * JOIN_KW + expr ::= * nm DOT nm + expr ::= * nm DOT nm DOT nm + expr ::= * expr ORACLE_OUTER_JOIN + expr ::= * INTEGER + expr ::= * FLOAT + expr ::= * STRING + expr ::= * ID LP exprlist RP + expr ::= * ID LP STAR RP + expr ::= * expr AND expr + expr ::= * expr OR expr + expr ::= * expr LT expr + expr ::= * expr GT expr + expr ::= * expr LE expr + expr ::= * expr GE expr + expr ::= * expr NE expr + expr ::= * expr EQ expr + expr ::= * expr BITAND expr + expr ::= * expr BITOR expr + expr ::= * expr LSHIFT expr + expr ::= * expr RSHIFT expr + expr ::= * expr likeop expr + expr ::= * expr NOT likeop expr + expr ::= * expr PLUS expr + expr ::= * expr MINUS expr + expr ::= * expr STAR expr + expr ::= * expr SLASH expr + expr ::= * expr REM expr + expr ::= expr REM * expr + expr ::= * expr CONCAT expr + expr ::= * expr ISNULL + expr ::= * expr IS NULL + expr ::= * expr NOTNULL + expr ::= * expr NOT NULL + expr ::= * expr IS NOT NULL + expr ::= * NOT expr + expr ::= * BITNOT expr + expr ::= * MINUS expr + expr ::= * PLUS expr + expr ::= * LP select RP + expr ::= * expr BETWEEN expr AND expr + expr ::= * expr NOT BETWEEN expr AND expr + expr ::= * expr IN LP exprlist RP + expr ::= * expr IN LP select RP + expr ::= * expr NOT IN LP exprlist RP + expr ::= * expr NOT IN LP select RP + expr ::= * CASE case_operand case_exprlist case_else END + expr ::= * RAISE LP IGNORE RP + expr ::= * RAISE LP ROLLBACK COMMA nm RP + expr ::= * RAISE LP ABORT COMMA nm RP + expr ::= * RAISE LP FAIL COMMA nm RP + + BITNOT shift 177 + CASE shift 183 + FLOAT shift 174 + ID shift 64 + INTEGER shift 173 + JOIN_KW shift 67 + LP shift 68 + MINUS shift 179 + NOT shift 175 + NULL shift 106 + PLUS shift 181 + RAISE shift 193 + STRING shift 66 + expr shift 151 + nm shift 107 + +State 151: + expr ::= expr * ORACLE_OUTER_JOIN + expr ::= expr * AND expr + expr ::= expr * OR expr + expr ::= expr * LT expr + expr ::= expr * GT expr + expr ::= expr * LE expr + expr ::= expr * GE expr + expr ::= expr * NE expr + expr ::= expr * EQ expr + expr ::= expr * BITAND expr + expr ::= expr * BITOR expr + expr ::= expr * LSHIFT expr + expr ::= expr * RSHIFT expr + expr ::= expr * likeop expr + expr ::= expr * NOT likeop expr + likeop ::= * LIKE + likeop ::= * GLOB + expr ::= expr * PLUS expr + expr ::= expr * MINUS expr + expr ::= expr * STAR expr + expr ::= expr * SLASH expr + expr ::= expr * REM expr + (202) expr ::= expr REM expr * + expr ::= expr * CONCAT expr + expr ::= expr * ISNULL + expr ::= expr * IS NULL + expr ::= expr * NOTNULL + expr ::= expr * NOT NULL + expr ::= expr * IS NOT NULL + expr ::= expr * BETWEEN expr AND expr + expr ::= expr * NOT BETWEEN expr AND expr + expr ::= expr * IN LP exprlist RP + expr ::= expr * IN LP select RP + expr ::= expr * NOT IN LP exprlist RP + expr ::= expr * NOT IN LP select RP + + CONCAT shift 152 + ORACLE_OUTER_JOIN shift 104 + likeop shift 135 + {default} reduce 202 + +State 152: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + expr ::= * LP expr RP + expr ::= * NULL + expr ::= * ID + expr ::= * JOIN_KW + expr ::= * nm DOT nm + expr ::= * nm DOT nm DOT nm + expr ::= * expr ORACLE_OUTER_JOIN + expr ::= * INTEGER + expr ::= * FLOAT + expr ::= * STRING + expr ::= * ID LP exprlist RP + expr ::= * ID LP STAR RP + expr ::= * expr AND expr + expr ::= * expr OR expr + expr ::= * expr LT expr + expr ::= * expr GT expr + expr ::= * expr LE expr + expr ::= * expr GE expr + expr ::= * expr NE expr + expr ::= * expr EQ expr + expr ::= * expr BITAND expr + expr ::= * expr BITOR expr + expr ::= * expr LSHIFT expr + expr ::= * expr RSHIFT expr + expr ::= * expr likeop expr + expr ::= * expr NOT likeop expr + expr ::= * expr PLUS expr + expr ::= * expr MINUS expr + expr ::= * expr STAR expr + expr ::= * expr SLASH expr + expr ::= * expr REM expr + expr ::= * expr CONCAT expr + expr ::= expr CONCAT * expr + expr ::= * expr ISNULL + expr ::= * expr IS NULL + expr ::= * expr NOTNULL + expr ::= * expr NOT NULL + expr ::= * expr IS NOT NULL + expr ::= * NOT expr + expr ::= * BITNOT expr + expr ::= * MINUS expr + expr ::= * PLUS expr + expr ::= * LP select RP + expr ::= * expr BETWEEN expr AND expr + expr ::= * expr NOT BETWEEN expr AND expr + expr ::= * expr IN LP exprlist RP + expr ::= * expr IN LP select RP + expr ::= * expr NOT IN LP exprlist RP + expr ::= * expr NOT IN LP select RP + expr ::= * CASE case_operand case_exprlist case_else END + expr ::= * RAISE LP IGNORE RP + expr ::= * RAISE LP ROLLBACK COMMA nm RP + expr ::= * RAISE LP ABORT COMMA nm RP + expr ::= * RAISE LP FAIL COMMA nm RP + + BITNOT shift 177 + CASE shift 183 + FLOAT shift 174 + ID shift 64 + INTEGER shift 173 + JOIN_KW shift 67 + LP shift 68 + MINUS shift 179 + NOT shift 175 + NULL shift 106 + PLUS shift 181 + RAISE shift 193 + STRING shift 66 + expr shift 153 + nm shift 107 + +State 153: + expr ::= expr * ORACLE_OUTER_JOIN + expr ::= expr * AND expr + expr ::= expr * OR expr + expr ::= expr * LT expr + expr ::= expr * GT expr + expr ::= expr * LE expr + expr ::= expr * GE expr + expr ::= expr * NE expr + expr ::= expr * EQ expr + expr ::= expr * BITAND expr + expr ::= expr * BITOR expr + expr ::= expr * LSHIFT expr + expr ::= expr * RSHIFT expr + expr ::= expr * likeop expr + expr ::= expr * NOT likeop expr + likeop ::= * LIKE + likeop ::= * GLOB + expr ::= expr * PLUS expr + expr ::= expr * MINUS expr + expr ::= expr * STAR expr + expr ::= expr * SLASH expr + expr ::= expr * REM expr + expr ::= expr * CONCAT expr + (203) expr ::= expr CONCAT expr * + expr ::= expr * ISNULL + expr ::= expr * IS NULL + expr ::= expr * NOTNULL + expr ::= expr * NOT NULL + expr ::= expr * IS NOT NULL + expr ::= expr * BETWEEN expr AND expr + expr ::= expr * NOT BETWEEN expr AND expr + expr ::= expr * IN LP exprlist RP + expr ::= expr * IN LP select RP + expr ::= expr * NOT IN LP exprlist RP + expr ::= expr * NOT IN LP select RP + + ORACLE_OUTER_JOIN shift 104 + likeop shift 135 + {default} reduce 203 + +State 154: + (204) expr ::= expr ISNULL * + + {default} reduce 204 + +State 155: + expr ::= expr IS * NULL + expr ::= expr IS * NOT NULL + + NOT shift 157 + NULL shift 156 + +State 156: + (205) expr ::= expr IS NULL * + + {default} reduce 205 + +State 157: + expr ::= expr IS NOT * NULL + + NULL shift 158 + +State 158: + (208) expr ::= expr IS NOT NULL * + + {default} reduce 208 + +State 159: + (206) expr ::= expr NOTNULL * + + {default} reduce 206 + +State 160: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + expr ::= * LP expr RP + expr ::= * NULL + expr ::= * ID + expr ::= * JOIN_KW + expr ::= * nm DOT nm + expr ::= * nm DOT nm DOT nm + expr ::= * expr ORACLE_OUTER_JOIN + expr ::= * INTEGER + expr ::= * FLOAT + expr ::= * STRING + expr ::= * ID LP exprlist RP + expr ::= * ID LP STAR RP + expr ::= * expr AND expr + expr ::= * expr OR expr + expr ::= * expr LT expr + expr ::= * expr GT expr + expr ::= * expr LE expr + expr ::= * expr GE expr + expr ::= * expr NE expr + expr ::= * expr EQ expr + expr ::= * expr BITAND expr + expr ::= * expr BITOR expr + expr ::= * expr LSHIFT expr + expr ::= * expr RSHIFT expr + expr ::= * expr likeop expr + expr ::= * expr NOT likeop expr + expr ::= * expr PLUS expr + expr ::= * expr MINUS expr + expr ::= * expr STAR expr + expr ::= * expr SLASH expr + expr ::= * expr REM expr + expr ::= * expr CONCAT expr + expr ::= * expr ISNULL + expr ::= * expr IS NULL + expr ::= * expr NOTNULL + expr ::= * expr NOT NULL + expr ::= * expr IS NOT NULL + expr ::= * NOT expr + expr ::= * BITNOT expr + expr ::= * MINUS expr + expr ::= * PLUS expr + expr ::= * LP select RP + expr ::= * expr BETWEEN expr AND expr + expr ::= expr BETWEEN * expr AND expr + expr ::= * expr NOT BETWEEN expr AND expr + expr ::= * expr IN LP exprlist RP + expr ::= * expr IN LP select RP + expr ::= * expr NOT IN LP exprlist RP + expr ::= * expr NOT IN LP select RP + expr ::= * CASE case_operand case_exprlist case_else END + expr ::= * RAISE LP IGNORE RP + expr ::= * RAISE LP ROLLBACK COMMA nm RP + expr ::= * RAISE LP ABORT COMMA nm RP + expr ::= * RAISE LP FAIL COMMA nm RP + + BITNOT shift 177 + CASE shift 183 + FLOAT shift 174 + ID shift 64 + INTEGER shift 173 + JOIN_KW shift 67 + LP shift 68 + MINUS shift 179 + NOT shift 175 + NULL shift 106 + PLUS shift 181 + RAISE shift 193 + STRING shift 66 + expr shift 161 + nm shift 107 + +State 161: + expr ::= expr * ORACLE_OUTER_JOIN + expr ::= expr * AND expr + expr ::= expr * OR expr + expr ::= expr * LT expr + expr ::= expr * GT expr + expr ::= expr * LE expr + expr ::= expr * GE expr + expr ::= expr * NE expr + expr ::= expr * EQ expr + expr ::= expr * BITAND expr + expr ::= expr * BITOR expr + expr ::= expr * LSHIFT expr + expr ::= expr * RSHIFT expr + expr ::= expr * likeop expr + expr ::= expr * NOT likeop expr + likeop ::= * LIKE + likeop ::= * GLOB + expr ::= expr * PLUS expr + expr ::= expr * MINUS expr + expr ::= expr * STAR expr + expr ::= expr * SLASH expr + expr ::= expr * REM expr + expr ::= expr * CONCAT expr + expr ::= expr * ISNULL + expr ::= expr * IS NULL + expr ::= expr * NOTNULL + expr ::= expr * NOT NULL + expr ::= expr * IS NOT NULL + expr ::= expr * BETWEEN expr AND expr + expr ::= expr BETWEEN expr * AND expr + expr ::= expr * NOT BETWEEN expr AND expr + expr ::= expr * IN LP exprlist RP + expr ::= expr * IN LP select RP + expr ::= expr * NOT IN LP exprlist RP + expr ::= expr * NOT IN LP select RP + + AND shift 162 + BETWEEN shift 160 + BITAND shift 127 + BITOR shift 129 + CONCAT shift 152 + EQ shift 125 + GE shift 121 + GLOB shift 141 + GT shift 117 + IN shift 164 + IS shift 155 + ISNULL shift 154 + LE shift 119 + LIKE shift 140 + LSHIFT shift 131 + LT shift 115 + MINUS shift 144 + NE shift 123 + NOT shift 137 + NOTNULL shift 159 + OR shift 113 + ORACLE_OUTER_JOIN shift 104 + PLUS shift 142 + REM shift 150 + RSHIFT shift 133 + SLASH shift 148 + STAR shift 146 + likeop shift 135 + +State 162: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + expr ::= * LP expr RP + expr ::= * NULL + expr ::= * ID + expr ::= * JOIN_KW + expr ::= * nm DOT nm + expr ::= * nm DOT nm DOT nm + expr ::= * expr ORACLE_OUTER_JOIN + expr ::= * INTEGER + expr ::= * FLOAT + expr ::= * STRING + expr ::= * ID LP exprlist RP + expr ::= * ID LP STAR RP + expr ::= * expr AND expr + expr ::= expr AND * expr + expr ::= * expr OR expr + expr ::= * expr LT expr + expr ::= * expr GT expr + expr ::= * expr LE expr + expr ::= * expr GE expr + expr ::= * expr NE expr + expr ::= * expr EQ expr + expr ::= * expr BITAND expr + expr ::= * expr BITOR expr + expr ::= * expr LSHIFT expr + expr ::= * expr RSHIFT expr + expr ::= * expr likeop expr + expr ::= * expr NOT likeop expr + expr ::= * expr PLUS expr + expr ::= * expr MINUS expr + expr ::= * expr STAR expr + expr ::= * expr SLASH expr + expr ::= * expr REM expr + expr ::= * expr CONCAT expr + expr ::= * expr ISNULL + expr ::= * expr IS NULL + expr ::= * expr NOTNULL + expr ::= * expr NOT NULL + expr ::= * expr IS NOT NULL + expr ::= * NOT expr + expr ::= * BITNOT expr + expr ::= * MINUS expr + expr ::= * PLUS expr + expr ::= * LP select RP + expr ::= * expr BETWEEN expr AND expr + expr ::= expr BETWEEN expr AND * expr + expr ::= * expr NOT BETWEEN expr AND expr + expr ::= * expr IN LP exprlist RP + expr ::= * expr IN LP select RP + expr ::= * expr NOT IN LP exprlist RP + expr ::= * expr NOT IN LP select RP + expr ::= * CASE case_operand case_exprlist case_else END + expr ::= * RAISE LP IGNORE RP + expr ::= * RAISE LP ROLLBACK COMMA nm RP + expr ::= * RAISE LP ABORT COMMA nm RP + expr ::= * RAISE LP FAIL COMMA nm RP + + BITNOT shift 177 + CASE shift 183 + FLOAT shift 174 + ID shift 64 + INTEGER shift 173 + JOIN_KW shift 67 + LP shift 68 + MINUS shift 179 + NOT shift 175 + NULL shift 106 + PLUS shift 181 + RAISE shift 193 + STRING shift 66 + expr shift 163 + nm shift 107 + +State 163: + expr ::= expr * ORACLE_OUTER_JOIN + expr ::= expr * AND expr + (182) expr ::= expr AND expr * + expr ::= expr * OR expr + expr ::= expr * LT expr + expr ::= expr * GT expr + expr ::= expr * LE expr + expr ::= expr * GE expr + expr ::= expr * NE expr + expr ::= expr * EQ expr + expr ::= expr * BITAND expr + expr ::= expr * BITOR expr + expr ::= expr * LSHIFT expr + expr ::= expr * RSHIFT expr + expr ::= expr * likeop expr + expr ::= expr * NOT likeop expr + likeop ::= * LIKE + likeop ::= * GLOB + expr ::= expr * PLUS expr + expr ::= expr * MINUS expr + expr ::= expr * STAR expr + expr ::= expr * SLASH expr + expr ::= expr * REM expr + expr ::= expr * CONCAT expr + expr ::= expr * ISNULL + expr ::= expr * IS NULL + expr ::= expr * NOTNULL + expr ::= expr * NOT NULL + expr ::= expr * IS NOT NULL + expr ::= expr * BETWEEN expr AND expr + (214) expr ::= expr BETWEEN expr AND expr * + expr ::= expr * NOT BETWEEN expr AND expr + expr ::= expr * IN LP exprlist RP + expr ::= expr * IN LP select RP + expr ::= expr * NOT IN LP exprlist RP + expr ::= expr * NOT IN LP select RP + + BITAND shift 127 + BITOR shift 129 + CONCAT shift 152 + GE shift 121 + GT shift 117 + LE shift 119 + LSHIFT shift 131 + LT shift 115 + MINUS shift 144 + ORACLE_OUTER_JOIN shift 104 + PLUS shift 142 + REM shift 150 + RSHIFT shift 133 + SLASH shift 148 + STAR shift 146 + likeop shift 135 + {default} reduce 214 + +State 164: + expr ::= expr IN * LP exprlist RP + expr ::= expr IN * LP select RP + + LP shift 165 + +State 165: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + select ::= * oneselect + select ::= * select multiselect_op oneselect + oneselect ::= * SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt + expr ::= * LP expr RP + expr ::= * NULL + expr ::= * ID + expr ::= * JOIN_KW + expr ::= * nm DOT nm + expr ::= * nm DOT nm DOT nm + expr ::= * expr ORACLE_OUTER_JOIN + expr ::= * INTEGER + expr ::= * FLOAT + expr ::= * STRING + expr ::= * ID LP exprlist RP + expr ::= * ID LP STAR RP + expr ::= * expr AND expr + expr ::= * expr OR expr + expr ::= * expr LT expr + expr ::= * expr GT expr + expr ::= * expr LE expr + expr ::= * expr GE expr + expr ::= * expr NE expr + expr ::= * expr EQ expr + expr ::= * expr BITAND expr + expr ::= * expr BITOR expr + expr ::= * expr LSHIFT expr + expr ::= * expr RSHIFT expr + expr ::= * expr likeop expr + expr ::= * expr NOT likeop expr + expr ::= * expr PLUS expr + expr ::= * expr MINUS expr + expr ::= * expr STAR expr + expr ::= * expr SLASH expr + expr ::= * expr REM expr + expr ::= * expr CONCAT expr + expr ::= * expr ISNULL + expr ::= * expr IS NULL + expr ::= * expr NOTNULL + expr ::= * expr NOT NULL + expr ::= * expr IS NOT NULL + expr ::= * NOT expr + expr ::= * BITNOT expr + expr ::= * MINUS expr + expr ::= * PLUS expr + expr ::= * LP select RP + expr ::= * expr BETWEEN expr AND expr + expr ::= * expr NOT BETWEEN expr AND expr + expr ::= * expr IN LP exprlist RP + expr ::= expr IN LP * exprlist RP + expr ::= * expr IN LP select RP + expr ::= expr IN LP * select RP + expr ::= * expr NOT IN LP exprlist RP + expr ::= * expr NOT IN LP select RP + expr ::= * CASE case_operand case_exprlist case_else END + exprlist ::= * exprlist COMMA expritem + exprlist ::= * expritem + expritem ::= * expr + (230) expritem ::= * + expr ::= * RAISE LP IGNORE RP + expr ::= * RAISE LP ROLLBACK COMMA nm RP + expr ::= * RAISE LP ABORT COMMA nm RP + expr ::= * RAISE LP FAIL COMMA nm RP + + BITNOT shift 177 + CASE shift 183 + FLOAT shift 174 + ID shift 64 + INTEGER shift 173 + JOIN_KW shift 67 + LP shift 68 + MINUS shift 179 + NOT shift 175 + NULL shift 106 + PLUS shift 181 + RAISE shift 193 + SELECT shift 73 + STRING shift 66 + expr shift 172 + expritem shift 219 + exprlist shift 215 + nm shift 107 + oneselect shift 69 + select shift 166 + {default} reduce 230 + +State 166: + select ::= select * multiselect_op oneselect + multiselect_op ::= * UNION + multiselect_op ::= * UNION ALL + multiselect_op ::= * INTERSECT + multiselect_op ::= * EXCEPT + expr ::= expr IN LP select * RP + + EXCEPT shift 170 + INTERSECT shift 169 + RP shift 171 + UNION shift 167 + multiselect_op shift 71 + +State 167: + (103) multiselect_op ::= UNION * + multiselect_op ::= UNION * ALL + + ALL shift 168 + SELECT reduce 103 + +State 168: + (104) multiselect_op ::= UNION ALL * + + SELECT reduce 104 + +State 169: + (105) multiselect_op ::= INTERSECT * + + SELECT reduce 105 + +State 170: + (106) multiselect_op ::= EXCEPT * + + SELECT reduce 106 + +State 171: + (217) expr ::= expr IN LP select RP * + + {default} reduce 217 + +State 172: + expr ::= expr * ORACLE_OUTER_JOIN + expr ::= expr * AND expr + expr ::= expr * OR expr + expr ::= expr * LT expr + expr ::= expr * GT expr + expr ::= expr * LE expr + expr ::= expr * GE expr + expr ::= expr * NE expr + expr ::= expr * EQ expr + expr ::= expr * BITAND expr + expr ::= expr * BITOR expr + expr ::= expr * LSHIFT expr + expr ::= expr * RSHIFT expr + expr ::= expr * likeop expr + expr ::= expr * NOT likeop expr + likeop ::= * LIKE + likeop ::= * GLOB + expr ::= expr * PLUS expr + expr ::= expr * MINUS expr + expr ::= expr * STAR expr + expr ::= expr * SLASH expr + expr ::= expr * REM expr + expr ::= expr * CONCAT expr + expr ::= expr * ISNULL + expr ::= expr * IS NULL + expr ::= expr * NOTNULL + expr ::= expr * NOT NULL + expr ::= expr * IS NOT NULL + expr ::= expr * BETWEEN expr AND expr + expr ::= expr * NOT BETWEEN expr AND expr + expr ::= expr * IN LP exprlist RP + expr ::= expr * IN LP select RP + expr ::= expr * NOT IN LP exprlist RP + expr ::= expr * NOT IN LP select RP + (229) expritem ::= expr * + + AND shift 105 + BETWEEN shift 160 + BITAND shift 127 + BITOR shift 129 + CONCAT shift 152 + EQ shift 125 + GE shift 121 + GLOB shift 141 + GT shift 117 + IN shift 164 + IS shift 155 + ISNULL shift 154 + LE shift 119 + LIKE shift 140 + LSHIFT shift 131 + LT shift 115 + MINUS shift 144 + NE shift 123 + NOT shift 137 + NOTNULL shift 159 + OR shift 113 + ORACLE_OUTER_JOIN shift 104 + PLUS shift 142 + REM shift 150 + RSHIFT shift 133 + SLASH shift 148 + STAR shift 146 + likeop shift 135 + {default} reduce 229 + +State 173: + (177) expr ::= INTEGER * + + {default} reduce 177 + +State 174: + (178) expr ::= FLOAT * + + {default} reduce 178 + +State 175: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + expr ::= * LP expr RP + expr ::= * NULL + expr ::= * ID + expr ::= * JOIN_KW + expr ::= * nm DOT nm + expr ::= * nm DOT nm DOT nm + expr ::= * expr ORACLE_OUTER_JOIN + expr ::= * INTEGER + expr ::= * FLOAT + expr ::= * STRING + expr ::= * ID LP exprlist RP + expr ::= * ID LP STAR RP + expr ::= * expr AND expr + expr ::= * expr OR expr + expr ::= * expr LT expr + expr ::= * expr GT expr + expr ::= * expr LE expr + expr ::= * expr GE expr + expr ::= * expr NE expr + expr ::= * expr EQ expr + expr ::= * expr BITAND expr + expr ::= * expr BITOR expr + expr ::= * expr LSHIFT expr + expr ::= * expr RSHIFT expr + expr ::= * expr likeop expr + expr ::= * expr NOT likeop expr + expr ::= * expr PLUS expr + expr ::= * expr MINUS expr + expr ::= * expr STAR expr + expr ::= * expr SLASH expr + expr ::= * expr REM expr + expr ::= * expr CONCAT expr + expr ::= * expr ISNULL + expr ::= * expr IS NULL + expr ::= * expr NOTNULL + expr ::= * expr NOT NULL + expr ::= * expr IS NOT NULL + expr ::= * NOT expr + expr ::= NOT * expr + expr ::= * BITNOT expr + expr ::= * MINUS expr + expr ::= * PLUS expr + expr ::= * LP select RP + expr ::= * expr BETWEEN expr AND expr + expr ::= * expr NOT BETWEEN expr AND expr + expr ::= * expr IN LP exprlist RP + expr ::= * expr IN LP select RP + expr ::= * expr NOT IN LP exprlist RP + expr ::= * expr NOT IN LP select RP + expr ::= * CASE case_operand case_exprlist case_else END + expr ::= * RAISE LP IGNORE RP + expr ::= * RAISE LP ROLLBACK COMMA nm RP + expr ::= * RAISE LP ABORT COMMA nm RP + expr ::= * RAISE LP FAIL COMMA nm RP + + BITNOT shift 177 + CASE shift 183 + FLOAT shift 174 + ID shift 64 + INTEGER shift 173 + JOIN_KW shift 67 + LP shift 68 + MINUS shift 179 + NOT shift 175 + NULL shift 106 + PLUS shift 181 + RAISE shift 193 + STRING shift 66 + expr shift 176 + nm shift 107 + +State 176: + expr ::= expr * ORACLE_OUTER_JOIN + expr ::= expr * AND expr + expr ::= expr * OR expr + expr ::= expr * LT expr + expr ::= expr * GT expr + expr ::= expr * LE expr + expr ::= expr * GE expr + expr ::= expr * NE expr + expr ::= expr * EQ expr + expr ::= expr * BITAND expr + expr ::= expr * BITOR expr + expr ::= expr * LSHIFT expr + expr ::= expr * RSHIFT expr + expr ::= expr * likeop expr + expr ::= expr * NOT likeop expr + likeop ::= * LIKE + likeop ::= * GLOB + expr ::= expr * PLUS expr + expr ::= expr * MINUS expr + expr ::= expr * STAR expr + expr ::= expr * SLASH expr + expr ::= expr * REM expr + expr ::= expr * CONCAT expr + expr ::= expr * ISNULL + expr ::= expr * IS NULL + expr ::= expr * NOTNULL + expr ::= expr * NOT NULL + expr ::= expr * IS NOT NULL + (209) expr ::= NOT expr * + expr ::= expr * BETWEEN expr AND expr + expr ::= expr * NOT BETWEEN expr AND expr + expr ::= expr * IN LP exprlist RP + expr ::= expr * IN LP select RP + expr ::= expr * NOT IN LP exprlist RP + expr ::= expr * NOT IN LP select RP + + BETWEEN shift 160 + BITAND shift 127 + BITOR shift 129 + CONCAT shift 152 + EQ shift 125 + GE shift 121 + GLOB shift 141 + GT shift 117 + IN shift 164 + IS shift 155 + ISNULL shift 154 + LE shift 119 + LIKE shift 140 + LSHIFT shift 131 + LT shift 115 + MINUS shift 144 + NE shift 123 + NOT shift 137 + NOTNULL shift 159 + ORACLE_OUTER_JOIN shift 104 + PLUS shift 142 + REM shift 150 + RSHIFT shift 133 + SLASH shift 148 + STAR shift 146 + likeop shift 135 + {default} reduce 209 + +State 177: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + expr ::= * LP expr RP + expr ::= * NULL + expr ::= * ID + expr ::= * JOIN_KW + expr ::= * nm DOT nm + expr ::= * nm DOT nm DOT nm + expr ::= * expr ORACLE_OUTER_JOIN + expr ::= * INTEGER + expr ::= * FLOAT + expr ::= * STRING + expr ::= * ID LP exprlist RP + expr ::= * ID LP STAR RP + expr ::= * expr AND expr + expr ::= * expr OR expr + expr ::= * expr LT expr + expr ::= * expr GT expr + expr ::= * expr LE expr + expr ::= * expr GE expr + expr ::= * expr NE expr + expr ::= * expr EQ expr + expr ::= * expr BITAND expr + expr ::= * expr BITOR expr + expr ::= * expr LSHIFT expr + expr ::= * expr RSHIFT expr + expr ::= * expr likeop expr + expr ::= * expr NOT likeop expr + expr ::= * expr PLUS expr + expr ::= * expr MINUS expr + expr ::= * expr STAR expr + expr ::= * expr SLASH expr + expr ::= * expr REM expr + expr ::= * expr CONCAT expr + expr ::= * expr ISNULL + expr ::= * expr IS NULL + expr ::= * expr NOTNULL + expr ::= * expr NOT NULL + expr ::= * expr IS NOT NULL + expr ::= * NOT expr + expr ::= * BITNOT expr + expr ::= BITNOT * expr + expr ::= * MINUS expr + expr ::= * PLUS expr + expr ::= * LP select RP + expr ::= * expr BETWEEN expr AND expr + expr ::= * expr NOT BETWEEN expr AND expr + expr ::= * expr IN LP exprlist RP + expr ::= * expr IN LP select RP + expr ::= * expr NOT IN LP exprlist RP + expr ::= * expr NOT IN LP select RP + expr ::= * CASE case_operand case_exprlist case_else END + expr ::= * RAISE LP IGNORE RP + expr ::= * RAISE LP ROLLBACK COMMA nm RP + expr ::= * RAISE LP ABORT COMMA nm RP + expr ::= * RAISE LP FAIL COMMA nm RP + + BITNOT shift 177 + CASE shift 183 + FLOAT shift 174 + ID shift 64 + INTEGER shift 173 + JOIN_KW shift 67 + LP shift 68 + MINUS shift 179 + NOT shift 175 + NULL shift 106 + PLUS shift 181 + RAISE shift 193 + STRING shift 66 + expr shift 178 + nm shift 107 + +State 178: + expr ::= expr * ORACLE_OUTER_JOIN + expr ::= expr * AND expr + expr ::= expr * OR expr + expr ::= expr * LT expr + expr ::= expr * GT expr + expr ::= expr * LE expr + expr ::= expr * GE expr + expr ::= expr * NE expr + expr ::= expr * EQ expr + expr ::= expr * BITAND expr + expr ::= expr * BITOR expr + expr ::= expr * LSHIFT expr + expr ::= expr * RSHIFT expr + expr ::= expr * likeop expr + expr ::= expr * NOT likeop expr + likeop ::= * LIKE + likeop ::= * GLOB + expr ::= expr * PLUS expr + expr ::= expr * MINUS expr + expr ::= expr * STAR expr + expr ::= expr * SLASH expr + expr ::= expr * REM expr + expr ::= expr * CONCAT expr + expr ::= expr * ISNULL + expr ::= expr * IS NULL + expr ::= expr * NOTNULL + expr ::= expr * NOT NULL + expr ::= expr * IS NOT NULL + (210) expr ::= BITNOT expr * + expr ::= expr * BETWEEN expr AND expr + expr ::= expr * NOT BETWEEN expr AND expr + expr ::= expr * IN LP exprlist RP + expr ::= expr * IN LP select RP + expr ::= expr * NOT IN LP exprlist RP + expr ::= expr * NOT IN LP select RP + + ORACLE_OUTER_JOIN shift 104 + likeop shift 135 + {default} reduce 210 + +State 179: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + expr ::= * LP expr RP + expr ::= * NULL + expr ::= * ID + expr ::= * JOIN_KW + expr ::= * nm DOT nm + expr ::= * nm DOT nm DOT nm + expr ::= * expr ORACLE_OUTER_JOIN + expr ::= * INTEGER + expr ::= * FLOAT + expr ::= * STRING + expr ::= * ID LP exprlist RP + expr ::= * ID LP STAR RP + expr ::= * expr AND expr + expr ::= * expr OR expr + expr ::= * expr LT expr + expr ::= * expr GT expr + expr ::= * expr LE expr + expr ::= * expr GE expr + expr ::= * expr NE expr + expr ::= * expr EQ expr + expr ::= * expr BITAND expr + expr ::= * expr BITOR expr + expr ::= * expr LSHIFT expr + expr ::= * expr RSHIFT expr + expr ::= * expr likeop expr + expr ::= * expr NOT likeop expr + expr ::= * expr PLUS expr + expr ::= * expr MINUS expr + expr ::= * expr STAR expr + expr ::= * expr SLASH expr + expr ::= * expr REM expr + expr ::= * expr CONCAT expr + expr ::= * expr ISNULL + expr ::= * expr IS NULL + expr ::= * expr NOTNULL + expr ::= * expr NOT NULL + expr ::= * expr IS NOT NULL + expr ::= * NOT expr + expr ::= * BITNOT expr + expr ::= * MINUS expr + expr ::= MINUS * expr + expr ::= * PLUS expr + expr ::= * LP select RP + expr ::= * expr BETWEEN expr AND expr + expr ::= * expr NOT BETWEEN expr AND expr + expr ::= * expr IN LP exprlist RP + expr ::= * expr IN LP select RP + expr ::= * expr NOT IN LP exprlist RP + expr ::= * expr NOT IN LP select RP + expr ::= * CASE case_operand case_exprlist case_else END + expr ::= * RAISE LP IGNORE RP + expr ::= * RAISE LP ROLLBACK COMMA nm RP + expr ::= * RAISE LP ABORT COMMA nm RP + expr ::= * RAISE LP FAIL COMMA nm RP + + BITNOT shift 177 + CASE shift 183 + FLOAT shift 174 + ID shift 64 + INTEGER shift 173 + JOIN_KW shift 67 + LP shift 68 + MINUS shift 179 + NOT shift 175 + NULL shift 106 + PLUS shift 181 + RAISE shift 193 + STRING shift 66 + expr shift 180 + nm shift 107 + +State 180: + expr ::= expr * ORACLE_OUTER_JOIN + expr ::= expr * AND expr + expr ::= expr * OR expr + expr ::= expr * LT expr + expr ::= expr * GT expr + expr ::= expr * LE expr + expr ::= expr * GE expr + expr ::= expr * NE expr + expr ::= expr * EQ expr + expr ::= expr * BITAND expr + expr ::= expr * BITOR expr + expr ::= expr * LSHIFT expr + expr ::= expr * RSHIFT expr + expr ::= expr * likeop expr + expr ::= expr * NOT likeop expr + likeop ::= * LIKE + likeop ::= * GLOB + expr ::= expr * PLUS expr + expr ::= expr * MINUS expr + expr ::= expr * STAR expr + expr ::= expr * SLASH expr + expr ::= expr * REM expr + expr ::= expr * CONCAT expr + expr ::= expr * ISNULL + expr ::= expr * IS NULL + expr ::= expr * NOTNULL + expr ::= expr * NOT NULL + expr ::= expr * IS NOT NULL + (211) expr ::= MINUS expr * + expr ::= expr * BETWEEN expr AND expr + expr ::= expr * NOT BETWEEN expr AND expr + expr ::= expr * IN LP exprlist RP + expr ::= expr * IN LP select RP + expr ::= expr * NOT IN LP exprlist RP + expr ::= expr * NOT IN LP select RP + + ORACLE_OUTER_JOIN shift 104 + likeop shift 135 + {default} reduce 211 + +State 181: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + expr ::= * LP expr RP + expr ::= * NULL + expr ::= * ID + expr ::= * JOIN_KW + expr ::= * nm DOT nm + expr ::= * nm DOT nm DOT nm + expr ::= * expr ORACLE_OUTER_JOIN + expr ::= * INTEGER + expr ::= * FLOAT + expr ::= * STRING + expr ::= * ID LP exprlist RP + expr ::= * ID LP STAR RP + expr ::= * expr AND expr + expr ::= * expr OR expr + expr ::= * expr LT expr + expr ::= * expr GT expr + expr ::= * expr LE expr + expr ::= * expr GE expr + expr ::= * expr NE expr + expr ::= * expr EQ expr + expr ::= * expr BITAND expr + expr ::= * expr BITOR expr + expr ::= * expr LSHIFT expr + expr ::= * expr RSHIFT expr + expr ::= * expr likeop expr + expr ::= * expr NOT likeop expr + expr ::= * expr PLUS expr + expr ::= * expr MINUS expr + expr ::= * expr STAR expr + expr ::= * expr SLASH expr + expr ::= * expr REM expr + expr ::= * expr CONCAT expr + expr ::= * expr ISNULL + expr ::= * expr IS NULL + expr ::= * expr NOTNULL + expr ::= * expr NOT NULL + expr ::= * expr IS NOT NULL + expr ::= * NOT expr + expr ::= * BITNOT expr + expr ::= * MINUS expr + expr ::= * PLUS expr + expr ::= PLUS * expr + expr ::= * LP select RP + expr ::= * expr BETWEEN expr AND expr + expr ::= * expr NOT BETWEEN expr AND expr + expr ::= * expr IN LP exprlist RP + expr ::= * expr IN LP select RP + expr ::= * expr NOT IN LP exprlist RP + expr ::= * expr NOT IN LP select RP + expr ::= * CASE case_operand case_exprlist case_else END + expr ::= * RAISE LP IGNORE RP + expr ::= * RAISE LP ROLLBACK COMMA nm RP + expr ::= * RAISE LP ABORT COMMA nm RP + expr ::= * RAISE LP FAIL COMMA nm RP + + BITNOT shift 177 + CASE shift 183 + FLOAT shift 174 + ID shift 64 + INTEGER shift 173 + JOIN_KW shift 67 + LP shift 68 + MINUS shift 179 + NOT shift 175 + NULL shift 106 + PLUS shift 181 + RAISE shift 193 + STRING shift 66 + expr shift 182 + nm shift 107 + +State 182: + expr ::= expr * ORACLE_OUTER_JOIN + expr ::= expr * AND expr + expr ::= expr * OR expr + expr ::= expr * LT expr + expr ::= expr * GT expr + expr ::= expr * LE expr + expr ::= expr * GE expr + expr ::= expr * NE expr + expr ::= expr * EQ expr + expr ::= expr * BITAND expr + expr ::= expr * BITOR expr + expr ::= expr * LSHIFT expr + expr ::= expr * RSHIFT expr + expr ::= expr * likeop expr + expr ::= expr * NOT likeop expr + likeop ::= * LIKE + likeop ::= * GLOB + expr ::= expr * PLUS expr + expr ::= expr * MINUS expr + expr ::= expr * STAR expr + expr ::= expr * SLASH expr + expr ::= expr * REM expr + expr ::= expr * CONCAT expr + expr ::= expr * ISNULL + expr ::= expr * IS NULL + expr ::= expr * NOTNULL + expr ::= expr * NOT NULL + expr ::= expr * IS NOT NULL + (212) expr ::= PLUS expr * + expr ::= expr * BETWEEN expr AND expr + expr ::= expr * NOT BETWEEN expr AND expr + expr ::= expr * IN LP exprlist RP + expr ::= expr * IN LP select RP + expr ::= expr * NOT IN LP exprlist RP + expr ::= expr * NOT IN LP select RP + + ORACLE_OUTER_JOIN shift 104 + likeop shift 135 + {default} reduce 212 + +State 183: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + expr ::= * LP expr RP + expr ::= * NULL + expr ::= * ID + expr ::= * JOIN_KW + expr ::= * nm DOT nm + expr ::= * nm DOT nm DOT nm + expr ::= * expr ORACLE_OUTER_JOIN + expr ::= * INTEGER + expr ::= * FLOAT + expr ::= * STRING + expr ::= * ID LP exprlist RP + expr ::= * ID LP STAR RP + expr ::= * expr AND expr + expr ::= * expr OR expr + expr ::= * expr LT expr + expr ::= * expr GT expr + expr ::= * expr LE expr + expr ::= * expr GE expr + expr ::= * expr NE expr + expr ::= * expr EQ expr + expr ::= * expr BITAND expr + expr ::= * expr BITOR expr + expr ::= * expr LSHIFT expr + expr ::= * expr RSHIFT expr + expr ::= * expr likeop expr + expr ::= * expr NOT likeop expr + expr ::= * expr PLUS expr + expr ::= * expr MINUS expr + expr ::= * expr STAR expr + expr ::= * expr SLASH expr + expr ::= * expr REM expr + expr ::= * expr CONCAT expr + expr ::= * expr ISNULL + expr ::= * expr IS NULL + expr ::= * expr NOTNULL + expr ::= * expr NOT NULL + expr ::= * expr IS NOT NULL + expr ::= * NOT expr + expr ::= * BITNOT expr + expr ::= * MINUS expr + expr ::= * PLUS expr + expr ::= * LP select RP + expr ::= * expr BETWEEN expr AND expr + expr ::= * expr NOT BETWEEN expr AND expr + expr ::= * expr IN LP exprlist RP + expr ::= * expr IN LP select RP + expr ::= * expr NOT IN LP exprlist RP + expr ::= * expr NOT IN LP select RP + expr ::= * CASE case_operand case_exprlist case_else END + expr ::= CASE * case_operand case_exprlist case_else END + case_operand ::= * expr + (226) case_operand ::= * + expr ::= * RAISE LP IGNORE RP + expr ::= * RAISE LP ROLLBACK COMMA nm RP + expr ::= * RAISE LP ABORT COMMA nm RP + expr ::= * RAISE LP FAIL COMMA nm RP + + BITNOT shift 177 + CASE shift 183 + FLOAT shift 174 + ID shift 64 + INTEGER shift 173 + JOIN_KW shift 67 + LP shift 68 + MINUS shift 179 + NOT shift 175 + NULL shift 106 + PLUS shift 181 + RAISE shift 193 + STRING shift 66 + WHEN reduce 226 + case_operand shift 185 + expr shift 184 + nm shift 107 + +State 184: + expr ::= expr * ORACLE_OUTER_JOIN + expr ::= expr * AND expr + expr ::= expr * OR expr + expr ::= expr * LT expr + expr ::= expr * GT expr + expr ::= expr * LE expr + expr ::= expr * GE expr + expr ::= expr * NE expr + expr ::= expr * EQ expr + expr ::= expr * BITAND expr + expr ::= expr * BITOR expr + expr ::= expr * LSHIFT expr + expr ::= expr * RSHIFT expr + expr ::= expr * likeop expr + expr ::= expr * NOT likeop expr + likeop ::= * LIKE + likeop ::= * GLOB + expr ::= expr * PLUS expr + expr ::= expr * MINUS expr + expr ::= expr * STAR expr + expr ::= expr * SLASH expr + expr ::= expr * REM expr + expr ::= expr * CONCAT expr + expr ::= expr * ISNULL + expr ::= expr * IS NULL + expr ::= expr * NOTNULL + expr ::= expr * NOT NULL + expr ::= expr * IS NOT NULL + expr ::= expr * BETWEEN expr AND expr + expr ::= expr * NOT BETWEEN expr AND expr + expr ::= expr * IN LP exprlist RP + expr ::= expr * IN LP select RP + expr ::= expr * NOT IN LP exprlist RP + expr ::= expr * NOT IN LP select RP + (225) case_operand ::= expr * + + AND shift 105 + BETWEEN shift 160 + BITAND shift 127 + BITOR shift 129 + CONCAT shift 152 + EQ shift 125 + GE shift 121 + GLOB shift 141 + GT shift 117 + IN shift 164 + IS shift 155 + ISNULL shift 154 + LE shift 119 + LIKE shift 140 + LSHIFT shift 131 + LT shift 115 + MINUS shift 144 + NE shift 123 + NOT shift 137 + NOTNULL shift 159 + OR shift 113 + ORACLE_OUTER_JOIN shift 104 + PLUS shift 142 + REM shift 150 + RSHIFT shift 133 + SLASH shift 148 + STAR shift 146 + WHEN reduce 225 + likeop shift 135 + +State 185: + expr ::= CASE case_operand * case_exprlist case_else END + case_exprlist ::= * case_exprlist WHEN expr THEN expr + case_exprlist ::= * WHEN expr THEN expr + + WHEN shift 211 + case_exprlist shift 186 + +State 186: + expr ::= CASE case_operand case_exprlist * case_else END + case_exprlist ::= case_exprlist * WHEN expr THEN expr + case_else ::= * ELSE expr + (224) case_else ::= * + + ELSE shift 209 + END reduce 224 + WHEN shift 189 + case_else shift 187 + +State 187: + expr ::= CASE case_operand case_exprlist case_else * END + + END shift 188 + +State 188: + (220) expr ::= CASE case_operand case_exprlist case_else END * + + {default} reduce 220 + +State 189: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + expr ::= * LP expr RP + expr ::= * NULL + expr ::= * ID + expr ::= * JOIN_KW + expr ::= * nm DOT nm + expr ::= * nm DOT nm DOT nm + expr ::= * expr ORACLE_OUTER_JOIN + expr ::= * INTEGER + expr ::= * FLOAT + expr ::= * STRING + expr ::= * ID LP exprlist RP + expr ::= * ID LP STAR RP + expr ::= * expr AND expr + expr ::= * expr OR expr + expr ::= * expr LT expr + expr ::= * expr GT expr + expr ::= * expr LE expr + expr ::= * expr GE expr + expr ::= * expr NE expr + expr ::= * expr EQ expr + expr ::= * expr BITAND expr + expr ::= * expr BITOR expr + expr ::= * expr LSHIFT expr + expr ::= * expr RSHIFT expr + expr ::= * expr likeop expr + expr ::= * expr NOT likeop expr + expr ::= * expr PLUS expr + expr ::= * expr MINUS expr + expr ::= * expr STAR expr + expr ::= * expr SLASH expr + expr ::= * expr REM expr + expr ::= * expr CONCAT expr + expr ::= * expr ISNULL + expr ::= * expr IS NULL + expr ::= * expr NOTNULL + expr ::= * expr NOT NULL + expr ::= * expr IS NOT NULL + expr ::= * NOT expr + expr ::= * BITNOT expr + expr ::= * MINUS expr + expr ::= * PLUS expr + expr ::= * LP select RP + expr ::= * expr BETWEEN expr AND expr + expr ::= * expr NOT BETWEEN expr AND expr + expr ::= * expr IN LP exprlist RP + expr ::= * expr IN LP select RP + expr ::= * expr NOT IN LP exprlist RP + expr ::= * expr NOT IN LP select RP + expr ::= * CASE case_operand case_exprlist case_else END + case_exprlist ::= case_exprlist WHEN * expr THEN expr + expr ::= * RAISE LP IGNORE RP + expr ::= * RAISE LP ROLLBACK COMMA nm RP + expr ::= * RAISE LP ABORT COMMA nm RP + expr ::= * RAISE LP FAIL COMMA nm RP + + BITNOT shift 177 + CASE shift 183 + FLOAT shift 174 + ID shift 64 + INTEGER shift 173 + JOIN_KW shift 67 + LP shift 68 + MINUS shift 179 + NOT shift 175 + NULL shift 106 + PLUS shift 181 + RAISE shift 193 + STRING shift 66 + expr shift 190 + nm shift 107 + +State 190: + expr ::= expr * ORACLE_OUTER_JOIN + expr ::= expr * AND expr + expr ::= expr * OR expr + expr ::= expr * LT expr + expr ::= expr * GT expr + expr ::= expr * LE expr + expr ::= expr * GE expr + expr ::= expr * NE expr + expr ::= expr * EQ expr + expr ::= expr * BITAND expr + expr ::= expr * BITOR expr + expr ::= expr * LSHIFT expr + expr ::= expr * RSHIFT expr + expr ::= expr * likeop expr + expr ::= expr * NOT likeop expr + likeop ::= * LIKE + likeop ::= * GLOB + expr ::= expr * PLUS expr + expr ::= expr * MINUS expr + expr ::= expr * STAR expr + expr ::= expr * SLASH expr + expr ::= expr * REM expr + expr ::= expr * CONCAT expr + expr ::= expr * ISNULL + expr ::= expr * IS NULL + expr ::= expr * NOTNULL + expr ::= expr * NOT NULL + expr ::= expr * IS NOT NULL + expr ::= expr * BETWEEN expr AND expr + expr ::= expr * NOT BETWEEN expr AND expr + expr ::= expr * IN LP exprlist RP + expr ::= expr * IN LP select RP + expr ::= expr * NOT IN LP exprlist RP + expr ::= expr * NOT IN LP select RP + case_exprlist ::= case_exprlist WHEN expr * THEN expr + + AND shift 105 + BETWEEN shift 160 + BITAND shift 127 + BITOR shift 129 + CONCAT shift 152 + EQ shift 125 + GE shift 121 + GLOB shift 141 + GT shift 117 + IN shift 164 + IS shift 155 + ISNULL shift 154 + LE shift 119 + LIKE shift 140 + LSHIFT shift 131 + LT shift 115 + MINUS shift 144 + NE shift 123 + NOT shift 137 + NOTNULL shift 159 + OR shift 113 + ORACLE_OUTER_JOIN shift 104 + PLUS shift 142 + REM shift 150 + RSHIFT shift 133 + SLASH shift 148 + STAR shift 146 + THEN shift 191 + likeop shift 135 + +State 191: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + expr ::= * LP expr RP + expr ::= * NULL + expr ::= * ID + expr ::= * JOIN_KW + expr ::= * nm DOT nm + expr ::= * nm DOT nm DOT nm + expr ::= * expr ORACLE_OUTER_JOIN + expr ::= * INTEGER + expr ::= * FLOAT + expr ::= * STRING + expr ::= * ID LP exprlist RP + expr ::= * ID LP STAR RP + expr ::= * expr AND expr + expr ::= * expr OR expr + expr ::= * expr LT expr + expr ::= * expr GT expr + expr ::= * expr LE expr + expr ::= * expr GE expr + expr ::= * expr NE expr + expr ::= * expr EQ expr + expr ::= * expr BITAND expr + expr ::= * expr BITOR expr + expr ::= * expr LSHIFT expr + expr ::= * expr RSHIFT expr + expr ::= * expr likeop expr + expr ::= * expr NOT likeop expr + expr ::= * expr PLUS expr + expr ::= * expr MINUS expr + expr ::= * expr STAR expr + expr ::= * expr SLASH expr + expr ::= * expr REM expr + expr ::= * expr CONCAT expr + expr ::= * expr ISNULL + expr ::= * expr IS NULL + expr ::= * expr NOTNULL + expr ::= * expr NOT NULL + expr ::= * expr IS NOT NULL + expr ::= * NOT expr + expr ::= * BITNOT expr + expr ::= * MINUS expr + expr ::= * PLUS expr + expr ::= * LP select RP + expr ::= * expr BETWEEN expr AND expr + expr ::= * expr NOT BETWEEN expr AND expr + expr ::= * expr IN LP exprlist RP + expr ::= * expr IN LP select RP + expr ::= * expr NOT IN LP exprlist RP + expr ::= * expr NOT IN LP select RP + expr ::= * CASE case_operand case_exprlist case_else END + case_exprlist ::= case_exprlist WHEN expr THEN * expr + expr ::= * RAISE LP IGNORE RP + expr ::= * RAISE LP ROLLBACK COMMA nm RP + expr ::= * RAISE LP ABORT COMMA nm RP + expr ::= * RAISE LP FAIL COMMA nm RP + + BITNOT shift 177 + CASE shift 183 + FLOAT shift 174 + ID shift 64 + INTEGER shift 173 + JOIN_KW shift 67 + LP shift 68 + MINUS shift 179 + NOT shift 175 + NULL shift 106 + PLUS shift 181 + RAISE shift 193 + STRING shift 66 + expr shift 192 + nm shift 107 + +State 192: + expr ::= expr * ORACLE_OUTER_JOIN + expr ::= expr * AND expr + expr ::= expr * OR expr + expr ::= expr * LT expr + expr ::= expr * GT expr + expr ::= expr * LE expr + expr ::= expr * GE expr + expr ::= expr * NE expr + expr ::= expr * EQ expr + expr ::= expr * BITAND expr + expr ::= expr * BITOR expr + expr ::= expr * LSHIFT expr + expr ::= expr * RSHIFT expr + expr ::= expr * likeop expr + expr ::= expr * NOT likeop expr + likeop ::= * LIKE + likeop ::= * GLOB + expr ::= expr * PLUS expr + expr ::= expr * MINUS expr + expr ::= expr * STAR expr + expr ::= expr * SLASH expr + expr ::= expr * REM expr + expr ::= expr * CONCAT expr + expr ::= expr * ISNULL + expr ::= expr * IS NULL + expr ::= expr * NOTNULL + expr ::= expr * NOT NULL + expr ::= expr * IS NOT NULL + expr ::= expr * BETWEEN expr AND expr + expr ::= expr * NOT BETWEEN expr AND expr + expr ::= expr * IN LP exprlist RP + expr ::= expr * IN LP select RP + expr ::= expr * NOT IN LP exprlist RP + expr ::= expr * NOT IN LP select RP + (221) case_exprlist ::= case_exprlist WHEN expr THEN expr * + + AND shift 105 + BETWEEN shift 160 + BITAND shift 127 + BITOR shift 129 + CONCAT shift 152 + EQ shift 125 + GE shift 121 + GLOB shift 141 + GT shift 117 + IN shift 164 + IS shift 155 + ISNULL shift 154 + LE shift 119 + LIKE shift 140 + LSHIFT shift 131 + LT shift 115 + MINUS shift 144 + NE shift 123 + NOT shift 137 + NOTNULL shift 159 + OR shift 113 + ORACLE_OUTER_JOIN shift 104 + PLUS shift 142 + REM shift 150 + RSHIFT shift 133 + SLASH shift 148 + STAR shift 146 + likeop shift 135 + {default} reduce 221 + +State 193: + expr ::= RAISE * LP IGNORE RP + expr ::= RAISE * LP ROLLBACK COMMA nm RP + expr ::= RAISE * LP ABORT COMMA nm RP + expr ::= RAISE * LP FAIL COMMA nm RP + + LP shift 194 + +State 194: + expr ::= RAISE LP * IGNORE RP + expr ::= RAISE LP * ROLLBACK COMMA nm RP + expr ::= RAISE LP * ABORT COMMA nm RP + expr ::= RAISE LP * FAIL COMMA nm RP + + ABORT shift 201 + FAIL shift 205 + IGNORE shift 195 + ROLLBACK shift 197 + +State 195: + expr ::= RAISE LP IGNORE * RP + + RP shift 196 + +State 196: + (278) expr ::= RAISE LP IGNORE RP * + + {default} reduce 278 + +State 197: + expr ::= RAISE LP ROLLBACK * COMMA nm RP + + COMMA shift 198 + +State 198: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + expr ::= RAISE LP ROLLBACK COMMA * nm RP + + ID shift 20 + JOIN_KW shift 22 + STRING shift 21 + nm shift 199 + +State 199: + expr ::= RAISE LP ROLLBACK COMMA nm * RP + + RP shift 200 + +State 200: + (279) expr ::= RAISE LP ROLLBACK COMMA nm RP * + + {default} reduce 279 + +State 201: + expr ::= RAISE LP ABORT * COMMA nm RP + + COMMA shift 202 + +State 202: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + expr ::= RAISE LP ABORT COMMA * nm RP + + ID shift 20 + JOIN_KW shift 22 + STRING shift 21 + nm shift 203 + +State 203: + expr ::= RAISE LP ABORT COMMA nm * RP + + RP shift 204 + +State 204: + (280) expr ::= RAISE LP ABORT COMMA nm RP * + + {default} reduce 280 + +State 205: + expr ::= RAISE LP FAIL * COMMA nm RP + + COMMA shift 206 + +State 206: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + expr ::= RAISE LP FAIL COMMA * nm RP + + ID shift 20 + JOIN_KW shift 22 + STRING shift 21 + nm shift 207 + +State 207: + expr ::= RAISE LP FAIL COMMA nm * RP + + RP shift 208 + +State 208: + (281) expr ::= RAISE LP FAIL COMMA nm RP * + + {default} reduce 281 + +State 209: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + expr ::= * LP expr RP + expr ::= * NULL + expr ::= * ID + expr ::= * JOIN_KW + expr ::= * nm DOT nm + expr ::= * nm DOT nm DOT nm + expr ::= * expr ORACLE_OUTER_JOIN + expr ::= * INTEGER + expr ::= * FLOAT + expr ::= * STRING + expr ::= * ID LP exprlist RP + expr ::= * ID LP STAR RP + expr ::= * expr AND expr + expr ::= * expr OR expr + expr ::= * expr LT expr + expr ::= * expr GT expr + expr ::= * expr LE expr + expr ::= * expr GE expr + expr ::= * expr NE expr + expr ::= * expr EQ expr + expr ::= * expr BITAND expr + expr ::= * expr BITOR expr + expr ::= * expr LSHIFT expr + expr ::= * expr RSHIFT expr + expr ::= * expr likeop expr + expr ::= * expr NOT likeop expr + expr ::= * expr PLUS expr + expr ::= * expr MINUS expr + expr ::= * expr STAR expr + expr ::= * expr SLASH expr + expr ::= * expr REM expr + expr ::= * expr CONCAT expr + expr ::= * expr ISNULL + expr ::= * expr IS NULL + expr ::= * expr NOTNULL + expr ::= * expr NOT NULL + expr ::= * expr IS NOT NULL + expr ::= * NOT expr + expr ::= * BITNOT expr + expr ::= * MINUS expr + expr ::= * PLUS expr + expr ::= * LP select RP + expr ::= * expr BETWEEN expr AND expr + expr ::= * expr NOT BETWEEN expr AND expr + expr ::= * expr IN LP exprlist RP + expr ::= * expr IN LP select RP + expr ::= * expr NOT IN LP exprlist RP + expr ::= * expr NOT IN LP select RP + expr ::= * CASE case_operand case_exprlist case_else END + case_else ::= ELSE * expr + expr ::= * RAISE LP IGNORE RP + expr ::= * RAISE LP ROLLBACK COMMA nm RP + expr ::= * RAISE LP ABORT COMMA nm RP + expr ::= * RAISE LP FAIL COMMA nm RP + + BITNOT shift 177 + CASE shift 183 + FLOAT shift 174 + ID shift 64 + INTEGER shift 173 + JOIN_KW shift 67 + LP shift 68 + MINUS shift 179 + NOT shift 175 + NULL shift 106 + PLUS shift 181 + RAISE shift 193 + STRING shift 66 + expr shift 210 + nm shift 107 + +State 210: + expr ::= expr * ORACLE_OUTER_JOIN + expr ::= expr * AND expr + expr ::= expr * OR expr + expr ::= expr * LT expr + expr ::= expr * GT expr + expr ::= expr * LE expr + expr ::= expr * GE expr + expr ::= expr * NE expr + expr ::= expr * EQ expr + expr ::= expr * BITAND expr + expr ::= expr * BITOR expr + expr ::= expr * LSHIFT expr + expr ::= expr * RSHIFT expr + expr ::= expr * likeop expr + expr ::= expr * NOT likeop expr + likeop ::= * LIKE + likeop ::= * GLOB + expr ::= expr * PLUS expr + expr ::= expr * MINUS expr + expr ::= expr * STAR expr + expr ::= expr * SLASH expr + expr ::= expr * REM expr + expr ::= expr * CONCAT expr + expr ::= expr * ISNULL + expr ::= expr * IS NULL + expr ::= expr * NOTNULL + expr ::= expr * NOT NULL + expr ::= expr * IS NOT NULL + expr ::= expr * BETWEEN expr AND expr + expr ::= expr * NOT BETWEEN expr AND expr + expr ::= expr * IN LP exprlist RP + expr ::= expr * IN LP select RP + expr ::= expr * NOT IN LP exprlist RP + expr ::= expr * NOT IN LP select RP + (223) case_else ::= ELSE expr * + + AND shift 105 + BETWEEN shift 160 + BITAND shift 127 + BITOR shift 129 + CONCAT shift 152 + END reduce 223 + EQ shift 125 + GE shift 121 + GLOB shift 141 + GT shift 117 + IN shift 164 + IS shift 155 + ISNULL shift 154 + LE shift 119 + LIKE shift 140 + LSHIFT shift 131 + LT shift 115 + MINUS shift 144 + NE shift 123 + NOT shift 137 + NOTNULL shift 159 + OR shift 113 + ORACLE_OUTER_JOIN shift 104 + PLUS shift 142 + REM shift 150 + RSHIFT shift 133 + SLASH shift 148 + STAR shift 146 + likeop shift 135 + +State 211: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + expr ::= * LP expr RP + expr ::= * NULL + expr ::= * ID + expr ::= * JOIN_KW + expr ::= * nm DOT nm + expr ::= * nm DOT nm DOT nm + expr ::= * expr ORACLE_OUTER_JOIN + expr ::= * INTEGER + expr ::= * FLOAT + expr ::= * STRING + expr ::= * ID LP exprlist RP + expr ::= * ID LP STAR RP + expr ::= * expr AND expr + expr ::= * expr OR expr + expr ::= * expr LT expr + expr ::= * expr GT expr + expr ::= * expr LE expr + expr ::= * expr GE expr + expr ::= * expr NE expr + expr ::= * expr EQ expr + expr ::= * expr BITAND expr + expr ::= * expr BITOR expr + expr ::= * expr LSHIFT expr + expr ::= * expr RSHIFT expr + expr ::= * expr likeop expr + expr ::= * expr NOT likeop expr + expr ::= * expr PLUS expr + expr ::= * expr MINUS expr + expr ::= * expr STAR expr + expr ::= * expr SLASH expr + expr ::= * expr REM expr + expr ::= * expr CONCAT expr + expr ::= * expr ISNULL + expr ::= * expr IS NULL + expr ::= * expr NOTNULL + expr ::= * expr NOT NULL + expr ::= * expr IS NOT NULL + expr ::= * NOT expr + expr ::= * BITNOT expr + expr ::= * MINUS expr + expr ::= * PLUS expr + expr ::= * LP select RP + expr ::= * expr BETWEEN expr AND expr + expr ::= * expr NOT BETWEEN expr AND expr + expr ::= * expr IN LP exprlist RP + expr ::= * expr IN LP select RP + expr ::= * expr NOT IN LP exprlist RP + expr ::= * expr NOT IN LP select RP + expr ::= * CASE case_operand case_exprlist case_else END + case_exprlist ::= WHEN * expr THEN expr + expr ::= * RAISE LP IGNORE RP + expr ::= * RAISE LP ROLLBACK COMMA nm RP + expr ::= * RAISE LP ABORT COMMA nm RP + expr ::= * RAISE LP FAIL COMMA nm RP + + BITNOT shift 177 + CASE shift 183 + FLOAT shift 174 + ID shift 64 + INTEGER shift 173 + JOIN_KW shift 67 + LP shift 68 + MINUS shift 179 + NOT shift 175 + NULL shift 106 + PLUS shift 181 + RAISE shift 193 + STRING shift 66 + expr shift 212 + nm shift 107 + +State 212: + expr ::= expr * ORACLE_OUTER_JOIN + expr ::= expr * AND expr + expr ::= expr * OR expr + expr ::= expr * LT expr + expr ::= expr * GT expr + expr ::= expr * LE expr + expr ::= expr * GE expr + expr ::= expr * NE expr + expr ::= expr * EQ expr + expr ::= expr * BITAND expr + expr ::= expr * BITOR expr + expr ::= expr * LSHIFT expr + expr ::= expr * RSHIFT expr + expr ::= expr * likeop expr + expr ::= expr * NOT likeop expr + likeop ::= * LIKE + likeop ::= * GLOB + expr ::= expr * PLUS expr + expr ::= expr * MINUS expr + expr ::= expr * STAR expr + expr ::= expr * SLASH expr + expr ::= expr * REM expr + expr ::= expr * CONCAT expr + expr ::= expr * ISNULL + expr ::= expr * IS NULL + expr ::= expr * NOTNULL + expr ::= expr * NOT NULL + expr ::= expr * IS NOT NULL + expr ::= expr * BETWEEN expr AND expr + expr ::= expr * NOT BETWEEN expr AND expr + expr ::= expr * IN LP exprlist RP + expr ::= expr * IN LP select RP + expr ::= expr * NOT IN LP exprlist RP + expr ::= expr * NOT IN LP select RP + case_exprlist ::= WHEN expr * THEN expr + + AND shift 105 + BETWEEN shift 160 + BITAND shift 127 + BITOR shift 129 + CONCAT shift 152 + EQ shift 125 + GE shift 121 + GLOB shift 141 + GT shift 117 + IN shift 164 + IS shift 155 + ISNULL shift 154 + LE shift 119 + LIKE shift 140 + LSHIFT shift 131 + LT shift 115 + MINUS shift 144 + NE shift 123 + NOT shift 137 + NOTNULL shift 159 + OR shift 113 + ORACLE_OUTER_JOIN shift 104 + PLUS shift 142 + REM shift 150 + RSHIFT shift 133 + SLASH shift 148 + STAR shift 146 + THEN shift 213 + likeop shift 135 + +State 213: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + expr ::= * LP expr RP + expr ::= * NULL + expr ::= * ID + expr ::= * JOIN_KW + expr ::= * nm DOT nm + expr ::= * nm DOT nm DOT nm + expr ::= * expr ORACLE_OUTER_JOIN + expr ::= * INTEGER + expr ::= * FLOAT + expr ::= * STRING + expr ::= * ID LP exprlist RP + expr ::= * ID LP STAR RP + expr ::= * expr AND expr + expr ::= * expr OR expr + expr ::= * expr LT expr + expr ::= * expr GT expr + expr ::= * expr LE expr + expr ::= * expr GE expr + expr ::= * expr NE expr + expr ::= * expr EQ expr + expr ::= * expr BITAND expr + expr ::= * expr BITOR expr + expr ::= * expr LSHIFT expr + expr ::= * expr RSHIFT expr + expr ::= * expr likeop expr + expr ::= * expr NOT likeop expr + expr ::= * expr PLUS expr + expr ::= * expr MINUS expr + expr ::= * expr STAR expr + expr ::= * expr SLASH expr + expr ::= * expr REM expr + expr ::= * expr CONCAT expr + expr ::= * expr ISNULL + expr ::= * expr IS NULL + expr ::= * expr NOTNULL + expr ::= * expr NOT NULL + expr ::= * expr IS NOT NULL + expr ::= * NOT expr + expr ::= * BITNOT expr + expr ::= * MINUS expr + expr ::= * PLUS expr + expr ::= * LP select RP + expr ::= * expr BETWEEN expr AND expr + expr ::= * expr NOT BETWEEN expr AND expr + expr ::= * expr IN LP exprlist RP + expr ::= * expr IN LP select RP + expr ::= * expr NOT IN LP exprlist RP + expr ::= * expr NOT IN LP select RP + expr ::= * CASE case_operand case_exprlist case_else END + case_exprlist ::= WHEN expr THEN * expr + expr ::= * RAISE LP IGNORE RP + expr ::= * RAISE LP ROLLBACK COMMA nm RP + expr ::= * RAISE LP ABORT COMMA nm RP + expr ::= * RAISE LP FAIL COMMA nm RP + + BITNOT shift 177 + CASE shift 183 + FLOAT shift 174 + ID shift 64 + INTEGER shift 173 + JOIN_KW shift 67 + LP shift 68 + MINUS shift 179 + NOT shift 175 + NULL shift 106 + PLUS shift 181 + RAISE shift 193 + STRING shift 66 + expr shift 214 + nm shift 107 + +State 214: + expr ::= expr * ORACLE_OUTER_JOIN + expr ::= expr * AND expr + expr ::= expr * OR expr + expr ::= expr * LT expr + expr ::= expr * GT expr + expr ::= expr * LE expr + expr ::= expr * GE expr + expr ::= expr * NE expr + expr ::= expr * EQ expr + expr ::= expr * BITAND expr + expr ::= expr * BITOR expr + expr ::= expr * LSHIFT expr + expr ::= expr * RSHIFT expr + expr ::= expr * likeop expr + expr ::= expr * NOT likeop expr + likeop ::= * LIKE + likeop ::= * GLOB + expr ::= expr * PLUS expr + expr ::= expr * MINUS expr + expr ::= expr * STAR expr + expr ::= expr * SLASH expr + expr ::= expr * REM expr + expr ::= expr * CONCAT expr + expr ::= expr * ISNULL + expr ::= expr * IS NULL + expr ::= expr * NOTNULL + expr ::= expr * NOT NULL + expr ::= expr * IS NOT NULL + expr ::= expr * BETWEEN expr AND expr + expr ::= expr * NOT BETWEEN expr AND expr + expr ::= expr * IN LP exprlist RP + expr ::= expr * IN LP select RP + expr ::= expr * NOT IN LP exprlist RP + expr ::= expr * NOT IN LP select RP + (222) case_exprlist ::= WHEN expr THEN expr * + + AND shift 105 + BETWEEN shift 160 + BITAND shift 127 + BITOR shift 129 + CONCAT shift 152 + EQ shift 125 + GE shift 121 + GLOB shift 141 + GT shift 117 + IN shift 164 + IS shift 155 + ISNULL shift 154 + LE shift 119 + LIKE shift 140 + LSHIFT shift 131 + LT shift 115 + MINUS shift 144 + NE shift 123 + NOT shift 137 + NOTNULL shift 159 + OR shift 113 + ORACLE_OUTER_JOIN shift 104 + PLUS shift 142 + REM shift 150 + RSHIFT shift 133 + SLASH shift 148 + STAR shift 146 + likeop shift 135 + {default} reduce 222 + +State 215: + expr ::= expr IN LP exprlist * RP + exprlist ::= exprlist * COMMA expritem + + COMMA shift 217 + RP shift 216 + +State 216: + (216) expr ::= expr IN LP exprlist RP * + + {default} reduce 216 + +State 217: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + expr ::= * LP expr RP + expr ::= * NULL + expr ::= * ID + expr ::= * JOIN_KW + expr ::= * nm DOT nm + expr ::= * nm DOT nm DOT nm + expr ::= * expr ORACLE_OUTER_JOIN + expr ::= * INTEGER + expr ::= * FLOAT + expr ::= * STRING + expr ::= * ID LP exprlist RP + expr ::= * ID LP STAR RP + expr ::= * expr AND expr + expr ::= * expr OR expr + expr ::= * expr LT expr + expr ::= * expr GT expr + expr ::= * expr LE expr + expr ::= * expr GE expr + expr ::= * expr NE expr + expr ::= * expr EQ expr + expr ::= * expr BITAND expr + expr ::= * expr BITOR expr + expr ::= * expr LSHIFT expr + expr ::= * expr RSHIFT expr + expr ::= * expr likeop expr + expr ::= * expr NOT likeop expr + expr ::= * expr PLUS expr + expr ::= * expr MINUS expr + expr ::= * expr STAR expr + expr ::= * expr SLASH expr + expr ::= * expr REM expr + expr ::= * expr CONCAT expr + expr ::= * expr ISNULL + expr ::= * expr IS NULL + expr ::= * expr NOTNULL + expr ::= * expr NOT NULL + expr ::= * expr IS NOT NULL + expr ::= * NOT expr + expr ::= * BITNOT expr + expr ::= * MINUS expr + expr ::= * PLUS expr + expr ::= * LP select RP + expr ::= * expr BETWEEN expr AND expr + expr ::= * expr NOT BETWEEN expr AND expr + expr ::= * expr IN LP exprlist RP + expr ::= * expr IN LP select RP + expr ::= * expr NOT IN LP exprlist RP + expr ::= * expr NOT IN LP select RP + expr ::= * CASE case_operand case_exprlist case_else END + exprlist ::= exprlist COMMA * expritem + expritem ::= * expr + (230) expritem ::= * + expr ::= * RAISE LP IGNORE RP + expr ::= * RAISE LP ROLLBACK COMMA nm RP + expr ::= * RAISE LP ABORT COMMA nm RP + expr ::= * RAISE LP FAIL COMMA nm RP + + BITNOT shift 177 + CASE shift 183 + FLOAT shift 174 + ID shift 64 + INTEGER shift 173 + JOIN_KW shift 67 + LP shift 68 + MINUS shift 179 + NOT shift 175 + NULL shift 106 + PLUS shift 181 + RAISE shift 193 + STRING shift 66 + expr shift 172 + expritem shift 218 + nm shift 107 + {default} reduce 230 + +State 218: + (227) exprlist ::= exprlist COMMA expritem * + + {default} reduce 227 + +State 219: + (228) exprlist ::= expritem * + + {default} reduce 228 + +State 220: + (207) expr ::= expr NOT NULL * + + {default} reduce 207 + +State 221: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + expr ::= * LP expr RP + expr ::= * NULL + expr ::= * ID + expr ::= * JOIN_KW + expr ::= * nm DOT nm + expr ::= * nm DOT nm DOT nm + expr ::= * expr ORACLE_OUTER_JOIN + expr ::= * INTEGER + expr ::= * FLOAT + expr ::= * STRING + expr ::= * ID LP exprlist RP + expr ::= * ID LP STAR RP + expr ::= * expr AND expr + expr ::= * expr OR expr + expr ::= * expr LT expr + expr ::= * expr GT expr + expr ::= * expr LE expr + expr ::= * expr GE expr + expr ::= * expr NE expr + expr ::= * expr EQ expr + expr ::= * expr BITAND expr + expr ::= * expr BITOR expr + expr ::= * expr LSHIFT expr + expr ::= * expr RSHIFT expr + expr ::= * expr likeop expr + expr ::= * expr NOT likeop expr + expr ::= * expr PLUS expr + expr ::= * expr MINUS expr + expr ::= * expr STAR expr + expr ::= * expr SLASH expr + expr ::= * expr REM expr + expr ::= * expr CONCAT expr + expr ::= * expr ISNULL + expr ::= * expr IS NULL + expr ::= * expr NOTNULL + expr ::= * expr NOT NULL + expr ::= * expr IS NOT NULL + expr ::= * NOT expr + expr ::= * BITNOT expr + expr ::= * MINUS expr + expr ::= * PLUS expr + expr ::= * LP select RP + expr ::= * expr BETWEEN expr AND expr + expr ::= * expr NOT BETWEEN expr AND expr + expr ::= expr NOT BETWEEN * expr AND expr + expr ::= * expr IN LP exprlist RP + expr ::= * expr IN LP select RP + expr ::= * expr NOT IN LP exprlist RP + expr ::= * expr NOT IN LP select RP + expr ::= * CASE case_operand case_exprlist case_else END + expr ::= * RAISE LP IGNORE RP + expr ::= * RAISE LP ROLLBACK COMMA nm RP + expr ::= * RAISE LP ABORT COMMA nm RP + expr ::= * RAISE LP FAIL COMMA nm RP + + BITNOT shift 177 + CASE shift 183 + FLOAT shift 174 + ID shift 64 + INTEGER shift 173 + JOIN_KW shift 67 + LP shift 68 + MINUS shift 179 + NOT shift 175 + NULL shift 106 + PLUS shift 181 + RAISE shift 193 + STRING shift 66 + expr shift 222 + nm shift 107 + +State 222: + expr ::= expr * ORACLE_OUTER_JOIN + expr ::= expr * AND expr + expr ::= expr * OR expr + expr ::= expr * LT expr + expr ::= expr * GT expr + expr ::= expr * LE expr + expr ::= expr * GE expr + expr ::= expr * NE expr + expr ::= expr * EQ expr + expr ::= expr * BITAND expr + expr ::= expr * BITOR expr + expr ::= expr * LSHIFT expr + expr ::= expr * RSHIFT expr + expr ::= expr * likeop expr + expr ::= expr * NOT likeop expr + likeop ::= * LIKE + likeop ::= * GLOB + expr ::= expr * PLUS expr + expr ::= expr * MINUS expr + expr ::= expr * STAR expr + expr ::= expr * SLASH expr + expr ::= expr * REM expr + expr ::= expr * CONCAT expr + expr ::= expr * ISNULL + expr ::= expr * IS NULL + expr ::= expr * NOTNULL + expr ::= expr * NOT NULL + expr ::= expr * IS NOT NULL + expr ::= expr * BETWEEN expr AND expr + expr ::= expr * NOT BETWEEN expr AND expr + expr ::= expr NOT BETWEEN expr * AND expr + expr ::= expr * IN LP exprlist RP + expr ::= expr * IN LP select RP + expr ::= expr * NOT IN LP exprlist RP + expr ::= expr * NOT IN LP select RP + + AND shift 223 + BETWEEN shift 160 + BITAND shift 127 + BITOR shift 129 + CONCAT shift 152 + EQ shift 125 + GE shift 121 + GLOB shift 141 + GT shift 117 + IN shift 164 + IS shift 155 + ISNULL shift 154 + LE shift 119 + LIKE shift 140 + LSHIFT shift 131 + LT shift 115 + MINUS shift 144 + NE shift 123 + NOT shift 137 + NOTNULL shift 159 + OR shift 113 + ORACLE_OUTER_JOIN shift 104 + PLUS shift 142 + REM shift 150 + RSHIFT shift 133 + SLASH shift 148 + STAR shift 146 + likeop shift 135 + +State 223: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + expr ::= * LP expr RP + expr ::= * NULL + expr ::= * ID + expr ::= * JOIN_KW + expr ::= * nm DOT nm + expr ::= * nm DOT nm DOT nm + expr ::= * expr ORACLE_OUTER_JOIN + expr ::= * INTEGER + expr ::= * FLOAT + expr ::= * STRING + expr ::= * ID LP exprlist RP + expr ::= * ID LP STAR RP + expr ::= * expr AND expr + expr ::= expr AND * expr + expr ::= * expr OR expr + expr ::= * expr LT expr + expr ::= * expr GT expr + expr ::= * expr LE expr + expr ::= * expr GE expr + expr ::= * expr NE expr + expr ::= * expr EQ expr + expr ::= * expr BITAND expr + expr ::= * expr BITOR expr + expr ::= * expr LSHIFT expr + expr ::= * expr RSHIFT expr + expr ::= * expr likeop expr + expr ::= * expr NOT likeop expr + expr ::= * expr PLUS expr + expr ::= * expr MINUS expr + expr ::= * expr STAR expr + expr ::= * expr SLASH expr + expr ::= * expr REM expr + expr ::= * expr CONCAT expr + expr ::= * expr ISNULL + expr ::= * expr IS NULL + expr ::= * expr NOTNULL + expr ::= * expr NOT NULL + expr ::= * expr IS NOT NULL + expr ::= * NOT expr + expr ::= * BITNOT expr + expr ::= * MINUS expr + expr ::= * PLUS expr + expr ::= * LP select RP + expr ::= * expr BETWEEN expr AND expr + expr ::= * expr NOT BETWEEN expr AND expr + expr ::= expr NOT BETWEEN expr AND * expr + expr ::= * expr IN LP exprlist RP + expr ::= * expr IN LP select RP + expr ::= * expr NOT IN LP exprlist RP + expr ::= * expr NOT IN LP select RP + expr ::= * CASE case_operand case_exprlist case_else END + expr ::= * RAISE LP IGNORE RP + expr ::= * RAISE LP ROLLBACK COMMA nm RP + expr ::= * RAISE LP ABORT COMMA nm RP + expr ::= * RAISE LP FAIL COMMA nm RP + + BITNOT shift 177 + CASE shift 183 + FLOAT shift 174 + ID shift 64 + INTEGER shift 173 + JOIN_KW shift 67 + LP shift 68 + MINUS shift 179 + NOT shift 175 + NULL shift 106 + PLUS shift 181 + RAISE shift 193 + STRING shift 66 + expr shift 224 + nm shift 107 + +State 224: + expr ::= expr * ORACLE_OUTER_JOIN + expr ::= expr * AND expr + (182) expr ::= expr AND expr * + expr ::= expr * OR expr + expr ::= expr * LT expr + expr ::= expr * GT expr + expr ::= expr * LE expr + expr ::= expr * GE expr + expr ::= expr * NE expr + expr ::= expr * EQ expr + expr ::= expr * BITAND expr + expr ::= expr * BITOR expr + expr ::= expr * LSHIFT expr + expr ::= expr * RSHIFT expr + expr ::= expr * likeop expr + expr ::= expr * NOT likeop expr + likeop ::= * LIKE + likeop ::= * GLOB + expr ::= expr * PLUS expr + expr ::= expr * MINUS expr + expr ::= expr * STAR expr + expr ::= expr * SLASH expr + expr ::= expr * REM expr + expr ::= expr * CONCAT expr + expr ::= expr * ISNULL + expr ::= expr * IS NULL + expr ::= expr * NOTNULL + expr ::= expr * NOT NULL + expr ::= expr * IS NOT NULL + expr ::= expr * BETWEEN expr AND expr + expr ::= expr * NOT BETWEEN expr AND expr + (215) expr ::= expr NOT BETWEEN expr AND expr * + expr ::= expr * IN LP exprlist RP + expr ::= expr * IN LP select RP + expr ::= expr * NOT IN LP exprlist RP + expr ::= expr * NOT IN LP select RP + + BETWEEN shift 160 + BITAND shift 127 + BITOR shift 129 + CONCAT shift 152 + EQ shift 125 + GE shift 121 + GLOB shift 141 + GT shift 117 + IN shift 164 + IS shift 155 + ISNULL shift 154 + LE shift 119 + LIKE shift 140 + LSHIFT shift 131 + LT shift 115 + MINUS shift 144 + NE shift 123 + NOT shift 137 + NOTNULL shift 159 + ORACLE_OUTER_JOIN shift 104 + PLUS shift 142 + REM shift 150 + RSHIFT shift 133 + SLASH shift 148 + STAR shift 146 + likeop shift 135 + {default} reduce 215 + +State 225: + expr ::= expr NOT IN * LP exprlist RP + expr ::= expr NOT IN * LP select RP + + LP shift 226 + +State 226: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + select ::= * oneselect + select ::= * select multiselect_op oneselect + oneselect ::= * SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt + expr ::= * LP expr RP + expr ::= * NULL + expr ::= * ID + expr ::= * JOIN_KW + expr ::= * nm DOT nm + expr ::= * nm DOT nm DOT nm + expr ::= * expr ORACLE_OUTER_JOIN + expr ::= * INTEGER + expr ::= * FLOAT + expr ::= * STRING + expr ::= * ID LP exprlist RP + expr ::= * ID LP STAR RP + expr ::= * expr AND expr + expr ::= * expr OR expr + expr ::= * expr LT expr + expr ::= * expr GT expr + expr ::= * expr LE expr + expr ::= * expr GE expr + expr ::= * expr NE expr + expr ::= * expr EQ expr + expr ::= * expr BITAND expr + expr ::= * expr BITOR expr + expr ::= * expr LSHIFT expr + expr ::= * expr RSHIFT expr + expr ::= * expr likeop expr + expr ::= * expr NOT likeop expr + expr ::= * expr PLUS expr + expr ::= * expr MINUS expr + expr ::= * expr STAR expr + expr ::= * expr SLASH expr + expr ::= * expr REM expr + expr ::= * expr CONCAT expr + expr ::= * expr ISNULL + expr ::= * expr IS NULL + expr ::= * expr NOTNULL + expr ::= * expr NOT NULL + expr ::= * expr IS NOT NULL + expr ::= * NOT expr + expr ::= * BITNOT expr + expr ::= * MINUS expr + expr ::= * PLUS expr + expr ::= * LP select RP + expr ::= * expr BETWEEN expr AND expr + expr ::= * expr NOT BETWEEN expr AND expr + expr ::= * expr IN LP exprlist RP + expr ::= * expr IN LP select RP + expr ::= * expr NOT IN LP exprlist RP + expr ::= expr NOT IN LP * exprlist RP + expr ::= * expr NOT IN LP select RP + expr ::= expr NOT IN LP * select RP + expr ::= * CASE case_operand case_exprlist case_else END + exprlist ::= * exprlist COMMA expritem + exprlist ::= * expritem + expritem ::= * expr + (230) expritem ::= * + expr ::= * RAISE LP IGNORE RP + expr ::= * RAISE LP ROLLBACK COMMA nm RP + expr ::= * RAISE LP ABORT COMMA nm RP + expr ::= * RAISE LP FAIL COMMA nm RP + + BITNOT shift 177 + CASE shift 183 + FLOAT shift 174 + ID shift 64 + INTEGER shift 173 + JOIN_KW shift 67 + LP shift 68 + MINUS shift 179 + NOT shift 175 + NULL shift 106 + PLUS shift 181 + RAISE shift 193 + SELECT shift 73 + STRING shift 66 + expr shift 172 + expritem shift 219 + exprlist shift 229 + nm shift 107 + oneselect shift 69 + select shift 227 + {default} reduce 230 + +State 227: + select ::= select * multiselect_op oneselect + multiselect_op ::= * UNION + multiselect_op ::= * UNION ALL + multiselect_op ::= * INTERSECT + multiselect_op ::= * EXCEPT + expr ::= expr NOT IN LP select * RP + + EXCEPT shift 170 + INTERSECT shift 169 + RP shift 228 + UNION shift 167 + multiselect_op shift 71 + +State 228: + (219) expr ::= expr NOT IN LP select RP * + + {default} reduce 219 + +State 229: + expr ::= expr NOT IN LP exprlist * RP + exprlist ::= exprlist * COMMA expritem + + COMMA shift 217 + RP shift 230 + +State 230: + (218) expr ::= expr NOT IN LP exprlist RP * + + {default} reduce 218 + +State 231: + sortlist ::= sortitem * collate sortorder + (144) collate ::= * + collate ::= * COLLATE id + + COLLATE shift 100 + collate shift 232 + {default} reduce 144 + +State 232: + sortlist ::= sortitem collate * sortorder + sortorder ::= * ASC + sortorder ::= * DESC + (143) sortorder ::= * + + ASC shift 58 + DESC shift 59 + sortorder shift 233 + {default} reduce 143 + +State 233: + (139) sortlist ::= sortitem collate sortorder * + + {default} reduce 139 + +State 234: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + having_opt ::= HAVING * expr + expr ::= * LP expr RP + expr ::= * NULL + expr ::= * ID + expr ::= * JOIN_KW + expr ::= * nm DOT nm + expr ::= * nm DOT nm DOT nm + expr ::= * expr ORACLE_OUTER_JOIN + expr ::= * INTEGER + expr ::= * FLOAT + expr ::= * STRING + expr ::= * ID LP exprlist RP + expr ::= * ID LP STAR RP + expr ::= * expr AND expr + expr ::= * expr OR expr + expr ::= * expr LT expr + expr ::= * expr GT expr + expr ::= * expr LE expr + expr ::= * expr GE expr + expr ::= * expr NE expr + expr ::= * expr EQ expr + expr ::= * expr BITAND expr + expr ::= * expr BITOR expr + expr ::= * expr LSHIFT expr + expr ::= * expr RSHIFT expr + expr ::= * expr likeop expr + expr ::= * expr NOT likeop expr + expr ::= * expr PLUS expr + expr ::= * expr MINUS expr + expr ::= * expr STAR expr + expr ::= * expr SLASH expr + expr ::= * expr REM expr + expr ::= * expr CONCAT expr + expr ::= * expr ISNULL + expr ::= * expr IS NULL + expr ::= * expr NOTNULL + expr ::= * expr NOT NULL + expr ::= * expr IS NOT NULL + expr ::= * NOT expr + expr ::= * BITNOT expr + expr ::= * MINUS expr + expr ::= * PLUS expr + expr ::= * LP select RP + expr ::= * expr BETWEEN expr AND expr + expr ::= * expr NOT BETWEEN expr AND expr + expr ::= * expr IN LP exprlist RP + expr ::= * expr IN LP select RP + expr ::= * expr NOT IN LP exprlist RP + expr ::= * expr NOT IN LP select RP + expr ::= * CASE case_operand case_exprlist case_else END + expr ::= * RAISE LP IGNORE RP + expr ::= * RAISE LP ROLLBACK COMMA nm RP + expr ::= * RAISE LP ABORT COMMA nm RP + expr ::= * RAISE LP FAIL COMMA nm RP + + BITNOT shift 177 + CASE shift 183 + FLOAT shift 174 + ID shift 64 + INTEGER shift 173 + JOIN_KW shift 67 + LP shift 68 + MINUS shift 179 + NOT shift 175 + NULL shift 106 + PLUS shift 181 + RAISE shift 193 + STRING shift 66 + expr shift 235 + nm shift 107 + +State 235: + (149) having_opt ::= HAVING expr * + expr ::= expr * ORACLE_OUTER_JOIN + expr ::= expr * AND expr + expr ::= expr * OR expr + expr ::= expr * LT expr + expr ::= expr * GT expr + expr ::= expr * LE expr + expr ::= expr * GE expr + expr ::= expr * NE expr + expr ::= expr * EQ expr + expr ::= expr * BITAND expr + expr ::= expr * BITOR expr + expr ::= expr * LSHIFT expr + expr ::= expr * RSHIFT expr + expr ::= expr * likeop expr + expr ::= expr * NOT likeop expr + likeop ::= * LIKE + likeop ::= * GLOB + expr ::= expr * PLUS expr + expr ::= expr * MINUS expr + expr ::= expr * STAR expr + expr ::= expr * SLASH expr + expr ::= expr * REM expr + expr ::= expr * CONCAT expr + expr ::= expr * ISNULL + expr ::= expr * IS NULL + expr ::= expr * NOTNULL + expr ::= expr * NOT NULL + expr ::= expr * IS NOT NULL + expr ::= expr * BETWEEN expr AND expr + expr ::= expr * NOT BETWEEN expr AND expr + expr ::= expr * IN LP exprlist RP + expr ::= expr * IN LP select RP + expr ::= expr * NOT IN LP exprlist RP + expr ::= expr * NOT IN LP select RP + + AND shift 105 + BETWEEN shift 160 + BITAND shift 127 + BITOR shift 129 + CONCAT shift 152 + EQ shift 125 + GE shift 121 + GLOB shift 141 + GT shift 117 + IN shift 164 + IS shift 155 + ISNULL shift 154 + LE shift 119 + LIKE shift 140 + LSHIFT shift 131 + LT shift 115 + MINUS shift 144 + NE shift 123 + NOT shift 137 + NOTNULL shift 159 + OR shift 113 + ORACLE_OUTER_JOIN shift 104 + PLUS shift 142 + REM shift 150 + RSHIFT shift 133 + SLASH shift 148 + STAR shift 146 + likeop shift 135 + {default} reduce 149 + +State 236: + groupby_opt ::= GROUP * BY exprlist + + BY shift 237 + +State 237: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + groupby_opt ::= GROUP BY * exprlist + expr ::= * LP expr RP + expr ::= * NULL + expr ::= * ID + expr ::= * JOIN_KW + expr ::= * nm DOT nm + expr ::= * nm DOT nm DOT nm + expr ::= * expr ORACLE_OUTER_JOIN + expr ::= * INTEGER + expr ::= * FLOAT + expr ::= * STRING + expr ::= * ID LP exprlist RP + expr ::= * ID LP STAR RP + expr ::= * expr AND expr + expr ::= * expr OR expr + expr ::= * expr LT expr + expr ::= * expr GT expr + expr ::= * expr LE expr + expr ::= * expr GE expr + expr ::= * expr NE expr + expr ::= * expr EQ expr + expr ::= * expr BITAND expr + expr ::= * expr BITOR expr + expr ::= * expr LSHIFT expr + expr ::= * expr RSHIFT expr + expr ::= * expr likeop expr + expr ::= * expr NOT likeop expr + expr ::= * expr PLUS expr + expr ::= * expr MINUS expr + expr ::= * expr STAR expr + expr ::= * expr SLASH expr + expr ::= * expr REM expr + expr ::= * expr CONCAT expr + expr ::= * expr ISNULL + expr ::= * expr IS NULL + expr ::= * expr NOTNULL + expr ::= * expr NOT NULL + expr ::= * expr IS NOT NULL + expr ::= * NOT expr + expr ::= * BITNOT expr + expr ::= * MINUS expr + expr ::= * PLUS expr + expr ::= * LP select RP + expr ::= * expr BETWEEN expr AND expr + expr ::= * expr NOT BETWEEN expr AND expr + expr ::= * expr IN LP exprlist RP + expr ::= * expr IN LP select RP + expr ::= * expr NOT IN LP exprlist RP + expr ::= * expr NOT IN LP select RP + expr ::= * CASE case_operand case_exprlist case_else END + exprlist ::= * exprlist COMMA expritem + exprlist ::= * expritem + expritem ::= * expr + (230) expritem ::= * + expr ::= * RAISE LP IGNORE RP + expr ::= * RAISE LP ROLLBACK COMMA nm RP + expr ::= * RAISE LP ABORT COMMA nm RP + expr ::= * RAISE LP FAIL COMMA nm RP + + BITNOT shift 177 + CASE shift 183 + FLOAT shift 174 + ID shift 64 + INTEGER shift 173 + JOIN_KW shift 67 + LP shift 68 + MINUS shift 179 + NOT shift 175 + NULL shift 106 + PLUS shift 181 + RAISE shift 193 + STRING shift 66 + expr shift 172 + expritem shift 219 + exprlist shift 238 + nm shift 107 + {default} reduce 230 + +State 238: + (147) groupby_opt ::= GROUP BY exprlist * + exprlist ::= exprlist * COMMA expritem + + COMMA shift 217 + {default} reduce 147 + +State 239: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + where_opt ::= WHERE * expr + expr ::= * LP expr RP + expr ::= * NULL + expr ::= * ID + expr ::= * JOIN_KW + expr ::= * nm DOT nm + expr ::= * nm DOT nm DOT nm + expr ::= * expr ORACLE_OUTER_JOIN + expr ::= * INTEGER + expr ::= * FLOAT + expr ::= * STRING + expr ::= * ID LP exprlist RP + expr ::= * ID LP STAR RP + expr ::= * expr AND expr + expr ::= * expr OR expr + expr ::= * expr LT expr + expr ::= * expr GT expr + expr ::= * expr LE expr + expr ::= * expr GE expr + expr ::= * expr NE expr + expr ::= * expr EQ expr + expr ::= * expr BITAND expr + expr ::= * expr BITOR expr + expr ::= * expr LSHIFT expr + expr ::= * expr RSHIFT expr + expr ::= * expr likeop expr + expr ::= * expr NOT likeop expr + expr ::= * expr PLUS expr + expr ::= * expr MINUS expr + expr ::= * expr STAR expr + expr ::= * expr SLASH expr + expr ::= * expr REM expr + expr ::= * expr CONCAT expr + expr ::= * expr ISNULL + expr ::= * expr IS NULL + expr ::= * expr NOTNULL + expr ::= * expr NOT NULL + expr ::= * expr IS NOT NULL + expr ::= * NOT expr + expr ::= * BITNOT expr + expr ::= * MINUS expr + expr ::= * PLUS expr + expr ::= * LP select RP + expr ::= * expr BETWEEN expr AND expr + expr ::= * expr NOT BETWEEN expr AND expr + expr ::= * expr IN LP exprlist RP + expr ::= * expr IN LP select RP + expr ::= * expr NOT IN LP exprlist RP + expr ::= * expr NOT IN LP select RP + expr ::= * CASE case_operand case_exprlist case_else END + expr ::= * RAISE LP IGNORE RP + expr ::= * RAISE LP ROLLBACK COMMA nm RP + expr ::= * RAISE LP ABORT COMMA nm RP + expr ::= * RAISE LP FAIL COMMA nm RP + + BITNOT shift 177 + CASE shift 183 + FLOAT shift 174 + ID shift 64 + INTEGER shift 173 + JOIN_KW shift 67 + LP shift 68 + MINUS shift 179 + NOT shift 175 + NULL shift 106 + PLUS shift 181 + RAISE shift 193 + STRING shift 66 + expr shift 240 + nm shift 107 + +State 240: + (156) where_opt ::= WHERE expr * + expr ::= expr * ORACLE_OUTER_JOIN + expr ::= expr * AND expr + expr ::= expr * OR expr + expr ::= expr * LT expr + expr ::= expr * GT expr + expr ::= expr * LE expr + expr ::= expr * GE expr + expr ::= expr * NE expr + expr ::= expr * EQ expr + expr ::= expr * BITAND expr + expr ::= expr * BITOR expr + expr ::= expr * LSHIFT expr + expr ::= expr * RSHIFT expr + expr ::= expr * likeop expr + expr ::= expr * NOT likeop expr + likeop ::= * LIKE + likeop ::= * GLOB + expr ::= expr * PLUS expr + expr ::= expr * MINUS expr + expr ::= expr * STAR expr + expr ::= expr * SLASH expr + expr ::= expr * REM expr + expr ::= expr * CONCAT expr + expr ::= expr * ISNULL + expr ::= expr * IS NULL + expr ::= expr * NOTNULL + expr ::= expr * NOT NULL + expr ::= expr * IS NOT NULL + expr ::= expr * BETWEEN expr AND expr + expr ::= expr * NOT BETWEEN expr AND expr + expr ::= expr * IN LP exprlist RP + expr ::= expr * IN LP select RP + expr ::= expr * NOT IN LP exprlist RP + expr ::= expr * NOT IN LP select RP + + AND shift 105 + BETWEEN shift 160 + BITAND shift 127 + BITOR shift 129 + CONCAT shift 152 + EQ shift 125 + GE shift 121 + GLOB shift 141 + GT shift 117 + IN shift 164 + IS shift 155 + ISNULL shift 154 + LE shift 119 + LIKE shift 140 + LSHIFT shift 131 + LT shift 115 + MINUS shift 144 + NE shift 123 + NOT shift 137 + NOTNULL shift 159 + OR shift 113 + ORACLE_OUTER_JOIN shift 104 + PLUS shift 142 + REM shift 150 + RSHIFT shift 133 + SLASH shift 148 + STAR shift 146 + likeop shift 135 + {default} reduce 156 + +State 241: + (111) sclp ::= selcollist COMMA * + + {default} reduce 111 + +State 242: + from ::= FROM * seltablist + stl_prefix ::= * seltablist joinop + (122) stl_prefix ::= * + seltablist ::= * stl_prefix nm dbnm as on_opt using_opt + seltablist ::= * stl_prefix LP select RP as on_opt using_opt + + seltablist shift 243 + stl_prefix shift 253 + {default} reduce 122 + +State 243: + (120) from ::= FROM seltablist * + stl_prefix ::= seltablist * joinop + joinop ::= * COMMA + joinop ::= * JOIN + joinop ::= * JOIN_KW JOIN + joinop ::= * JOIN_KW nm JOIN + joinop ::= * JOIN_KW nm nm JOIN + + COMMA shift 245 + JOIN shift 246 + JOIN_KW shift 247 + joinop shift 244 + {default} reduce 120 + +State 244: + (121) stl_prefix ::= seltablist joinop * + + {default} reduce 121 + +State 245: + (127) joinop ::= COMMA * + + {default} reduce 127 + +State 246: + (128) joinop ::= JOIN * + + {default} reduce 128 + +State 247: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + joinop ::= JOIN_KW * JOIN + joinop ::= JOIN_KW * nm JOIN + joinop ::= JOIN_KW * nm nm JOIN + + ID shift 20 + JOIN shift 248 + JOIN_KW shift 22 + STRING shift 21 + nm shift 249 + +State 248: + (129) joinop ::= JOIN_KW JOIN * + + {default} reduce 129 + +State 249: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + joinop ::= JOIN_KW nm * JOIN + joinop ::= JOIN_KW nm * nm JOIN + + ID shift 20 + JOIN shift 250 + JOIN_KW shift 22 + STRING shift 21 + nm shift 251 + +State 250: + (130) joinop ::= JOIN_KW nm JOIN * + + {default} reduce 130 + +State 251: + joinop ::= JOIN_KW nm nm * JOIN + + JOIN shift 252 + +State 252: + (131) joinop ::= JOIN_KW nm nm JOIN * + + {default} reduce 131 + +State 253: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + seltablist ::= stl_prefix * nm dbnm as on_opt using_opt + seltablist ::= stl_prefix * LP select RP as on_opt using_opt + + ID shift 20 + JOIN_KW shift 22 + LP shift 277 + STRING shift 21 + nm shift 254 + +State 254: + seltablist ::= stl_prefix nm * dbnm as on_opt using_opt + (125) dbnm ::= * + dbnm ::= * DOT nm + + DOT shift 275 + dbnm shift 255 + {default} reduce 125 + +State 255: + ids ::= * ID + ids ::= * STRING + as ::= * AS nm + as ::= * ids + (118) as ::= * + seltablist ::= stl_prefix nm dbnm * as on_opt using_opt + + AS shift 258 + ID shift 256 + STRING shift 257 + as shift 261 + ids shift 260 + {default} reduce 118 + +State 256: + (26) ids ::= ID * + + {default} reduce 26 + +State 257: + (27) ids ::= STRING * + + {default} reduce 27 + +State 258: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + as ::= AS * nm + + ID shift 20 + JOIN_KW shift 22 + STRING shift 21 + nm shift 259 + +State 259: + (116) as ::= AS nm * + + {default} reduce 116 + +State 260: + (117) as ::= ids * + + {default} reduce 117 + +State 261: + seltablist ::= stl_prefix nm dbnm as * on_opt using_opt + on_opt ::= * ON expr + (133) on_opt ::= * + + ON shift 273 + on_opt shift 262 + {default} reduce 133 + +State 262: + seltablist ::= stl_prefix nm dbnm as on_opt * using_opt + using_opt ::= * USING LP idxlist RP + (135) using_opt ::= * + + USING shift 264 + using_opt shift 263 + {default} reduce 135 + +State 263: + (123) seltablist ::= stl_prefix nm dbnm as on_opt using_opt * + + {default} reduce 123 + +State 264: + using_opt ::= USING * LP idxlist RP + + LP shift 265 + +State 265: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + using_opt ::= USING LP * idxlist RP + idxlist ::= * idxlist COMMA idxitem + idxlist ::= * idxitem + idxitem ::= * nm sortorder + + ID shift 20 + JOIN_KW shift 22 + STRING shift 21 + idxitem shift 272 + idxlist shift 266 + nm shift 270 + +State 266: + using_opt ::= USING LP idxlist * RP + idxlist ::= idxlist * COMMA idxitem + + COMMA shift 268 + RP shift 267 + +State 267: + (134) using_opt ::= USING LP idxlist RP * + + {default} reduce 134 + +State 268: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + idxlist ::= idxlist COMMA * idxitem + idxitem ::= * nm sortorder + + ID shift 20 + JOIN_KW shift 22 + STRING shift 21 + idxitem shift 269 + nm shift 270 + +State 269: + (236) idxlist ::= idxlist COMMA idxitem * + + {default} reduce 236 + +State 270: + sortorder ::= * ASC + sortorder ::= * DESC + (143) sortorder ::= * + idxitem ::= nm * sortorder + + ASC shift 58 + DESC shift 59 + sortorder shift 271 + {default} reduce 143 + +State 271: + (238) idxitem ::= nm sortorder * + + {default} reduce 238 + +State 272: + (237) idxlist ::= idxitem * + + {default} reduce 237 + +State 273: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + on_opt ::= ON * expr + expr ::= * LP expr RP + expr ::= * NULL + expr ::= * ID + expr ::= * JOIN_KW + expr ::= * nm DOT nm + expr ::= * nm DOT nm DOT nm + expr ::= * expr ORACLE_OUTER_JOIN + expr ::= * INTEGER + expr ::= * FLOAT + expr ::= * STRING + expr ::= * ID LP exprlist RP + expr ::= * ID LP STAR RP + expr ::= * expr AND expr + expr ::= * expr OR expr + expr ::= * expr LT expr + expr ::= * expr GT expr + expr ::= * expr LE expr + expr ::= * expr GE expr + expr ::= * expr NE expr + expr ::= * expr EQ expr + expr ::= * expr BITAND expr + expr ::= * expr BITOR expr + expr ::= * expr LSHIFT expr + expr ::= * expr RSHIFT expr + expr ::= * expr likeop expr + expr ::= * expr NOT likeop expr + expr ::= * expr PLUS expr + expr ::= * expr MINUS expr + expr ::= * expr STAR expr + expr ::= * expr SLASH expr + expr ::= * expr REM expr + expr ::= * expr CONCAT expr + expr ::= * expr ISNULL + expr ::= * expr IS NULL + expr ::= * expr NOTNULL + expr ::= * expr NOT NULL + expr ::= * expr IS NOT NULL + expr ::= * NOT expr + expr ::= * BITNOT expr + expr ::= * MINUS expr + expr ::= * PLUS expr + expr ::= * LP select RP + expr ::= * expr BETWEEN expr AND expr + expr ::= * expr NOT BETWEEN expr AND expr + expr ::= * expr IN LP exprlist RP + expr ::= * expr IN LP select RP + expr ::= * expr NOT IN LP exprlist RP + expr ::= * expr NOT IN LP select RP + expr ::= * CASE case_operand case_exprlist case_else END + expr ::= * RAISE LP IGNORE RP + expr ::= * RAISE LP ROLLBACK COMMA nm RP + expr ::= * RAISE LP ABORT COMMA nm RP + expr ::= * RAISE LP FAIL COMMA nm RP + + BITNOT shift 177 + CASE shift 183 + FLOAT shift 174 + ID shift 64 + INTEGER shift 173 + JOIN_KW shift 67 + LP shift 68 + MINUS shift 179 + NOT shift 175 + NULL shift 106 + PLUS shift 181 + RAISE shift 193 + STRING shift 66 + expr shift 274 + nm shift 107 + +State 274: + (132) on_opt ::= ON expr * + expr ::= expr * ORACLE_OUTER_JOIN + expr ::= expr * AND expr + expr ::= expr * OR expr + expr ::= expr * LT expr + expr ::= expr * GT expr + expr ::= expr * LE expr + expr ::= expr * GE expr + expr ::= expr * NE expr + expr ::= expr * EQ expr + expr ::= expr * BITAND expr + expr ::= expr * BITOR expr + expr ::= expr * LSHIFT expr + expr ::= expr * RSHIFT expr + expr ::= expr * likeop expr + expr ::= expr * NOT likeop expr + likeop ::= * LIKE + likeop ::= * GLOB + expr ::= expr * PLUS expr + expr ::= expr * MINUS expr + expr ::= expr * STAR expr + expr ::= expr * SLASH expr + expr ::= expr * REM expr + expr ::= expr * CONCAT expr + expr ::= expr * ISNULL + expr ::= expr * IS NULL + expr ::= expr * NOTNULL + expr ::= expr * NOT NULL + expr ::= expr * IS NOT NULL + expr ::= expr * BETWEEN expr AND expr + expr ::= expr * NOT BETWEEN expr AND expr + expr ::= expr * IN LP exprlist RP + expr ::= expr * IN LP select RP + expr ::= expr * NOT IN LP exprlist RP + expr ::= expr * NOT IN LP select RP + + AND shift 105 + BETWEEN shift 160 + BITAND shift 127 + BITOR shift 129 + CONCAT shift 152 + EQ shift 125 + GE shift 121 + GLOB shift 141 + GT shift 117 + IN shift 164 + IS shift 155 + ISNULL shift 154 + LE shift 119 + LIKE shift 140 + LSHIFT shift 131 + LT shift 115 + MINUS shift 144 + NE shift 123 + NOT shift 137 + NOTNULL shift 159 + OR shift 113 + ORACLE_OUTER_JOIN shift 104 + PLUS shift 142 + REM shift 150 + RSHIFT shift 133 + SLASH shift 148 + STAR shift 146 + likeop shift 135 + {default} reduce 132 + +State 275: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + dbnm ::= DOT * nm + + ID shift 20 + JOIN_KW shift 22 + STRING shift 21 + nm shift 276 + +State 276: + (126) dbnm ::= DOT nm * + + {default} reduce 126 + +State 277: + select ::= * oneselect + select ::= * select multiselect_op oneselect + oneselect ::= * SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt + seltablist ::= stl_prefix LP * select RP as on_opt using_opt + + SELECT shift 73 + oneselect shift 69 + select shift 278 + +State 278: + select ::= select * multiselect_op oneselect + multiselect_op ::= * UNION + multiselect_op ::= * UNION ALL + multiselect_op ::= * INTERSECT + multiselect_op ::= * EXCEPT + seltablist ::= stl_prefix LP select * RP as on_opt using_opt + + EXCEPT shift 170 + INTERSECT shift 169 + RP shift 279 + UNION shift 167 + multiselect_op shift 71 + +State 279: + ids ::= * ID + ids ::= * STRING + as ::= * AS nm + as ::= * ids + (118) as ::= * + seltablist ::= stl_prefix LP select RP * as on_opt using_opt + + AS shift 258 + ID shift 256 + STRING shift 257 + as shift 280 + ids shift 260 + {default} reduce 118 + +State 280: + seltablist ::= stl_prefix LP select RP as * on_opt using_opt + on_opt ::= * ON expr + (133) on_opt ::= * + + ON shift 273 + on_opt shift 281 + {default} reduce 133 + +State 281: + seltablist ::= stl_prefix LP select RP as on_opt * using_opt + using_opt ::= * USING LP idxlist RP + (135) using_opt ::= * + + USING shift 264 + using_opt shift 282 + {default} reduce 135 + +State 282: + (124) seltablist ::= stl_prefix LP select RP as on_opt using_opt * + + {default} reduce 124 + +State 283: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + selcollist ::= sclp * expr as + selcollist ::= sclp * STAR + selcollist ::= sclp * nm DOT STAR + expr ::= * LP expr RP + expr ::= * NULL + expr ::= * ID + expr ::= * JOIN_KW + expr ::= * nm DOT nm + expr ::= * nm DOT nm DOT nm + expr ::= * expr ORACLE_OUTER_JOIN + expr ::= * INTEGER + expr ::= * FLOAT + expr ::= * STRING + expr ::= * ID LP exprlist RP + expr ::= * ID LP STAR RP + expr ::= * expr AND expr + expr ::= * expr OR expr + expr ::= * expr LT expr + expr ::= * expr GT expr + expr ::= * expr LE expr + expr ::= * expr GE expr + expr ::= * expr NE expr + expr ::= * expr EQ expr + expr ::= * expr BITAND expr + expr ::= * expr BITOR expr + expr ::= * expr LSHIFT expr + expr ::= * expr RSHIFT expr + expr ::= * expr likeop expr + expr ::= * expr NOT likeop expr + expr ::= * expr PLUS expr + expr ::= * expr MINUS expr + expr ::= * expr STAR expr + expr ::= * expr SLASH expr + expr ::= * expr REM expr + expr ::= * expr CONCAT expr + expr ::= * expr ISNULL + expr ::= * expr IS NULL + expr ::= * expr NOTNULL + expr ::= * expr NOT NULL + expr ::= * expr IS NOT NULL + expr ::= * NOT expr + expr ::= * BITNOT expr + expr ::= * MINUS expr + expr ::= * PLUS expr + expr ::= * LP select RP + expr ::= * expr BETWEEN expr AND expr + expr ::= * expr NOT BETWEEN expr AND expr + expr ::= * expr IN LP exprlist RP + expr ::= * expr IN LP select RP + expr ::= * expr NOT IN LP exprlist RP + expr ::= * expr NOT IN LP select RP + expr ::= * CASE case_operand case_exprlist case_else END + expr ::= * RAISE LP IGNORE RP + expr ::= * RAISE LP ROLLBACK COMMA nm RP + expr ::= * RAISE LP ABORT COMMA nm RP + expr ::= * RAISE LP FAIL COMMA nm RP + + BITNOT shift 177 + CASE shift 183 + FLOAT shift 174 + ID shift 64 + INTEGER shift 173 + JOIN_KW shift 67 + LP shift 68 + MINUS shift 179 + NOT shift 175 + NULL shift 106 + PLUS shift 181 + RAISE shift 193 + STAR shift 286 + STRING shift 66 + expr shift 284 + nm shift 287 + +State 284: + ids ::= * ID + ids ::= * STRING + selcollist ::= sclp expr * as + as ::= * AS nm + as ::= * ids + (118) as ::= * + expr ::= expr * ORACLE_OUTER_JOIN + expr ::= expr * AND expr + expr ::= expr * OR expr + expr ::= expr * LT expr + expr ::= expr * GT expr + expr ::= expr * LE expr + expr ::= expr * GE expr + expr ::= expr * NE expr + expr ::= expr * EQ expr + expr ::= expr * BITAND expr + expr ::= expr * BITOR expr + expr ::= expr * LSHIFT expr + expr ::= expr * RSHIFT expr + expr ::= expr * likeop expr + expr ::= expr * NOT likeop expr + likeop ::= * LIKE + likeop ::= * GLOB + expr ::= expr * PLUS expr + expr ::= expr * MINUS expr + expr ::= expr * STAR expr + expr ::= expr * SLASH expr + expr ::= expr * REM expr + expr ::= expr * CONCAT expr + expr ::= expr * ISNULL + expr ::= expr * IS NULL + expr ::= expr * NOTNULL + expr ::= expr * NOT NULL + expr ::= expr * IS NOT NULL + expr ::= expr * BETWEEN expr AND expr + expr ::= expr * NOT BETWEEN expr AND expr + expr ::= expr * IN LP exprlist RP + expr ::= expr * IN LP select RP + expr ::= expr * NOT IN LP exprlist RP + expr ::= expr * NOT IN LP select RP + + AND shift 105 + AS shift 258 + BETWEEN shift 160 + BITAND shift 127 + BITOR shift 129 + CONCAT shift 152 + EQ shift 125 + GE shift 121 + GLOB shift 141 + GT shift 117 + ID shift 256 + IN shift 164 + IS shift 155 + ISNULL shift 154 + LE shift 119 + LIKE shift 140 + LSHIFT shift 131 + LT shift 115 + MINUS shift 144 + NE shift 123 + NOT shift 137 + NOTNULL shift 159 + OR shift 113 + ORACLE_OUTER_JOIN shift 104 + PLUS shift 142 + REM shift 150 + RSHIFT shift 133 + SLASH shift 148 + STAR shift 146 + STRING shift 257 + as shift 285 + ids shift 260 + likeop shift 135 + {default} reduce 118 + +State 285: + (113) selcollist ::= sclp expr as * + + {default} reduce 113 + +State 286: + (114) selcollist ::= sclp STAR * + + {default} reduce 114 + +State 287: + selcollist ::= sclp nm * DOT STAR + expr ::= nm * DOT nm + expr ::= nm * DOT nm DOT nm + + DOT shift 288 + +State 288: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + selcollist ::= sclp nm DOT * STAR + expr ::= nm DOT * nm + expr ::= nm DOT * nm DOT nm + + ID shift 20 + JOIN_KW shift 22 + STAR shift 289 + STRING shift 21 + nm shift 109 + +State 289: + (115) selcollist ::= sclp nm DOT STAR * + + {default} reduce 115 + +State 290: + (108) distinct ::= DISTINCT * + + {default} reduce 108 + +State 291: + (109) distinct ::= ALL * + + {default} reduce 109 + +State 292: + (213) expr ::= LP select RP * + + {default} reduce 213 + +State 293: + expr ::= LP expr * RP + expr ::= expr * ORACLE_OUTER_JOIN + expr ::= expr * AND expr + expr ::= expr * OR expr + expr ::= expr * LT expr + expr ::= expr * GT expr + expr ::= expr * LE expr + expr ::= expr * GE expr + expr ::= expr * NE expr + expr ::= expr * EQ expr + expr ::= expr * BITAND expr + expr ::= expr * BITOR expr + expr ::= expr * LSHIFT expr + expr ::= expr * RSHIFT expr + expr ::= expr * likeop expr + expr ::= expr * NOT likeop expr + likeop ::= * LIKE + likeop ::= * GLOB + expr ::= expr * PLUS expr + expr ::= expr * MINUS expr + expr ::= expr * STAR expr + expr ::= expr * SLASH expr + expr ::= expr * REM expr + expr ::= expr * CONCAT expr + expr ::= expr * ISNULL + expr ::= expr * IS NULL + expr ::= expr * NOTNULL + expr ::= expr * NOT NULL + expr ::= expr * IS NOT NULL + expr ::= expr * BETWEEN expr AND expr + expr ::= expr * NOT BETWEEN expr AND expr + expr ::= expr * IN LP exprlist RP + expr ::= expr * IN LP select RP + expr ::= expr * NOT IN LP exprlist RP + expr ::= expr * NOT IN LP select RP + + AND shift 105 + BETWEEN shift 160 + BITAND shift 127 + BITOR shift 129 + CONCAT shift 152 + EQ shift 125 + GE shift 121 + GLOB shift 141 + GT shift 117 + IN shift 164 + IS shift 155 + ISNULL shift 154 + LE shift 119 + LIKE shift 140 + LSHIFT shift 131 + LT shift 115 + MINUS shift 144 + NE shift 123 + NOT shift 137 + NOTNULL shift 159 + OR shift 113 + ORACLE_OUTER_JOIN shift 104 + PLUS shift 142 + REM shift 150 + RP shift 294 + RSHIFT shift 133 + SLASH shift 148 + STAR shift 146 + likeop shift 135 + +State 294: + (170) expr ::= LP expr RP * + + {default} reduce 170 + +State 295: + expr ::= ID LP exprlist * RP + exprlist ::= exprlist * COMMA expritem + + COMMA shift 217 + RP shift 296 + +State 296: + (180) expr ::= ID LP exprlist RP * + + {default} reduce 180 + +State 297: + expr ::= ID LP STAR * RP + + RP shift 298 + +State 298: + (181) expr ::= ID LP STAR RP * + + {default} reduce 181 + +State 299: + ccons ::= CHECK LP expr * RP onconf + expr ::= expr * ORACLE_OUTER_JOIN + expr ::= expr * AND expr + expr ::= expr * OR expr + expr ::= expr * LT expr + expr ::= expr * GT expr + expr ::= expr * LE expr + expr ::= expr * GE expr + expr ::= expr * NE expr + expr ::= expr * EQ expr + expr ::= expr * BITAND expr + expr ::= expr * BITOR expr + expr ::= expr * LSHIFT expr + expr ::= expr * RSHIFT expr + expr ::= expr * likeop expr + expr ::= expr * NOT likeop expr + likeop ::= * LIKE + likeop ::= * GLOB + expr ::= expr * PLUS expr + expr ::= expr * MINUS expr + expr ::= expr * STAR expr + expr ::= expr * SLASH expr + expr ::= expr * REM expr + expr ::= expr * CONCAT expr + expr ::= expr * ISNULL + expr ::= expr * IS NULL + expr ::= expr * NOTNULL + expr ::= expr * NOT NULL + expr ::= expr * IS NOT NULL + expr ::= expr * BETWEEN expr AND expr + expr ::= expr * NOT BETWEEN expr AND expr + expr ::= expr * IN LP exprlist RP + expr ::= expr * IN LP select RP + expr ::= expr * NOT IN LP exprlist RP + expr ::= expr * NOT IN LP select RP + + AND shift 105 + BETWEEN shift 160 + BITAND shift 127 + BITOR shift 129 + CONCAT shift 152 + EQ shift 125 + GE shift 121 + GLOB shift 141 + GT shift 117 + IN shift 164 + IS shift 155 + ISNULL shift 154 + LE shift 119 + LIKE shift 140 + LSHIFT shift 131 + LT shift 115 + MINUS shift 144 + NE shift 123 + NOT shift 137 + NOTNULL shift 159 + OR shift 113 + ORACLE_OUTER_JOIN shift 104 + PLUS shift 142 + REM shift 150 + RP shift 300 + RSHIFT shift 133 + SLASH shift 148 + STAR shift 146 + likeop shift 135 + +State 300: + ccons ::= CHECK LP expr RP * onconf + (88) onconf ::= * + onconf ::= * ON CONFLICT resolvetype + + ON shift 10 + onconf shift 301 + {default} reduce 88 + +State 301: + (57) ccons ::= CHECK LP expr RP onconf * + + {default} reduce 57 + +State 302: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + ccons ::= REFERENCES * nm idxlist_opt refargs + + ID shift 20 + JOIN_KW shift 22 + STRING shift 21 + nm shift 303 + +State 303: + ccons ::= REFERENCES nm * idxlist_opt refargs + (234) idxlist_opt ::= * + idxlist_opt ::= * LP idxlist RP + + LP shift 321 + idxlist_opt shift 304 + {default} reduce 234 + +State 304: + ccons ::= REFERENCES nm idxlist_opt * refargs + (61) refargs ::= * + refargs ::= * refargs refarg + + refargs shift 305 + {default} reduce 61 + +State 305: + (58) ccons ::= REFERENCES nm idxlist_opt refargs * + refargs ::= refargs * refarg + refarg ::= * MATCH nm + refarg ::= * ON DELETE refact + refarg ::= * ON UPDATE refact + refarg ::= * ON INSERT refact + + MATCH shift 307 + ON shift 309 + refarg shift 306 + {default} reduce 58 + +State 306: + (62) refargs ::= refargs refarg * + + {default} reduce 62 + +State 307: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + refarg ::= MATCH * nm + + ID shift 20 + JOIN_KW shift 22 + STRING shift 21 + nm shift 308 + +State 308: + (63) refarg ::= MATCH nm * + + {default} reduce 63 + +State 309: + refarg ::= ON * DELETE refact + refarg ::= ON * UPDATE refact + refarg ::= ON * INSERT refact + + DELETE shift 310 + INSERT shift 319 + UPDATE shift 317 + +State 310: + refarg ::= ON DELETE * refact + refact ::= * SET NULL + refact ::= * SET DEFAULT + refact ::= * CASCADE + refact ::= * RESTRICT + + CASCADE shift 315 + RESTRICT shift 316 + SET shift 312 + refact shift 311 + +State 311: + (64) refarg ::= ON DELETE refact * + + {default} reduce 64 + +State 312: + refact ::= SET * NULL + refact ::= SET * DEFAULT + + DEFAULT shift 314 + NULL shift 313 + +State 313: + (67) refact ::= SET NULL * + + {default} reduce 67 + +State 314: + (68) refact ::= SET DEFAULT * + + {default} reduce 68 + +State 315: + (69) refact ::= CASCADE * + + {default} reduce 69 + +State 316: + (70) refact ::= RESTRICT * + + {default} reduce 70 + +State 317: + refarg ::= ON UPDATE * refact + refact ::= * SET NULL + refact ::= * SET DEFAULT + refact ::= * CASCADE + refact ::= * RESTRICT + + CASCADE shift 315 + RESTRICT shift 316 + SET shift 312 + refact shift 318 + +State 318: + (65) refarg ::= ON UPDATE refact * + + {default} reduce 65 + +State 319: + refarg ::= ON INSERT * refact + refact ::= * SET NULL + refact ::= * SET DEFAULT + refact ::= * CASCADE + refact ::= * RESTRICT + + CASCADE shift 315 + RESTRICT shift 316 + SET shift 312 + refact shift 320 + +State 320: + (66) refarg ::= ON INSERT refact * + + {default} reduce 66 + +State 321: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + idxlist_opt ::= LP * idxlist RP + idxlist ::= * idxlist COMMA idxitem + idxlist ::= * idxitem + idxitem ::= * nm sortorder + + ID shift 20 + JOIN_KW shift 22 + STRING shift 21 + idxitem shift 272 + idxlist shift 322 + nm shift 270 + +State 322: + idxlist_opt ::= LP idxlist * RP + idxlist ::= idxlist * COMMA idxitem + + COMMA shift 268 + RP shift 323 + +State 323: + (235) idxlist_opt ::= LP idxlist RP * + + {default} reduce 235 + +State 324: + (59) ccons ::= defer_subclause * + + {default} reduce 59 + +State 325: + id ::= * ID + ccons ::= COLLATE * id + + ID shift 101 + id shift 326 + +State 326: + (60) ccons ::= COLLATE id * + + {default} reduce 60 + +State 327: + defer_subclause ::= DEFERRABLE * init_deferred_pred_opt + (73) init_deferred_pred_opt ::= * + init_deferred_pred_opt ::= * INITIALLY DEFERRED + init_deferred_pred_opt ::= * INITIALLY IMMEDIATE + + INITIALLY shift 51 + init_deferred_pred_opt shift 328 + {default} reduce 73 + +State 328: + (72) defer_subclause ::= DEFERRABLE init_deferred_pred_opt * + + {default} reduce 72 + +State 329: + (43) carg ::= ccons * + + {default} reduce 43 + +State 330: + carg ::= DEFAULT * STRING + carg ::= DEFAULT * ID + carg ::= DEFAULT * INTEGER + carg ::= DEFAULT * PLUS INTEGER + carg ::= DEFAULT * MINUS INTEGER + carg ::= DEFAULT * FLOAT + carg ::= DEFAULT * PLUS FLOAT + carg ::= DEFAULT * MINUS FLOAT + carg ::= DEFAULT * NULL + + FLOAT shift 340 + ID shift 332 + INTEGER shift 333 + MINUS shift 337 + NULL shift 341 + PLUS shift 334 + STRING shift 331 + +State 331: + (44) carg ::= DEFAULT STRING * + + {default} reduce 44 + +State 332: + (45) carg ::= DEFAULT ID * + + {default} reduce 45 + +State 333: + (46) carg ::= DEFAULT INTEGER * + + {default} reduce 46 + +State 334: + carg ::= DEFAULT PLUS * INTEGER + carg ::= DEFAULT PLUS * FLOAT + + FLOAT shift 336 + INTEGER shift 335 + +State 335: + (47) carg ::= DEFAULT PLUS INTEGER * + + {default} reduce 47 + +State 336: + (50) carg ::= DEFAULT PLUS FLOAT * + + {default} reduce 50 + +State 337: + carg ::= DEFAULT MINUS * INTEGER + carg ::= DEFAULT MINUS * FLOAT + + FLOAT shift 339 + INTEGER shift 338 + +State 338: + (48) carg ::= DEFAULT MINUS INTEGER * + + {default} reduce 48 + +State 339: + (51) carg ::= DEFAULT MINUS FLOAT * + + {default} reduce 51 + +State 340: + (49) carg ::= DEFAULT FLOAT * + + {default} reduce 49 + +State 341: + (52) carg ::= DEFAULT NULL * + + {default} reduce 52 + +State 342: + ids ::= * ID + ids ::= * STRING + (32) type ::= typename * + type ::= typename * LP signed RP + type ::= typename * LP signed COMMA signed RP + typename ::= typename * ids + + ID shift 256 + LP shift 343 + STRING shift 257 + ids shift 349 + {default} reduce 32 + +State 343: + type ::= typename LP * signed RP + type ::= typename LP * signed COMMA signed RP + signed ::= * INTEGER + signed ::= * PLUS INTEGER + signed ::= * MINUS INTEGER + + INTEGER shift 83 + MINUS shift 86 + PLUS shift 84 + signed shift 344 + +State 344: + type ::= typename LP signed * RP + type ::= typename LP signed * COMMA signed RP + + COMMA shift 346 + RP shift 345 + +State 345: + (33) type ::= typename LP signed RP * + + {default} reduce 33 + +State 346: + type ::= typename LP signed COMMA * signed RP + signed ::= * INTEGER + signed ::= * PLUS INTEGER + signed ::= * MINUS INTEGER + + INTEGER shift 83 + MINUS shift 86 + PLUS shift 84 + signed shift 347 + +State 347: + type ::= typename LP signed COMMA signed * RP + + RP shift 348 + +State 348: + (34) type ::= typename LP signed COMMA signed RP * + + {default} reduce 34 + +State 349: + (36) typename ::= typename ids * + + {default} reduce 36 + +State 350: + (35) typename ::= ids * + + {default} reduce 35 + +State 351: + (24) columnid ::= nm * + + {default} reduce 24 + +State 352: + (77) conslist_opt ::= COMMA conslist * + conslist ::= conslist * COMMA tcons + conslist ::= conslist * tcons + tcons ::= * CONSTRAINT nm + tcons ::= * PRIMARY KEY LP idxlist RP onconf + tcons ::= * UNIQUE LP idxlist RP onconf + tcons ::= * CHECK expr onconf + tcons ::= * FOREIGN KEY LP idxlist RP REFERENCES nm idxlist_opt refargs defer_subclause_opt + + CHECK shift 368 + COMMA shift 353 + CONSTRAINT shift 355 + FOREIGN shift 371 + PRIMARY shift 357 + RP reduce 77 + UNIQUE shift 363 + tcons shift 383 + +State 353: + conslist ::= conslist COMMA * tcons + tcons ::= * CONSTRAINT nm + tcons ::= * PRIMARY KEY LP idxlist RP onconf + tcons ::= * UNIQUE LP idxlist RP onconf + tcons ::= * CHECK expr onconf + tcons ::= * FOREIGN KEY LP idxlist RP REFERENCES nm idxlist_opt refargs defer_subclause_opt + + CHECK shift 368 + CONSTRAINT shift 355 + FOREIGN shift 371 + PRIMARY shift 357 + UNIQUE shift 363 + tcons shift 354 + +State 354: + (78) conslist ::= conslist COMMA tcons * + + {default} reduce 78 + +State 355: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + tcons ::= CONSTRAINT * nm + + ID shift 20 + JOIN_KW shift 22 + STRING shift 21 + nm shift 356 + +State 356: + (81) tcons ::= CONSTRAINT nm * + + {default} reduce 81 + +State 357: + tcons ::= PRIMARY * KEY LP idxlist RP onconf + + KEY shift 358 + +State 358: + tcons ::= PRIMARY KEY * LP idxlist RP onconf + + LP shift 359 + +State 359: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + tcons ::= PRIMARY KEY LP * idxlist RP onconf + idxlist ::= * idxlist COMMA idxitem + idxlist ::= * idxitem + idxitem ::= * nm sortorder + + ID shift 20 + JOIN_KW shift 22 + STRING shift 21 + idxitem shift 272 + idxlist shift 360 + nm shift 270 + +State 360: + tcons ::= PRIMARY KEY LP idxlist * RP onconf + idxlist ::= idxlist * COMMA idxitem + + COMMA shift 268 + RP shift 361 + +State 361: + tcons ::= PRIMARY KEY LP idxlist RP * onconf + (88) onconf ::= * + onconf ::= * ON CONFLICT resolvetype + + ON shift 10 + onconf shift 362 + {default} reduce 88 + +State 362: + (82) tcons ::= PRIMARY KEY LP idxlist RP onconf * + + {default} reduce 82 + +State 363: + tcons ::= UNIQUE * LP idxlist RP onconf + + LP shift 364 + +State 364: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + tcons ::= UNIQUE LP * idxlist RP onconf + idxlist ::= * idxlist COMMA idxitem + idxlist ::= * idxitem + idxitem ::= * nm sortorder + + ID shift 20 + JOIN_KW shift 22 + STRING shift 21 + idxitem shift 272 + idxlist shift 365 + nm shift 270 + +State 365: + tcons ::= UNIQUE LP idxlist * RP onconf + idxlist ::= idxlist * COMMA idxitem + + COMMA shift 268 + RP shift 366 + +State 366: + tcons ::= UNIQUE LP idxlist RP * onconf + (88) onconf ::= * + onconf ::= * ON CONFLICT resolvetype + + ON shift 10 + onconf shift 367 + {default} reduce 88 + +State 367: + (83) tcons ::= UNIQUE LP idxlist RP onconf * + + {default} reduce 83 + +State 368: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + tcons ::= CHECK * expr onconf + expr ::= * LP expr RP + expr ::= * NULL + expr ::= * ID + expr ::= * JOIN_KW + expr ::= * nm DOT nm + expr ::= * nm DOT nm DOT nm + expr ::= * expr ORACLE_OUTER_JOIN + expr ::= * INTEGER + expr ::= * FLOAT + expr ::= * STRING + expr ::= * ID LP exprlist RP + expr ::= * ID LP STAR RP + expr ::= * expr AND expr + expr ::= * expr OR expr + expr ::= * expr LT expr + expr ::= * expr GT expr + expr ::= * expr LE expr + expr ::= * expr GE expr + expr ::= * expr NE expr + expr ::= * expr EQ expr + expr ::= * expr BITAND expr + expr ::= * expr BITOR expr + expr ::= * expr LSHIFT expr + expr ::= * expr RSHIFT expr + expr ::= * expr likeop expr + expr ::= * expr NOT likeop expr + expr ::= * expr PLUS expr + expr ::= * expr MINUS expr + expr ::= * expr STAR expr + expr ::= * expr SLASH expr + expr ::= * expr REM expr + expr ::= * expr CONCAT expr + expr ::= * expr ISNULL + expr ::= * expr IS NULL + expr ::= * expr NOTNULL + expr ::= * expr NOT NULL + expr ::= * expr IS NOT NULL + expr ::= * NOT expr + expr ::= * BITNOT expr + expr ::= * MINUS expr + expr ::= * PLUS expr + expr ::= * LP select RP + expr ::= * expr BETWEEN expr AND expr + expr ::= * expr NOT BETWEEN expr AND expr + expr ::= * expr IN LP exprlist RP + expr ::= * expr IN LP select RP + expr ::= * expr NOT IN LP exprlist RP + expr ::= * expr NOT IN LP select RP + expr ::= * CASE case_operand case_exprlist case_else END + expr ::= * RAISE LP IGNORE RP + expr ::= * RAISE LP ROLLBACK COMMA nm RP + expr ::= * RAISE LP ABORT COMMA nm RP + expr ::= * RAISE LP FAIL COMMA nm RP + + BITNOT shift 177 + CASE shift 183 + FLOAT shift 174 + ID shift 64 + INTEGER shift 173 + JOIN_KW shift 67 + LP shift 68 + MINUS shift 179 + NOT shift 175 + NULL shift 106 + PLUS shift 181 + RAISE shift 193 + STRING shift 66 + expr shift 369 + nm shift 107 + +State 369: + tcons ::= CHECK expr * onconf + (88) onconf ::= * + onconf ::= * ON CONFLICT resolvetype + expr ::= expr * ORACLE_OUTER_JOIN + expr ::= expr * AND expr + expr ::= expr * OR expr + expr ::= expr * LT expr + expr ::= expr * GT expr + expr ::= expr * LE expr + expr ::= expr * GE expr + expr ::= expr * NE expr + expr ::= expr * EQ expr + expr ::= expr * BITAND expr + expr ::= expr * BITOR expr + expr ::= expr * LSHIFT expr + expr ::= expr * RSHIFT expr + expr ::= expr * likeop expr + expr ::= expr * NOT likeop expr + likeop ::= * LIKE + likeop ::= * GLOB + expr ::= expr * PLUS expr + expr ::= expr * MINUS expr + expr ::= expr * STAR expr + expr ::= expr * SLASH expr + expr ::= expr * REM expr + expr ::= expr * CONCAT expr + expr ::= expr * ISNULL + expr ::= expr * IS NULL + expr ::= expr * NOTNULL + expr ::= expr * NOT NULL + expr ::= expr * IS NOT NULL + expr ::= expr * BETWEEN expr AND expr + expr ::= expr * NOT BETWEEN expr AND expr + expr ::= expr * IN LP exprlist RP + expr ::= expr * IN LP select RP + expr ::= expr * NOT IN LP exprlist RP + expr ::= expr * NOT IN LP select RP + + AND shift 105 + BETWEEN shift 160 + BITAND shift 127 + BITOR shift 129 + CONCAT shift 152 + EQ shift 125 + GE shift 121 + GLOB shift 141 + GT shift 117 + IN shift 164 + IS shift 155 + ISNULL shift 154 + LE shift 119 + LIKE shift 140 + LSHIFT shift 131 + LT shift 115 + MINUS shift 144 + NE shift 123 + NOT shift 137 + NOTNULL shift 159 + ON shift 10 + OR shift 113 + ORACLE_OUTER_JOIN shift 104 + PLUS shift 142 + REM shift 150 + RSHIFT shift 133 + SLASH shift 148 + STAR shift 146 + likeop shift 135 + onconf shift 370 + {default} reduce 88 + +State 370: + (84) tcons ::= CHECK expr onconf * + + {default} reduce 84 + +State 371: + tcons ::= FOREIGN * KEY LP idxlist RP REFERENCES nm idxlist_opt refargs defer_subclause_opt + + KEY shift 372 + +State 372: + tcons ::= FOREIGN KEY * LP idxlist RP REFERENCES nm idxlist_opt refargs defer_subclause_opt + + LP shift 373 + +State 373: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + tcons ::= FOREIGN KEY LP * idxlist RP REFERENCES nm idxlist_opt refargs defer_subclause_opt + idxlist ::= * idxlist COMMA idxitem + idxlist ::= * idxitem + idxitem ::= * nm sortorder + + ID shift 20 + JOIN_KW shift 22 + STRING shift 21 + idxitem shift 272 + idxlist shift 374 + nm shift 270 + +State 374: + tcons ::= FOREIGN KEY LP idxlist * RP REFERENCES nm idxlist_opt refargs defer_subclause_opt + idxlist ::= idxlist * COMMA idxitem + + COMMA shift 268 + RP shift 375 + +State 375: + tcons ::= FOREIGN KEY LP idxlist RP * REFERENCES nm idxlist_opt refargs defer_subclause_opt + + REFERENCES shift 376 + +State 376: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + tcons ::= FOREIGN KEY LP idxlist RP REFERENCES * nm idxlist_opt refargs defer_subclause_opt + + ID shift 20 + JOIN_KW shift 22 + STRING shift 21 + nm shift 377 + +State 377: + tcons ::= FOREIGN KEY LP idxlist RP REFERENCES nm * idxlist_opt refargs defer_subclause_opt + (234) idxlist_opt ::= * + idxlist_opt ::= * LP idxlist RP + + LP shift 321 + idxlist_opt shift 378 + {default} reduce 234 + +State 378: + (61) refargs ::= * + refargs ::= * refargs refarg + tcons ::= FOREIGN KEY LP idxlist RP REFERENCES nm idxlist_opt * refargs defer_subclause_opt + + refargs shift 379 + {default} reduce 61 + +State 379: + refargs ::= refargs * refarg + refarg ::= * MATCH nm + refarg ::= * ON DELETE refact + refarg ::= * ON UPDATE refact + refarg ::= * ON INSERT refact + defer_subclause ::= * NOT DEFERRABLE init_deferred_pred_opt + defer_subclause ::= * DEFERRABLE init_deferred_pred_opt + tcons ::= FOREIGN KEY LP idxlist RP REFERENCES nm idxlist_opt refargs * defer_subclause_opt + (86) defer_subclause_opt ::= * + defer_subclause_opt ::= * defer_subclause + + DEFERRABLE shift 327 + MATCH shift 307 + NOT shift 380 + ON shift 309 + defer_subclause shift 382 + defer_subclause_opt shift 381 + refarg shift 306 + {default} reduce 86 + +State 380: + defer_subclause ::= NOT * DEFERRABLE init_deferred_pred_opt + + DEFERRABLE shift 49 + +State 381: + (85) tcons ::= FOREIGN KEY LP idxlist RP REFERENCES nm idxlist_opt refargs defer_subclause_opt * + + {default} reduce 85 + +State 382: + (87) defer_subclause_opt ::= defer_subclause * + + {default} reduce 87 + +State 383: + (79) conslist ::= conslist tcons * + + {default} reduce 79 + +State 384: + (80) conslist ::= tcons * + + {default} reduce 80 + +State 385: + (22) columnlist ::= column * + + {default} reduce 22 + +State 386: + create_table_args ::= AS * select + select ::= * oneselect + select ::= * select multiselect_op oneselect + oneselect ::= * SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt + + SELECT shift 73 + oneselect shift 69 + select shift 387 + +State 387: + (20) create_table_args ::= AS select * + select ::= select * multiselect_op oneselect + multiselect_op ::= * UNION + multiselect_op ::= * UNION ALL + multiselect_op ::= * INTERSECT + multiselect_op ::= * EXCEPT + + EXCEPT shift 170 + INTERSECT shift 169 + SEMI reduce 20 + UNION shift 167 + multiselect_op shift 71 + +State 388: + create_table ::= CREATE * temp TABLE nm + temp ::= * TEMP + (18) temp ::= * + cmd ::= CREATE * temp VIEW nm AS select + cmd ::= CREATE * temp uniqueflag INDEX nm ON nm dbnm LP idxlist RP onconf + cmd ::= CREATE * trigger_decl BEGIN trigger_cmd_list END + trigger_decl ::= * temp TRIGGER nm trigger_time trigger_event ON nm dbnm foreach_clause when_clause + + TEMP shift 434 + temp shift 389 + trigger_decl shift 435 + {default} reduce 18 + +State 389: + create_table ::= CREATE temp * TABLE nm + cmd ::= CREATE temp * VIEW nm AS select + cmd ::= CREATE temp * uniqueflag INDEX nm ON nm dbnm LP idxlist RP onconf + uniqueflag ::= * UNIQUE + (233) uniqueflag ::= * + trigger_decl ::= temp * TRIGGER nm trigger_time trigger_event ON nm dbnm foreach_clause when_clause + + INDEX reduce 233 + TABLE shift 390 + TRIGGER shift 407 + UNIQUE shift 406 + VIEW shift 392 + uniqueflag shift 396 + +State 390: + create_table ::= CREATE temp TABLE * nm + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + + ID shift 20 + JOIN_KW shift 22 + STRING shift 21 + nm shift 391 + +State 391: + (16) create_table ::= CREATE temp TABLE nm * + + {default} reduce 16 + +State 392: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + cmd ::= CREATE temp VIEW * nm AS select + + ID shift 20 + JOIN_KW shift 22 + STRING shift 21 + nm shift 393 + +State 393: + cmd ::= CREATE temp VIEW nm * AS select + + AS shift 394 + +State 394: + cmd ::= CREATE temp VIEW nm AS * select + select ::= * oneselect + select ::= * select multiselect_op oneselect + oneselect ::= * SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt + + SELECT shift 73 + oneselect shift 69 + select shift 395 + +State 395: + (98) cmd ::= CREATE temp VIEW nm AS select * + select ::= select * multiselect_op oneselect + multiselect_op ::= * UNION + multiselect_op ::= * UNION ALL + multiselect_op ::= * INTERSECT + multiselect_op ::= * EXCEPT + + EXCEPT shift 170 + INTERSECT shift 169 + SEMI reduce 98 + UNION shift 167 + multiselect_op shift 71 + +State 396: + cmd ::= CREATE temp uniqueflag * INDEX nm ON nm dbnm LP idxlist RP onconf + + INDEX shift 397 + +State 397: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + cmd ::= CREATE temp uniqueflag INDEX * nm ON nm dbnm LP idxlist RP onconf + + ID shift 20 + JOIN_KW shift 22 + STRING shift 21 + nm shift 398 + +State 398: + cmd ::= CREATE temp uniqueflag INDEX nm * ON nm dbnm LP idxlist RP onconf + + ON shift 399 + +State 399: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + cmd ::= CREATE temp uniqueflag INDEX nm ON * nm dbnm LP idxlist RP onconf + + ID shift 20 + JOIN_KW shift 22 + STRING shift 21 + nm shift 400 + +State 400: + (125) dbnm ::= * + dbnm ::= * DOT nm + cmd ::= CREATE temp uniqueflag INDEX nm ON nm * dbnm LP idxlist RP onconf + + DOT shift 275 + LP reduce 125 + dbnm shift 401 + +State 401: + cmd ::= CREATE temp uniqueflag INDEX nm ON nm dbnm * LP idxlist RP onconf + + LP shift 402 + +State 402: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + cmd ::= CREATE temp uniqueflag INDEX nm ON nm dbnm LP * idxlist RP onconf + idxlist ::= * idxlist COMMA idxitem + idxlist ::= * idxitem + idxitem ::= * nm sortorder + + ID shift 20 + JOIN_KW shift 22 + STRING shift 21 + idxitem shift 272 + idxlist shift 403 + nm shift 270 + +State 403: + cmd ::= CREATE temp uniqueflag INDEX nm ON nm dbnm LP idxlist * RP onconf + idxlist ::= idxlist * COMMA idxitem + + COMMA shift 268 + RP shift 404 + +State 404: + (88) onconf ::= * + onconf ::= * ON CONFLICT resolvetype + cmd ::= CREATE temp uniqueflag INDEX nm ON nm dbnm LP idxlist RP * onconf + + ON shift 10 + SEMI reduce 88 + onconf shift 405 + +State 405: + (231) cmd ::= CREATE temp uniqueflag INDEX nm ON nm dbnm LP idxlist RP onconf * + + SEMI reduce 231 + +State 406: + (232) uniqueflag ::= UNIQUE * + + INDEX reduce 232 + +State 407: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + trigger_decl ::= temp TRIGGER * nm trigger_time trigger_event ON nm dbnm foreach_clause when_clause + + ID shift 20 + JOIN_KW shift 22 + STRING shift 21 + nm shift 408 + +State 408: + trigger_decl ::= temp TRIGGER nm * trigger_time trigger_event ON nm dbnm foreach_clause when_clause + trigger_time ::= * BEFORE + trigger_time ::= * AFTER + trigger_time ::= * INSTEAD OF + (261) trigger_time ::= * + + AFTER shift 431 + BEFORE shift 430 + INSTEAD shift 432 + trigger_time shift 409 + {default} reduce 261 + +State 409: + trigger_decl ::= temp TRIGGER nm trigger_time * trigger_event ON nm dbnm foreach_clause when_clause + trigger_event ::= * DELETE + trigger_event ::= * INSERT + trigger_event ::= * UPDATE + trigger_event ::= * UPDATE OF inscollist + + DELETE shift 422 + INSERT shift 423 + UPDATE shift 424 + trigger_event shift 410 + +State 410: + trigger_decl ::= temp TRIGGER nm trigger_time trigger_event * ON nm dbnm foreach_clause when_clause + + ON shift 411 + +State 411: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + trigger_decl ::= temp TRIGGER nm trigger_time trigger_event ON * nm dbnm foreach_clause when_clause + + ID shift 20 + JOIN_KW shift 22 + STRING shift 21 + nm shift 412 + +State 412: + (125) dbnm ::= * + dbnm ::= * DOT nm + trigger_decl ::= temp TRIGGER nm trigger_time trigger_event ON nm * dbnm foreach_clause when_clause + + DOT shift 275 + dbnm shift 413 + {default} reduce 125 + +State 413: + trigger_decl ::= temp TRIGGER nm trigger_time trigger_event ON nm dbnm * foreach_clause when_clause + (266) foreach_clause ::= * + foreach_clause ::= * FOR EACH ROW + foreach_clause ::= * FOR EACH STATEMENT + + FOR shift 418 + foreach_clause shift 414 + {default} reduce 266 + +State 414: + trigger_decl ::= temp TRIGGER nm trigger_time trigger_event ON nm dbnm foreach_clause * when_clause + (269) when_clause ::= * + when_clause ::= * WHEN expr + + BEGIN reduce 269 + WHEN shift 416 + when_clause shift 415 + +State 415: + (257) trigger_decl ::= temp TRIGGER nm trigger_time trigger_event ON nm dbnm foreach_clause when_clause * + + BEGIN reduce 257 + +State 416: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + expr ::= * LP expr RP + expr ::= * NULL + expr ::= * ID + expr ::= * JOIN_KW + expr ::= * nm DOT nm + expr ::= * nm DOT nm DOT nm + expr ::= * expr ORACLE_OUTER_JOIN + expr ::= * INTEGER + expr ::= * FLOAT + expr ::= * STRING + expr ::= * ID LP exprlist RP + expr ::= * ID LP STAR RP + expr ::= * expr AND expr + expr ::= * expr OR expr + expr ::= * expr LT expr + expr ::= * expr GT expr + expr ::= * expr LE expr + expr ::= * expr GE expr + expr ::= * expr NE expr + expr ::= * expr EQ expr + expr ::= * expr BITAND expr + expr ::= * expr BITOR expr + expr ::= * expr LSHIFT expr + expr ::= * expr RSHIFT expr + expr ::= * expr likeop expr + expr ::= * expr NOT likeop expr + expr ::= * expr PLUS expr + expr ::= * expr MINUS expr + expr ::= * expr STAR expr + expr ::= * expr SLASH expr + expr ::= * expr REM expr + expr ::= * expr CONCAT expr + expr ::= * expr ISNULL + expr ::= * expr IS NULL + expr ::= * expr NOTNULL + expr ::= * expr NOT NULL + expr ::= * expr IS NOT NULL + expr ::= * NOT expr + expr ::= * BITNOT expr + expr ::= * MINUS expr + expr ::= * PLUS expr + expr ::= * LP select RP + expr ::= * expr BETWEEN expr AND expr + expr ::= * expr NOT BETWEEN expr AND expr + expr ::= * expr IN LP exprlist RP + expr ::= * expr IN LP select RP + expr ::= * expr NOT IN LP exprlist RP + expr ::= * expr NOT IN LP select RP + expr ::= * CASE case_operand case_exprlist case_else END + when_clause ::= WHEN * expr + expr ::= * RAISE LP IGNORE RP + expr ::= * RAISE LP ROLLBACK COMMA nm RP + expr ::= * RAISE LP ABORT COMMA nm RP + expr ::= * RAISE LP FAIL COMMA nm RP + + BITNOT shift 177 + CASE shift 183 + FLOAT shift 174 + ID shift 64 + INTEGER shift 173 + JOIN_KW shift 67 + LP shift 68 + MINUS shift 179 + NOT shift 175 + NULL shift 106 + PLUS shift 181 + RAISE shift 193 + STRING shift 66 + expr shift 417 + nm shift 107 + +State 417: + expr ::= expr * ORACLE_OUTER_JOIN + expr ::= expr * AND expr + expr ::= expr * OR expr + expr ::= expr * LT expr + expr ::= expr * GT expr + expr ::= expr * LE expr + expr ::= expr * GE expr + expr ::= expr * NE expr + expr ::= expr * EQ expr + expr ::= expr * BITAND expr + expr ::= expr * BITOR expr + expr ::= expr * LSHIFT expr + expr ::= expr * RSHIFT expr + expr ::= expr * likeop expr + expr ::= expr * NOT likeop expr + likeop ::= * LIKE + likeop ::= * GLOB + expr ::= expr * PLUS expr + expr ::= expr * MINUS expr + expr ::= expr * STAR expr + expr ::= expr * SLASH expr + expr ::= expr * REM expr + expr ::= expr * CONCAT expr + expr ::= expr * ISNULL + expr ::= expr * IS NULL + expr ::= expr * NOTNULL + expr ::= expr * NOT NULL + expr ::= expr * IS NOT NULL + expr ::= expr * BETWEEN expr AND expr + expr ::= expr * NOT BETWEEN expr AND expr + expr ::= expr * IN LP exprlist RP + expr ::= expr * IN LP select RP + expr ::= expr * NOT IN LP exprlist RP + expr ::= expr * NOT IN LP select RP + (270) when_clause ::= WHEN expr * + + AND shift 105 + BEGIN reduce 270 + BETWEEN shift 160 + BITAND shift 127 + BITOR shift 129 + CONCAT shift 152 + EQ shift 125 + GE shift 121 + GLOB shift 141 + GT shift 117 + IN shift 164 + IS shift 155 + ISNULL shift 154 + LE shift 119 + LIKE shift 140 + LSHIFT shift 131 + LT shift 115 + MINUS shift 144 + NE shift 123 + NOT shift 137 + NOTNULL shift 159 + OR shift 113 + ORACLE_OUTER_JOIN shift 104 + PLUS shift 142 + REM shift 150 + RSHIFT shift 133 + SLASH shift 148 + STAR shift 146 + likeop shift 135 + +State 418: + foreach_clause ::= FOR * EACH ROW + foreach_clause ::= FOR * EACH STATEMENT + + EACH shift 419 + +State 419: + foreach_clause ::= FOR EACH * ROW + foreach_clause ::= FOR EACH * STATEMENT + + ROW shift 420 + STATEMENT shift 421 + +State 420: + (267) foreach_clause ::= FOR EACH ROW * + + {default} reduce 267 + +State 421: + (268) foreach_clause ::= FOR EACH STATEMENT * + + {default} reduce 268 + +State 422: + (262) trigger_event ::= DELETE * + + ON reduce 262 + +State 423: + (263) trigger_event ::= INSERT * + + ON reduce 263 + +State 424: + (264) trigger_event ::= UPDATE * + trigger_event ::= UPDATE * OF inscollist + + OF shift 425 + ON reduce 264 + +State 425: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + inscollist ::= * inscollist COMMA nm + inscollist ::= * nm + trigger_event ::= UPDATE OF * inscollist + + ID shift 20 + JOIN_KW shift 22 + STRING shift 21 + inscollist shift 426 + nm shift 429 + +State 426: + inscollist ::= inscollist * COMMA nm + (265) trigger_event ::= UPDATE OF inscollist * + + COMMA shift 427 + ON reduce 265 + +State 427: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + inscollist ::= inscollist COMMA * nm + + ID shift 20 + JOIN_KW shift 22 + STRING shift 21 + nm shift 428 + +State 428: + (168) inscollist ::= inscollist COMMA nm * + + {default} reduce 168 + +State 429: + (169) inscollist ::= nm * + + {default} reduce 169 + +State 430: + (258) trigger_time ::= BEFORE * + + {default} reduce 258 + +State 431: + (259) trigger_time ::= AFTER * + + {default} reduce 259 + +State 432: + trigger_time ::= INSTEAD * OF + + OF shift 433 + +State 433: + (260) trigger_time ::= INSTEAD OF * + + {default} reduce 260 + +State 434: + (17) temp ::= TEMP * + + {default} reduce 17 + +State 435: + cmd ::= CREATE trigger_decl * BEGIN trigger_cmd_list END + + BEGIN shift 436 + +State 436: + select ::= * oneselect + select ::= * select multiselect_op oneselect + oneselect ::= * SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt + cmd ::= CREATE trigger_decl BEGIN * trigger_cmd_list END + trigger_cmd_list ::= * trigger_cmd SEMI trigger_cmd_list + (272) trigger_cmd_list ::= * + trigger_cmd ::= * UPDATE orconf nm SET setlist where_opt + trigger_cmd ::= * INSERT orconf INTO nm inscollist_opt VALUES LP itemlist RP + trigger_cmd ::= * INSERT orconf INTO nm inscollist_opt select + trigger_cmd ::= * DELETE FROM nm where_opt + trigger_cmd ::= * select + + DELETE shift 474 + END reduce 272 + INSERT shift 458 + SELECT shift 73 + UPDATE shift 443 + oneselect shift 69 + select shift 437 + trigger_cmd shift 440 + trigger_cmd_list shift 438 + +State 437: + select ::= select * multiselect_op oneselect + multiselect_op ::= * UNION + multiselect_op ::= * UNION ALL + multiselect_op ::= * INTERSECT + multiselect_op ::= * EXCEPT + (277) trigger_cmd ::= select * + + EXCEPT shift 170 + INTERSECT shift 169 + SEMI reduce 277 + UNION shift 167 + multiselect_op shift 71 + +State 438: + cmd ::= CREATE trigger_decl BEGIN trigger_cmd_list * END + + END shift 439 + +State 439: + (256) cmd ::= CREATE trigger_decl BEGIN trigger_cmd_list END * + + SEMI reduce 256 + +State 440: + trigger_cmd_list ::= trigger_cmd * SEMI trigger_cmd_list + + SEMI shift 441 + +State 441: + select ::= * oneselect + select ::= * select multiselect_op oneselect + oneselect ::= * SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt + trigger_cmd_list ::= * trigger_cmd SEMI trigger_cmd_list + trigger_cmd_list ::= trigger_cmd SEMI * trigger_cmd_list + (272) trigger_cmd_list ::= * + trigger_cmd ::= * UPDATE orconf nm SET setlist where_opt + trigger_cmd ::= * INSERT orconf INTO nm inscollist_opt VALUES LP itemlist RP + trigger_cmd ::= * INSERT orconf INTO nm inscollist_opt select + trigger_cmd ::= * DELETE FROM nm where_opt + trigger_cmd ::= * select + + DELETE shift 474 + END reduce 272 + INSERT shift 458 + SELECT shift 73 + UPDATE shift 443 + oneselect shift 69 + select shift 437 + trigger_cmd shift 440 + trigger_cmd_list shift 442 + +State 442: + (271) trigger_cmd_list ::= trigger_cmd SEMI trigger_cmd_list * + + END reduce 271 + +State 443: + (90) orconf ::= * + orconf ::= * OR resolvetype + trigger_cmd ::= UPDATE * orconf nm SET setlist where_opt + + OR shift 444 + orconf shift 446 + {default} reduce 90 + +State 444: + orconf ::= OR * resolvetype + resolvetype ::= * ROLLBACK + resolvetype ::= * ABORT + resolvetype ::= * FAIL + resolvetype ::= * IGNORE + resolvetype ::= * REPLACE + + ABORT shift 14 + FAIL shift 15 + IGNORE shift 16 + REPLACE shift 17 + ROLLBACK shift 13 + resolvetype shift 445 + +State 445: + (91) orconf ::= OR resolvetype * + + {default} reduce 91 + +State 446: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + trigger_cmd ::= UPDATE orconf * nm SET setlist where_opt + + ID shift 20 + JOIN_KW shift 22 + STRING shift 21 + nm shift 447 + +State 447: + trigger_cmd ::= UPDATE orconf nm * SET setlist where_opt + + SET shift 448 + +State 448: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + setlist ::= * setlist COMMA nm EQ expr + setlist ::= * nm EQ expr + trigger_cmd ::= UPDATE orconf nm SET * setlist where_opt + + ID shift 20 + JOIN_KW shift 22 + STRING shift 21 + nm shift 455 + setlist shift 449 + +State 449: + (155) where_opt ::= * + where_opt ::= * WHERE expr + setlist ::= setlist * COMMA nm EQ expr + trigger_cmd ::= UPDATE orconf nm SET setlist * where_opt + + COMMA shift 450 + SEMI reduce 155 + WHERE shift 239 + where_opt shift 454 + +State 450: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + setlist ::= setlist COMMA * nm EQ expr + + ID shift 20 + JOIN_KW shift 22 + STRING shift 21 + nm shift 451 + +State 451: + setlist ::= setlist COMMA nm * EQ expr + + EQ shift 452 + +State 452: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + setlist ::= setlist COMMA nm EQ * expr + expr ::= * LP expr RP + expr ::= * NULL + expr ::= * ID + expr ::= * JOIN_KW + expr ::= * nm DOT nm + expr ::= * nm DOT nm DOT nm + expr ::= * expr ORACLE_OUTER_JOIN + expr ::= * INTEGER + expr ::= * FLOAT + expr ::= * STRING + expr ::= * ID LP exprlist RP + expr ::= * ID LP STAR RP + expr ::= * expr AND expr + expr ::= * expr OR expr + expr ::= * expr LT expr + expr ::= * expr GT expr + expr ::= * expr LE expr + expr ::= * expr GE expr + expr ::= * expr NE expr + expr ::= * expr EQ expr + expr ::= * expr BITAND expr + expr ::= * expr BITOR expr + expr ::= * expr LSHIFT expr + expr ::= * expr RSHIFT expr + expr ::= * expr likeop expr + expr ::= * expr NOT likeop expr + expr ::= * expr PLUS expr + expr ::= * expr MINUS expr + expr ::= * expr STAR expr + expr ::= * expr SLASH expr + expr ::= * expr REM expr + expr ::= * expr CONCAT expr + expr ::= * expr ISNULL + expr ::= * expr IS NULL + expr ::= * expr NOTNULL + expr ::= * expr NOT NULL + expr ::= * expr IS NOT NULL + expr ::= * NOT expr + expr ::= * BITNOT expr + expr ::= * MINUS expr + expr ::= * PLUS expr + expr ::= * LP select RP + expr ::= * expr BETWEEN expr AND expr + expr ::= * expr NOT BETWEEN expr AND expr + expr ::= * expr IN LP exprlist RP + expr ::= * expr IN LP select RP + expr ::= * expr NOT IN LP exprlist RP + expr ::= * expr NOT IN LP select RP + expr ::= * CASE case_operand case_exprlist case_else END + expr ::= * RAISE LP IGNORE RP + expr ::= * RAISE LP ROLLBACK COMMA nm RP + expr ::= * RAISE LP ABORT COMMA nm RP + expr ::= * RAISE LP FAIL COMMA nm RP + + BITNOT shift 177 + CASE shift 183 + FLOAT shift 174 + ID shift 64 + INTEGER shift 173 + JOIN_KW shift 67 + LP shift 68 + MINUS shift 179 + NOT shift 175 + NULL shift 106 + PLUS shift 181 + RAISE shift 193 + STRING shift 66 + expr shift 453 + nm shift 107 + +State 453: + (158) setlist ::= setlist COMMA nm EQ expr * + expr ::= expr * ORACLE_OUTER_JOIN + expr ::= expr * AND expr + expr ::= expr * OR expr + expr ::= expr * LT expr + expr ::= expr * GT expr + expr ::= expr * LE expr + expr ::= expr * GE expr + expr ::= expr * NE expr + expr ::= expr * EQ expr + expr ::= expr * BITAND expr + expr ::= expr * BITOR expr + expr ::= expr * LSHIFT expr + expr ::= expr * RSHIFT expr + expr ::= expr * likeop expr + expr ::= expr * NOT likeop expr + likeop ::= * LIKE + likeop ::= * GLOB + expr ::= expr * PLUS expr + expr ::= expr * MINUS expr + expr ::= expr * STAR expr + expr ::= expr * SLASH expr + expr ::= expr * REM expr + expr ::= expr * CONCAT expr + expr ::= expr * ISNULL + expr ::= expr * IS NULL + expr ::= expr * NOTNULL + expr ::= expr * NOT NULL + expr ::= expr * IS NOT NULL + expr ::= expr * BETWEEN expr AND expr + expr ::= expr * NOT BETWEEN expr AND expr + expr ::= expr * IN LP exprlist RP + expr ::= expr * IN LP select RP + expr ::= expr * NOT IN LP exprlist RP + expr ::= expr * NOT IN LP select RP + + AND shift 105 + BETWEEN shift 160 + BITAND shift 127 + BITOR shift 129 + CONCAT shift 152 + EQ shift 125 + GE shift 121 + GLOB shift 141 + GT shift 117 + IN shift 164 + IS shift 155 + ISNULL shift 154 + LE shift 119 + LIKE shift 140 + LSHIFT shift 131 + LT shift 115 + MINUS shift 144 + NE shift 123 + NOT shift 137 + NOTNULL shift 159 + OR shift 113 + ORACLE_OUTER_JOIN shift 104 + PLUS shift 142 + REM shift 150 + RSHIFT shift 133 + SLASH shift 148 + STAR shift 146 + likeop shift 135 + {default} reduce 158 + +State 454: + (273) trigger_cmd ::= UPDATE orconf nm SET setlist where_opt * + + SEMI reduce 273 + +State 455: + setlist ::= nm * EQ expr + + EQ shift 456 + +State 456: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + setlist ::= nm EQ * expr + expr ::= * LP expr RP + expr ::= * NULL + expr ::= * ID + expr ::= * JOIN_KW + expr ::= * nm DOT nm + expr ::= * nm DOT nm DOT nm + expr ::= * expr ORACLE_OUTER_JOIN + expr ::= * INTEGER + expr ::= * FLOAT + expr ::= * STRING + expr ::= * ID LP exprlist RP + expr ::= * ID LP STAR RP + expr ::= * expr AND expr + expr ::= * expr OR expr + expr ::= * expr LT expr + expr ::= * expr GT expr + expr ::= * expr LE expr + expr ::= * expr GE expr + expr ::= * expr NE expr + expr ::= * expr EQ expr + expr ::= * expr BITAND expr + expr ::= * expr BITOR expr + expr ::= * expr LSHIFT expr + expr ::= * expr RSHIFT expr + expr ::= * expr likeop expr + expr ::= * expr NOT likeop expr + expr ::= * expr PLUS expr + expr ::= * expr MINUS expr + expr ::= * expr STAR expr + expr ::= * expr SLASH expr + expr ::= * expr REM expr + expr ::= * expr CONCAT expr + expr ::= * expr ISNULL + expr ::= * expr IS NULL + expr ::= * expr NOTNULL + expr ::= * expr NOT NULL + expr ::= * expr IS NOT NULL + expr ::= * NOT expr + expr ::= * BITNOT expr + expr ::= * MINUS expr + expr ::= * PLUS expr + expr ::= * LP select RP + expr ::= * expr BETWEEN expr AND expr + expr ::= * expr NOT BETWEEN expr AND expr + expr ::= * expr IN LP exprlist RP + expr ::= * expr IN LP select RP + expr ::= * expr NOT IN LP exprlist RP + expr ::= * expr NOT IN LP select RP + expr ::= * CASE case_operand case_exprlist case_else END + expr ::= * RAISE LP IGNORE RP + expr ::= * RAISE LP ROLLBACK COMMA nm RP + expr ::= * RAISE LP ABORT COMMA nm RP + expr ::= * RAISE LP FAIL COMMA nm RP + + BITNOT shift 177 + CASE shift 183 + FLOAT shift 174 + ID shift 64 + INTEGER shift 173 + JOIN_KW shift 67 + LP shift 68 + MINUS shift 179 + NOT shift 175 + NULL shift 106 + PLUS shift 181 + RAISE shift 193 + STRING shift 66 + expr shift 457 + nm shift 107 + +State 457: + (159) setlist ::= nm EQ expr * + expr ::= expr * ORACLE_OUTER_JOIN + expr ::= expr * AND expr + expr ::= expr * OR expr + expr ::= expr * LT expr + expr ::= expr * GT expr + expr ::= expr * LE expr + expr ::= expr * GE expr + expr ::= expr * NE expr + expr ::= expr * EQ expr + expr ::= expr * BITAND expr + expr ::= expr * BITOR expr + expr ::= expr * LSHIFT expr + expr ::= expr * RSHIFT expr + expr ::= expr * likeop expr + expr ::= expr * NOT likeop expr + likeop ::= * LIKE + likeop ::= * GLOB + expr ::= expr * PLUS expr + expr ::= expr * MINUS expr + expr ::= expr * STAR expr + expr ::= expr * SLASH expr + expr ::= expr * REM expr + expr ::= expr * CONCAT expr + expr ::= expr * ISNULL + expr ::= expr * IS NULL + expr ::= expr * NOTNULL + expr ::= expr * NOT NULL + expr ::= expr * IS NOT NULL + expr ::= expr * BETWEEN expr AND expr + expr ::= expr * NOT BETWEEN expr AND expr + expr ::= expr * IN LP exprlist RP + expr ::= expr * IN LP select RP + expr ::= expr * NOT IN LP exprlist RP + expr ::= expr * NOT IN LP select RP + + AND shift 105 + BETWEEN shift 160 + BITAND shift 127 + BITOR shift 129 + CONCAT shift 152 + EQ shift 125 + GE shift 121 + GLOB shift 141 + GT shift 117 + IN shift 164 + IS shift 155 + ISNULL shift 154 + LE shift 119 + LIKE shift 140 + LSHIFT shift 131 + LT shift 115 + MINUS shift 144 + NE shift 123 + NOT shift 137 + NOTNULL shift 159 + OR shift 113 + ORACLE_OUTER_JOIN shift 104 + PLUS shift 142 + REM shift 150 + RSHIFT shift 133 + SLASH shift 148 + STAR shift 146 + likeop shift 135 + {default} reduce 159 + +State 458: + (90) orconf ::= * + orconf ::= * OR resolvetype + trigger_cmd ::= INSERT * orconf INTO nm inscollist_opt VALUES LP itemlist RP + trigger_cmd ::= INSERT * orconf INTO nm inscollist_opt select + + INTO reduce 90 + OR shift 444 + orconf shift 459 + +State 459: + trigger_cmd ::= INSERT orconf * INTO nm inscollist_opt VALUES LP itemlist RP + trigger_cmd ::= INSERT orconf * INTO nm inscollist_opt select + + INTO shift 460 + +State 460: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + trigger_cmd ::= INSERT orconf INTO * nm inscollist_opt VALUES LP itemlist RP + trigger_cmd ::= INSERT orconf INTO * nm inscollist_opt select + + ID shift 20 + JOIN_KW shift 22 + STRING shift 21 + nm shift 461 + +State 461: + (166) inscollist_opt ::= * + inscollist_opt ::= * LP inscollist RP + trigger_cmd ::= INSERT orconf INTO nm * inscollist_opt VALUES LP itemlist RP + trigger_cmd ::= INSERT orconf INTO nm * inscollist_opt select + + LP shift 462 + inscollist_opt shift 465 + {default} reduce 166 + +State 462: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + inscollist_opt ::= LP * inscollist RP + inscollist ::= * inscollist COMMA nm + inscollist ::= * nm + + ID shift 20 + JOIN_KW shift 22 + STRING shift 21 + inscollist shift 463 + nm shift 429 + +State 463: + inscollist_opt ::= LP inscollist * RP + inscollist ::= inscollist * COMMA nm + + COMMA shift 427 + RP shift 464 + +State 464: + (167) inscollist_opt ::= LP inscollist RP * + + {default} reduce 167 + +State 465: + select ::= * oneselect + select ::= * select multiselect_op oneselect + oneselect ::= * SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt + trigger_cmd ::= INSERT orconf INTO nm inscollist_opt * VALUES LP itemlist RP + trigger_cmd ::= INSERT orconf INTO nm inscollist_opt * select + + SELECT shift 73 + VALUES shift 467 + oneselect shift 69 + select shift 466 + +State 466: + select ::= select * multiselect_op oneselect + multiselect_op ::= * UNION + multiselect_op ::= * UNION ALL + multiselect_op ::= * INTERSECT + multiselect_op ::= * EXCEPT + (275) trigger_cmd ::= INSERT orconf INTO nm inscollist_opt select * + + EXCEPT shift 170 + INTERSECT shift 169 + SEMI reduce 275 + UNION shift 167 + multiselect_op shift 71 + +State 467: + trigger_cmd ::= INSERT orconf INTO nm inscollist_opt VALUES * LP itemlist RP + + LP shift 468 + +State 468: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + itemlist ::= * itemlist COMMA expr + itemlist ::= * expr + expr ::= * LP expr RP + expr ::= * NULL + expr ::= * ID + expr ::= * JOIN_KW + expr ::= * nm DOT nm + expr ::= * nm DOT nm DOT nm + expr ::= * expr ORACLE_OUTER_JOIN + expr ::= * INTEGER + expr ::= * FLOAT + expr ::= * STRING + expr ::= * ID LP exprlist RP + expr ::= * ID LP STAR RP + expr ::= * expr AND expr + expr ::= * expr OR expr + expr ::= * expr LT expr + expr ::= * expr GT expr + expr ::= * expr LE expr + expr ::= * expr GE expr + expr ::= * expr NE expr + expr ::= * expr EQ expr + expr ::= * expr BITAND expr + expr ::= * expr BITOR expr + expr ::= * expr LSHIFT expr + expr ::= * expr RSHIFT expr + expr ::= * expr likeop expr + expr ::= * expr NOT likeop expr + expr ::= * expr PLUS expr + expr ::= * expr MINUS expr + expr ::= * expr STAR expr + expr ::= * expr SLASH expr + expr ::= * expr REM expr + expr ::= * expr CONCAT expr + expr ::= * expr ISNULL + expr ::= * expr IS NULL + expr ::= * expr NOTNULL + expr ::= * expr NOT NULL + expr ::= * expr IS NOT NULL + expr ::= * NOT expr + expr ::= * BITNOT expr + expr ::= * MINUS expr + expr ::= * PLUS expr + expr ::= * LP select RP + expr ::= * expr BETWEEN expr AND expr + expr ::= * expr NOT BETWEEN expr AND expr + expr ::= * expr IN LP exprlist RP + expr ::= * expr IN LP select RP + expr ::= * expr NOT IN LP exprlist RP + expr ::= * expr NOT IN LP select RP + expr ::= * CASE case_operand case_exprlist case_else END + trigger_cmd ::= INSERT orconf INTO nm inscollist_opt VALUES LP * itemlist RP + expr ::= * RAISE LP IGNORE RP + expr ::= * RAISE LP ROLLBACK COMMA nm RP + expr ::= * RAISE LP ABORT COMMA nm RP + expr ::= * RAISE LP FAIL COMMA nm RP + + BITNOT shift 177 + CASE shift 183 + FLOAT shift 174 + ID shift 64 + INTEGER shift 173 + JOIN_KW shift 67 + LP shift 68 + MINUS shift 179 + NOT shift 175 + NULL shift 106 + PLUS shift 181 + RAISE shift 193 + STRING shift 66 + expr shift 473 + itemlist shift 469 + nm shift 107 + +State 469: + itemlist ::= itemlist * COMMA expr + trigger_cmd ::= INSERT orconf INTO nm inscollist_opt VALUES LP itemlist * RP + + COMMA shift 470 + RP shift 472 + +State 470: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + itemlist ::= itemlist COMMA * expr + expr ::= * LP expr RP + expr ::= * NULL + expr ::= * ID + expr ::= * JOIN_KW + expr ::= * nm DOT nm + expr ::= * nm DOT nm DOT nm + expr ::= * expr ORACLE_OUTER_JOIN + expr ::= * INTEGER + expr ::= * FLOAT + expr ::= * STRING + expr ::= * ID LP exprlist RP + expr ::= * ID LP STAR RP + expr ::= * expr AND expr + expr ::= * expr OR expr + expr ::= * expr LT expr + expr ::= * expr GT expr + expr ::= * expr LE expr + expr ::= * expr GE expr + expr ::= * expr NE expr + expr ::= * expr EQ expr + expr ::= * expr BITAND expr + expr ::= * expr BITOR expr + expr ::= * expr LSHIFT expr + expr ::= * expr RSHIFT expr + expr ::= * expr likeop expr + expr ::= * expr NOT likeop expr + expr ::= * expr PLUS expr + expr ::= * expr MINUS expr + expr ::= * expr STAR expr + expr ::= * expr SLASH expr + expr ::= * expr REM expr + expr ::= * expr CONCAT expr + expr ::= * expr ISNULL + expr ::= * expr IS NULL + expr ::= * expr NOTNULL + expr ::= * expr NOT NULL + expr ::= * expr IS NOT NULL + expr ::= * NOT expr + expr ::= * BITNOT expr + expr ::= * MINUS expr + expr ::= * PLUS expr + expr ::= * LP select RP + expr ::= * expr BETWEEN expr AND expr + expr ::= * expr NOT BETWEEN expr AND expr + expr ::= * expr IN LP exprlist RP + expr ::= * expr IN LP select RP + expr ::= * expr NOT IN LP exprlist RP + expr ::= * expr NOT IN LP select RP + expr ::= * CASE case_operand case_exprlist case_else END + expr ::= * RAISE LP IGNORE RP + expr ::= * RAISE LP ROLLBACK COMMA nm RP + expr ::= * RAISE LP ABORT COMMA nm RP + expr ::= * RAISE LP FAIL COMMA nm RP + + BITNOT shift 177 + CASE shift 183 + FLOAT shift 174 + ID shift 64 + INTEGER shift 173 + JOIN_KW shift 67 + LP shift 68 + MINUS shift 179 + NOT shift 175 + NULL shift 106 + PLUS shift 181 + RAISE shift 193 + STRING shift 66 + expr shift 471 + nm shift 107 + +State 471: + (164) itemlist ::= itemlist COMMA expr * + expr ::= expr * ORACLE_OUTER_JOIN + expr ::= expr * AND expr + expr ::= expr * OR expr + expr ::= expr * LT expr + expr ::= expr * GT expr + expr ::= expr * LE expr + expr ::= expr * GE expr + expr ::= expr * NE expr + expr ::= expr * EQ expr + expr ::= expr * BITAND expr + expr ::= expr * BITOR expr + expr ::= expr * LSHIFT expr + expr ::= expr * RSHIFT expr + expr ::= expr * likeop expr + expr ::= expr * NOT likeop expr + likeop ::= * LIKE + likeop ::= * GLOB + expr ::= expr * PLUS expr + expr ::= expr * MINUS expr + expr ::= expr * STAR expr + expr ::= expr * SLASH expr + expr ::= expr * REM expr + expr ::= expr * CONCAT expr + expr ::= expr * ISNULL + expr ::= expr * IS NULL + expr ::= expr * NOTNULL + expr ::= expr * NOT NULL + expr ::= expr * IS NOT NULL + expr ::= expr * BETWEEN expr AND expr + expr ::= expr * NOT BETWEEN expr AND expr + expr ::= expr * IN LP exprlist RP + expr ::= expr * IN LP select RP + expr ::= expr * NOT IN LP exprlist RP + expr ::= expr * NOT IN LP select RP + + AND shift 105 + BETWEEN shift 160 + BITAND shift 127 + BITOR shift 129 + CONCAT shift 152 + EQ shift 125 + GE shift 121 + GLOB shift 141 + GT shift 117 + IN shift 164 + IS shift 155 + ISNULL shift 154 + LE shift 119 + LIKE shift 140 + LSHIFT shift 131 + LT shift 115 + MINUS shift 144 + NE shift 123 + NOT shift 137 + NOTNULL shift 159 + OR shift 113 + ORACLE_OUTER_JOIN shift 104 + PLUS shift 142 + REM shift 150 + RSHIFT shift 133 + SLASH shift 148 + STAR shift 146 + likeop shift 135 + {default} reduce 164 + +State 472: + (274) trigger_cmd ::= INSERT orconf INTO nm inscollist_opt VALUES LP itemlist RP * + + SEMI reduce 274 + +State 473: + (165) itemlist ::= expr * + expr ::= expr * ORACLE_OUTER_JOIN + expr ::= expr * AND expr + expr ::= expr * OR expr + expr ::= expr * LT expr + expr ::= expr * GT expr + expr ::= expr * LE expr + expr ::= expr * GE expr + expr ::= expr * NE expr + expr ::= expr * EQ expr + expr ::= expr * BITAND expr + expr ::= expr * BITOR expr + expr ::= expr * LSHIFT expr + expr ::= expr * RSHIFT expr + expr ::= expr * likeop expr + expr ::= expr * NOT likeop expr + likeop ::= * LIKE + likeop ::= * GLOB + expr ::= expr * PLUS expr + expr ::= expr * MINUS expr + expr ::= expr * STAR expr + expr ::= expr * SLASH expr + expr ::= expr * REM expr + expr ::= expr * CONCAT expr + expr ::= expr * ISNULL + expr ::= expr * IS NULL + expr ::= expr * NOTNULL + expr ::= expr * NOT NULL + expr ::= expr * IS NOT NULL + expr ::= expr * BETWEEN expr AND expr + expr ::= expr * NOT BETWEEN expr AND expr + expr ::= expr * IN LP exprlist RP + expr ::= expr * IN LP select RP + expr ::= expr * NOT IN LP exprlist RP + expr ::= expr * NOT IN LP select RP + + AND shift 105 + BETWEEN shift 160 + BITAND shift 127 + BITOR shift 129 + CONCAT shift 152 + EQ shift 125 + GE shift 121 + GLOB shift 141 + GT shift 117 + IN shift 164 + IS shift 155 + ISNULL shift 154 + LE shift 119 + LIKE shift 140 + LSHIFT shift 131 + LT shift 115 + MINUS shift 144 + NE shift 123 + NOT shift 137 + NOTNULL shift 159 + OR shift 113 + ORACLE_OUTER_JOIN shift 104 + PLUS shift 142 + REM shift 150 + RSHIFT shift 133 + SLASH shift 148 + STAR shift 146 + likeop shift 135 + {default} reduce 165 + +State 474: + trigger_cmd ::= DELETE * FROM nm where_opt + + FROM shift 475 + +State 475: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + trigger_cmd ::= DELETE FROM * nm where_opt + + ID shift 20 + JOIN_KW shift 22 + STRING shift 21 + nm shift 476 + +State 476: + (155) where_opt ::= * + where_opt ::= * WHERE expr + trigger_cmd ::= DELETE FROM nm * where_opt + + SEMI reduce 155 + WHERE shift 239 + where_opt shift 477 + +State 477: + (276) trigger_cmd ::= DELETE FROM nm where_opt * + + SEMI reduce 276 + +State 478: + cmd ::= DROP * TABLE nm + cmd ::= DROP * VIEW nm + cmd ::= DROP * INDEX nm dbnm + cmd ::= DROP * TRIGGER nm dbnm + + INDEX shift 483 + TABLE shift 479 + TRIGGER shift 486 + VIEW shift 481 + +State 479: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + cmd ::= DROP TABLE * nm + + ID shift 20 + JOIN_KW shift 22 + STRING shift 21 + nm shift 480 + +State 480: + (97) cmd ::= DROP TABLE nm * + + SEMI reduce 97 + +State 481: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + cmd ::= DROP VIEW * nm + + ID shift 20 + JOIN_KW shift 22 + STRING shift 21 + nm shift 482 + +State 482: + (99) cmd ::= DROP VIEW nm * + + SEMI reduce 99 + +State 483: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + cmd ::= DROP INDEX * nm dbnm + + ID shift 20 + JOIN_KW shift 22 + STRING shift 21 + nm shift 484 + +State 484: + (125) dbnm ::= * + dbnm ::= * DOT nm + cmd ::= DROP INDEX nm * dbnm + + DOT shift 275 + SEMI reduce 125 + dbnm shift 485 + +State 485: + (239) cmd ::= DROP INDEX nm dbnm * + + SEMI reduce 239 + +State 486: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + cmd ::= DROP TRIGGER * nm dbnm + + ID shift 20 + JOIN_KW shift 22 + STRING shift 21 + nm shift 487 + +State 487: + (125) dbnm ::= * + dbnm ::= * DOT nm + cmd ::= DROP TRIGGER nm * dbnm + + DOT shift 275 + SEMI reduce 125 + dbnm shift 488 + +State 488: + (282) cmd ::= DROP TRIGGER nm dbnm * + + SEMI reduce 282 + +State 489: + (100) cmd ::= select * + select ::= select * multiselect_op oneselect + multiselect_op ::= * UNION + multiselect_op ::= * UNION ALL + multiselect_op ::= * INTERSECT + multiselect_op ::= * EXCEPT + + EXCEPT shift 170 + INTERSECT shift 169 + SEMI reduce 100 + UNION shift 167 + multiselect_op shift 71 + +State 490: + cmd ::= DELETE * FROM nm dbnm where_opt + + FROM shift 491 + +State 491: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + cmd ::= DELETE FROM * nm dbnm where_opt + + ID shift 20 + JOIN_KW shift 22 + STRING shift 21 + nm shift 492 + +State 492: + (125) dbnm ::= * + dbnm ::= * DOT nm + cmd ::= DELETE FROM nm * dbnm where_opt + + DOT shift 275 + dbnm shift 493 + {default} reduce 125 + +State 493: + cmd ::= DELETE FROM nm dbnm * where_opt + (155) where_opt ::= * + where_opt ::= * WHERE expr + + SEMI reduce 155 + WHERE shift 239 + where_opt shift 494 + +State 494: + (154) cmd ::= DELETE FROM nm dbnm where_opt * + + SEMI reduce 154 + +State 495: + (90) orconf ::= * + orconf ::= * OR resolvetype + cmd ::= UPDATE * orconf nm dbnm SET setlist where_opt + + OR shift 444 + orconf shift 496 + {default} reduce 90 + +State 496: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + cmd ::= UPDATE orconf * nm dbnm SET setlist where_opt + + ID shift 20 + JOIN_KW shift 22 + STRING shift 21 + nm shift 497 + +State 497: + (125) dbnm ::= * + dbnm ::= * DOT nm + cmd ::= UPDATE orconf nm * dbnm SET setlist where_opt + + DOT shift 275 + SET reduce 125 + dbnm shift 498 + +State 498: + cmd ::= UPDATE orconf nm dbnm * SET setlist where_opt + + SET shift 499 + +State 499: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + cmd ::= UPDATE orconf nm dbnm SET * setlist where_opt + setlist ::= * setlist COMMA nm EQ expr + setlist ::= * nm EQ expr + + ID shift 20 + JOIN_KW shift 22 + STRING shift 21 + nm shift 455 + setlist shift 500 + +State 500: + (155) where_opt ::= * + where_opt ::= * WHERE expr + cmd ::= UPDATE orconf nm dbnm SET setlist * where_opt + setlist ::= setlist * COMMA nm EQ expr + + COMMA shift 450 + SEMI reduce 155 + WHERE shift 239 + where_opt shift 501 + +State 501: + (157) cmd ::= UPDATE orconf nm dbnm SET setlist where_opt * + + SEMI reduce 157 + +State 502: + cmd ::= insert_cmd * INTO nm dbnm inscollist_opt VALUES LP itemlist RP + cmd ::= insert_cmd * INTO nm dbnm inscollist_opt select + + INTO shift 503 + +State 503: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + cmd ::= insert_cmd INTO * nm dbnm inscollist_opt VALUES LP itemlist RP + cmd ::= insert_cmd INTO * nm dbnm inscollist_opt select + + ID shift 20 + JOIN_KW shift 22 + STRING shift 21 + nm shift 504 + +State 504: + (125) dbnm ::= * + dbnm ::= * DOT nm + cmd ::= insert_cmd INTO nm * dbnm inscollist_opt VALUES LP itemlist RP + cmd ::= insert_cmd INTO nm * dbnm inscollist_opt select + + DOT shift 275 + dbnm shift 505 + {default} reduce 125 + +State 505: + cmd ::= insert_cmd INTO nm dbnm * inscollist_opt VALUES LP itemlist RP + cmd ::= insert_cmd INTO nm dbnm * inscollist_opt select + (166) inscollist_opt ::= * + inscollist_opt ::= * LP inscollist RP + + LP shift 462 + inscollist_opt shift 506 + {default} reduce 166 + +State 506: + select ::= * oneselect + select ::= * select multiselect_op oneselect + oneselect ::= * SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt + cmd ::= insert_cmd INTO nm dbnm inscollist_opt * VALUES LP itemlist RP + cmd ::= insert_cmd INTO nm dbnm inscollist_opt * select + + SELECT shift 73 + VALUES shift 508 + oneselect shift 69 + select shift 507 + +State 507: + select ::= select * multiselect_op oneselect + multiselect_op ::= * UNION + multiselect_op ::= * UNION ALL + multiselect_op ::= * INTERSECT + multiselect_op ::= * EXCEPT + (161) cmd ::= insert_cmd INTO nm dbnm inscollist_opt select * + + EXCEPT shift 170 + INTERSECT shift 169 + SEMI reduce 161 + UNION shift 167 + multiselect_op shift 71 + +State 508: + cmd ::= insert_cmd INTO nm dbnm inscollist_opt VALUES * LP itemlist RP + + LP shift 509 + +State 509: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + cmd ::= insert_cmd INTO nm dbnm inscollist_opt VALUES LP * itemlist RP + itemlist ::= * itemlist COMMA expr + itemlist ::= * expr + expr ::= * LP expr RP + expr ::= * NULL + expr ::= * ID + expr ::= * JOIN_KW + expr ::= * nm DOT nm + expr ::= * nm DOT nm DOT nm + expr ::= * expr ORACLE_OUTER_JOIN + expr ::= * INTEGER + expr ::= * FLOAT + expr ::= * STRING + expr ::= * ID LP exprlist RP + expr ::= * ID LP STAR RP + expr ::= * expr AND expr + expr ::= * expr OR expr + expr ::= * expr LT expr + expr ::= * expr GT expr + expr ::= * expr LE expr + expr ::= * expr GE expr + expr ::= * expr NE expr + expr ::= * expr EQ expr + expr ::= * expr BITAND expr + expr ::= * expr BITOR expr + expr ::= * expr LSHIFT expr + expr ::= * expr RSHIFT expr + expr ::= * expr likeop expr + expr ::= * expr NOT likeop expr + expr ::= * expr PLUS expr + expr ::= * expr MINUS expr + expr ::= * expr STAR expr + expr ::= * expr SLASH expr + expr ::= * expr REM expr + expr ::= * expr CONCAT expr + expr ::= * expr ISNULL + expr ::= * expr IS NULL + expr ::= * expr NOTNULL + expr ::= * expr NOT NULL + expr ::= * expr IS NOT NULL + expr ::= * NOT expr + expr ::= * BITNOT expr + expr ::= * MINUS expr + expr ::= * PLUS expr + expr ::= * LP select RP + expr ::= * expr BETWEEN expr AND expr + expr ::= * expr NOT BETWEEN expr AND expr + expr ::= * expr IN LP exprlist RP + expr ::= * expr IN LP select RP + expr ::= * expr NOT IN LP exprlist RP + expr ::= * expr NOT IN LP select RP + expr ::= * CASE case_operand case_exprlist case_else END + expr ::= * RAISE LP IGNORE RP + expr ::= * RAISE LP ROLLBACK COMMA nm RP + expr ::= * RAISE LP ABORT COMMA nm RP + expr ::= * RAISE LP FAIL COMMA nm RP + + BITNOT shift 177 + CASE shift 183 + FLOAT shift 174 + ID shift 64 + INTEGER shift 173 + JOIN_KW shift 67 + LP shift 68 + MINUS shift 179 + NOT shift 175 + NULL shift 106 + PLUS shift 181 + RAISE shift 193 + STRING shift 66 + expr shift 473 + itemlist shift 510 + nm shift 107 + +State 510: + cmd ::= insert_cmd INTO nm dbnm inscollist_opt VALUES LP itemlist * RP + itemlist ::= itemlist * COMMA expr + + COMMA shift 470 + RP shift 511 + +State 511: + (160) cmd ::= insert_cmd INTO nm dbnm inscollist_opt VALUES LP itemlist RP * + + SEMI reduce 160 + +State 512: + (90) orconf ::= * + orconf ::= * OR resolvetype + insert_cmd ::= INSERT * orconf + + INTO reduce 90 + OR shift 444 + orconf shift 513 + +State 513: + (162) insert_cmd ::= INSERT orconf * + + INTO reduce 162 + +State 514: + (163) insert_cmd ::= REPLACE * + + INTO reduce 163 + +State 515: + (90) orconf ::= * + orconf ::= * OR resolvetype + cmd ::= COPY * orconf nm dbnm FROM nm USING DELIMITERS STRING + cmd ::= COPY * orconf nm dbnm FROM nm + + OR shift 444 + orconf shift 516 + {default} reduce 90 + +State 516: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + cmd ::= COPY orconf * nm dbnm FROM nm USING DELIMITERS STRING + cmd ::= COPY orconf * nm dbnm FROM nm + + ID shift 20 + JOIN_KW shift 22 + STRING shift 21 + nm shift 517 + +State 517: + (125) dbnm ::= * + dbnm ::= * DOT nm + cmd ::= COPY orconf nm * dbnm FROM nm USING DELIMITERS STRING + cmd ::= COPY orconf nm * dbnm FROM nm + + DOT shift 275 + FROM reduce 125 + dbnm shift 518 + +State 518: + cmd ::= COPY orconf nm dbnm * FROM nm USING DELIMITERS STRING + cmd ::= COPY orconf nm dbnm * FROM nm + + FROM shift 519 + +State 519: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + cmd ::= COPY orconf nm dbnm FROM * nm USING DELIMITERS STRING + cmd ::= COPY orconf nm dbnm FROM * nm + + ID shift 20 + JOIN_KW shift 22 + STRING shift 21 + nm shift 520 + +State 520: + cmd ::= COPY orconf nm dbnm FROM nm * USING DELIMITERS STRING + (241) cmd ::= COPY orconf nm dbnm FROM nm * + + SEMI reduce 241 + USING shift 521 + +State 521: + cmd ::= COPY orconf nm dbnm FROM nm USING * DELIMITERS STRING + + DELIMITERS shift 522 + +State 522: + cmd ::= COPY orconf nm dbnm FROM nm USING DELIMITERS * STRING + + STRING shift 523 + +State 523: + (240) cmd ::= COPY orconf nm dbnm FROM nm USING DELIMITERS STRING * + + SEMI reduce 240 + +State 524: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + (242) cmd ::= VACUUM * + cmd ::= VACUUM * nm + + ID shift 20 + JOIN_KW shift 22 + SEMI reduce 242 + STRING shift 21 + nm shift 525 + +State 525: + (243) cmd ::= VACUUM nm * + + SEMI reduce 243 + +State 526: + ids ::= * ID + ids ::= * STRING + cmd ::= PRAGMA * ids EQ nm + cmd ::= PRAGMA * ids EQ ON + cmd ::= PRAGMA * ids EQ plus_num + cmd ::= PRAGMA * ids EQ minus_num + cmd ::= PRAGMA * ids LP nm RP + cmd ::= PRAGMA * ids + + ID shift 256 + STRING shift 257 + ids shift 527 + +State 527: + cmd ::= PRAGMA ids * EQ nm + cmd ::= PRAGMA ids * EQ ON + cmd ::= PRAGMA ids * EQ plus_num + cmd ::= PRAGMA ids * EQ minus_num + cmd ::= PRAGMA ids * LP nm RP + (249) cmd ::= PRAGMA ids * + + EQ shift 528 + LP shift 540 + SEMI reduce 249 + +State 528: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + cmd ::= PRAGMA ids EQ * nm + cmd ::= PRAGMA ids EQ * ON + cmd ::= PRAGMA ids EQ * plus_num + cmd ::= PRAGMA ids EQ * minus_num + plus_num ::= * plus_opt number + minus_num ::= * MINUS number + plus_opt ::= * PLUS + (255) plus_opt ::= * + + ID shift 20 + JOIN_KW shift 22 + MINUS shift 537 + ON shift 530 + PLUS shift 539 + STRING shift 21 + minus_num shift 532 + nm shift 529 + plus_num shift 531 + plus_opt shift 533 + {default} reduce 255 + +State 529: + (244) cmd ::= PRAGMA ids EQ nm * + + SEMI reduce 244 + +State 530: + (245) cmd ::= PRAGMA ids EQ ON * + + SEMI reduce 245 + +State 531: + (246) cmd ::= PRAGMA ids EQ plus_num * + + SEMI reduce 246 + +State 532: + (247) cmd ::= PRAGMA ids EQ minus_num * + + SEMI reduce 247 + +State 533: + plus_num ::= plus_opt * number + number ::= * INTEGER + number ::= * FLOAT + + FLOAT shift 536 + INTEGER shift 535 + number shift 534 + +State 534: + (250) plus_num ::= plus_opt number * + + SEMI reduce 250 + +State 535: + (252) number ::= INTEGER * + + SEMI reduce 252 + +State 536: + (253) number ::= FLOAT * + + SEMI reduce 253 + +State 537: + minus_num ::= MINUS * number + number ::= * INTEGER + number ::= * FLOAT + + FLOAT shift 536 + INTEGER shift 535 + number shift 538 + +State 538: + (251) minus_num ::= MINUS number * + + SEMI reduce 251 + +State 539: + (254) plus_opt ::= PLUS * + + {default} reduce 254 + +State 540: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + cmd ::= PRAGMA ids LP * nm RP + + ID shift 20 + JOIN_KW shift 22 + STRING shift 21 + nm shift 541 + +State 541: + cmd ::= PRAGMA ids LP nm * RP + + RP shift 542 + +State 542: + (248) cmd ::= PRAGMA ids LP nm RP * + + SEMI reduce 248 + +State 543: + cmd ::= ATTACH * database_kw_opt ids AS nm + database_kw_opt ::= * DATABASE + (285) database_kw_opt ::= * + + DATABASE shift 548 + database_kw_opt shift 544 + {default} reduce 285 + +State 544: + ids ::= * ID + ids ::= * STRING + cmd ::= ATTACH database_kw_opt * ids AS nm + + ID shift 256 + STRING shift 257 + ids shift 545 + +State 545: + cmd ::= ATTACH database_kw_opt ids * AS nm + + AS shift 546 + +State 546: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + cmd ::= ATTACH database_kw_opt ids AS * nm + + ID shift 20 + JOIN_KW shift 22 + STRING shift 21 + nm shift 547 + +State 547: + (283) cmd ::= ATTACH database_kw_opt ids AS nm * + + SEMI reduce 283 + +State 548: + (284) database_kw_opt ::= DATABASE * + + {default} reduce 284 + +State 549: + database_kw_opt ::= * DATABASE + (285) database_kw_opt ::= * + cmd ::= DETACH * database_kw_opt nm + + DATABASE shift 548 + database_kw_opt shift 550 + {default} reduce 285 + +State 550: + nm ::= * ID + nm ::= * STRING + nm ::= * JOIN_KW + cmd ::= DETACH database_kw_opt * nm + + ID shift 20 + JOIN_KW shift 22 + STRING shift 21 + nm shift 551 + +State 551: + (286) cmd ::= DETACH database_kw_opt nm * + + SEMI reduce 286 + +State 552: + (4) ecmd ::= SEMI * + + {default} reduce 4 + +State 553: + (6) explain ::= EXPLAIN * + + {default} reduce 6 + +State 554: + (1) cmdlist ::= ecmd * + + {default} reduce 1 + diff --git a/kexi/3rdparty/kexisql/src/parse.y b/kexi/3rdparty/kexisql/src/parse.y new file mode 100644 index 00000000..29bb493b --- /dev/null +++ b/kexi/3rdparty/kexisql/src/parse.y @@ -0,0 +1,866 @@ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains SQLite's grammar for SQL. Process this file +** using the lemon parser generator to generate C code that runs +** the parser. Lemon will also generate a header file containing +** numeric codes for all of the tokens. +** +** @(#) $Id: parse.y 410099 2005-05-06 17:52:07Z staniek $ +*/ +%token_prefix TK_ +%token_type {Token} +%default_type {Token} +%extra_argument {Parse *pParse} +%syntax_error { + if( pParse->zErrMsg==0 ){ + if( TOKEN.z[0] ){ + sqliteSetNString(&pParse->zErrMsg, + "near \"", -1, TOKEN.z, TOKEN.n, "\": syntax error", -1, 0); + }else{ + sqliteSetString(&pParse->zErrMsg, "incomplete SQL statement", 0); + } + } + pParse->nErr++; +} +%name sqliteParser +%include { +#include "sqliteInt.h" +#include "parse.h" + +/* +** An instance of this structure holds information about the +** LIMIT clause of a SELECT statement. +*/ +struct LimitVal { + int limit; /* The LIMIT value. -1 if there is no limit */ + int offset; /* The OFFSET. 0 if there is none */ +}; + +/* +** An instance of the following structure describes the event of a +** TRIGGER. "a" is the event type, one of TK_UPDATE, TK_INSERT, +** TK_DELETE, or TK_INSTEAD. If the event is of the form +** +** UPDATE ON (a,b,c) +** +** Then the "b" IdList records the list "a,b,c". +*/ +struct TrigEvent { int a; IdList * b; }; + +} // end %include + +// These are extra tokens used by the lexer but never seen by the +// parser. We put them in a rule so that the parser generator will +// add them to the parse.h output file. +// +%nonassoc END_OF_FILE ILLEGAL SPACE UNCLOSED_STRING COMMENT FUNCTION + COLUMN AGG_FUNCTION. + +// Input is zero or more commands. +input ::= cmdlist. + +// A list of commands is zero or more commands +// +cmdlist ::= ecmd. +cmdlist ::= cmdlist ecmd. +ecmd ::= explain cmdx SEMI. +ecmd ::= SEMI. +cmdx ::= cmd. { sqliteExec(pParse); } +explain ::= EXPLAIN. { sqliteBeginParse(pParse, 1); } +explain ::= . { sqliteBeginParse(pParse, 0); } + +///////////////////// Begin and end transactions. //////////////////////////// +// + +cmd ::= BEGIN trans_opt onconf(R). {sqliteBeginTransaction(pParse,R);} +trans_opt ::= . +trans_opt ::= TRANSACTION. +trans_opt ::= TRANSACTION nm. +cmd ::= COMMIT trans_opt. {sqliteCommitTransaction(pParse);} +cmd ::= END trans_opt. {sqliteCommitTransaction(pParse);} +cmd ::= ROLLBACK trans_opt. {sqliteRollbackTransaction(pParse);} + +///////////////////// The CREATE TABLE statement //////////////////////////// +// +cmd ::= create_table create_table_args. +create_table ::= CREATE(X) temp(T) TABLE nm(Y). { + sqliteStartTable(pParse,&X,&Y,T,0); +} +%type temp {int} +temp(A) ::= TEMP. {A = 1;} +temp(A) ::= . {A = 0;} +create_table_args ::= LP columnlist conslist_opt RP(X). { + sqliteEndTable(pParse,&X,0); +} +create_table_args ::= AS select(S). { + sqliteEndTable(pParse,0,S); + sqliteSelectDelete(S); +} +columnlist ::= columnlist COMMA column. +columnlist ::= column. + +// About the only information used for a column is the name of the +// column. The type is always just "text". But the code will accept +// an elaborate typename. Perhaps someday we'll do something with it. +// +column ::= columnid type carglist. +columnid ::= nm(X). {sqliteAddColumn(pParse,&X);} + +// An IDENTIFIER can be a generic identifier, or one of several +// keywords. Any non-standard keyword can also be an identifier. +// +%type id {Token} +id(A) ::= ID(X). {A = X;} + +// The following directive causes tokens ABORT, AFTER, ASC, etc. to +// fallback to ID if they will not parse as their original value. +// This obviates the need for the "id" nonterminal. +// +%fallback ID + ABORT AFTER ASC ATTACH BEFORE BEGIN CASCADE CLUSTER CONFLICT + COPY DATABASE DEFERRED DELIMITERS DESC DETACH EACH END EXPLAIN FAIL FOR + IGNORE IMMEDIATE INITIALLY INSTEAD MATCH KEY + OF OFFSET PRAGMA RAISE REPLACE RESTRICT ROW STATEMENT + TEMP TRIGGER VACUUM VIEW. + +// And "ids" is an identifer-or-string. +// +%type ids {Token} +ids(A) ::= ID(X). {A = X;} +ids(A) ::= STRING(X). {A = X;} + +// The name of a column or table can be any of the following: +// +%type nm {Token} +nm(A) ::= ID(X). {A = X;} +nm(A) ::= STRING(X). {A = X;} +nm(A) ::= JOIN_KW(X). {A = X;} + +type ::= . +type ::= typename(X). {sqliteAddColumnType(pParse,&X,&X);} +type ::= typename(X) LP signed RP(Y). {sqliteAddColumnType(pParse,&X,&Y);} +type ::= typename(X) LP signed COMMA signed RP(Y). + {sqliteAddColumnType(pParse,&X,&Y);} +%type typename {Token} +typename(A) ::= ids(X). {A = X;} +typename(A) ::= typename(X) ids. {A = X;} +%type signed {int} +signed(A) ::= INTEGER(X). { A = atoi(X.z); } +signed(A) ::= PLUS INTEGER(X). { A = atoi(X.z); } +signed(A) ::= MINUS INTEGER(X). { A = -atoi(X.z); } +carglist ::= carglist carg. +carglist ::= . +carg ::= CONSTRAINT nm ccons. +carg ::= ccons. +carg ::= DEFAULT STRING(X). {sqliteAddDefaultValue(pParse,&X,0);} +carg ::= DEFAULT ID(X). {sqliteAddDefaultValue(pParse,&X,0);} +carg ::= DEFAULT INTEGER(X). {sqliteAddDefaultValue(pParse,&X,0);} +carg ::= DEFAULT PLUS INTEGER(X). {sqliteAddDefaultValue(pParse,&X,0);} +carg ::= DEFAULT MINUS INTEGER(X). {sqliteAddDefaultValue(pParse,&X,1);} +carg ::= DEFAULT FLOAT(X). {sqliteAddDefaultValue(pParse,&X,0);} +carg ::= DEFAULT PLUS FLOAT(X). {sqliteAddDefaultValue(pParse,&X,0);} +carg ::= DEFAULT MINUS FLOAT(X). {sqliteAddDefaultValue(pParse,&X,1);} +carg ::= DEFAULT NULL. + +// In addition to the type name, we also care about the primary key and +// UNIQUE constraints. +// +ccons ::= NULL onconf. +ccons ::= NOT NULL onconf(R). {sqliteAddNotNull(pParse, R);} +ccons ::= PRIMARY KEY sortorder onconf(R). {sqliteAddPrimaryKey(pParse,0,R);} +ccons ::= UNIQUE onconf(R). {sqliteCreateIndex(pParse,0,0,0,R,0,0,0);} +ccons ::= CHECK LP expr RP onconf. +ccons ::= REFERENCES nm(T) idxlist_opt(TA) refargs(R). + {sqliteCreateForeignKey(pParse,0,&T,TA,R);} +ccons ::= defer_subclause(D). {sqliteDeferForeignKey(pParse,D);} +ccons ::= COLLATE id(C). { + sqliteAddCollateType(pParse, sqliteCollateType(C.z, C.n)); +} + +// The next group of rules parses the arguments to a REFERENCES clause +// that determine if the referential integrity checking is deferred or +// or immediate and which determine what action to take if a ref-integ +// check fails. +// +%type refargs {int} +refargs(A) ::= . { A = OE_Restrict * 0x010101; } +refargs(A) ::= refargs(X) refarg(Y). { A = (X & Y.mask) | Y.value; } +%type refarg {struct {int value; int mask;}} +refarg(A) ::= MATCH nm. { A.value = 0; A.mask = 0x000000; } +refarg(A) ::= ON DELETE refact(X). { A.value = X; A.mask = 0x0000ff; } +refarg(A) ::= ON UPDATE refact(X). { A.value = X<<8; A.mask = 0x00ff00; } +refarg(A) ::= ON INSERT refact(X). { A.value = X<<16; A.mask = 0xff0000; } +%type refact {int} +refact(A) ::= SET NULL. { A = OE_SetNull; } +refact(A) ::= SET DEFAULT. { A = OE_SetDflt; } +refact(A) ::= CASCADE. { A = OE_Cascade; } +refact(A) ::= RESTRICT. { A = OE_Restrict; } +%type defer_subclause {int} +defer_subclause(A) ::= NOT DEFERRABLE init_deferred_pred_opt(X). {A = X;} +defer_subclause(A) ::= DEFERRABLE init_deferred_pred_opt(X). {A = X;} +%type init_deferred_pred_opt {int} +init_deferred_pred_opt(A) ::= . {A = 0;} +init_deferred_pred_opt(A) ::= INITIALLY DEFERRED. {A = 1;} +init_deferred_pred_opt(A) ::= INITIALLY IMMEDIATE. {A = 0;} + +// For the time being, the only constraint we care about is the primary +// key and UNIQUE. Both create indices. +// +conslist_opt ::= . +conslist_opt ::= COMMA conslist. +conslist ::= conslist COMMA tcons. +conslist ::= conslist tcons. +conslist ::= tcons. +tcons ::= CONSTRAINT nm. +tcons ::= PRIMARY KEY LP idxlist(X) RP onconf(R). + {sqliteAddPrimaryKey(pParse,X,R);} +tcons ::= UNIQUE LP idxlist(X) RP onconf(R). + {sqliteCreateIndex(pParse,0,0,X,R,0,0,0);} +tcons ::= CHECK expr onconf. +tcons ::= FOREIGN KEY LP idxlist(FA) RP + REFERENCES nm(T) idxlist_opt(TA) refargs(R) defer_subclause_opt(D). { + sqliteCreateForeignKey(pParse, FA, &T, TA, R); + sqliteDeferForeignKey(pParse, D); +} +%type defer_subclause_opt {int} +defer_subclause_opt(A) ::= . {A = 0;} +defer_subclause_opt(A) ::= defer_subclause(X). {A = X;} + +// The following is a non-standard extension that allows us to declare the +// default behavior when there is a constraint conflict. +// +%type onconf {int} +%type orconf {int} +%type resolvetype {int} +onconf(A) ::= . { A = OE_Default; } +onconf(A) ::= ON CONFLICT resolvetype(X). { A = X; } +orconf(A) ::= . { A = OE_Default; } +orconf(A) ::= OR resolvetype(X). { A = X; } +resolvetype(A) ::= ROLLBACK. { A = OE_Rollback; } +resolvetype(A) ::= ABORT. { A = OE_Abort; } +resolvetype(A) ::= FAIL. { A = OE_Fail; } +resolvetype(A) ::= IGNORE. { A = OE_Ignore; } +resolvetype(A) ::= REPLACE. { A = OE_Replace; } + +////////////////////////// The DROP TABLE ///////////////////////////////////// +// +cmd ::= DROP TABLE nm(X). {sqliteDropTable(pParse,&X,0);} + +///////////////////// The CREATE VIEW statement ///////////////////////////// +// +cmd ::= CREATE(X) temp(T) VIEW nm(Y) AS select(S). { + sqliteCreateView(pParse, &X, &Y, S, T); +} +cmd ::= DROP VIEW nm(X). { + sqliteDropTable(pParse, &X, 1); +} + +//////////////////////// The SELECT statement ///////////////////////////////// +// +cmd ::= select(X). { + sqliteSelect(pParse, X, SRT_Callback, 0, 0, 0, 0); + sqliteSelectDelete(X); +} + +%type select {Select*} +%destructor select {sqliteSelectDelete($$);} +%type oneselect {Select*} +%destructor oneselect {sqliteSelectDelete($$);} + +select(A) ::= oneselect(X). {A = X;} +select(A) ::= select(X) multiselect_op(Y) oneselect(Z). { + if( Z ){ + Z->op = Y; + Z->pPrior = X; + } + A = Z; +} +%type multiselect_op {int} +multiselect_op(A) ::= UNION. {A = TK_UNION;} +multiselect_op(A) ::= UNION ALL. {A = TK_ALL;} +multiselect_op(A) ::= INTERSECT. {A = TK_INTERSECT;} +multiselect_op(A) ::= EXCEPT. {A = TK_EXCEPT;} +oneselect(A) ::= SELECT distinct(D) selcollist(W) from(X) where_opt(Y) + groupby_opt(P) having_opt(Q) orderby_opt(Z) limit_opt(L). { + A = sqliteSelectNew(W,X,Y,P,Q,Z,D,L.limit,L.offset); +} + +// The "distinct" nonterminal is true (1) if the DISTINCT keyword is +// present and false (0) if it is not. +// +%type distinct {int} +distinct(A) ::= DISTINCT. {A = 1;} +distinct(A) ::= ALL. {A = 0;} +distinct(A) ::= . {A = 0;} + +// selcollist is a list of expressions that are to become the return +// values of the SELECT statement. The "*" in statements like +// "SELECT * FROM ..." is encoded as a special expression with an +// opcode of TK_ALL. +// +%type selcollist {ExprList*} +%destructor selcollist {sqliteExprListDelete($$);} +%type sclp {ExprList*} +%destructor sclp {sqliteExprListDelete($$);} +sclp(A) ::= selcollist(X) COMMA. {A = X;} +sclp(A) ::= . {A = 0;} +selcollist(A) ::= sclp(P) expr(X) as(Y). { + A = sqliteExprListAppend(P,X,Y.n?&Y:0); +} +selcollist(A) ::= sclp(P) STAR. { + A = sqliteExprListAppend(P, sqliteExpr(TK_ALL, 0, 0, 0), 0); +} +selcollist(A) ::= sclp(P) nm(X) DOT STAR. { + Expr *pRight = sqliteExpr(TK_ALL, 0, 0, 0); + Expr *pLeft = sqliteExpr(TK_ID, 0, 0, &X); + A = sqliteExprListAppend(P, sqliteExpr(TK_DOT, pLeft, pRight, 0), 0); +} + +// An option "AS <id>" phrase that can follow one of the expressions that +// define the result set, or one of the tables in the FROM clause. +// +%type as {Token} +as(X) ::= AS nm(Y). { X = Y; } +as(X) ::= ids(Y). { X = Y; } +as(X) ::= . { X.n = 0; } + + +%type seltablist {SrcList*} +%destructor seltablist {sqliteSrcListDelete($$);} +%type stl_prefix {SrcList*} +%destructor stl_prefix {sqliteSrcListDelete($$);} +%type from {SrcList*} +%destructor from {sqliteSrcListDelete($$);} + +// A complete FROM clause. +// +from(A) ::= . {A = sqliteMalloc(sizeof(*A));} +from(A) ::= FROM seltablist(X). {A = X;} + +// "seltablist" is a "Select Table List" - the content of the FROM clause +// in a SELECT statement. "stl_prefix" is a prefix of this list. +// +stl_prefix(A) ::= seltablist(X) joinop(Y). { + A = X; + if( A && A->nSrc>0 ) A->a[A->nSrc-1].jointype = Y; +} +stl_prefix(A) ::= . {A = 0;} +seltablist(A) ::= stl_prefix(X) nm(Y) dbnm(D) as(Z) on_opt(N) using_opt(U). { + A = sqliteSrcListAppend(X,&Y,&D); + if( Z.n ) sqliteSrcListAddAlias(A,&Z); + if( N ){ + if( A && A->nSrc>1 ){ A->a[A->nSrc-2].pOn = N; } + else { sqliteExprDelete(N); } + } + if( U ){ + if( A && A->nSrc>1 ){ A->a[A->nSrc-2].pUsing = U; } + else { sqliteIdListDelete(U); } + } +} +seltablist(A) ::= stl_prefix(X) LP select(S) RP as(Z) on_opt(N) using_opt(U). { + A = sqliteSrcListAppend(X,0,0); + A->a[A->nSrc-1].pSelect = S; + if( Z.n ) sqliteSrcListAddAlias(A,&Z); + if( N ){ + if( A && A->nSrc>1 ){ A->a[A->nSrc-2].pOn = N; } + else { sqliteExprDelete(N); } + } + if( U ){ + if( A && A->nSrc>1 ){ A->a[A->nSrc-2].pUsing = U; } + else { sqliteIdListDelete(U); } + } +} + +%type dbnm {Token} +dbnm(A) ::= . {A.z=0; A.n=0;} +dbnm(A) ::= DOT nm(X). {A = X;} + +%type joinop {int} +%type joinop2 {int} +joinop(X) ::= COMMA. { X = JT_INNER; } +joinop(X) ::= JOIN. { X = JT_INNER; } +joinop(X) ::= JOIN_KW(A) JOIN. { X = sqliteJoinType(pParse,&A,0,0); } +joinop(X) ::= JOIN_KW(A) nm(B) JOIN. { X = sqliteJoinType(pParse,&A,&B,0); } +joinop(X) ::= JOIN_KW(A) nm(B) nm(C) JOIN. + { X = sqliteJoinType(pParse,&A,&B,&C); } + +%type on_opt {Expr*} +%destructor on_opt {sqliteExprDelete($$);} +on_opt(N) ::= ON expr(E). {N = E;} +on_opt(N) ::= . {N = 0;} + +%type using_opt {IdList*} +%destructor using_opt {sqliteIdListDelete($$);} +using_opt(U) ::= USING LP idxlist(L) RP. {U = L;} +using_opt(U) ::= . {U = 0;} + + +%type orderby_opt {ExprList*} +%destructor orderby_opt {sqliteExprListDelete($$);} +%type sortlist {ExprList*} +%destructor sortlist {sqliteExprListDelete($$);} +%type sortitem {Expr*} +%destructor sortitem {sqliteExprDelete($$);} + +orderby_opt(A) ::= . {A = 0;} +orderby_opt(A) ::= ORDER BY sortlist(X). {A = X;} +sortlist(A) ::= sortlist(X) COMMA sortitem(Y) collate(C) sortorder(Z). { + A = sqliteExprListAppend(X,Y,0); + if( A ) A->a[A->nExpr-1].sortOrder = C+Z; +} +sortlist(A) ::= sortitem(Y) collate(C) sortorder(Z). { + A = sqliteExprListAppend(0,Y,0); + if( A ) A->a[0].sortOrder = C+Z; +} +sortitem(A) ::= expr(X). {A = X;} + +%type sortorder {int} +%type collate {int} + +sortorder(A) ::= ASC. {A = SQLITE_SO_ASC;} +sortorder(A) ::= DESC. {A = SQLITE_SO_DESC;} +sortorder(A) ::= . {A = SQLITE_SO_ASC;} +collate(C) ::= . {C = SQLITE_SO_UNK;} +collate(C) ::= COLLATE id(X). {C = sqliteCollateType(X.z, X.n);} + +%type groupby_opt {ExprList*} +%destructor groupby_opt {sqliteExprListDelete($$);} +groupby_opt(A) ::= . {A = 0;} +groupby_opt(A) ::= GROUP BY exprlist(X). {A = X;} + +%type having_opt {Expr*} +%destructor having_opt {sqliteExprDelete($$);} +having_opt(A) ::= . {A = 0;} +having_opt(A) ::= HAVING expr(X). {A = X;} + +%type limit_opt {struct LimitVal} +limit_opt(A) ::= . {A.limit = -1; A.offset = 0;} +limit_opt(A) ::= LIMIT signed(X). {A.limit = X; A.offset = 0;} +limit_opt(A) ::= LIMIT signed(X) OFFSET signed(Y). + {A.limit = X; A.offset = Y;} +limit_opt(A) ::= LIMIT signed(X) COMMA signed(Y). + {A.limit = Y; A.offset = X;} + +/////////////////////////// The DELETE statement ///////////////////////////// +// +cmd ::= DELETE FROM nm(X) dbnm(D) where_opt(Y). { + sqliteDeleteFrom(pParse, sqliteSrcListAppend(0,&X,&D), Y); +} + +%type where_opt {Expr*} +%destructor where_opt {sqliteExprDelete($$);} + +where_opt(A) ::= . {A = 0;} +where_opt(A) ::= WHERE expr(X). {A = X;} + +%type setlist {ExprList*} +%destructor setlist {sqliteExprListDelete($$);} + +////////////////////////// The UPDATE command //////////////////////////////// +// +cmd ::= UPDATE orconf(R) nm(X) dbnm(D) SET setlist(Y) where_opt(Z). + {sqliteUpdate(pParse,sqliteSrcListAppend(0,&X,&D),Y,Z,R);} + +setlist(A) ::= setlist(Z) COMMA nm(X) EQ expr(Y). + {A = sqliteExprListAppend(Z,Y,&X);} +setlist(A) ::= nm(X) EQ expr(Y). {A = sqliteExprListAppend(0,Y,&X);} + +////////////////////////// The INSERT command ///////////////////////////////// +// +cmd ::= insert_cmd(R) INTO nm(X) dbnm(D) inscollist_opt(F) + VALUES LP itemlist(Y) RP. + {sqliteInsert(pParse, sqliteSrcListAppend(0,&X,&D), Y, 0, F, R);} +cmd ::= insert_cmd(R) INTO nm(X) dbnm(D) inscollist_opt(F) select(S). + {sqliteInsert(pParse, sqliteSrcListAppend(0,&X,&D), 0, S, F, R);} + +%type insert_cmd {int} +insert_cmd(A) ::= INSERT orconf(R). {A = R;} +insert_cmd(A) ::= REPLACE. {A = OE_Replace;} + + +%type itemlist {ExprList*} +%destructor itemlist {sqliteExprListDelete($$);} + +itemlist(A) ::= itemlist(X) COMMA expr(Y). {A = sqliteExprListAppend(X,Y,0);} +itemlist(A) ::= expr(X). {A = sqliteExprListAppend(0,X,0);} + +%type inscollist_opt {IdList*} +%destructor inscollist_opt {sqliteIdListDelete($$);} +%type inscollist {IdList*} +%destructor inscollist {sqliteIdListDelete($$);} + +inscollist_opt(A) ::= . {A = 0;} +inscollist_opt(A) ::= LP inscollist(X) RP. {A = X;} +inscollist(A) ::= inscollist(X) COMMA nm(Y). {A = sqliteIdListAppend(X,&Y);} +inscollist(A) ::= nm(Y). {A = sqliteIdListAppend(0,&Y);} + +/////////////////////////// Expression Processing ///////////////////////////// +// +%left OR. +%left AND. +%right NOT. +%left EQ NE ISNULL NOTNULL IS LIKE GLOB BETWEEN IN. +%left GT GE LT LE. +%left BITAND BITOR LSHIFT RSHIFT. +%left PLUS MINUS. +%left STAR SLASH REM. +%left CONCAT. +%right UMINUS UPLUS BITNOT. +%right ORACLE_OUTER_JOIN. + +%type expr {Expr*} +%destructor expr {sqliteExprDelete($$);} + +expr(A) ::= LP(B) expr(X) RP(E). {A = X; sqliteExprSpan(A,&B,&E); } +expr(A) ::= NULL(X). {A = sqliteExpr(TK_NULL, 0, 0, &X);} +expr(A) ::= ID(X). {A = sqliteExpr(TK_ID, 0, 0, &X);} +expr(A) ::= JOIN_KW(X). {A = sqliteExpr(TK_ID, 0, 0, &X);} +expr(A) ::= nm(X) DOT nm(Y). { + Expr *temp1 = sqliteExpr(TK_ID, 0, 0, &X); + Expr *temp2 = sqliteExpr(TK_ID, 0, 0, &Y); + A = sqliteExpr(TK_DOT, temp1, temp2, 0); +} +expr(A) ::= nm(X) DOT nm(Y) DOT nm(Z). { + Expr *temp1 = sqliteExpr(TK_ID, 0, 0, &X); + Expr *temp2 = sqliteExpr(TK_ID, 0, 0, &Y); + Expr *temp3 = sqliteExpr(TK_ID, 0, 0, &Z); + Expr *temp4 = sqliteExpr(TK_DOT, temp2, temp3, 0); + A = sqliteExpr(TK_DOT, temp1, temp4, 0); +} +expr(A) ::= expr(B) ORACLE_OUTER_JOIN. + {A = B; ExprSetProperty(A,EP_Oracle8Join);} +expr(A) ::= INTEGER(X). {A = sqliteExpr(TK_INTEGER, 0, 0, &X);} +expr(A) ::= FLOAT(X). {A = sqliteExpr(TK_FLOAT, 0, 0, &X);} +expr(A) ::= STRING(X). {A = sqliteExpr(TK_STRING, 0, 0, &X);} +expr(A) ::= ID(X) LP exprlist(Y) RP(E). { + A = sqliteExprFunction(Y, &X); + sqliteExprSpan(A,&X,&E); +} +expr(A) ::= ID(X) LP STAR RP(E). { + A = sqliteExprFunction(0, &X); + sqliteExprSpan(A,&X,&E); +} +expr(A) ::= expr(X) AND expr(Y). {A = sqliteExpr(TK_AND, X, Y, 0);} +expr(A) ::= expr(X) OR expr(Y). {A = sqliteExpr(TK_OR, X, Y, 0);} +expr(A) ::= expr(X) LT expr(Y). {A = sqliteExpr(TK_LT, X, Y, 0);} +expr(A) ::= expr(X) GT expr(Y). {A = sqliteExpr(TK_GT, X, Y, 0);} +expr(A) ::= expr(X) LE expr(Y). {A = sqliteExpr(TK_LE, X, Y, 0);} +expr(A) ::= expr(X) GE expr(Y). {A = sqliteExpr(TK_GE, X, Y, 0);} +expr(A) ::= expr(X) NE expr(Y). {A = sqliteExpr(TK_NE, X, Y, 0);} +expr(A) ::= expr(X) EQ expr(Y). {A = sqliteExpr(TK_EQ, X, Y, 0);} +expr(A) ::= expr(X) BITAND expr(Y). {A = sqliteExpr(TK_BITAND, X, Y, 0);} +expr(A) ::= expr(X) BITOR expr(Y). {A = sqliteExpr(TK_BITOR, X, Y, 0);} +expr(A) ::= expr(X) LSHIFT expr(Y). {A = sqliteExpr(TK_LSHIFT, X, Y, 0);} +expr(A) ::= expr(X) RSHIFT expr(Y). {A = sqliteExpr(TK_RSHIFT, X, Y, 0);} +expr(A) ::= expr(X) likeop(OP) expr(Y). [LIKE] { + ExprList *pList = sqliteExprListAppend(0, Y, 0); + pList = sqliteExprListAppend(pList, X, 0); + A = sqliteExprFunction(pList, 0); + if( A ) A->op = OP; + sqliteExprSpan(A, &X->span, &Y->span); +} +expr(A) ::= expr(X) NOT likeop(OP) expr(Y). [LIKE] { + ExprList *pList = sqliteExprListAppend(0, Y, 0); + pList = sqliteExprListAppend(pList, X, 0); + A = sqliteExprFunction(pList, 0); + if( A ) A->op = OP; + A = sqliteExpr(TK_NOT, A, 0, 0); + sqliteExprSpan(A,&X->span,&Y->span); +} +%type likeop {int} +likeop(A) ::= LIKE. {A = TK_LIKE;} +likeop(A) ::= GLOB. {A = TK_GLOB;} +expr(A) ::= expr(X) PLUS expr(Y). {A = sqliteExpr(TK_PLUS, X, Y, 0);} +expr(A) ::= expr(X) MINUS expr(Y). {A = sqliteExpr(TK_MINUS, X, Y, 0);} +expr(A) ::= expr(X) STAR expr(Y). {A = sqliteExpr(TK_STAR, X, Y, 0);} +expr(A) ::= expr(X) SLASH expr(Y). {A = sqliteExpr(TK_SLASH, X, Y, 0);} +expr(A) ::= expr(X) REM expr(Y). {A = sqliteExpr(TK_REM, X, Y, 0);} +expr(A) ::= expr(X) CONCAT expr(Y). {A = sqliteExpr(TK_CONCAT, X, Y, 0);} +expr(A) ::= expr(X) ISNULL(E). { + A = sqliteExpr(TK_ISNULL, X, 0, 0); + sqliteExprSpan(A,&X->span,&E); +} +expr(A) ::= expr(X) IS NULL(E). { + A = sqliteExpr(TK_ISNULL, X, 0, 0); + sqliteExprSpan(A,&X->span,&E); +} +expr(A) ::= expr(X) NOTNULL(E). { + A = sqliteExpr(TK_NOTNULL, X, 0, 0); + sqliteExprSpan(A,&X->span,&E); +} +expr(A) ::= expr(X) NOT NULL(E). { + A = sqliteExpr(TK_NOTNULL, X, 0, 0); + sqliteExprSpan(A,&X->span,&E); +} +expr(A) ::= expr(X) IS NOT NULL(E). { + A = sqliteExpr(TK_NOTNULL, X, 0, 0); + sqliteExprSpan(A,&X->span,&E); +} +expr(A) ::= NOT(B) expr(X). { + A = sqliteExpr(TK_NOT, X, 0, 0); + sqliteExprSpan(A,&B,&X->span); +} +expr(A) ::= BITNOT(B) expr(X). { + A = sqliteExpr(TK_BITNOT, X, 0, 0); + sqliteExprSpan(A,&B,&X->span); +} +expr(A) ::= MINUS(B) expr(X). [UMINUS] { + A = sqliteExpr(TK_UMINUS, X, 0, 0); + sqliteExprSpan(A,&B,&X->span); +} +expr(A) ::= PLUS(B) expr(X). [UPLUS] { + A = sqliteExpr(TK_UPLUS, X, 0, 0); + sqliteExprSpan(A,&B,&X->span); +} +expr(A) ::= LP(B) select(X) RP(E). { + A = sqliteExpr(TK_SELECT, 0, 0, 0); + if( A ) A->pSelect = X; + sqliteExprSpan(A,&B,&E); +} +expr(A) ::= expr(W) BETWEEN expr(X) AND expr(Y). { + ExprList *pList = sqliteExprListAppend(0, X, 0); + pList = sqliteExprListAppend(pList, Y, 0); + A = sqliteExpr(TK_BETWEEN, W, 0, 0); + if( A ) A->pList = pList; + sqliteExprSpan(A,&W->span,&Y->span); +} +expr(A) ::= expr(W) NOT BETWEEN expr(X) AND expr(Y). { + ExprList *pList = sqliteExprListAppend(0, X, 0); + pList = sqliteExprListAppend(pList, Y, 0); + A = sqliteExpr(TK_BETWEEN, W, 0, 0); + if( A ) A->pList = pList; + A = sqliteExpr(TK_NOT, A, 0, 0); + sqliteExprSpan(A,&W->span,&Y->span); +} +expr(A) ::= expr(X) IN LP exprlist(Y) RP(E). { + A = sqliteExpr(TK_IN, X, 0, 0); + if( A ) A->pList = Y; + sqliteExprSpan(A,&X->span,&E); +} +expr(A) ::= expr(X) IN LP select(Y) RP(E). { + A = sqliteExpr(TK_IN, X, 0, 0); + if( A ) A->pSelect = Y; + sqliteExprSpan(A,&X->span,&E); +} +expr(A) ::= expr(X) NOT IN LP exprlist(Y) RP(E). { + A = sqliteExpr(TK_IN, X, 0, 0); + if( A ) A->pList = Y; + A = sqliteExpr(TK_NOT, A, 0, 0); + sqliteExprSpan(A,&X->span,&E); +} +expr(A) ::= expr(X) NOT IN LP select(Y) RP(E). { + A = sqliteExpr(TK_IN, X, 0, 0); + if( A ) A->pSelect = Y; + A = sqliteExpr(TK_NOT, A, 0, 0); + sqliteExprSpan(A,&X->span,&E); +} + +/* CASE expressions */ +expr(A) ::= CASE(C) case_operand(X) case_exprlist(Y) case_else(Z) END(E). { + A = sqliteExpr(TK_CASE, X, Z, 0); + if( A ) A->pList = Y; + sqliteExprSpan(A, &C, &E); +} +%type case_exprlist {ExprList*} +%destructor case_exprlist {sqliteExprListDelete($$);} +case_exprlist(A) ::= case_exprlist(X) WHEN expr(Y) THEN expr(Z). { + A = sqliteExprListAppend(X, Y, 0); + A = sqliteExprListAppend(A, Z, 0); +} +case_exprlist(A) ::= WHEN expr(Y) THEN expr(Z). { + A = sqliteExprListAppend(0, Y, 0); + A = sqliteExprListAppend(A, Z, 0); +} +%type case_else {Expr*} +case_else(A) ::= ELSE expr(X). {A = X;} +case_else(A) ::= . {A = 0;} +%type case_operand {Expr*} +case_operand(A) ::= expr(X). {A = X;} +case_operand(A) ::= . {A = 0;} + +%type exprlist {ExprList*} +%destructor exprlist {sqliteExprListDelete($$);} +%type expritem {Expr*} +%destructor expritem {sqliteExprDelete($$);} + +exprlist(A) ::= exprlist(X) COMMA expritem(Y). + {A = sqliteExprListAppend(X,Y,0);} +exprlist(A) ::= expritem(X). {A = sqliteExprListAppend(0,X,0);} +expritem(A) ::= expr(X). {A = X;} +expritem(A) ::= . {A = 0;} + +///////////////////////////// The CREATE INDEX command /////////////////////// +// +cmd ::= CREATE(S) temp(T) uniqueflag(U) INDEX nm(X) + ON nm(Y) dbnm(D) LP idxlist(Z) RP(E) onconf(R). { + SrcList *pSrc = sqliteSrcListAppend(0, &Y, &D); + if( U!=OE_None ) U = R; + if( U==OE_Default) U = OE_Abort; + sqliteCreateIndex(pParse, &X, pSrc, Z, U, T, &S, &E); +} + +%type uniqueflag {int} +uniqueflag(A) ::= UNIQUE. { A = OE_Abort; } +uniqueflag(A) ::= . { A = OE_None; } + +%type idxlist {IdList*} +%destructor idxlist {sqliteIdListDelete($$);} +%type idxlist_opt {IdList*} +%destructor idxlist_opt {sqliteIdListDelete($$);} +%type idxitem {Token} + +idxlist_opt(A) ::= . {A = 0;} +idxlist_opt(A) ::= LP idxlist(X) RP. {A = X;} +idxlist(A) ::= idxlist(X) COMMA idxitem(Y). {A = sqliteIdListAppend(X,&Y);} +idxlist(A) ::= idxitem(Y). {A = sqliteIdListAppend(0,&Y);} +idxitem(A) ::= nm(X) sortorder. {A = X;} + +///////////////////////////// The DROP INDEX command ///////////////////////// +// + +cmd ::= DROP INDEX nm(X) dbnm(Y). { + sqliteDropIndex(pParse, sqliteSrcListAppend(0,&X,&Y)); +} + + +///////////////////////////// The COPY command /////////////////////////////// +// +cmd ::= COPY orconf(R) nm(X) dbnm(D) FROM nm(Y) USING DELIMITERS STRING(Z). + {sqliteCopy(pParse,sqliteSrcListAppend(0,&X,&D),&Y,&Z,R);} +cmd ::= COPY orconf(R) nm(X) dbnm(D) FROM nm(Y). + {sqliteCopy(pParse,sqliteSrcListAppend(0,&X,&D),&Y,0,R);} + +///////////////////////////// The VACUUM command ///////////////////////////// +// +cmd ::= VACUUM. {sqliteVacuum(pParse,0);} +cmd ::= VACUUM nm(X). {sqliteVacuum(pParse,&X);} + +///////////////////////////// The PRAGMA command ///////////////////////////// +// +cmd ::= PRAGMA ids(X) EQ nm(Y). {sqlitePragma(pParse,&X,&Y,0);} +cmd ::= PRAGMA ids(X) EQ ON(Y). {sqlitePragma(pParse,&X,&Y,0);} +cmd ::= PRAGMA ids(X) EQ plus_num(Y). {sqlitePragma(pParse,&X,&Y,0);} +cmd ::= PRAGMA ids(X) EQ minus_num(Y). {sqlitePragma(pParse,&X,&Y,1);} +cmd ::= PRAGMA ids(X) LP nm(Y) RP. {sqlitePragma(pParse,&X,&Y,0);} +cmd ::= PRAGMA ids(X). {sqlitePragma(pParse,&X,&X,0);} +plus_num(A) ::= plus_opt number(X). {A = X;} +minus_num(A) ::= MINUS number(X). {A = X;} +number(A) ::= INTEGER(X). {A = X;} +number(A) ::= FLOAT(X). {A = X;} +plus_opt ::= PLUS. +plus_opt ::= . + +//////////////////////////// The CREATE TRIGGER command ///////////////////// + +cmd ::= CREATE(A) trigger_decl BEGIN trigger_cmd_list(S) END(Z). { + Token all; + all.z = A.z; + all.n = (Z.z - A.z) + Z.n; + sqliteFinishTrigger(pParse, S, &all); +} + +trigger_decl ::= temp(T) TRIGGER nm(B) trigger_time(C) trigger_event(D) + ON nm(E) dbnm(DB) foreach_clause(F) when_clause(G). { + SrcList *pTab = sqliteSrcListAppend(0, &E, &DB); + sqliteBeginTrigger(pParse, &B, C, D.a, D.b, pTab, F, G, T); +} + +%type trigger_time {int} +trigger_time(A) ::= BEFORE. { A = TK_BEFORE; } +trigger_time(A) ::= AFTER. { A = TK_AFTER; } +trigger_time(A) ::= INSTEAD OF. { A = TK_INSTEAD;} +trigger_time(A) ::= . { A = TK_BEFORE; } + +%type trigger_event {struct TrigEvent} +%destructor trigger_event {sqliteIdListDelete($$.b);} +trigger_event(A) ::= DELETE. { A.a = TK_DELETE; A.b = 0; } +trigger_event(A) ::= INSERT. { A.a = TK_INSERT; A.b = 0; } +trigger_event(A) ::= UPDATE. { A.a = TK_UPDATE; A.b = 0;} +trigger_event(A) ::= UPDATE OF inscollist(X). {A.a = TK_UPDATE; A.b = X; } + +%type foreach_clause {int} +foreach_clause(A) ::= . { A = TK_ROW; } +foreach_clause(A) ::= FOR EACH ROW. { A = TK_ROW; } +foreach_clause(A) ::= FOR EACH STATEMENT. { A = TK_STATEMENT; } + +%type when_clause {Expr *} +when_clause(A) ::= . { A = 0; } +when_clause(A) ::= WHEN expr(X). { A = X; } + +%type trigger_cmd_list {TriggerStep *} +%destructor trigger_cmd_list {sqliteDeleteTriggerStep($$);} +trigger_cmd_list(A) ::= trigger_cmd(X) SEMI trigger_cmd_list(Y). { + X->pNext = Y; + A = X; +} +trigger_cmd_list(A) ::= . { A = 0; } + +%type trigger_cmd {TriggerStep *} +%destructor trigger_cmd {sqliteDeleteTriggerStep($$);} +// UPDATE +trigger_cmd(A) ::= UPDATE orconf(R) nm(X) SET setlist(Y) where_opt(Z). + { A = sqliteTriggerUpdateStep(&X, Y, Z, R); } + +// INSERT +trigger_cmd(A) ::= INSERT orconf(R) INTO nm(X) inscollist_opt(F) + VALUES LP itemlist(Y) RP. +{A = sqliteTriggerInsertStep(&X, F, Y, 0, R);} + +trigger_cmd(A) ::= INSERT orconf(R) INTO nm(X) inscollist_opt(F) select(S). + {A = sqliteTriggerInsertStep(&X, F, 0, S, R);} + +// DELETE +trigger_cmd(A) ::= DELETE FROM nm(X) where_opt(Y). + {A = sqliteTriggerDeleteStep(&X, Y);} + +// SELECT +trigger_cmd(A) ::= select(X). {A = sqliteTriggerSelectStep(X); } + +// The special RAISE expression that may occur in trigger programs +expr(A) ::= RAISE(X) LP IGNORE RP(Y). { + A = sqliteExpr(TK_RAISE, 0, 0, 0); + A->iColumn = OE_Ignore; + sqliteExprSpan(A, &X, &Y); +} +expr(A) ::= RAISE(X) LP ROLLBACK COMMA nm(Z) RP(Y). { + A = sqliteExpr(TK_RAISE, 0, 0, &Z); + A->iColumn = OE_Rollback; + sqliteExprSpan(A, &X, &Y); +} +expr(A) ::= RAISE(X) LP ABORT COMMA nm(Z) RP(Y). { + A = sqliteExpr(TK_RAISE, 0, 0, &Z); + A->iColumn = OE_Abort; + sqliteExprSpan(A, &X, &Y); +} +expr(A) ::= RAISE(X) LP FAIL COMMA nm(Z) RP(Y). { + A = sqliteExpr(TK_RAISE, 0, 0, &Z); + A->iColumn = OE_Fail; + sqliteExprSpan(A, &X, &Y); +} + +//////////////////////// DROP TRIGGER statement ////////////////////////////// +cmd ::= DROP TRIGGER nm(X) dbnm(D). { + sqliteDropTrigger(pParse,sqliteSrcListAppend(0,&X,&D)); +} + +//////////////////////// ATTACH DATABASE file AS name ///////////////////////// +cmd ::= ATTACH database_kw_opt ids(F) AS nm(D). { + sqliteAttach(pParse, &F, &D); +} + +database_kw_opt ::= DATABASE. +database_kw_opt ::= . + +//////////////////////// DETACH DATABASE name ///////////////////////////////// +cmd ::= DETACH database_kw_opt nm(D). { + sqliteDetach(pParse, &D); +} diff --git a/kexi/3rdparty/kexisql/src/patches/shell.c.patch b/kexi/3rdparty/kexisql/src/patches/shell.c.patch new file mode 100644 index 00000000..0d7d2dae --- /dev/null +++ b/kexi/3rdparty/kexisql/src/patches/shell.c.patch @@ -0,0 +1,217 @@ +--- shell.c.orig/shell.c 2004-07-22 22:08:28.000000000 +0200 ++++ shell.c 2005-05-04 18:47:40.000000000 +0200 +@@ -12,7 +12,7 @@ + ** This file contains code to implement the "sqlite" command line + ** utility for accessing SQLite databases. + ** +-** $Id: shell.c,v 1.93 2004/03/17 23:42:13 drh Exp $ ++** $Id: shell.c 409279 2005-05-04 15:23:02Z staniek $ + */ + #include <stdlib.h> + #include <string.h> +@@ -20,11 +20,19 @@ + #include "sqlite.h" + #include <ctype.h> + ++#if defined(_WIN32) ++# include <io.h> ++#endif ++ + #if !defined(_WIN32) && !defined(WIN32) && !defined(__MACOS__) + # include <signal.h> + # include <pwd.h> + # include <unistd.h> + # include <sys/types.h> ++ ++#define strnicmp strncasecmp ++#define stricmp strcasecmp ++ + #endif + + #ifdef __MACOS__ +@@ -47,6 +55,12 @@ + # define stifle_history(X) + #endif + ++/* js */ ++char verboseDump = 0; ++int nObjects = 0; /* used to count progress */ ++int curObjects = 0; ++/* \js */ ++ + /* Make sure isatty() has a prototype. + */ + extern int isatty(); +@@ -80,7 +94,28 @@ + /* + ** Determines if a string is a number of not. + */ +-extern int sqliteIsNumber(const char*); ++/* extern int sqliteIsNumber(const char*); */ ++static int isNumber(const unsigned char *z){ ++ if( *z=='-' || *z=='+' ) z++; ++ if( !isdigit(*z) ){ ++ return 0; ++ } ++ z++; ++ while( isdigit(*z) ){ z++; } ++ if( *z=='.' ){ ++ z++; ++ if( !isdigit(*z) ) return 0; ++ while( isdigit(*z) ){ z++; } ++ } ++ if( *z=='e' || *z=='E' ){ ++ z++; ++ if( *z=='+' || *z=='-' ) z++; ++ if( !isdigit(*z) ) return 0; ++ while( isdigit(*z) ){ z++; } ++ } ++ return *z==0; ++} ++ + + /* + ** This routine reads a line of text from standard input, stores +@@ -392,7 +427,7 @@ + char *zSep = i>0 ? ",": ""; + if( azArg[i]==0 ){ + fprintf(p->out,"%sNULL",zSep); +- }else if( sqliteIsNumber(azArg[i]) ){ ++ }else if( isNumber(azArg[i]) ){ + fprintf(p->out,"%s%s",zSep, azArg[i]); + }else{ + if( zSep[0] ) fprintf(p->out,"%s",zSep); +@@ -452,10 +487,14 @@ + */ + static int dump_callback(void *pArg, int nArg, char **azArg, char **azCol){ + struct callback_data *p = (struct callback_data *)pArg; ++ struct callback_data d2; + if( nArg!=3 ) return 1; + fprintf(p->out, "%s;\n", azArg[2]); + if( strcmp(azArg[1],"table")==0 ){ +- struct callback_data d2; ++/* js */ ++ if (verboseDump) ++ fprintf(stderr, "%%%d\n", (++curObjects * 100 / nObjects)); ++/* \js */ + d2 = *p; + d2.mode = MODE_Insert; + d2.zDestTable = 0; +@@ -542,6 +581,14 @@ + int rc = 0; + char *azArg[50]; + ++/* js */ ++ sqlite_vm *pVm; ++ char *errMsg; ++ int ncolumns; /* OUT: Number of columns in result */ ++ const char **pazValue; /* OUT: Column data */ ++ const char **pazColName; /* OUT: Column names and datatypes */ ++/* \js */ ++ + /* Parse the input line into tokens. + */ + while( zLine[i] && nArg<ArraySize(azArg) ){ +@@ -586,6 +633,24 @@ + if( c=='d' && strncmp(azArg[0], "dump", n)==0 ){ + char *zErrMsg = 0; + open_db(p); ++ ++/* js */ ++if (SQLITE_OK!=sqlite_compile(p->db, "SELECT COUNT(1) FROM sqlite_master", ++0, &pVm, &errMsg)) { ++ fprintf(stderr, "%s\n", errMsg); ++ exit(1); ++} ++if (SQLITE_ROW!=sqlite_step( pVm, &ncolumns, &pazValue, &pazColName )) { ++ exit(1); ++} ++nObjects = atoi(pazValue[0]); ++ ++if (SQLITE_OK!=sqlite_finalize( pVm, &errMsg)) { ++ fprintf(stderr, "%s\n", errMsg); ++ exit(1); ++} ++/* \js */ ++ + fprintf(p->out, "BEGIN TRANSACTION;\n"); + if( nArg==1 ){ + sqlite_exec(p->db, +@@ -812,8 +877,9 @@ + data.showHeader = 0; + data.mode = MODE_Semi; + if( nArg>1 ){ +- extern int sqliteStrICmp(const char*,const char*); +- if( sqliteStrICmp(azArg[1],"sqlite_master")==0 ){ ++/* extern int sqliteStrICmp(const char*,const char*); ++ if( sqliteStrICmp(azArg[1],"sqlite_master")==0 ){*/ ++ if( stricmp(azArg[1],"sqlite_master")==0 ){ + char *new_argv[2], *new_colv[2]; + new_argv[0] = "CREATE TABLE sqlite_master (\n" + " type text,\n" +@@ -826,7 +892,8 @@ + 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( sqliteStrICmp(azArg[1],"sqlite_temp_master")==0 ){*/ ++ }else if( stricmp(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" +@@ -997,10 +1064,11 @@ + ** as is the Oracle "/". + */ + static int _is_command_terminator(const char *zLine){ +- extern int sqliteStrNICmp(const char*,const char*,int); ++/* extern int sqliteStrNICmp(const char*,const char*,int); */ + while( isspace(*zLine) ){ zLine++; }; + if( zLine[0]=='/' && _all_whitespace(&zLine[1]) ) return 1; /* Oracle */ +- if( sqliteStrNICmp(zLine,"go",2)==0 && _all_whitespace(&zLine[2]) ){ ++/* if( sqliteStrNICmp(zLine,"go",2)==0 && _all_whitespace(&zLine[2]) ){ */ ++ if( strnicmp(zLine,"go",2)==0 && _all_whitespace(&zLine[2]) ){ + return 1; /* SQL Server */ + } + return 0; +@@ -1210,7 +1278,7 @@ + const char *zInitFile = 0; + char *zFirstCmd = 0; + int i; +- extern int sqliteOsFileExists(const char*); ++/* extern int sqliteOsFileExists(const char*); */ + + #ifdef __MACOS__ + argc = ccommand(&argv); +@@ -1257,7 +1325,7 @@ + ** files from being created if a user mistypes the database name argument + ** to the sqlite command-line tool. + */ +- if( sqliteOsFileExists(data.zDbFilename) ){ ++ if( access(data.zDbFilename, 0)==0 ){ + open_db(&data); + } + +@@ -1297,8 +1365,10 @@ + }else if( strcmp(z,"-echo")==0 ){ + data.echoOn = 1; + }else if( strcmp(z,"-version")==0 ){ +- printf("%s\n", sqlite_version); ++ printf("%s\n", sqlite_libversion()); + return 1; ++ }else if( strcmp(z,"-verbose-dump")==0 ){ ++ verboseDump = 1; + }else if( strcmp(z,"-help")==0 ){ + usage(1); + }else{ +@@ -1330,9 +1400,9 @@ + char *zHome; + char *zHistory = 0; + printf( +- "SQLite version %s\n" ++ "SQLite version %s (bundled with Kexi)\n" + "Enter \".help\" for instructions\n", +- sqlite_version ++ sqlite_libversion() + ); + zHome = find_home_dir(); + if( zHome && (zHistory = malloc(strlen(zHome)+20))!=0 ){ diff --git a/kexi/3rdparty/kexisql/src/pragma.c b/kexi/3rdparty/kexisql/src/pragma.c new file mode 100644 index 00000000..4f102657 --- /dev/null +++ b/kexi/3rdparty/kexisql/src/pragma.c @@ -0,0 +1,712 @@ +/* +** 2003 April 6 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains code used to implement the PRAGMA command. +** +** $Id: pragma.c 410099 2005-05-06 17:52:07Z staniek $ +*/ +#include "sqliteInt.h" +#include <ctype.h> + +/* +** Interpret the given string as a boolean value. +*/ +static int getBoolean(const char *z){ + static char *azTrue[] = { "yes", "on", "true" }; + int i; + if( z[0]==0 ) return 0; + if( isdigit(z[0]) || (z[0]=='-' && isdigit(z[1])) ){ + return atoi(z); + } + for(i=0; i<sizeof(azTrue)/sizeof(azTrue[0]); i++){ + if( sqliteStrICmp(z,azTrue[i])==0 ) return 1; + } + return 0; +} + +/* +** Interpret the given string as a safety level. Return 0 for OFF, +** 1 for ON or NORMAL and 2 for FULL. Return 1 for an empty or +** unrecognized string argument. +** +** Note that the values returned are one less that the values that +** should be passed into sqliteBtreeSetSafetyLevel(). The is done +** to support legacy SQL code. The safety level used to be boolean +** and older scripts may have used numbers 0 for OFF and 1 for ON. +*/ +static int getSafetyLevel(char *z){ + static const struct { + const char *zWord; + int val; + } aKey[] = { + { "no", 0 }, + { "off", 0 }, + { "false", 0 }, + { "yes", 1 }, + { "on", 1 }, + { "true", 1 }, + { "full", 2 }, + }; + int i; + if( z[0]==0 ) return 1; + if( isdigit(z[0]) || (z[0]=='-' && isdigit(z[1])) ){ + return atoi(z); + } + for(i=0; i<sizeof(aKey)/sizeof(aKey[0]); i++){ + if( sqliteStrICmp(z,aKey[i].zWord)==0 ) return aKey[i].val; + } + return 1; +} + +/* +** Interpret the given string as a temp db location. Return 1 for file +** backed temporary databases, 2 for the Red-Black tree in memory database +** and 0 to use the compile-time default. +*/ +static int getTempStore(const char *z){ + if( z[0]>='0' && z[0]<='2' ){ + return z[0] - '0'; + }else if( sqliteStrICmp(z, "file")==0 ){ + return 1; + }else if( sqliteStrICmp(z, "memory")==0 ){ + return 2; + }else{ + return 0; + } +} + +/* +** If the TEMP database is open, close it and mark the database schema +** as needing reloading. This must be done when using the TEMP_STORE +** or DEFAULT_TEMP_STORE pragmas. +*/ +static int changeTempStorage(Parse *pParse, const char *zStorageType){ + int ts = getTempStore(zStorageType); + sqlite *db = pParse->db; + if( db->temp_store==ts ) return SQLITE_OK; + if( db->aDb[1].pBt!=0 ){ + if( db->flags & SQLITE_InTrans ){ + sqliteErrorMsg(pParse, "temporary storage cannot be changed " + "from within a transaction"); + return SQLITE_ERROR; + } + sqliteBtreeClose(db->aDb[1].pBt); + db->aDb[1].pBt = 0; + sqliteResetInternalSchema(db, 0); + } + db->temp_store = ts; + return SQLITE_OK; +} + +/* +** Check to see if zRight and zLeft refer to a pragma that queries +** or changes one of the flags in db->flags. Return 1 if so and 0 if not. +** Also, implement the pragma. +*/ +static int flagPragma(Parse *pParse, const char *zLeft, const char *zRight){ + static const struct { + const char *zName; /* Name of the pragma */ + int mask; /* Mask for the db->flags value */ + } aPragma[] = { + { "vdbe_trace", SQLITE_VdbeTrace }, + { "full_column_names", SQLITE_FullColNames }, + { "short_column_names", SQLITE_ShortColNames }, + { "show_datatypes", SQLITE_ReportTypes }, + { "count_changes", SQLITE_CountRows }, + { "empty_result_callbacks", SQLITE_NullCallback }, + }; + int i; + for(i=0; i<sizeof(aPragma)/sizeof(aPragma[0]); i++){ + if( sqliteStrICmp(zLeft, aPragma[i].zName)==0 ){ + sqlite *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; + } + return 1; + } + } + return 0; +} + +/* +** Process a pragma statement. +** +** Pragmas are of this form: +** +** PRAGMA id = value +** +** The identifier might also be a string. The value is a string, and +** identifier, or a number. If minusFlag is true, then the value is +** a number that was preceded by a minus sign. +*/ +void sqlitePragma(Parse *pParse, Token *pLeft, Token *pRight, int minusFlag){ + char *zLeft = 0; + char *zRight = 0; + sqlite *db = pParse->db; + Vdbe *v = sqliteGetVdbe(pParse); + if( v==0 ) return; + + zLeft = sqliteStrNDup(pLeft->z, pLeft->n); + sqliteDequote(zLeft); + if( minusFlag ){ + zRight = 0; + sqliteSetNString(&zRight, "-", 1, pRight->z, pRight->n, 0); + }else{ + zRight = sqliteStrNDup(pRight->z, pRight->n); + sqliteDequote(zRight); + } + if( sqliteAuthCheck(pParse, SQLITE_PRAGMA, zLeft, zRight, 0) ){ + sqliteFree(zLeft); + sqliteFree(zRight); + return; + } + + /* + ** PRAGMA default_cache_size + ** PRAGMA default_cache_size=N + ** + ** The first form reports the current persistent setting for the + ** page cache size. The value returned is the maximum number of + ** pages in the page cache. The second form sets both the current + ** page cache size value and the persistent page cache size value + ** stored in the database file. + ** + ** The default cache size is stored in meta-value 2 of page 1 of the + ** database file. The cache size is actually the absolute value of + ** this memory location. The sign of meta-value 2 determines the + ** synchronous setting. A negative value means synchronous is off + ** and a positive value means synchronous is on. + */ + if( sqliteStrICmp(zLeft,"default_cache_size")==0 ){ + static VdbeOpList getCacheSize[] = { + { OP_ReadCookie, 0, 2, 0}, + { OP_AbsValue, 0, 0, 0}, + { OP_Dup, 0, 0, 0}, + { OP_Integer, 0, 0, 0}, + { OP_Ne, 0, 6, 0}, + { OP_Integer, 0, 0, 0}, /* 5 */ + { OP_ColumnName, 0, 1, "cache_size"}, + { OP_Callback, 1, 0, 0}, + }; + int addr; + if( pRight->z==pLeft->z ){ + addr = sqliteVdbeAddOpList(v, ArraySize(getCacheSize), getCacheSize); + sqliteVdbeChangeP1(v, addr+5, MAX_PAGES); + }else{ + int size = atoi(zRight); + if( size<0 ) size = -size; + sqliteBeginWriteOperation(pParse, 0, 0); + sqliteVdbeAddOp(v, OP_Integer, size, 0); + sqliteVdbeAddOp(v, OP_ReadCookie, 0, 2); + addr = sqliteVdbeAddOp(v, OP_Integer, 0, 0); + sqliteVdbeAddOp(v, OP_Ge, 0, addr+3); + sqliteVdbeAddOp(v, OP_Negative, 0, 0); + sqliteVdbeAddOp(v, OP_SetCookie, 0, 2); + sqliteEndWriteOperation(pParse); + db->cache_size = db->cache_size<0 ? -size : size; + sqliteBtreeSetCacheSize(db->aDb[0].pBt, db->cache_size); + } + }else + + /* + ** PRAGMA cache_size + ** PRAGMA cache_size=N + ** + ** The first form reports the current local setting for the + ** page cache size. The local setting can be different from + ** the persistent cache size value that is stored in the database + ** file itself. The value returned is the maximum number of + ** pages in the page cache. The second form sets the local + ** page cache size value. It does not change the persistent + ** cache size stored on the disk so the cache size will revert + ** to its default value when the database is closed and reopened. + ** N should be a positive integer. + */ + if( sqliteStrICmp(zLeft,"cache_size")==0 ){ + static VdbeOpList getCacheSize[] = { + { OP_ColumnName, 0, 1, "cache_size"}, + { OP_Callback, 1, 0, 0}, + }; + if( pRight->z==pLeft->z ){ + int size = db->cache_size;; + if( size<0 ) size = -size; + sqliteVdbeAddOp(v, OP_Integer, size, 0); + sqliteVdbeAddOpList(v, ArraySize(getCacheSize), getCacheSize); + }else{ + int size = atoi(zRight); + if( size<0 ) size = -size; + if( db->cache_size<0 ) size = -size; + db->cache_size = size; + sqliteBtreeSetCacheSize(db->aDb[0].pBt, db->cache_size); + } + }else + + /* + ** PRAGMA default_synchronous + ** PRAGMA default_synchronous=ON|OFF|NORMAL|FULL + ** + ** The first form returns the persistent value of the "synchronous" setting + ** that is stored in the database. This is the synchronous setting that + ** is used whenever the database is opened unless overridden by a separate + ** "synchronous" pragma. The second form changes the persistent and the + ** local synchronous setting to the value given. + ** + ** If synchronous is OFF, SQLite does not attempt any fsync() systems calls + ** to make sure data is committed to disk. Write operations are very fast, + ** but a power failure can leave the database in an inconsistent state. + ** If synchronous is ON or NORMAL, SQLite will do an fsync() system call to + ** make sure data is being written to disk. The risk of corruption due to + ** a power loss in this mode is negligible but non-zero. If synchronous + ** is FULL, extra fsync()s occur to reduce the risk of corruption to near + ** zero, but with a write performance penalty. The default mode is NORMAL. + */ + if( sqliteStrICmp(zLeft,"default_synchronous")==0 ){ + static VdbeOpList getSync[] = { + { OP_ColumnName, 0, 1, "synchronous"}, + { OP_ReadCookie, 0, 3, 0}, + { OP_Dup, 0, 0, 0}, + { OP_If, 0, 0, 0}, /* 3 */ + { OP_ReadCookie, 0, 2, 0}, + { OP_Integer, 0, 0, 0}, + { OP_Lt, 0, 5, 0}, + { OP_AddImm, 1, 0, 0}, + { OP_Callback, 1, 0, 0}, + { OP_Halt, 0, 0, 0}, + { OP_AddImm, -1, 0, 0}, /* 10 */ + { OP_Callback, 1, 0, 0} + }; + if( pRight->z==pLeft->z ){ + int addr = sqliteVdbeAddOpList(v, ArraySize(getSync), getSync); + sqliteVdbeChangeP2(v, addr+3, addr+10); + }else{ + int addr; + int size = db->cache_size; + if( size<0 ) size = -size; + sqliteBeginWriteOperation(pParse, 0, 0); + sqliteVdbeAddOp(v, OP_ReadCookie, 0, 2); + sqliteVdbeAddOp(v, OP_Dup, 0, 0); + addr = sqliteVdbeAddOp(v, OP_Integer, 0, 0); + sqliteVdbeAddOp(v, OP_Ne, 0, addr+3); + sqliteVdbeAddOp(v, OP_AddImm, MAX_PAGES, 0); + sqliteVdbeAddOp(v, OP_AbsValue, 0, 0); + db->safety_level = getSafetyLevel(zRight)+1; + if( db->safety_level==1 ){ + sqliteVdbeAddOp(v, OP_Negative, 0, 0); + size = -size; + } + sqliteVdbeAddOp(v, OP_SetCookie, 0, 2); + sqliteVdbeAddOp(v, OP_Integer, db->safety_level, 0); + sqliteVdbeAddOp(v, OP_SetCookie, 0, 3); + sqliteEndWriteOperation(pParse); + db->cache_size = size; + sqliteBtreeSetCacheSize(db->aDb[0].pBt, db->cache_size); + sqliteBtreeSetSafetyLevel(db->aDb[0].pBt, db->safety_level); + } + }else + + /* + ** PRAGMA synchronous + ** PRAGMA synchronous=OFF|ON|NORMAL|FULL + ** + ** Return or set the local value of the synchronous flag. Changing + ** the local value does not make changes to the disk file and the + ** default value will be restored the next time the database is + ** opened. + */ + if( sqliteStrICmp(zLeft,"synchronous")==0 ){ + static VdbeOpList getSync[] = { + { OP_ColumnName, 0, 1, "synchronous"}, + { OP_Callback, 1, 0, 0}, + }; + if( pRight->z==pLeft->z ){ + sqliteVdbeAddOp(v, OP_Integer, db->safety_level-1, 0); + sqliteVdbeAddOpList(v, ArraySize(getSync), getSync); + }else{ + int size = db->cache_size; + if( size<0 ) size = -size; + db->safety_level = getSafetyLevel(zRight)+1; + if( db->safety_level==1 ) size = -size; + db->cache_size = size; + sqliteBtreeSetCacheSize(db->aDb[0].pBt, db->cache_size); + sqliteBtreeSetSafetyLevel(db->aDb[0].pBt, db->safety_level); + } + }else + +#ifndef NDEBUG + if( sqliteStrICmp(zLeft, "trigger_overhead_test")==0 ){ + if( getBoolean(zRight) ){ + always_code_trigger_setup = 1; + }else{ + always_code_trigger_setup = 0; + } + }else +#endif + + if( flagPragma(pParse, zLeft, zRight) ){ + /* The flagPragma() call also generates any necessary code */ + }else + + if( sqliteStrICmp(zLeft, "table_info")==0 ){ + Table *pTab; + pTab = sqliteFindTable(db, zRight, 0); + if( pTab ){ + static VdbeOpList tableInfoPreface[] = { + { OP_ColumnName, 0, 0, "cid"}, + { OP_ColumnName, 1, 0, "name"}, + { OP_ColumnName, 2, 0, "type"}, + { OP_ColumnName, 3, 0, "notnull"}, + { OP_ColumnName, 4, 0, "dflt_value"}, + { OP_ColumnName, 5, 1, "pk"}, + }; + int i; + sqliteVdbeAddOpList(v, ArraySize(tableInfoPreface), tableInfoPreface); + sqliteViewGetColumnNames(pParse, pTab); + for(i=0; i<pTab->nCol; 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; i<pIdx->nColumn; 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; j<pFK->nCol; 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; i<db->nDb; i++){ + if( db->aDb[i].pBt==0 ) continue; + assert( db->aDb[i].zName!=0 ); + sqliteVdbeAddOp(v, OP_Integer, i, 0); + sqliteVdbeOp3(v, OP_String, 0, 0, db->aDb[i].zName, 0); + sqliteVdbeOp3(v, OP_String, 0, 0, + sqliteBtreeGetFilename(db->aDb[i].pBt), 0); + sqliteVdbeAddOp(v, OP_Callback, 3, 0); + } + }else + + + /* + ** PRAGMA temp_store + ** PRAGMA temp_store = "default"|"memory"|"file" + ** + ** Return or set the local value of the temp_store flag. Changing + ** the local value does not make changes to the disk file and the default + ** value will be restored the next time the database is opened. + ** + ** Note that it is possible for the library compile-time options to + ** override this setting + */ + if( sqliteStrICmp(zLeft, "temp_store")==0 ){ + static VdbeOpList getTmpDbLoc[] = { + { OP_ColumnName, 0, 1, "temp_store"}, + { OP_Callback, 1, 0, 0}, + }; + if( pRight->z==pLeft->z ){ + sqliteVdbeAddOp(v, OP_Integer, db->temp_store, 0); + sqliteVdbeAddOpList(v, ArraySize(getTmpDbLoc), getTmpDbLoc); + }else{ + changeTempStorage(pParse, zRight); + } + }else + + /* + ** PRAGMA default_temp_store + ** PRAGMA default_temp_store = "default"|"memory"|"file" + ** + ** Return or set the value of the persistent temp_store flag. Any + ** change does not take effect until the next time the database is + ** opened. + ** + ** Note that it is possible for the library compile-time options to + ** override this setting + */ + if( sqliteStrICmp(zLeft, "default_temp_store")==0 ){ + static VdbeOpList getTmpDbLoc[] = { + { OP_ColumnName, 0, 1, "temp_store"}, + { OP_ReadCookie, 0, 5, 0}, + { OP_Callback, 1, 0, 0}}; + if( pRight->z==pLeft->z ){ + sqliteVdbeAddOpList(v, ArraySize(getTmpDbLoc), getTmpDbLoc); + }else{ + sqliteBeginWriteOperation(pParse, 0, 0); + sqliteVdbeAddOp(v, OP_Integer, getTempStore(zRight), 0); + sqliteVdbeAddOp(v, OP_SetCookie, 0, 5); + sqliteEndWriteOperation(pParse); + } + }else + +#ifndef NDEBUG + if( sqliteStrICmp(zLeft, "parser_trace")==0 ){ + extern void sqliteParserTrace(FILE*, char *); + if( getBoolean(zRight) ){ + sqliteParserTrace(stdout, "parser: "); + }else{ + sqliteParserTrace(0, 0); + } + }else +#endif + + if( sqliteStrICmp(zLeft, "integrity_check")==0 ){ + int i, j, addr; + + /* Code that initializes the integrity check program. Set the + ** error count 0 + */ + static VdbeOpList initCode[] = { + { OP_Integer, 0, 0, 0}, + { OP_MemStore, 0, 1, 0}, + { OP_ColumnName, 0, 1, "integrity_check"}, + }; + + /* Code to do an BTree integrity check on a single database file. + */ + static VdbeOpList checkDb[] = { + { OP_SetInsert, 0, 0, "2"}, + { OP_Integer, 0, 0, 0}, /* 1 */ + { OP_OpenRead, 0, 2, 0}, + { OP_Rewind, 0, 7, 0}, /* 3 */ + { OP_Column, 0, 3, 0}, /* 4 */ + { OP_SetInsert, 0, 0, 0}, + { OP_Next, 0, 4, 0}, /* 6 */ + { OP_IntegrityCk, 0, 0, 0}, /* 7 */ + { OP_Dup, 0, 1, 0}, + { OP_String, 0, 0, "ok"}, + { OP_StrEq, 0, 12, 0}, /* 10 */ + { OP_MemIncr, 0, 0, 0}, + { OP_String, 0, 0, "*** in database "}, + { OP_String, 0, 0, 0}, /* 13 */ + { OP_String, 0, 0, " ***\n"}, + { OP_Pull, 3, 0, 0}, + { OP_Concat, 4, 1, 0}, + { OP_Callback, 1, 0, 0}, + }; + + /* Code that appears at the end of the integrity check. If no error + ** messages have been generated, output OK. Otherwise output the + ** error message + */ + static VdbeOpList endCode[] = { + { OP_MemLoad, 0, 0, 0}, + { OP_Integer, 0, 0, 0}, + { OP_Ne, 0, 0, 0}, /* 2 */ + { OP_String, 0, 0, "ok"}, + { OP_Callback, 1, 0, 0}, + }; + + /* Initialize the VDBE program */ + sqliteVdbeAddOpList(v, ArraySize(initCode), initCode); + + /* Do an integrity check on each database file */ + for(i=0; i<db->nDb; i++){ + HashElem *x; + + /* Do an integrity check of the B-Tree + */ + addr = sqliteVdbeAddOpList(v, ArraySize(checkDb), checkDb); + sqliteVdbeChangeP1(v, addr+1, i); + sqliteVdbeChangeP2(v, addr+3, addr+7); + sqliteVdbeChangeP2(v, addr+6, addr+4); + sqliteVdbeChangeP2(v, addr+7, i); + sqliteVdbeChangeP2(v, addr+10, addr+ArraySize(checkDb)); + sqliteVdbeChangeP3(v, addr+13, db->aDb[i].zName, P3_STATIC); + + /* Make sure all the indices are constructed correctly. + */ + sqliteCodeVerifySchema(pParse, i); + for(x=sqliteHashFirst(&db->aDb[i].tblHash); x; x=sqliteHashNext(x)){ + Table *pTab = sqliteHashData(x); + Index *pIdx; + int loopTop; + + if( pTab->pIndex==0 ) continue; + sqliteVdbeAddOp(v, OP_Integer, i, 0); + sqliteVdbeOp3(v, OP_OpenRead, 1, pTab->tnum, pTab->zName, 0); + for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){ + if( pIdx->tnum==0 ) continue; + sqliteVdbeAddOp(v, OP_Integer, pIdx->iDb, 0); + sqliteVdbeOp3(v, OP_OpenRead, j+2, pIdx->tnum, pIdx->zName, 0); + } + sqliteVdbeAddOp(v, OP_Integer, 0, 0); + sqliteVdbeAddOp(v, OP_MemStore, 1, 1); + loopTop = sqliteVdbeAddOp(v, OP_Rewind, 1, 0); + sqliteVdbeAddOp(v, OP_MemIncr, 1, 0); + for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){ + int k, jmp2; + static VdbeOpList idxErr[] = { + { OP_MemIncr, 0, 0, 0}, + { OP_String, 0, 0, "rowid "}, + { OP_Recno, 1, 0, 0}, + { OP_String, 0, 0, " missing from index "}, + { OP_String, 0, 0, 0}, /* 4 */ + { OP_Concat, 4, 0, 0}, + { OP_Callback, 1, 0, 0}, + }; + sqliteVdbeAddOp(v, OP_Recno, 1, 0); + for(k=0; k<pIdx->nColumn; k++){ + int idx = pIdx->aiColumn[k]; + if( idx==pTab->iPKey ){ + sqliteVdbeAddOp(v, OP_Recno, 1, 0); + }else{ + sqliteVdbeAddOp(v, OP_Column, 1, idx); + } + } + sqliteVdbeAddOp(v, OP_MakeIdxKey, pIdx->nColumn, 0); + if( db->file_format>=4 ) sqliteAddIdxKeyType(v, pIdx); + jmp2 = sqliteVdbeAddOp(v, OP_Found, j+2, 0); + addr = sqliteVdbeAddOpList(v, ArraySize(idxErr), idxErr); + sqliteVdbeChangeP3(v, addr+4, pIdx->zName, P3_STATIC); + sqliteVdbeChangeP2(v, jmp2, sqliteVdbeCurrentAddr(v)); + } + sqliteVdbeAddOp(v, OP_Next, 1, loopTop+1); + sqliteVdbeChangeP2(v, loopTop, sqliteVdbeCurrentAddr(v)); + for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){ + static VdbeOpList cntIdx[] = { + { OP_Integer, 0, 0, 0}, + { OP_MemStore, 2, 1, 0}, + { OP_Rewind, 0, 0, 0}, /* 2 */ + { OP_MemIncr, 2, 0, 0}, + { OP_Next, 0, 0, 0}, /* 4 */ + { OP_MemLoad, 1, 0, 0}, + { OP_MemLoad, 2, 0, 0}, + { OP_Eq, 0, 0, 0}, /* 7 */ + { OP_MemIncr, 0, 0, 0}, + { OP_String, 0, 0, "wrong # of entries in index "}, + { OP_String, 0, 0, 0}, /* 10 */ + { OP_Concat, 2, 0, 0}, + { OP_Callback, 1, 0, 0}, + }; + if( pIdx->tnum==0 ) continue; + addr = sqliteVdbeAddOpList(v, ArraySize(cntIdx), cntIdx); + sqliteVdbeChangeP1(v, addr+2, j+2); + sqliteVdbeChangeP2(v, addr+2, addr+5); + sqliteVdbeChangeP1(v, addr+4, j+2); + sqliteVdbeChangeP2(v, addr+4, addr+3); + sqliteVdbeChangeP2(v, addr+7, addr+ArraySize(cntIdx)); + sqliteVdbeChangeP3(v, addr+10, pIdx->zName, P3_STATIC); + } + } + } + addr = sqliteVdbeAddOpList(v, ArraySize(endCode), endCode); + sqliteVdbeChangeP2(v, addr+2, addr+ArraySize(endCode)); + }else + + {} + sqliteFree(zLeft); + sqliteFree(zRight); +} diff --git a/kexi/3rdparty/kexisql/src/printf.c b/kexi/3rdparty/kexisql/src/printf.c new file mode 100644 index 00000000..f867d62a --- /dev/null +++ b/kexi/3rdparty/kexisql/src/printf.c @@ -0,0 +1,858 @@ +/* +** The "printf" code that follows dates from the 1980's. It is in +** the public domain. The original comments are included here for +** completeness. They are very out-of-date but might be useful as +** an historical reference. Most of the "enhancements" have been backed +** out so that the functionality is now the same as standard printf(). +** +************************************************************************** +** +** The following modules is an enhanced replacement for the "printf" subroutines +** found in the standard C library. The following enhancements are +** supported: +** +** + Additional functions. The standard set of "printf" functions +** includes printf, fprintf, sprintf, vprintf, vfprintf, and +** vsprintf. This module adds the following: +** +** * snprintf -- Works like sprintf, but has an extra argument +** which is the size of the buffer written to. +** +** * mprintf -- Similar to sprintf. Writes output to memory +** obtained from malloc. +** +** * xprintf -- Calls a function to dispose of output. +** +** * nprintf -- No output, but returns the number of characters +** that would have been output by printf. +** +** * A v- version (ex: vsnprintf) of every function is also +** supplied. +** +** + A few extensions to the formatting notation are supported: +** +** * The "=" flag (similar to "-") causes the output to be +** be centered in the appropriately sized field. +** +** * The %b field outputs an integer in binary notation. +** +** * The %c field now accepts a precision. The character output +** is repeated by the number of times the precision specifies. +** +** * The %' field works like %c, but takes as its character the +** next character of the format string, instead of the next +** argument. For example, printf("%.78'-") prints 78 minus +** signs, the same as printf("%.78c",'-'). +** +** + When compiled using GCC on a SPARC, this version of printf is +** faster than the library printf for SUN OS 4.1. +** +** + All functions are fully reentrant. +** +*/ +#include "sqliteInt.h" + +/* +** Conversion types fall into various categories as defined by the +** following enumeration. +*/ +#define etRADIX 1 /* Integer types. %d, %x, %o, and so forth */ +#define etFLOAT 2 /* Floating point. %f */ +#define etEXP 3 /* Exponentional notation. %e and %E */ +#define etGENERIC 4 /* Floating or exponential, depending on exponent. %g */ +#define etSIZE 5 /* Return number of characters processed so far. %n */ +#define etSTRING 6 /* Strings. %s */ +#define etDYNSTRING 7 /* Dynamically allocated strings. %z */ +#define etPERCENT 8 /* Percent symbol. %% */ +#define etCHARX 9 /* Characters. %c */ +#define etERROR 10 /* Used to indicate no such conversion type */ +/* The rest are extensions, not normally found in printf() */ +#define etCHARLIT 11 /* Literal characters. %' */ +#define etSQLESCAPE 12 /* Strings with '\'' doubled. %q */ +#define etSQLESCAPE2 13 /* Strings with '\'' doubled and enclosed in '', + NULL pointers replaced by SQL NULL. %Q */ +#define etTOKEN 14 /* a pointer to a Token structure */ +#define etSRCLIST 15 /* a pointer to a SrcList */ + + +/* +** An "etByte" is an 8-bit unsigned value. +*/ +typedef unsigned char etByte; + +/* +** Each builtin conversion character (ex: the 'd' in "%d") is described +** by an instance of the following structure +*/ +typedef struct et_info { /* Information about each format field */ + char fmttype; /* The format field code letter */ + etByte base; /* The base for radix conversion */ + etByte flags; /* One or more of FLAG_ constants below */ + etByte type; /* Conversion paradigm */ + char *charset; /* The character set for conversion */ + char *prefix; /* Prefix on non-zero values in alt format */ +} et_info; + +/* +** Allowed values for et_info.flags +*/ +#define FLAG_SIGNED 1 /* True if the value to convert is signed */ +#define FLAG_INTERN 2 /* True if for internal use only */ + + +/* +** The following table is searched linearly, so it is good to put the +** most frequently used conversion types first. +*/ +static et_info fmtinfo[] = { + { 'd', 10, 1, etRADIX, "0123456789", 0 }, + { 's', 0, 0, etSTRING, 0, 0 }, + { 'z', 0, 2, etDYNSTRING, 0, 0 }, + { 'q', 0, 0, etSQLESCAPE, 0, 0 }, + { 'Q', 0, 0, etSQLESCAPE2, 0, 0 }, + { 'c', 0, 0, etCHARX, 0, 0 }, + { 'o', 8, 0, etRADIX, "01234567", "0" }, + { 'u', 10, 0, etRADIX, "0123456789", 0 }, + { 'x', 16, 0, etRADIX, "0123456789abcdef", "x0" }, + { 'X', 16, 0, etRADIX, "0123456789ABCDEF", "X0" }, + { 'f', 0, 1, etFLOAT, 0, 0 }, + { 'e', 0, 1, etEXP, "e", 0 }, + { 'E', 0, 1, etEXP, "E", 0 }, + { 'g', 0, 1, etGENERIC, "e", 0 }, + { 'G', 0, 1, etGENERIC, "E", 0 }, + { 'i', 10, 1, etRADIX, "0123456789", 0 }, + { 'n', 0, 0, etSIZE, 0, 0 }, + { '%', 0, 0, etPERCENT, 0, 0 }, + { 'p', 10, 0, etRADIX, "0123456789", 0 }, + { 'T', 0, 2, etTOKEN, 0, 0 }, + { 'S', 0, 2, etSRCLIST, 0, 0 }, +}; +#define etNINFO (sizeof(fmtinfo)/sizeof(fmtinfo[0])) + +/* +** If NOFLOATINGPOINT is defined, then none of the floating point +** conversions will work. +*/ +#ifndef etNOFLOATINGPOINT +/* +** "*val" is a double such that 0.1 <= *val < 10.0 +** Return the ascii code for the leading digit of *val, then +** multiply "*val" by 10.0 to renormalize. +** +** Example: +** input: *val = 3.14159 +** output: *val = 1.4159 function return = '3' +** +** The counter *cnt is incremented each time. After counter exceeds +** 16 (the number of significant digits in a 64-bit float) '0' is +** always returned. +*/ +static int et_getdigit(LONGDOUBLE_TYPE *val, int *cnt){ + int digit; + LONGDOUBLE_TYPE d; + if( (*cnt)++ >= 16 ) return '0'; + digit = (int)*val; + d = digit; + digit += '0'; + *val = (*val - d)*10.0; + return digit; +} +#endif + +#define etBUFSIZE 1000 /* Size of the output buffer */ + +/* +** The root program. All variations call this core. +** +** INPUTS: +** func This is a pointer to a function taking three arguments +** 1. A pointer to anything. Same as the "arg" parameter. +** 2. A pointer to the list of characters to be output +** (Note, this list is NOT null terminated.) +** 3. An integer number of characters to be output. +** (Note: This number might be zero.) +** +** arg This is the pointer to anything which will be passed as the +** first argument to "func". Use it for whatever you like. +** +** fmt This is the format string, as in the usual print. +** +** ap This is a pointer to a list of arguments. Same as in +** vfprint. +** +** OUTPUTS: +** The return value is the total number of characters sent to +** the function "func". Returns -1 on a error. +** +** Note that the order in which automatic variables are declared below +** seems to make a big difference in determining how fast this beast +** will run. +*/ +static int vxprintf( + void (*func)(void*,const char*,int), /* Consumer of text */ + void *arg, /* First argument to the consumer */ + int useExtended, /* Allow extended %-conversions */ + const char *fmt, /* Format string */ + va_list ap /* arguments */ +){ + int c; /* Next character in the format string */ + char *bufpt; /* Pointer to the conversion buffer */ + int precision; /* Precision of the current field */ + int length; /* Length of the field */ + int idx; /* A general purpose loop counter */ + int count; /* Total number of characters output */ + int width; /* Width of the current field */ + etByte flag_leftjustify; /* True if "-" flag is present */ + etByte flag_plussign; /* True if "+" flag is present */ + etByte flag_blanksign; /* True if " " flag is present */ + etByte flag_alternateform; /* True if "#" flag is present */ + etByte flag_zeropad; /* True if field width constant starts with zero */ + etByte flag_long; /* True if "l" flag is present */ + unsigned long longvalue; /* Value for integer types */ + LONGDOUBLE_TYPE realvalue; /* Value for real types */ + et_info *infop; /* Pointer to the appropriate info structure */ + char buf[etBUFSIZE]; /* Conversion buffer */ + char prefix; /* Prefix character. "+" or "-" or " " or '\0'. */ + etByte errorflag = 0; /* True if an error is encountered */ + etByte xtype; /* Conversion paradigm */ + char *zExtra; /* Extra memory used for etTCLESCAPE conversions */ + static char spaces[] = " "; +#define etSPACESIZE (sizeof(spaces)-1) +#ifndef etNOFLOATINGPOINT + int exp; /* exponent of real numbers */ + double rounder; /* Used for rounding floating point values */ + etByte flag_dp; /* True if decimal point should be shown */ + etByte flag_rtz; /* True if trailing zeros should be removed */ + etByte flag_exp; /* True to force display of the exponent */ + int nsd; /* Number of significant digits returned */ +#endif + + func(arg,"",0); + count = length = 0; + bufpt = 0; + for(; (c=(*fmt))!=0; ++fmt){ + if( c!='%' ){ + int amt; + bufpt = (char *)fmt; + amt = 1; + while( (c=(*++fmt))!='%' && c!=0 ) amt++; + (*func)(arg,bufpt,amt); + count += amt; + if( c==0 ) break; + } + if( (c=(*++fmt))==0 ){ + errorflag = 1; + (*func)(arg,"%",1); + count++; + break; + } + /* Find out what flags are present */ + flag_leftjustify = flag_plussign = flag_blanksign = + flag_alternateform = flag_zeropad = 0; + do{ + switch( c ){ + case '-': flag_leftjustify = 1; c = 0; break; + case '+': flag_plussign = 1; c = 0; break; + case ' ': flag_blanksign = 1; c = 0; break; + case '#': flag_alternateform = 1; c = 0; break; + case '0': flag_zeropad = 1; c = 0; break; + default: break; + } + }while( c==0 && (c=(*++fmt))!=0 ); + /* Get the field width */ + width = 0; + if( c=='*' ){ + width = va_arg(ap,int); + if( width<0 ){ + flag_leftjustify = 1; + width = -width; + } + c = *++fmt; + }else{ + while( c>='0' && c<='9' ){ + width = width*10 + c - '0'; + c = *++fmt; + } + } + if( width > etBUFSIZE-10 ){ + width = etBUFSIZE-10; + } + /* Get the precision */ + if( c=='.' ){ + precision = 0; + c = *++fmt; + if( c=='*' ){ + precision = va_arg(ap,int); + if( precision<0 ) precision = -precision; + c = *++fmt; + }else{ + while( c>='0' && c<='9' ){ + precision = precision*10 + c - '0'; + c = *++fmt; + } + } + /* Limit the precision to prevent overflowing buf[] during conversion */ + if( precision>etBUFSIZE-40 ) precision = etBUFSIZE-40; + }else{ + precision = -1; + } + /* Get the conversion type modifier */ + if( c=='l' ){ + flag_long = 1; + c = *++fmt; + }else{ + flag_long = 0; + } + /* Fetch the info entry for the field */ + infop = 0; + xtype = etERROR; + for(idx=0; idx<etNINFO; idx++){ + if( c==fmtinfo[idx].fmttype ){ + infop = &fmtinfo[idx]; + if( useExtended || (infop->flags & FLAG_INTERN)==0 ){ + xtype = infop->type; + } + break; + } + } + zExtra = 0; + + /* + ** At this point, variables are initialized as follows: + ** + ** flag_alternateform TRUE if a '#' is present. + ** flag_plussign TRUE if a '+' is present. + ** flag_leftjustify TRUE if a '-' is present or if the + ** field width was negative. + ** flag_zeropad TRUE if the width began with 0. + ** flag_long TRUE if the letter 'l' (ell) prefixed + ** the conversion character. + ** flag_blanksign TRUE if a ' ' is present. + ** width The specified field width. This is + ** always non-negative. Zero is the default. + ** precision The specified precision. The default + ** is -1. + ** xtype The class of the conversion. + ** infop Pointer to the appropriate info struct. + */ + switch( xtype ){ + case etRADIX: + if( flag_long ) longvalue = va_arg(ap,long); + else longvalue = va_arg(ap,int); +#if 1 + /* For the format %#x, the value zero is printed "0" not "0x0". + ** I think this is stupid. */ + if( longvalue==0 ) flag_alternateform = 0; +#else + /* More sensible: turn off the prefix for octal (to prevent "00"), + ** but leave the prefix for hex. */ + if( longvalue==0 && infop->base==8 ) flag_alternateform = 0; +#endif + if( infop->flags & FLAG_SIGNED ){ + if( *(long*)&longvalue<0 ){ + longvalue = -*(long*)&longvalue; + prefix = '-'; + }else if( flag_plussign ) prefix = '+'; + else if( flag_blanksign ) prefix = ' '; + else prefix = 0; + }else prefix = 0; + if( flag_zeropad && precision<width-(prefix!=0) ){ + precision = width-(prefix!=0); + } + bufpt = &buf[etBUFSIZE-1]; + { + register char *cset; /* Use registers for speed */ + register int base; + cset = infop->charset; + base = infop->base; + do{ /* Convert to ascii */ + *(--bufpt) = cset[longvalue%base]; + longvalue = longvalue/base; + }while( longvalue>0 ); + } + length = &buf[etBUFSIZE-1]-bufpt; + for(idx=precision-length; idx>0; idx--){ + *(--bufpt) = '0'; /* Zero pad */ + } + if( prefix ) *(--bufpt) = prefix; /* Add sign */ + if( flag_alternateform && infop->prefix ){ /* Add "0" or "0x" */ + char *pre, x; + pre = infop->prefix; + if( *bufpt!=pre[0] ){ + for(pre=infop->prefix; (x=(*pre))!=0; pre++) *(--bufpt) = x; + } + } + length = &buf[etBUFSIZE-1]-bufpt; + break; + case etFLOAT: + case etEXP: + case etGENERIC: + realvalue = va_arg(ap,double); +#ifndef etNOFLOATINGPOINT + if( precision<0 ) precision = 6; /* Set default precision */ + if( precision>etBUFSIZE-10 ) precision = etBUFSIZE-10; + if( realvalue<0.0 ){ + realvalue = -realvalue; + prefix = '-'; + }else{ + if( flag_plussign ) prefix = '+'; + else if( flag_blanksign ) prefix = ' '; + else prefix = 0; + } + if( infop->type==etGENERIC && precision>0 ) precision--; + rounder = 0.0; +#if 0 + /* Rounding works like BSD when the constant 0.4999 is used. Wierd! */ + for(idx=precision, rounder=0.4999; idx>0; idx--, rounder*=0.1); +#else + /* It makes more sense to use 0.5 */ + for(idx=precision, rounder=0.5; idx>0; idx--, rounder*=0.1); +#endif + if( infop->type==etFLOAT ) realvalue += rounder; + /* Normalize realvalue to within 10.0 > realvalue >= 1.0 */ + exp = 0; + if( realvalue>0.0 ){ + while( realvalue>=1e8 && exp<=350 ){ realvalue *= 1e-8; exp+=8; } + while( realvalue>=10.0 && exp<=350 ){ realvalue *= 0.1; exp++; } + while( realvalue<1e-8 && exp>=-350 ){ realvalue *= 1e8; exp-=8; } + while( realvalue<1.0 && exp>=-350 ){ realvalue *= 10.0; exp--; } + if( exp>350 || exp<-350 ){ + bufpt = "NaN"; + length = 3; + break; + } + } + bufpt = buf; + /* + ** If the field type is etGENERIC, then convert to either etEXP + ** or etFLOAT, as appropriate. + */ + flag_exp = xtype==etEXP; + if( xtype!=etFLOAT ){ + realvalue += rounder; + if( realvalue>=10.0 ){ realvalue *= 0.1; exp++; } + } + if( xtype==etGENERIC ){ + flag_rtz = !flag_alternateform; + if( exp<-4 || exp>precision ){ + xtype = etEXP; + }else{ + precision = precision - exp; + xtype = etFLOAT; + } + }else{ + flag_rtz = 0; + } + /* + ** The "exp+precision" test causes output to be of type etEXP if + ** the precision is too large to fit in buf[]. + */ + nsd = 0; + if( xtype==etFLOAT && exp+precision<etBUFSIZE-30 ){ + flag_dp = (precision>0 || flag_alternateform); + if( prefix ) *(bufpt++) = prefix; /* Sign */ + if( exp<0 ) *(bufpt++) = '0'; /* Digits before "." */ + else for(; exp>=0; exp--) *(bufpt++) = et_getdigit(&realvalue,&nsd); + if( flag_dp ) *(bufpt++) = '.'; /* The decimal point */ + for(exp++; exp<0 && precision>0; precision--, exp++){ + *(bufpt++) = '0'; + } + while( (precision--)>0 ) *(bufpt++) = et_getdigit(&realvalue,&nsd); + *(bufpt--) = 0; /* Null terminate */ + if( flag_rtz && flag_dp ){ /* Remove trailing zeros and "." */ + while( bufpt>=buf && *bufpt=='0' ) *(bufpt--) = 0; + if( bufpt>=buf && *bufpt=='.' ) *(bufpt--) = 0; + } + bufpt++; /* point to next free slot */ + }else{ /* etEXP or etGENERIC */ + flag_dp = (precision>0 || flag_alternateform); + if( prefix ) *(bufpt++) = prefix; /* Sign */ + *(bufpt++) = et_getdigit(&realvalue,&nsd); /* First digit */ + if( flag_dp ) *(bufpt++) = '.'; /* Decimal point */ + while( (precision--)>0 ) *(bufpt++) = et_getdigit(&realvalue,&nsd); + bufpt--; /* point to last digit */ + if( flag_rtz && flag_dp ){ /* Remove tail zeros */ + while( bufpt>=buf && *bufpt=='0' ) *(bufpt--) = 0; + if( bufpt>=buf && *bufpt=='.' ) *(bufpt--) = 0; + } + bufpt++; /* point to next free slot */ + if( exp || flag_exp ){ + *(bufpt++) = infop->charset[0]; + if( exp<0 ){ *(bufpt++) = '-'; exp = -exp; } /* sign of exp */ + else { *(bufpt++) = '+'; } + if( exp>=100 ){ + *(bufpt++) = (exp/100)+'0'; /* 100's digit */ + exp %= 100; + } + *(bufpt++) = exp/10+'0'; /* 10's digit */ + *(bufpt++) = exp%10+'0'; /* 1's digit */ + } + } + /* The converted number is in buf[] and zero terminated. Output it. + ** Note that the number is in the usual order, not reversed as with + ** integer conversions. */ + length = bufpt-buf; + bufpt = buf; + + /* Special case: Add leading zeros if the flag_zeropad flag is + ** set and we are not left justified */ + if( flag_zeropad && !flag_leftjustify && length < width){ + int i; + int nPad = width - length; + for(i=width; i>=nPad; i--){ + bufpt[i] = bufpt[i-nPad]; + } + i = prefix!=0; + while( nPad-- ) bufpt[i++] = '0'; + length = width; + } +#endif + break; + case etSIZE: + *(va_arg(ap,int*)) = count; + length = width = 0; + break; + case etPERCENT: + buf[0] = '%'; + bufpt = buf; + length = 1; + break; + case etCHARLIT: + case etCHARX: + c = buf[0] = (xtype==etCHARX ? va_arg(ap,int) : *++fmt); + if( precision>=0 ){ + for(idx=1; idx<precision; idx++) buf[idx] = c; + length = precision; + }else{ + length =1; + } + bufpt = buf; + break; + case etSTRING: + case etDYNSTRING: + bufpt = va_arg(ap,char*); + if( bufpt==0 ){ + bufpt = ""; + }else if( xtype==etDYNSTRING ){ + zExtra = bufpt; + } + length = strlen(bufpt); + if( precision>=0 && precision<length ) length = precision; + break; + case etSQLESCAPE: + case etSQLESCAPE2: + { + int i, j, n, c, isnull; + char *arg = va_arg(ap,char*); + isnull = arg==0; + if( isnull ) arg = (xtype==etSQLESCAPE2 ? "NULL" : "(NULL)"); + for(i=n=0; (c=arg[i])!=0; i++){ + if( c=='\'' ) n++; + } + n += i + 1 + ((!isnull && xtype==etSQLESCAPE2) ? 2 : 0); + if( n>etBUFSIZE ){ + 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 && precision<length ) length = precision; + } + break; + case etTOKEN: { + Token *pToken = va_arg(ap, Token*); + (*func)(arg, pToken->z, pToken->n); + length = width = 0; + break; + } + case etSRCLIST: { + SrcList *pSrc = va_arg(ap, SrcList*); + int k = va_arg(ap, int); + struct SrcList_item *pItem = &pSrc->a[k]; + assert( k>=0 && k<pSrc->nSrc ); + if( pItem->zDatabase && pItem->zDatabase[0] ){ + (*func)(arg, pItem->zDatabase, strlen(pItem->zDatabase)); + (*func)(arg, ".", 1); + } + (*func)(arg, pItem->zName, strlen(pItem->zName)); + length = width = 0; + break; + } + case etERROR: + buf[0] = '%'; + buf[1] = c; + errorflag = 0; + idx = 1+(c!=0); + (*func)(arg,"%",idx); + count += idx; + if( c==0 ) fmt--; + break; + }/* End switch over the format type */ + /* + ** The text of the conversion is pointed to by "bufpt" and is + ** "length" characters long. The field width is "width". Do + ** the output. + */ + if( !flag_leftjustify ){ + register int nspace; + nspace = width-length; + if( nspace>0 ){ + count += nspace; + while( nspace>=etSPACESIZE ){ + (*func)(arg,spaces,etSPACESIZE); + nspace -= etSPACESIZE; + } + if( nspace>0 ) (*func)(arg,spaces,nspace); + } + } + if( length>0 ){ + (*func)(arg,bufpt,length); + count += length; + } + if( flag_leftjustify ){ + register int nspace; + nspace = width-length; + if( nspace>0 ){ + count += nspace; + while( nspace>=etSPACESIZE ){ + (*func)(arg,spaces,etSPACESIZE); + nspace -= etSPACESIZE; + } + if( nspace>0 ) (*func)(arg,spaces,nspace); + } + } + if( zExtra ){ + sqliteFree(zExtra); + } + }/* End for loop over the format string */ + return errorflag ? -1 : count; +} /* End of function */ + + +/* This structure is used to store state information about the +** write to memory that is currently in progress. +*/ +struct sgMprintf { + char *zBase; /* A base allocation */ + char *zText; /* The string collected so far */ + int nChar; /* Length of the string so far */ + int nTotal; /* Output size if unconstrained */ + int nAlloc; /* Amount of space allocated in zText */ + void *(*xRealloc)(void*,int); /* Function used to realloc memory */ +}; + +/* +** This function implements the callback from vxprintf. +** +** This routine add nNewChar characters of text in zNewText to +** the sgMprintf structure pointed to by "arg". +*/ +static void mout(void *arg, const char *zNewText, int nNewChar){ + struct sgMprintf *pM = (struct sgMprintf*)arg; + pM->nTotal += nNewChar; + if( pM->nChar + nNewChar + 1 > pM->nAlloc ){ + if( pM->xRealloc==0 ){ + nNewChar = pM->nAlloc - pM->nChar - 1; + }else{ + pM->nAlloc = pM->nChar + nNewChar*2 + 1; + if( pM->zText==pM->zBase ){ + pM->zText = pM->xRealloc(0, pM->nAlloc); + if( pM->zText && pM->nChar ){ + memcpy(pM->zText, pM->zBase, pM->nChar); + } + }else{ + pM->zText = pM->xRealloc(pM->zText, pM->nAlloc); + } + } + } + if( pM->zText ){ + if( nNewChar>0 ){ + memcpy(&pM->zText[pM->nChar], zNewText, nNewChar); + pM->nChar += nNewChar; + } + pM->zText[pM->nChar] = 0; + } +} + +/* +** This routine is a wrapper around xprintf() that invokes mout() as +** the consumer. +*/ +static char *base_vprintf( + void *(*xRealloc)(void*,int), /* Routine to realloc memory. May be NULL */ + int useInternal, /* Use internal %-conversions if true */ + char *zInitBuf, /* Initially write here, before mallocing */ + int nInitBuf, /* Size of zInitBuf[] */ + const char *zFormat, /* format string */ + va_list ap /* arguments */ +){ + struct sgMprintf sM; + sM.zBase = sM.zText = zInitBuf; + sM.nChar = sM.nTotal = 0; + sM.nAlloc = nInitBuf; + sM.xRealloc = xRealloc; + vxprintf(mout, &sM, useInternal, zFormat, ap); + if( xRealloc ){ + if( sM.zText==sM.zBase ){ + sM.zText = xRealloc(0, sM.nChar+1); + memcpy(sM.zText, sM.zBase, sM.nChar+1); + }else if( sM.nAlloc>sM.nChar+10 ){ + sM.zText = xRealloc(sM.zText, sM.nChar+1); + } + } + return sM.zText; +} + +/* +** Realloc that is a real function, not a macro. +*/ +static void *printf_realloc(void *old, int size){ + return sqliteRealloc(old,size); +} + +/* +** Print into memory obtained from sqliteMalloc(). Use the internal +** %-conversion extensions. +*/ +char *sqliteVMPrintf(const char *zFormat, va_list ap){ + char zBase[1000]; + return base_vprintf(printf_realloc, 1, zBase, sizeof(zBase), zFormat, ap); +} + +/* +** Print into memory obtained from sqliteMalloc(). Use the internal +** %-conversion extensions. +*/ +char *sqliteMPrintf(const char *zFormat, ...){ + va_list ap; + char *z; + char zBase[1000]; + va_start(ap, zFormat); + z = base_vprintf(printf_realloc, 1, zBase, sizeof(zBase), zFormat, ap); + va_end(ap); + return z; +} + +/* +** Print into memory obtained from malloc(). Do not use the internal +** %-conversion extensions. This routine is for use by external users. +*/ +char *sqlite_mprintf(const char *zFormat, ...){ + va_list ap; + char *z; + char zBuf[200]; + + va_start(ap,zFormat); + z = base_vprintf((void*(*)(void*,int))realloc, 0, + zBuf, sizeof(zBuf), zFormat, ap); + va_end(ap); + return z; +} + +/* This is the varargs version of sqlite_mprintf. +*/ +char *sqlite_vmprintf(const char *zFormat, va_list ap){ + char zBuf[200]; + return base_vprintf((void*(*)(void*,int))realloc, 0, + zBuf, sizeof(zBuf), zFormat, ap); +} + +/* +** sqlite_snprintf() works like snprintf() except that it ignores the +** current locale settings. This is important for SQLite because we +** are not able to use a "," as the decimal point in place of "." as +** specified by some locales. +*/ +char *sqlite_snprintf(int n, char *zBuf, const char *zFormat, ...){ + char *z; + va_list ap; + + va_start(ap,zFormat); + z = base_vprintf(0, 0, zBuf, n, zFormat, ap); + va_end(ap); + return z; +} + +/* +** The following four routines implement the varargs versions of the +** sqlite_exec() and sqlite_get_table() interfaces. See the sqlite.h +** header files for a more detailed description of how these interfaces +** work. +** +** These routines are all just simple wrappers. +*/ +int sqlite_exec_printf( + sqlite *db, /* An open database */ + const char *sqlFormat, /* printf-style format string for the SQL */ + sqlite_callback xCallback, /* Callback function */ + void *pArg, /* 1st argument to callback function */ + char **errmsg, /* Error msg written here */ + ... /* Arguments to the format string. */ +){ + va_list ap; + int rc; + + va_start(ap, errmsg); + rc = sqlite_exec_vprintf(db, sqlFormat, xCallback, pArg, errmsg, ap); + va_end(ap); + return rc; +} +int sqlite_exec_vprintf( + sqlite *db, /* An open database */ + const char *sqlFormat, /* printf-style format string for the SQL */ + sqlite_callback xCallback, /* Callback function */ + void *pArg, /* 1st argument to callback function */ + char **errmsg, /* Error msg written here */ + va_list ap /* Arguments to the format string. */ +){ + char *zSql; + int rc; + + zSql = sqlite_vmprintf(sqlFormat, ap); + rc = sqlite_exec(db, zSql, xCallback, pArg, errmsg); + free(zSql); + return rc; +} +int sqlite_get_table_printf( + sqlite *db, /* An open database */ + const char *sqlFormat, /* printf-style format string for the SQL */ + char ***resultp, /* Result written to a char *[] that this points to */ + int *nrow, /* Number of result rows written here */ + int *ncol, /* Number of result columns written here */ + char **errmsg, /* Error msg written here */ + ... /* Arguments to the format string */ +){ + va_list ap; + int rc; + + va_start(ap, errmsg); + rc = sqlite_get_table_vprintf(db, sqlFormat, resultp, nrow, ncol, errmsg, ap); + va_end(ap); + return rc; +} +int sqlite_get_table_vprintf( + sqlite *db, /* An open database */ + const char *sqlFormat, /* printf-style format string for the SQL */ + char ***resultp, /* Result written to a char *[] that this points to */ + int *nrow, /* Number of result rows written here */ + int *ncolumn, /* Number of result columns written here */ + char **errmsg, /* Error msg written here */ + va_list ap /* Arguments to the format string */ +){ + char *zSql; + int rc; + + zSql = sqlite_vmprintf(sqlFormat, ap); + rc = sqlite_get_table(db, zSql, resultp, nrow, ncolumn, errmsg); + free(zSql); + return rc; +} diff --git a/kexi/3rdparty/kexisql/src/random.c b/kexi/3rdparty/kexisql/src/random.c new file mode 100644 index 00000000..b3d08a12 --- /dev/null +++ b/kexi/3rdparty/kexisql/src/random.c @@ -0,0 +1,97 @@ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains code to implement a pseudo-random number +** generator (PRNG) for SQLite. +** +** Random numbers are used by some of the database backends in order +** to generate random integer keys for tables or random filenames. +** +** $Id: random.c 410099 2005-05-06 17:52:07Z staniek $ +*/ +#include "sqliteInt.h" +#include "os.h" + + +/* +** Get a single 8-bit random value from the RC4 PRNG. The Mutex +** must be held while executing this routine. +** +** Why not just use a library random generator like lrand48() for this? +** Because the OP_NewRecno opcode in the VDBE depends on having a very +** good source of random numbers. The lrand48() library function may +** well be good enough. But maybe not. Or maybe lrand48() has some +** subtle problems on some systems that could cause problems. It is hard +** to know. To minimize the risk of problems due to bad lrand48() +** implementations, SQLite uses this random number generator based +** on RC4, which we know works very well. +*/ +static int randomByte(){ + unsigned char t; + + /* All threads share a single random number generator. + ** This structure is the current state of the generator. + */ + static struct { + unsigned char isInit; /* True if initialized */ + unsigned char i, j; /* State variables */ + unsigned char s[256]; /* State variables */ + } prng; + + /* Initialize the state of the random number generator once, + ** the first time this routine is called. The seed value does + ** not need to contain a lot of randomness since we are not + ** trying to do secure encryption or anything like that... + ** + ** Nothing in this file or anywhere else in SQLite does any kind of + ** encryption. The RC4 algorithm is being used as a PRNG (pseudo-random + ** number generator) not as an encryption device. + */ + if( !prng.isInit ){ + int i; + char k[256]; + prng.j = 0; + prng.i = 0; + sqliteOsRandomSeed(k); + for(i=0; i<256; i++){ + prng.s[i] = i; + } + for(i=0; i<256; i++){ + prng.j += prng.s[i] + k[i]; + t = prng.s[prng.j]; + prng.s[prng.j] = prng.s[i]; + prng.s[i] = t; + } + prng.isInit = 1; + } + + /* Generate and return single random byte + */ + prng.i++; + t = prng.s[prng.i]; + prng.j += t; + prng.s[prng.i] = prng.s[prng.j]; + prng.s[prng.j] = t; + t += prng.s[prng.i]; + return prng.s[t]; +} + +/* +** Return N random bytes. +*/ +void sqliteRandomness(int N, void *pBuf){ + unsigned char *zBuf = pBuf; + sqliteOsEnterMutex(); + while( N-- ){ + *(zBuf++) = randomByte(); + } + sqliteOsLeaveMutex(); +} diff --git a/kexi/3rdparty/kexisql/src/select.c b/kexi/3rdparty/kexisql/src/select.c new file mode 100644 index 00000000..7ae02d33 --- /dev/null +++ b/kexi/3rdparty/kexisql/src/select.c @@ -0,0 +1,2434 @@ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains C code routines that are called by the parser +** to handle SELECT statements in SQLite. +** +** $Id: select.c 410099 2005-05-06 17:52:07Z staniek $ +*/ +#include "sqliteInt.h" + + +/* +** Allocate a new Select structure and return a pointer to that +** structure. +*/ +Select *sqliteSelectNew( + ExprList *pEList, /* which columns to include in the result */ + SrcList *pSrc, /* the FROM clause -- which tables to scan */ + Expr *pWhere, /* the WHERE clause */ + ExprList *pGroupBy, /* the GROUP BY clause */ + Expr *pHaving, /* the HAVING clause */ + ExprList *pOrderBy, /* the ORDER BY clause */ + int isDistinct, /* true if the DISTINCT keyword is present */ + int nLimit, /* LIMIT value. -1 means not used */ + int nOffset /* OFFSET value. 0 means no offset */ +){ + Select *pNew; + pNew = sqliteMalloc( sizeof(*pNew) ); + if( pNew==0 ){ + sqliteExprListDelete(pEList); + sqliteSrcListDelete(pSrc); + sqliteExprDelete(pWhere); + sqliteExprListDelete(pGroupBy); + sqliteExprDelete(pHaving); + sqliteExprListDelete(pOrderBy); + }else{ + if( pEList==0 ){ + pEList = sqliteExprListAppend(0, sqliteExpr(TK_ALL,0,0,0), 0); + } + pNew->pEList = pEList; + pNew->pSrc = pSrc; + pNew->pWhere = pWhere; + pNew->pGroupBy = pGroupBy; + pNew->pHaving = pHaving; + pNew->pOrderBy = pOrderBy; + pNew->isDistinct = isDistinct; + pNew->op = TK_SELECT; + pNew->nLimit = nLimit; + pNew->nOffset = nOffset; + pNew->iLimit = -1; + pNew->iOffset = -1; + } + return pNew; +} + +/* +** Given 1 to 3 identifiers preceeding the JOIN keyword, determine the +** type of join. Return an integer constant that expresses that type +** in terms of the following bit values: +** +** JT_INNER +** JT_OUTER +** JT_NATURAL +** JT_LEFT +** JT_RIGHT +** +** A full outer join is the combination of JT_LEFT and JT_RIGHT. +** +** If an illegal or unsupported join type is seen, then still return +** a join type, but put an error in the pParse structure. +*/ +int sqliteJoinType(Parse *pParse, Token *pA, Token *pB, Token *pC){ + int jointype = 0; + Token *apAll[3]; + Token *p; + static struct { + const char *zKeyword; + int nChar; + int code; + } keywords[] = { + { "natural", 7, JT_NATURAL }, + { "left", 4, JT_LEFT|JT_OUTER }, + { "right", 5, JT_RIGHT|JT_OUTER }, + { "full", 4, JT_LEFT|JT_RIGHT|JT_OUTER }, + { "outer", 5, JT_OUTER }, + { "inner", 5, JT_INNER }, + { "cross", 5, JT_INNER }, + }; + int i, j; + apAll[0] = pA; + apAll[1] = pB; + apAll[2] = pC; + for(i=0; i<3 && apAll[i]; i++){ + p = apAll[i]; + for(j=0; j<sizeof(keywords)/sizeof(keywords[0]); j++){ + if( p->n==keywords[j].nChar + && sqliteStrNICmp(p->z, keywords[j].zKeyword, p->n)==0 ){ + jointype |= keywords[j].code; + break; + } + } + if( j>=sizeof(keywords)/sizeof(keywords[0]) ){ + jointype |= JT_ERROR; + break; + } + } + if( + (jointype & (JT_INNER|JT_OUTER))==(JT_INNER|JT_OUTER) || + (jointype & JT_ERROR)!=0 + ){ + static Token dummy = { 0, 0 }; + char *zSp1 = " ", *zSp2 = " "; + if( pB==0 ){ pB = &dummy; zSp1 = 0; } + if( pC==0 ){ pC = &dummy; zSp2 = 0; } + sqliteSetNString(&pParse->zErrMsg, "unknown or unsupported join type: ", 0, + pA->z, pA->n, zSp1, 1, pB->z, pB->n, zSp2, 1, pC->z, pC->n, 0); + pParse->nErr++; + jointype = JT_INNER; + }else if( jointype & JT_RIGHT ){ + sqliteErrorMsg(pParse, + "RIGHT and FULL OUTER JOINs are not currently supported"); + jointype = JT_INNER; + } + return jointype; +} + +/* +** Return the index of a column in a table. Return -1 if the column +** is not contained in the table. +*/ +static int columnIndex(Table *pTab, const char *zCol){ + int i; + for(i=0; i<pTab->nCol; i++){ + if( sqliteStrICmp(pTab->aCol[i].zName, zCol)==0 ) return i; + } + return -1; +} + +/* +** Add a term to the WHERE expression in *ppExpr that requires the +** zCol column to be equal in the two tables pTab1 and pTab2. +*/ +static void addWhereTerm( + const char *zCol, /* Name of the column */ + const Table *pTab1, /* First table */ + const Table *pTab2, /* Second table */ + Expr **ppExpr /* Add the equality term to this expression */ +){ + Token dummy; + Expr *pE1a, *pE1b, *pE1c; + Expr *pE2a, *pE2b, *pE2c; + Expr *pE; + + dummy.z = zCol; + dummy.n = strlen(zCol); + dummy.dyn = 0; + pE1a = sqliteExpr(TK_ID, 0, 0, &dummy); + pE2a = sqliteExpr(TK_ID, 0, 0, &dummy); + dummy.z = pTab1->zName; + dummy.n = strlen(dummy.z); + pE1b = sqliteExpr(TK_ID, 0, 0, &dummy); + dummy.z = pTab2->zName; + dummy.n = strlen(dummy.z); + pE2b = sqliteExpr(TK_ID, 0, 0, &dummy); + pE1c = sqliteExpr(TK_DOT, pE1b, pE1a, 0); + pE2c = sqliteExpr(TK_DOT, pE2b, pE2a, 0); + pE = sqliteExpr(TK_EQ, pE1c, pE2c, 0); + ExprSetProperty(pE, EP_FromJoin); + if( *ppExpr ){ + *ppExpr = sqliteExpr(TK_AND, *ppExpr, pE, 0); + }else{ + *ppExpr = pE; + } +} + +/* +** Set the EP_FromJoin property on all terms of the given expression. +** +** The EP_FromJoin property is used on terms of an expression to tell +** the LEFT OUTER JOIN processing logic that this term is part of the +** join restriction specified in the ON or USING clause and not a part +** of the more general WHERE clause. These terms are moved over to the +** WHERE clause during join processing but we need to remember that they +** originated in the ON or USING clause. +*/ +static void setJoinExpr(Expr *p){ + while( p ){ + ExprSetProperty(p, EP_FromJoin); + setJoinExpr(p->pLeft); + p = p->pRight; + } +} + +/* +** This routine processes the join information for a SELECT statement. +** ON and USING clauses are converted into extra terms of the WHERE clause. +** NATURAL joins also create extra WHERE clause terms. +** +** This routine returns the number of errors encountered. +*/ +static int sqliteProcessJoin(Parse *pParse, Select *p){ + SrcList *pSrc; + int i, j; + pSrc = p->pSrc; + for(i=0; i<pSrc->nSrc-1; i++){ + struct SrcList_item *pTerm = &pSrc->a[i]; + struct SrcList_item *pOther = &pSrc->a[i+1]; + + if( pTerm->pTab==0 || pOther->pTab==0 ) continue; + + /* When the NATURAL keyword is present, add WHERE clause terms for + ** every column that the two tables have in common. + */ + if( pTerm->jointype & JT_NATURAL ){ + Table *pTab; + if( pTerm->pOn || pTerm->pUsing ){ + sqliteErrorMsg(pParse, "a NATURAL join may not have " + "an ON or USING clause", 0); + return 1; + } + pTab = pTerm->pTab; + for(j=0; j<pTab->nCol; j++){ + if( columnIndex(pOther->pTab, pTab->aCol[j].zName)>=0 ){ + addWhereTerm(pTab->aCol[j].zName, pTab, pOther->pTab, &p->pWhere); + } + } + } + + /* Disallow both ON and USING clauses in the same join + */ + if( pTerm->pOn && pTerm->pUsing ){ + sqliteErrorMsg(pParse, "cannot have both ON and USING " + "clauses in the same join"); + return 1; + } + + /* Add the ON clause to the end of the WHERE clause, connected by + ** and AND operator. + */ + if( pTerm->pOn ){ + setJoinExpr(pTerm->pOn); + if( p->pWhere==0 ){ + p->pWhere = pTerm->pOn; + }else{ + p->pWhere = sqliteExpr(TK_AND, p->pWhere, pTerm->pOn, 0); + } + pTerm->pOn = 0; + } + + /* Create extra terms on the WHERE clause for each column named + ** in the USING clause. Example: If the two tables to be joined are + ** A and B and the USING clause names X, Y, and Z, then add this + ** to the WHERE clause: A.X=B.X AND A.Y=B.Y AND A.Z=B.Z + ** Report an error if any column mentioned in the USING clause is + ** not contained in both tables to be joined. + */ + if( pTerm->pUsing ){ + IdList *pList; + int j; + assert( i<pSrc->nSrc-1 ); + pList = pTerm->pUsing; + for(j=0; j<pList->nId; j++){ + if( columnIndex(pTerm->pTab, pList->a[j].zName)<0 || + columnIndex(pOther->pTab, pList->a[j].zName)<0 ){ + sqliteErrorMsg(pParse, "cannot join using column %s - column " + "not present in both tables", pList->a[j].zName); + return 1; + } + addWhereTerm(pList->a[j].zName, pTerm->pTab, pOther->pTab, &p->pWhere); + } + } + } + return 0; +} + +/* +** Delete the given Select structure and all of its substructures. +*/ +void sqliteSelectDelete(Select *p){ + if( p==0 ) return; + sqliteExprListDelete(p->pEList); + sqliteSrcListDelete(p->pSrc); + sqliteExprDelete(p->pWhere); + sqliteExprListDelete(p->pGroupBy); + sqliteExprDelete(p->pHaving); + sqliteExprListDelete(p->pOrderBy); + sqliteSelectDelete(p->pPrior); + sqliteFree(p->zSelect); + sqliteFree(p); +} + +/* +** Delete the aggregate information from the parse structure. +*/ +static void sqliteAggregateInfoReset(Parse *pParse){ + sqliteFree(pParse->aAgg); + pParse->aAgg = 0; + pParse->nAgg = 0; + pParse->useAgg = 0; +} + +/* +** Insert code into "v" that will push the record on the top of the +** stack into the sorter. +*/ +static void pushOntoSorter(Parse *pParse, Vdbe *v, ExprList *pOrderBy){ + char *zSortOrder; + int i; + zSortOrder = sqliteMalloc( pOrderBy->nExpr + 1 ); + if( zSortOrder==0 ) return; + for(i=0; i<pOrderBy->nExpr; i++){ + int order = pOrderBy->a[i].sortOrder; + int type; + int c; + if( (order & SQLITE_SO_TYPEMASK)==SQLITE_SO_TEXT ){ + type = SQLITE_SO_TEXT; + }else if( (order & SQLITE_SO_TYPEMASK)==SQLITE_SO_NUM ){ + type = SQLITE_SO_NUM; + }else if( pParse->db->file_format>=4 ){ + type = sqliteExprType(pOrderBy->a[i].pExpr); + }else{ + type = SQLITE_SO_NUM; + } + if( (order & SQLITE_SO_DIRMASK)==SQLITE_SO_ASC ){ + c = type==SQLITE_SO_TEXT ? 'A' : '+'; + }else{ + c = type==SQLITE_SO_TEXT ? 'D' : '-'; + } + zSortOrder[i] = c; + sqliteExprCode(pParse, pOrderBy->a[i].pExpr); + } + zSortOrder[pOrderBy->nExpr] = 0; + sqliteVdbeOp3(v, OP_SortMakeKey, pOrderBy->nExpr, 0, zSortOrder, P3_DYNAMIC); + sqliteVdbeAddOp(v, OP_SortPut, 0, 0); +} + +/* +** This routine adds a P3 argument to the last VDBE opcode that was +** inserted. The P3 argument added is a string suitable for the +** OP_MakeKey or OP_MakeIdxKey opcodes. The string consists of +** characters 't' or 'n' depending on whether or not the various +** fields of the key to be generated should be treated as numeric +** or as text. See the OP_MakeKey and OP_MakeIdxKey opcode +** documentation for additional information about the P3 string. +** See also the sqliteAddIdxKeyType() routine. +*/ +void sqliteAddKeyType(Vdbe *v, ExprList *pEList){ + int nColumn = pEList->nExpr; + char *zType = sqliteMalloc( nColumn+1 ); + int i; + if( zType==0 ) return; + for(i=0; i<nColumn; i++){ + zType[i] = sqliteExprType(pEList->a[i].pExpr)==SQLITE_SO_NUM ? 'n' : 't'; + } + zType[i] = 0; + sqliteVdbeChangeP3(v, -1, zType, P3_DYNAMIC); +} + +/* +** Add code to implement the OFFSET and LIMIT +*/ +static void codeLimiter( + Vdbe *v, /* Generate code into this VM */ + Select *p, /* The SELECT statement being coded */ + int iContinue, /* Jump here to skip the current record */ + int iBreak, /* Jump here to end the loop */ + int nPop /* Number of times to pop stack when jumping */ +){ + if( p->iOffset>=0 ){ + int addr = sqliteVdbeCurrentAddr(v) + 2; + if( nPop>0 ) addr++; + sqliteVdbeAddOp(v, OP_MemIncr, p->iOffset, addr); + if( nPop>0 ){ + sqliteVdbeAddOp(v, OP_Pop, nPop, 0); + } + sqliteVdbeAddOp(v, OP_Goto, 0, iContinue); + } + if( p->iLimit>=0 ){ + sqliteVdbeAddOp(v, OP_MemIncr, p->iLimit, iBreak); + } +} + +/* +** This routine generates the code for the inside of the inner loop +** of a SELECT. +** +** If srcTab and nColumn are both zero, then the pEList expressions +** are evaluated in order to get the data for this row. If nColumn>0 +** then data is pulled from srcTab and pEList is used only to get the +** datatypes for each column. +*/ +static int selectInnerLoop( + Parse *pParse, /* The parser context */ + Select *p, /* The complete select statement being coded */ + ExprList *pEList, /* List of values being extracted */ + int srcTab, /* Pull data from this table */ + int nColumn, /* Number of columns in the source table */ + ExprList *pOrderBy, /* If not NULL, sort results using this key */ + int distinct, /* If >=0, make sure results are distinct */ + int eDest, /* How to dispose of the results */ + int iParm, /* An argument to the disposal method */ + int iContinue, /* Jump here to continue with next row */ + int iBreak /* Jump here to break out of the inner loop */ +){ + Vdbe *v = pParse->pVdbe; + int i; + int hasDistinct; /* True if the DISTINCT keyword is present */ + + if( v==0 ) return 0; + assert( pEList!=0 ); + + /* If there was a LIMIT clause on the SELECT statement, then do the check + ** to see if this row should be output. + */ + hasDistinct = distinct>=0 && pEList && pEList->nExpr>0; + if( pOrderBy==0 && !hasDistinct ){ + codeLimiter(v, p, iContinue, iBreak, 0); + } + + /* Pull the requested columns. + */ + if( nColumn>0 ){ + for(i=0; i<nColumn; i++){ + sqliteVdbeAddOp(v, OP_Column, srcTab, i); + } + }else{ + nColumn = pEList->nExpr; + for(i=0; i<pEList->nExpr; i++){ + sqliteExprCode(pParse, pEList->a[i].pExpr); + } + } + + /* If the DISTINCT keyword was present on the SELECT statement + ** and this row has been seen before, then do not make this row + ** part of the result. + */ + if( hasDistinct ){ +#if NULL_ALWAYS_DISTINCT + sqliteVdbeAddOp(v, OP_IsNull, -pEList->nExpr, sqliteVdbeCurrentAddr(v)+7); +#endif + sqliteVdbeAddOp(v, OP_MakeKey, pEList->nExpr, 1); + if( pParse->db->file_format>=4 ) sqliteAddKeyType(v, pEList); + sqliteVdbeAddOp(v, OP_Distinct, distinct, sqliteVdbeCurrentAddr(v)+3); + sqliteVdbeAddOp(v, OP_Pop, pEList->nExpr+1, 0); + sqliteVdbeAddOp(v, OP_Goto, 0, iContinue); + sqliteVdbeAddOp(v, OP_String, 0, 0); + sqliteVdbeAddOp(v, OP_PutStrKey, distinct, 0); + if( pOrderBy==0 ){ + codeLimiter(v, p, iContinue, iBreak, nColumn); + } + } + + switch( eDest ){ + /* In this mode, write each query result to the key of the temporary + ** table iParm. + */ + case SRT_Union: { + sqliteVdbeAddOp(v, OP_MakeRecord, nColumn, NULL_ALWAYS_DISTINCT); + sqliteVdbeAddOp(v, OP_String, 0, 0); + sqliteVdbeAddOp(v, OP_PutStrKey, iParm, 0); + break; + } + + /* Store the result as data using a unique key. + */ + case SRT_Table: + case SRT_TempTable: { + sqliteVdbeAddOp(v, OP_MakeRecord, nColumn, 0); + if( pOrderBy ){ + pushOntoSorter(pParse, v, pOrderBy); + }else{ + sqliteVdbeAddOp(v, OP_NewRecno, iParm, 0); + sqliteVdbeAddOp(v, OP_Pull, 1, 0); + sqliteVdbeAddOp(v, OP_PutIntKey, iParm, 0); + } + break; + } + + /* Construct a record from the query result, but instead of + ** saving that record, use it as a key to delete elements from + ** the temporary table iParm. + */ + case SRT_Except: { + int addr; + addr = sqliteVdbeAddOp(v, OP_MakeRecord, nColumn, NULL_ALWAYS_DISTINCT); + sqliteVdbeAddOp(v, OP_NotFound, iParm, addr+3); + sqliteVdbeAddOp(v, OP_Delete, iParm, 0); + break; + } + + /* If we are creating a set for an "expr IN (SELECT ...)" construct, + ** then there should be a single item on the stack. Write this + ** item into the set table with bogus data. + */ + case SRT_Set: { + int addr1 = sqliteVdbeCurrentAddr(v); + int addr2; + assert( nColumn==1 ); + sqliteVdbeAddOp(v, OP_NotNull, -1, addr1+3); + sqliteVdbeAddOp(v, OP_Pop, 1, 0); + addr2 = sqliteVdbeAddOp(v, OP_Goto, 0, 0); + if( pOrderBy ){ + pushOntoSorter(pParse, v, pOrderBy); + }else{ + sqliteVdbeAddOp(v, OP_String, 0, 0); + sqliteVdbeAddOp(v, OP_PutStrKey, iParm, 0); + } + sqliteVdbeChangeP2(v, addr2, sqliteVdbeCurrentAddr(v)); + break; + } + + /* If this is a scalar select that is part of an expression, then + ** store the results in the appropriate memory cell and break out + ** of the scan loop. + */ + case SRT_Mem: { + assert( nColumn==1 ); + if( pOrderBy ){ + pushOntoSorter(pParse, v, pOrderBy); + }else{ + sqliteVdbeAddOp(v, OP_MemStore, iParm, 1); + sqliteVdbeAddOp(v, OP_Goto, 0, iBreak); + } + break; + } + + /* Send the data to the callback function. + */ + case SRT_Callback: + case SRT_Sorter: { + if( pOrderBy ){ + sqliteVdbeAddOp(v, OP_SortMakeRec, nColumn, 0); + pushOntoSorter(pParse, v, pOrderBy); + }else{ + assert( eDest==SRT_Callback ); + sqliteVdbeAddOp(v, OP_Callback, nColumn, 0); + } + break; + } + + /* Invoke a subroutine to handle the results. The subroutine itself + ** is responsible for popping the results off of the stack. + */ + case SRT_Subroutine: { + if( pOrderBy ){ + sqliteVdbeAddOp(v, OP_MakeRecord, nColumn, 0); + pushOntoSorter(pParse, v, pOrderBy); + }else{ + sqliteVdbeAddOp(v, OP_Gosub, 0, iParm); + } + break; + } + + /* Discard the results. This is used for SELECT statements inside + ** the body of a TRIGGER. The purpose of such selects is to call + ** user-defined functions that have side effects. We do not care + ** about the actual results of the select. + */ + default: { + assert( eDest==SRT_Discard ); + sqliteVdbeAddOp(v, OP_Pop, nColumn, 0); + break; + } + } + return 0; +} + +/* +** If the inner loop was generated using a non-null pOrderBy argument, +** then the results were placed in a sorter. After the loop is terminated +** we need to run the sorter and output the results. The following +** routine generates the code needed to do that. +*/ +static void generateSortTail( + Select *p, /* The SELECT statement */ + Vdbe *v, /* Generate code into this VDBE */ + int nColumn, /* Number of columns of data */ + int eDest, /* Write the sorted results here */ + int iParm /* Optional parameter associated with eDest */ +){ + int end1 = sqliteVdbeMakeLabel(v); + int end2 = sqliteVdbeMakeLabel(v); + int addr; + if( eDest==SRT_Sorter ) return; + sqliteVdbeAddOp(v, OP_Sort, 0, 0); + addr = sqliteVdbeAddOp(v, OP_SortNext, 0, end1); + codeLimiter(v, p, addr, end2, 1); + switch( eDest ){ + case SRT_Callback: { + sqliteVdbeAddOp(v, OP_SortCallback, nColumn, 0); + break; + } + case SRT_Table: + case SRT_TempTable: { + sqliteVdbeAddOp(v, OP_NewRecno, iParm, 0); + sqliteVdbeAddOp(v, OP_Pull, 1, 0); + sqliteVdbeAddOp(v, OP_PutIntKey, iParm, 0); + break; + } + case SRT_Set: { + assert( nColumn==1 ); + sqliteVdbeAddOp(v, OP_NotNull, -1, sqliteVdbeCurrentAddr(v)+3); + sqliteVdbeAddOp(v, OP_Pop, 1, 0); + sqliteVdbeAddOp(v, OP_Goto, 0, sqliteVdbeCurrentAddr(v)+3); + sqliteVdbeAddOp(v, OP_String, 0, 0); + sqliteVdbeAddOp(v, OP_PutStrKey, iParm, 0); + break; + } + case SRT_Mem: { + assert( nColumn==1 ); + sqliteVdbeAddOp(v, OP_MemStore, iParm, 1); + sqliteVdbeAddOp(v, OP_Goto, 0, end1); + break; + } + case SRT_Subroutine: { + int i; + for(i=0; i<nColumn; i++){ + sqliteVdbeAddOp(v, OP_Column, -1-i, i); + } + sqliteVdbeAddOp(v, OP_Gosub, 0, iParm); + sqliteVdbeAddOp(v, OP_Pop, 1, 0); + break; + } + default: { + /* Do nothing */ + break; + } + } + sqliteVdbeAddOp(v, OP_Goto, 0, addr); + sqliteVdbeResolveLabel(v, end2); + sqliteVdbeAddOp(v, OP_Pop, 1, 0); + sqliteVdbeResolveLabel(v, end1); + sqliteVdbeAddOp(v, OP_SortReset, 0, 0); +} + +/* +** Generate code that will tell the VDBE the datatypes of +** columns in the result set. +** +** 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 "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. +*/ +static void generateColumnTypes( + Parse *pParse, /* Parser context */ + SrcList *pTabList, /* List of tables */ + ExprList *pEList /* Expressions defining the result set */ +){ + Vdbe *v = pParse->pVdbe; + int i, j; + for(i=0; i<pEList->nExpr; 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; j<pTabList->nSrc && pTabList->a[j].iCursor!=p->iTable; j++){} + assert( j<pTabList->nSrc ); + pTab = pTabList->a[j].pTab; + if( iCol<0 ) iCol = pTab->iPKey; + assert( iCol==-1 || (iCol>=0 && iCol<pTab->nCol) ); + if( iCol<0 ){ + zType = "INTEGER"; + }else{ + zType = pTab->aCol[iCol].zType; + } + }else{ + if( sqliteExprType(p)==SQLITE_SO_TEXT ){ + zType = "TEXT"; + }else{ + zType = "NUMERIC"; + } + } + sqliteVdbeOp3(v, OP_ColumnName, i + pEList->nExpr, 0, zType, 0); + } +} + +/* +** Generate code that will tell the VDBE the names of columns +** in the result set. This information is used to provide the +** azCol[] values in the callback. +*/ +static void generateColumnNames( + Parse *pParse, /* Parser context */ + SrcList *pTabList, /* List of tables */ + ExprList *pEList /* Expressions defining the result set */ +){ + Vdbe *v = pParse->pVdbe; + int i, j; + sqlite *db = pParse->db; + int fullNames, shortNames; + + assert( v!=0 ); + if( pParse->colNamesSet || v==0 || sqlite_malloc_failed ) return; + pParse->colNamesSet = 1; + fullNames = (db->flags & SQLITE_FullColNames)!=0; + shortNames = (db->flags & SQLITE_ShortColNames)!=0; + for(i=0; i<pEList->nExpr; i++){ + Expr *p; + int p2 = i==pEList->nExpr-1; + p = pEList->a[i].pExpr; + if( p==0 ) continue; + if( pEList->a[i].zName ){ + char *zName = pEList->a[i].zName; + sqliteVdbeOp3(v, OP_ColumnName, i, p2, zName, 0); + continue; + } + if( p->op==TK_COLUMN && pTabList ){ + Table *pTab; + char *zCol; + int iCol = p->iColumn; + for(j=0; j<pTabList->nSrc && pTabList->a[j].iCursor!=p->iTable; j++){} + assert( j<pTabList->nSrc ); + pTab = pTabList->a[j].pTab; + if( iCol<0 ) iCol = pTab->iPKey; + assert( iCol==-1 || (iCol>=0 && iCol<pTab->nCol) ); + if( iCol<0 ){ + zCol = "_ROWID_"; + }else{ + zCol = pTab->aCol[iCol].zName; + } + if( !shortNames && !fullNames && p->span.z && p->span.z[0] ){ + int addr = sqliteVdbeOp3(v,OP_ColumnName, i, p2, p->span.z, p->span.n); + sqliteVdbeCompressSpace(v, addr); + }else if( fullNames || (!shortNames && pTabList->nSrc>1) ){ + char *zName = 0; + char *zTab; + + zTab = pTabList->a[j].zAlias; + if( fullNames || zTab==0 ) zTab = pTab->zName; + sqliteSetString(&zName, zTab, ".", zCol, 0); + sqliteVdbeOp3(v, OP_ColumnName, i, p2, zName, P3_DYNAMIC); + }else{ + sqliteVdbeOp3(v, OP_ColumnName, i, p2, zCol, 0); + } + }else if( p->span.z && p->span.z[0] ){ + int addr = sqliteVdbeOp3(v,OP_ColumnName, i, p2, p->span.z, p->span.n); + sqliteVdbeCompressSpace(v, addr); + }else{ + char zName[30]; + assert( p->op!=TK_COLUMN || pTabList==0 ); + sprintf(zName, "column%d", i+1); + sqliteVdbeOp3(v, OP_ColumnName, i, p2, zName, 0); + } + } +} + +/* +** Name of the connection operator, used for error messages. +*/ +static const char *selectOpName(int id){ + char *z; + switch( id ){ + case TK_ALL: z = "UNION ALL"; break; + case TK_INTERSECT: z = "INTERSECT"; break; + case TK_EXCEPT: z = "EXCEPT"; break; + default: z = "UNION"; break; + } + return z; +} + +/* +** Forward declaration +*/ +static int fillInColumnList(Parse*, Select*); + +/* +** Given a SELECT statement, generate a Table structure that describes +** the result set of that SELECT. +*/ +Table *sqliteResultSetOfSelect(Parse *pParse, char *zTabName, Select *pSelect){ + Table *pTab; + int i, j; + ExprList *pEList; + Column *aCol; + + if( fillInColumnList(pParse, pSelect) ){ + return 0; + } + pTab = sqliteMalloc( sizeof(Table) ); + if( pTab==0 ){ + return 0; + } + pTab->zName = zTabName ? sqliteStrDup(zTabName) : 0; + pEList = pSelect->pEList; + pTab->nCol = pEList->nExpr; + assert( pTab->nCol>0 ); + pTab->aCol = aCol = sqliteMalloc( sizeof(pTab->aCol[0])*pTab->nCol ); + for(i=0; i<pTab->nCol; i++){ + Expr *p, *pR; + if( pEList->a[i].zName ){ + aCol[i].zName = sqliteStrDup(pEList->a[i].zName); + }else if( (p=pEList->a[i].pExpr)->op==TK_DOT + && (pR=p->pRight)!=0 && pR->token.z && pR->token.z[0] ){ + int cnt; + sqliteSetNString(&aCol[i].zName, pR->token.z, pR->token.n, 0); + for(j=cnt=0; j<i; j++){ + if( sqliteStrICmp(aCol[j].zName, aCol[i].zName)==0 ){ + int n; + char zBuf[30]; + sprintf(zBuf,"_%d",++cnt); + n = strlen(zBuf); + sqliteSetNString(&aCol[i].zName, pR->token.z, pR->token.n, zBuf, n,0); + j = -1; + } + } + }else if( p->span.z && p->span.z[0] ){ + sqliteSetNString(&pTab->aCol[i].zName, p->span.z, p->span.n, 0); + }else{ + char zBuf[30]; + sprintf(zBuf, "column%d", i+1); + aCol[i].zName = sqliteStrDup(zBuf); + } + sqliteDequote(aCol[i].zName); + } + pTab->iPKey = -1; + return pTab; +} + +/* +** For the given SELECT statement, do three things. +** +** (1) Fill in the pTabList->a[].pTab fields in the SrcList that +** defines the set of tables that should be scanned. For views, +** fill pTabList->a[].pSelect with a copy of the SELECT statement +** that implements the view. A copy is made of the view's SELECT +** statement so that we can freely modify or delete that statement +** without worrying about messing up the presistent representation +** of the view. +** +** (2) Add terms to the WHERE clause to accomodate the NATURAL keyword +** on joins and the ON and USING clause of joins. +** +** (3) Scan the list of columns in the result set (pEList) looking +** for instances of the "*" operator or the TABLE.* operator. +** If found, expand each "*" to be every column in every table +** and TABLE.* to be every column in TABLE. +** +** Return 0 on success. If there are problems, leave an error message +** in pParse and return non-zero. +*/ +static int fillInColumnList(Parse *pParse, Select *p){ + int i, j, k, rc; + SrcList *pTabList; + ExprList *pEList; + Table *pTab; + + if( p==0 || p->pSrc==0 ) return 1; + pTabList = p->pSrc; + pEList = p->pEList; + + /* Look up every table in the table list. + */ + for(i=0; i<pTabList->nSrc; i++){ + if( pTabList->a[i].pTab ){ + /* This routine has run before! No need to continue */ + return 0; + } + if( pTabList->a[i].zName==0 ){ + /* A sub-query in the FROM clause of a SELECT */ + assert( pTabList->a[i].pSelect!=0 ); + if( pTabList->a[i].zAlias==0 ){ + char zFakeName[60]; + sprintf(zFakeName, "sqlite_subquery_%p_", + (void*)pTabList->a[i].pSelect); + sqliteSetString(&pTabList->a[i].zAlias, zFakeName, 0); + } + pTabList->a[i].pTab = pTab = + sqliteResultSetOfSelect(pParse, pTabList->a[i].zAlias, + pTabList->a[i].pSelect); + if( pTab==0 ){ + return 1; + } + /* The isTransient flag indicates that the Table structure has been + ** dynamically allocated and may be freed at any time. In other words, + ** pTab is not pointing to a persistent table structure that defines + ** part of the schema. */ + pTab->isTransient = 1; + }else{ + /* An ordinary table or view name in the FROM clause */ + pTabList->a[i].pTab = pTab = + sqliteLocateTable(pParse,pTabList->a[i].zName,pTabList->a[i].zDatabase); + if( pTab==0 ){ + return 1; + } + if( pTab->pSelect ){ + /* We reach here if the named table is a really a view */ + if( sqliteViewGetColumnNames(pParse, pTab) ){ + return 1; + } + /* If pTabList->a[i].pSelect!=0 it means we are dealing with a + ** view within a view. The SELECT structure has already been + ** copied by the outer view so we can skip the copy step here + ** in the inner view. + */ + if( pTabList->a[i].pSelect==0 ){ + pTabList->a[i].pSelect = sqliteSelectDup(pTab->pSelect); + } + } + } + } + + /* Process NATURAL keywords, and ON and USING clauses of joins. + */ + if( sqliteProcessJoin(pParse, p) ) return 1; + + /* For every "*" that occurs in the column list, insert the names of + ** all columns in all tables. And for every TABLE.* insert the names + ** of all columns in TABLE. The parser inserted a special expression + ** with the TK_ALL operator for each "*" that it found in the column list. + ** The following code just has to locate the TK_ALL expressions and expand + ** each one to the list of all columns in all tables. + ** + ** The first loop just checks to see if there are any "*" operators + ** that need expanding. + */ + for(k=0; k<pEList->nExpr; k++){ + Expr *pE = pEList->a[k].pExpr; + if( pE->op==TK_ALL ) break; + if( pE->op==TK_DOT && pE->pRight && pE->pRight->op==TK_ALL + && pE->pLeft && pE->pLeft->op==TK_ID ) break; + } + rc = 0; + if( k<pEList->nExpr ){ + /* + ** If we get here it means the result set contains one or more "*" + ** operators that need to be expanded. Loop through each expression + ** in the result set and expand them one by one. + */ + struct ExprList_item *a = pEList->a; + ExprList *pNew = 0; + for(k=0; k<pEList->nExpr; k++){ + Expr *pE = a[k].pExpr; + if( pE->op!=TK_ALL && + (pE->op!=TK_DOT || pE->pRight==0 || pE->pRight->op!=TK_ALL) ){ + /* This particular expression does not need to be expanded. + */ + pNew = sqliteExprListAppend(pNew, a[k].pExpr, 0); + pNew->a[pNew->nExpr-1].zName = a[k].zName; + a[k].pExpr = 0; + a[k].zName = 0; + }else{ + /* This expression is a "*" or a "TABLE.*" and needs to be + ** expanded. */ + int tableSeen = 0; /* Set to 1 when TABLE matches */ + char *zTName; /* text of name of TABLE */ + if( pE->op==TK_DOT && pE->pLeft ){ + zTName = sqliteTableNameFromToken(&pE->pLeft->token); + }else{ + zTName = 0; + } + for(i=0; i<pTabList->nSrc; i++){ + Table *pTab = pTabList->a[i].pTab; + char *zTabName = pTabList->a[i].zAlias; + if( zTabName==0 || zTabName[0]==0 ){ + zTabName = pTab->zName; + } + if( zTName && (zTabName==0 || zTabName[0]==0 || + sqliteStrICmp(zTName, zTabName)!=0) ){ + continue; + } + tableSeen = 1; + for(j=0; j<pTab->nCol; j++){ + Expr *pExpr, *pLeft, *pRight; + char *zName = pTab->aCol[j].zName; + + if( i>0 && (pTabList->a[i-1].jointype & JT_NATURAL)!=0 && + columnIndex(pTabList->a[i-1].pTab, zName)>=0 ){ + /* In a NATURAL join, omit the join columns from the + ** table on the right */ + continue; + } + if( i>0 && sqliteIdListIndex(pTabList->a[i-1].pUsing, zName)>=0 ){ + /* In a join with a USING clause, omit columns in the + ** using clause from the table on the right. */ + continue; + } + pRight = sqliteExpr(TK_ID, 0, 0, 0); + if( pRight==0 ) break; + pRight->token.z = zName; + pRight->token.n = strlen(zName); + pRight->token.dyn = 0; + if( zTabName && pTabList->nSrc>1 ){ + pLeft = sqliteExpr(TK_ID, 0, 0, 0); + pExpr = sqliteExpr(TK_DOT, pLeft, pRight, 0); + if( pExpr==0 ) break; + pLeft->token.z = zTabName; + pLeft->token.n = strlen(zTabName); + pLeft->token.dyn = 0; + sqliteSetString((char**)&pExpr->span.z, zTabName, ".", zName, 0); + pExpr->span.n = strlen(pExpr->span.z); + pExpr->span.dyn = 1; + pExpr->token.z = 0; + pExpr->token.n = 0; + pExpr->token.dyn = 0; + }else{ + pExpr = pRight; + pExpr->span = pExpr->token; + } + pNew = sqliteExprListAppend(pNew, pExpr, 0); + } + } + if( !tableSeen ){ + if( zTName ){ + sqliteErrorMsg(pParse, "no such table: %s", zTName); + }else{ + sqliteErrorMsg(pParse, "no tables specified"); + } + rc = 1; + } + sqliteFree(zTName); + } + } + sqliteExprListDelete(pEList); + p->pEList = pNew; + } + return rc; +} + +/* +** This routine recursively unlinks the Select.pSrc.a[].pTab pointers +** in a select structure. It just sets the pointers to NULL. This +** routine is recursive in the sense that if the Select.pSrc.a[].pSelect +** pointer is not NULL, this routine is called recursively on that pointer. +** +** This routine is called on the Select structure that defines a +** VIEW in order to undo any bindings to tables. This is necessary +** because those tables might be DROPed by a subsequent SQL command. +** If the bindings are not removed, then the Select.pSrc->a[].pTab field +** will be left pointing to a deallocated Table structure after the +** DROP and a coredump will occur the next time the VIEW is used. +*/ +void sqliteSelectUnbind(Select *p){ + int i; + SrcList *pSrc = p->pSrc; + Table *pTab; + if( p==0 ) return; + for(i=0; i<pSrc->nSrc; i++){ + if( (pTab = pSrc->a[i].pTab)!=0 ){ + if( pTab->isTransient ){ + sqliteDeleteTable(0, pTab); + } + pSrc->a[i].pTab = 0; + if( pSrc->a[i].pSelect ){ + sqliteSelectUnbind(pSrc->a[i].pSelect); + } + } + } +} + +/* +** This routine associates entries in an ORDER BY expression list with +** columns in a result. For each ORDER BY expression, the opcode of +** the top-level node is changed to TK_COLUMN and the iColumn value of +** the top-level node is filled in with column number and the iTable +** value of the top-level node is filled with iTable parameter. +** +** If there are prior SELECT clauses, they are processed first. A match +** in an earlier SELECT takes precedence over a later SELECT. +** +** Any entry that does not match is flagged as an error. The number +** of errors is returned. +** +** This routine does NOT correctly initialize the Expr.dataType field +** of the ORDER BY expressions. The multiSelectSortOrder() routine +** must be called to do that after the individual select statements +** have all been analyzed. This routine is unable to compute Expr.dataType +** because it must be called before the individual select statements +** have been analyzed. +*/ +static int matchOrderbyToColumn( + Parse *pParse, /* A place to leave error messages */ + Select *pSelect, /* Match to result columns of this SELECT */ + ExprList *pOrderBy, /* The ORDER BY values to match against columns */ + int iTable, /* Insert this value in iTable */ + int mustComplete /* If TRUE all ORDER BYs must match */ +){ + int nErr = 0; + int i, j; + ExprList *pEList; + + if( pSelect==0 || pOrderBy==0 ) return 1; + if( mustComplete ){ + for(i=0; i<pOrderBy->nExpr; i++){ pOrderBy->a[i].done = 0; } + } + if( fillInColumnList(pParse, pSelect) ){ + return 1; + } + if( pSelect->pPrior ){ + if( matchOrderbyToColumn(pParse, pSelect->pPrior, pOrderBy, iTable, 0) ){ + return 1; + } + } + pEList = pSelect->pEList; + for(i=0; i<pOrderBy->nExpr; i++){ + Expr *pE = pOrderBy->a[i].pExpr; + int iCol = -1; + if( pOrderBy->a[i].done ) continue; + if( sqliteExprIsInteger(pE, &iCol) ){ + if( iCol<=0 || iCol>pEList->nExpr ){ + sqliteErrorMsg(pParse, + "ORDER BY position %d should be between 1 and %d", + iCol, pEList->nExpr); + nErr++; + break; + } + if( !mustComplete ) continue; + iCol--; + } + for(j=0; iCol<0 && j<pEList->nExpr; j++){ + if( pEList->a[j].zName && (pE->op==TK_ID || pE->op==TK_STRING) ){ + char *zName, *zLabel; + zName = pEList->a[j].zName; + assert( pE->token.z ); + zLabel = sqliteStrNDup(pE->token.z, pE->token.n); + sqliteDequote(zLabel); + if( sqliteStrICmp(zName, zLabel)==0 ){ + iCol = j; + } + sqliteFree(zLabel); + } + if( iCol<0 && sqliteExprCompare(pE, pEList->a[j].pExpr) ){ + iCol = j; + } + } + if( iCol>=0 ){ + pE->op = TK_COLUMN; + pE->iColumn = iCol; + pE->iTable = iTable; + pOrderBy->a[i].done = 1; + } + if( iCol<0 && mustComplete ){ + sqliteErrorMsg(pParse, + "ORDER BY term number %d does not match any result column", i+1); + nErr++; + break; + } + } + return nErr; +} + +/* +** Get a VDBE for the given parser context. Create a new one if necessary. +** If an error occurs, return NULL and leave a message in pParse. +*/ +Vdbe *sqliteGetVdbe(Parse *pParse){ + Vdbe *v = pParse->pVdbe; + if( v==0 ){ + v = pParse->pVdbe = sqliteVdbeCreate(pParse->db); + } + return v; +} + +/* +** This routine sets the Expr.dataType field on all elements of +** the pOrderBy expression list. The pOrderBy list will have been +** set up by matchOrderbyToColumn(). Hence each expression has +** a TK_COLUMN as its root node. The Expr.iColumn refers to a +** column in the result set. The datatype is set to SQLITE_SO_TEXT +** if the corresponding column in p and every SELECT to the left of +** p has a datatype of SQLITE_SO_TEXT. If the cooressponding column +** in p or any of the left SELECTs is SQLITE_SO_NUM, then the datatype +** of the order-by expression is set to SQLITE_SO_NUM. +** +** Examples: +** +** CREATE TABLE one(a INTEGER, b TEXT); +** CREATE TABLE two(c VARCHAR(5), d FLOAT); +** +** SELECT b, b FROM one UNION SELECT d, c FROM two ORDER BY 1, 2; +** +** The primary sort key will use SQLITE_SO_NUM because the "d" in +** the second SELECT is numeric. The 1st column of the first SELECT +** is text but that does not matter because a numeric always overrides +** a text. +** +** The secondary key will use the SQLITE_SO_TEXT sort order because +** both the (second) "b" in the first SELECT and the "c" in the second +** SELECT have a datatype of text. +*/ +static void multiSelectSortOrder(Select *p, ExprList *pOrderBy){ + int i; + ExprList *pEList; + if( pOrderBy==0 ) return; + if( p==0 ){ + for(i=0; i<pOrderBy->nExpr; i++){ + pOrderBy->a[i].pExpr->dataType = SQLITE_SO_TEXT; + } + return; + } + multiSelectSortOrder(p->pPrior, pOrderBy); + pEList = p->pEList; + for(i=0; i<pOrderBy->nExpr; i++){ + Expr *pE = pOrderBy->a[i].pExpr; + if( pE->dataType==SQLITE_SO_NUM ) continue; + assert( pE->iColumn>=0 ); + if( pEList->nExpr>pE->iColumn ){ + pE->dataType = sqliteExprType(pEList->a[pE->iColumn].pExpr); + } + } +} + +/* +** Compute the iLimit and iOffset fields of the SELECT based on the +** nLimit and nOffset fields. nLimit and nOffset hold the integers +** that appear in the original SQL statement after the LIMIT and OFFSET +** keywords. Or that hold -1 and 0 if those keywords are omitted. +** iLimit and iOffset are the integer memory register numbers for +** counters used to compute the limit and offset. If there is no +** limit and/or offset, then iLimit and iOffset are negative. +** +** This routine changes the values if iLimit and iOffset only if +** a limit or offset is defined by nLimit and nOffset. iLimit and +** iOffset should have been preset to appropriate default values +** (usually but not always -1) prior to calling this routine. +** Only if nLimit>=0 or nOffset>0 do the limit registers get +** redefined. The UNION ALL operator uses this property to force +** the reuse of the same limit and offset registers across multiple +** SELECT statements. +*/ +static void computeLimitRegisters(Parse *pParse, Select *p){ + /* + ** If the comparison is p->nLimit>0 then "LIMIT 0" shows + ** all rows. It is the same as no limit. If the comparision is + ** p->nLimit>=0 then "LIMIT 0" show no rows at all. + ** "LIMIT -1" always shows all rows. There is some + ** contraversy about what the correct behavior should be. + ** The current implementation interprets "LIMIT 0" to mean + ** no rows. + */ + if( p->nLimit>=0 ){ + int iMem = pParse->nMem++; + Vdbe *v = sqliteGetVdbe(pParse); + if( v==0 ) return; + sqliteVdbeAddOp(v, OP_Integer, -p->nLimit, 0); + sqliteVdbeAddOp(v, OP_MemStore, iMem, 1); + p->iLimit = iMem; + } + if( p->nOffset>0 ){ + int iMem = pParse->nMem++; + Vdbe *v = sqliteGetVdbe(pParse); + if( v==0 ) return; + sqliteVdbeAddOp(v, OP_Integer, -p->nOffset, 0); + sqliteVdbeAddOp(v, OP_MemStore, iMem, 1); + p->iOffset = iMem; + } +} + +/* +** This routine is called to process a query that is really the union +** or intersection of two or more separate queries. +** +** "p" points to the right-most of the two queries. the query on the +** left is p->pPrior. The left query could also be a compound query +** in which case this routine will be called recursively. +** +** The results of the total query are to be written into a destination +** of type eDest with parameter iParm. +** +** Example 1: Consider a three-way compound SQL statement. +** +** SELECT a FROM t1 UNION SELECT b FROM t2 UNION SELECT c FROM t3 +** +** This statement is parsed up as follows: +** +** SELECT c FROM t3 +** | +** `-----> SELECT b FROM t2 +** | +** `------> SELECT a FROM t1 +** +** The arrows in the diagram above represent the Select.pPrior pointer. +** So if this routine is called with p equal to the t3 query, then +** pPrior will be the t2 query. p->op will be TK_UNION in this case. +** +** Notice that because of the way SQLite parses compound SELECTs, the +** individual selects always group from left to right. +*/ +static int multiSelect(Parse *pParse, Select *p, int eDest, int iParm){ + int rc; /* Success code from a subroutine */ + Select *pPrior; /* Another SELECT immediately to our left */ + Vdbe *v; /* Generate code to this VDBE */ + + /* Make sure there is no ORDER BY or LIMIT clause on prior SELECTs. Only + ** the last SELECT in the series may have an ORDER BY or LIMIT. + */ + if( p==0 || p->pPrior==0 ) return 1; + pPrior = p->pPrior; + if( pPrior->pOrderBy ){ + sqliteErrorMsg(pParse,"ORDER BY clause should come after %s not before", + selectOpName(p->op)); + return 1; + } + if( pPrior->nLimit>=0 || pPrior->nOffset>0 ){ + sqliteErrorMsg(pParse,"LIMIT clause should come after %s not before", + selectOpName(p->op)); + return 1; + } + + /* Make sure we have a valid query engine. If not, create a new one. + */ + v = sqliteGetVdbe(pParse); + if( v==0 ) return 1; + + /* Create the destination temporary table if necessary + */ + if( eDest==SRT_TempTable ){ + sqliteVdbeAddOp(v, OP_OpenTemp, iParm, 0); + eDest = SRT_Table; + } + + /* Generate code for the left and right SELECT statements. + */ + switch( p->op ){ + case TK_ALL: { + if( p->pOrderBy==0 ){ + pPrior->nLimit = p->nLimit; + pPrior->nOffset = p->nOffset; + rc = sqliteSelect(pParse, pPrior, eDest, iParm, 0, 0, 0); + if( rc ) return rc; + p->pPrior = 0; + p->iLimit = pPrior->iLimit; + p->iOffset = pPrior->iOffset; + p->nLimit = -1; + p->nOffset = 0; + rc = sqliteSelect(pParse, p, eDest, iParm, 0, 0, 0); + p->pPrior = pPrior; + if( rc ) return rc; + break; + } + /* For UNION ALL ... ORDER BY fall through to the next case */ + } + case TK_EXCEPT: + case TK_UNION: { + int unionTab; /* Cursor number of the temporary table holding result */ + int op; /* One of the SRT_ operations to apply to self */ + int priorOp; /* The SRT_ operation to apply to prior selects */ + int nLimit, nOffset; /* Saved values of p->nLimit and p->nOffset */ + ExprList *pOrderBy; /* The ORDER BY clause for the right SELECT */ + + priorOp = p->op==TK_ALL ? SRT_Table : SRT_Union; + if( eDest==priorOp && p->pOrderBy==0 && p->nLimit<0 && p->nOffset==0 ){ + /* We can reuse a temporary table generated by a SELECT to our + ** right. + */ + unionTab = iParm; + }else{ + /* We will need to create our own temporary table to hold the + ** intermediate results. + */ + unionTab = pParse->nTab++; + if( p->pOrderBy + && matchOrderbyToColumn(pParse, p, p->pOrderBy, unionTab, 1) ){ + return 1; + } + if( p->op!=TK_ALL ){ + sqliteVdbeAddOp(v, OP_OpenTemp, unionTab, 1); + sqliteVdbeAddOp(v, OP_KeyAsData, unionTab, 1); + }else{ + sqliteVdbeAddOp(v, OP_OpenTemp, unionTab, 0); + } + } + + /* Code the SELECT statements to our left + */ + rc = sqliteSelect(pParse, pPrior, priorOp, unionTab, 0, 0, 0); + if( rc ) return rc; + + /* Code the current SELECT statement + */ + switch( p->op ){ + case TK_EXCEPT: op = SRT_Except; break; + case TK_UNION: op = SRT_Union; break; + case TK_ALL: op = SRT_Table; break; + } + p->pPrior = 0; + pOrderBy = p->pOrderBy; + p->pOrderBy = 0; + nLimit = p->nLimit; + p->nLimit = -1; + nOffset = p->nOffset; + p->nOffset = 0; + rc = sqliteSelect(pParse, p, op, unionTab, 0, 0, 0); + p->pPrior = pPrior; + p->pOrderBy = pOrderBy; + p->nLimit = nLimit; + p->nOffset = nOffset; + if( rc ) return rc; + + /* Convert the data in the temporary table into whatever form + ** it is that we currently need. + */ + if( eDest!=priorOp || unionTab!=iParm ){ + int iCont, iBreak, iStart; + assert( p->pEList ); + if( eDest==SRT_Callback ){ + generateColumnNames(pParse, 0, p->pEList); + generateColumnTypes(pParse, p->pSrc, p->pEList); + } + iBreak = sqliteVdbeMakeLabel(v); + iCont = sqliteVdbeMakeLabel(v); + sqliteVdbeAddOp(v, OP_Rewind, unionTab, iBreak); + computeLimitRegisters(pParse, p); + iStart = sqliteVdbeCurrentAddr(v); + multiSelectSortOrder(p, p->pOrderBy); + rc = selectInnerLoop(pParse, p, p->pEList, unionTab, p->pEList->nExpr, + p->pOrderBy, -1, eDest, iParm, + iCont, iBreak); + if( rc ) return 1; + sqliteVdbeResolveLabel(v, iCont); + sqliteVdbeAddOp(v, OP_Next, unionTab, iStart); + sqliteVdbeResolveLabel(v, iBreak); + sqliteVdbeAddOp(v, OP_Close, unionTab, 0); + if( p->pOrderBy ){ + generateSortTail(p, v, p->pEList->nExpr, eDest, iParm); + } + } + break; + } + case TK_INTERSECT: { + int tab1, tab2; + int iCont, iBreak, iStart; + int nLimit, nOffset; + + /* INTERSECT is different from the others since it requires + ** two temporary tables. Hence it has its own case. Begin + ** by allocating the tables we will need. + */ + tab1 = pParse->nTab++; + tab2 = pParse->nTab++; + if( p->pOrderBy && matchOrderbyToColumn(pParse,p,p->pOrderBy,tab1,1) ){ + return 1; + } + sqliteVdbeAddOp(v, OP_OpenTemp, tab1, 1); + sqliteVdbeAddOp(v, OP_KeyAsData, tab1, 1); + + /* Code the SELECTs to our left into temporary table "tab1". + */ + rc = sqliteSelect(pParse, pPrior, SRT_Union, tab1, 0, 0, 0); + if( rc ) return rc; + + /* Code the current SELECT into temporary table "tab2" + */ + sqliteVdbeAddOp(v, OP_OpenTemp, tab2, 1); + sqliteVdbeAddOp(v, OP_KeyAsData, tab2, 1); + p->pPrior = 0; + nLimit = p->nLimit; + p->nLimit = -1; + nOffset = p->nOffset; + p->nOffset = 0; + rc = sqliteSelect(pParse, p, SRT_Union, tab2, 0, 0, 0); + p->pPrior = pPrior; + p->nLimit = nLimit; + p->nOffset = nOffset; + if( rc ) return rc; + + /* Generate code to take the intersection of the two temporary + ** tables. + */ + assert( p->pEList ); + if( eDest==SRT_Callback ){ + generateColumnNames(pParse, 0, p->pEList); + generateColumnTypes(pParse, p->pSrc, p->pEList); + } + iBreak = sqliteVdbeMakeLabel(v); + iCont = sqliteVdbeMakeLabel(v); + sqliteVdbeAddOp(v, OP_Rewind, tab1, iBreak); + computeLimitRegisters(pParse, p); + iStart = sqliteVdbeAddOp(v, OP_FullKey, tab1, 0); + sqliteVdbeAddOp(v, OP_NotFound, tab2, iCont); + multiSelectSortOrder(p, p->pOrderBy); + rc = selectInnerLoop(pParse, p, p->pEList, tab1, p->pEList->nExpr, + p->pOrderBy, -1, eDest, iParm, + iCont, iBreak); + if( rc ) return 1; + sqliteVdbeResolveLabel(v, iCont); + sqliteVdbeAddOp(v, OP_Next, tab1, iStart); + sqliteVdbeResolveLabel(v, iBreak); + sqliteVdbeAddOp(v, OP_Close, tab2, 0); + sqliteVdbeAddOp(v, OP_Close, tab1, 0); + if( p->pOrderBy ){ + generateSortTail(p, v, p->pEList->nExpr, eDest, iParm); + } + break; + } + } + assert( p->pEList && pPrior->pEList ); + if( p->pEList->nExpr!=pPrior->pEList->nExpr ){ + sqliteErrorMsg(pParse, "SELECTs to the left and right of %s" + " do not have the same number of result columns", selectOpName(p->op)); + return 1; + } + return 0; +} + +/* +** Scan through the expression pExpr. Replace every reference to +** a column in table number iTable with a copy of the iColumn-th +** entry in pEList. (But leave references to the ROWID column +** unchanged.) +** +** This routine is part of the flattening procedure. A subquery +** whose result set is defined by pEList appears as entry in the +** FROM clause of a SELECT such that the VDBE cursor assigned to that +** FORM clause entry is iTable. This routine make the necessary +** changes to pExpr so that it refers directly to the source table +** of the subquery rather the result set of the subquery. +*/ +static void substExprList(ExprList*,int,ExprList*); /* Forward Decl */ +static void substExpr(Expr *pExpr, int iTable, ExprList *pEList){ + if( pExpr==0 ) return; + if( pExpr->op==TK_COLUMN && pExpr->iTable==iTable ){ + if( pExpr->iColumn<0 ){ + pExpr->op = TK_NULL; + }else{ + Expr *pNew; + assert( pEList!=0 && pExpr->iColumn<pEList->nExpr ); + assert( pExpr->pLeft==0 && pExpr->pRight==0 && pExpr->pList==0 ); + pNew = pEList->a[pExpr->iColumn].pExpr; + assert( pNew!=0 ); + pExpr->op = pNew->op; + pExpr->dataType = pNew->dataType; + assert( pExpr->pLeft==0 ); + pExpr->pLeft = sqliteExprDup(pNew->pLeft); + assert( pExpr->pRight==0 ); + pExpr->pRight = sqliteExprDup(pNew->pRight); + assert( pExpr->pList==0 ); + pExpr->pList = sqliteExprListDup(pNew->pList); + pExpr->iTable = pNew->iTable; + pExpr->iColumn = pNew->iColumn; + pExpr->iAgg = pNew->iAgg; + sqliteTokenCopy(&pExpr->token, &pNew->token); + sqliteTokenCopy(&pExpr->span, &pNew->span); + } + }else{ + substExpr(pExpr->pLeft, iTable, pEList); + substExpr(pExpr->pRight, iTable, pEList); + substExprList(pExpr->pList, iTable, pEList); + } +} +static void +substExprList(ExprList *pList, int iTable, ExprList *pEList){ + int i; + if( pList==0 ) return; + for(i=0; i<pList->nExpr; i++){ + substExpr(pList->a[i].pExpr, iTable, pEList); + } +} + +/* +** This routine attempts to flatten subqueries in order to speed +** execution. It returns 1 if it makes changes and 0 if no flattening +** occurs. +** +** To understand the concept of flattening, consider the following +** query: +** +** SELECT a FROM (SELECT x+y AS a FROM t1 WHERE z<100) WHERE a>5 +** +** The default way of implementing this query is to execute the +** subquery first and store the results in a temporary table, then +** run the outer query on that temporary table. This requires two +** passes over the data. Furthermore, because the temporary table +** has no indices, the WHERE clause on the outer query cannot be +** optimized. +** +** This routine attempts to rewrite queries such as the above into +** a single flat select, like this: +** +** SELECT x+y AS a FROM t1 WHERE z<100 AND a>5 +** +** The code generated for this simpification gives the same result +** but only has to scan the data once. And because indices might +** exist on the table t1, a complete scan of the data might be +** avoided. +** +** Flattening is only attempted if all of the following are true: +** +** (1) The subquery and the outer query do not both use aggregates. +** +** (2) The subquery is not an aggregate or the outer query is not a join. +** +** (3) The subquery is not the right operand of a left outer join, or +** the subquery is not itself a join. (Ticket #306) +** +** (4) The subquery is not DISTINCT or the outer query is not a join. +** +** (5) The subquery is not DISTINCT or the outer query does not use +** aggregates. +** +** (6) The subquery does not use aggregates or the outer query is not +** DISTINCT. +** +** (7) The subquery has a FROM clause. +** +** (8) The subquery does not use LIMIT or the outer query is not a join. +** +** (9) The subquery does not use LIMIT or the outer query does not use +** aggregates. +** +** (10) The subquery does not use aggregates or the outer query does not +** use LIMIT. +** +** (11) The subquery and the outer query do not both have ORDER BY clauses. +** +** (12) The subquery is not the right term of a LEFT OUTER JOIN or the +** subquery has no WHERE clause. (added by ticket #350) +** +** In this routine, the "p" parameter is a pointer to the outer query. +** The subquery is p->pSrc->a[iFrom]. isAgg is true if the outer query +** uses aggregates and subqueryIsAgg is true if the subquery uses aggregates. +** +** If flattening is not attempted, this routine is a no-op and returns 0. +** If flattening is attempted this routine returns 1. +** +** All of the expression analysis must occur on both the outer query and +** the subquery before this routine runs. +*/ +static int flattenSubquery( + Parse *pParse, /* The parsing context */ + Select *p, /* The parent or outer SELECT statement */ + int iFrom, /* Index in p->pSrc->a[] of the inner subquery */ + int isAgg, /* True if outer SELECT uses aggregate functions */ + int subqueryIsAgg /* True if the subquery uses aggregate functions */ +){ + Select *pSub; /* The inner query or "subquery" */ + SrcList *pSrc; /* The FROM clause of the outer query */ + SrcList *pSubSrc; /* The FROM clause of the subquery */ + ExprList *pList; /* The result set of the outer query */ + int iParent; /* VDBE cursor number of the pSub result set temp table */ + int i; + Expr *pWhere; + + /* Check to see if flattening is permitted. Return 0 if not. + */ + if( p==0 ) return 0; + pSrc = p->pSrc; + assert( pSrc && iFrom>=0 && iFrom<pSrc->nSrc ); + pSub = pSrc->a[iFrom].pSelect; + assert( pSub!=0 ); + if( isAgg && subqueryIsAgg ) return 0; + if( subqueryIsAgg && pSrc->nSrc>1 ) return 0; + pSubSrc = pSub->pSrc; + assert( pSubSrc ); + if( pSubSrc->nSrc==0 ) return 0; + if( (pSub->isDistinct || pSub->nLimit>=0) && (pSrc->nSrc>1 || isAgg) ){ + return 0; + } + if( (p->isDistinct || p->nLimit>=0) && subqueryIsAgg ) return 0; + if( p->pOrderBy && pSub->pOrderBy ) return 0; + + /* Restriction 3: If the subquery is a join, make sure the subquery is + ** not used as the right operand of an outer join. Examples of why this + ** is not allowed: + ** + ** t1 LEFT OUTER JOIN (t2 JOIN t3) + ** + ** If we flatten the above, we would get + ** + ** (t1 LEFT OUTER JOIN t2) JOIN t3 + ** + ** which is not at all the same thing. + */ + if( pSubSrc->nSrc>1 && iFrom>0 && (pSrc->a[iFrom-1].jointype & JT_OUTER)!=0 ){ + return 0; + } + + /* Restriction 12: If the subquery is the right operand of a left outer + ** join, make sure the subquery has no WHERE clause. + ** An examples of why this is not allowed: + ** + ** t1 LEFT OUTER JOIN (SELECT * FROM t2 WHERE t2.x>0) + ** + ** If we flatten the above, we would get + ** + ** (t1 LEFT OUTER JOIN t2) WHERE t2.x>0 + ** + ** But the t2.x>0 test will always fail on a NULL row of t2, which + ** effectively converts the OUTER JOIN into an INNER JOIN. + */ + if( iFrom>0 && (pSrc->a[iFrom-1].jointype & JT_OUTER)!=0 + && pSub->pWhere!=0 ){ + return 0; + } + + /* If we reach this point, it means flattening is permitted for the + ** iFrom-th entry of the FROM clause in the outer query. + */ + + /* Move all of the FROM elements of the subquery into the + ** the FROM clause of the outer query. Before doing this, remember + ** the cursor number for the original outer query FROM element in + ** iParent. The iParent cursor will never be used. Subsequent code + ** will scan expressions looking for iParent references and replace + ** those references with expressions that resolve to the subquery FROM + ** elements we are now copying in. + */ + iParent = pSrc->a[iFrom].iCursor; + { + int nSubSrc = pSubSrc->nSrc; + int jointype = pSrc->a[iFrom].jointype; + + if( pSrc->a[iFrom].pTab && pSrc->a[iFrom].pTab->isTransient ){ + sqliteDeleteTable(0, pSrc->a[iFrom].pTab); + } + sqliteFree(pSrc->a[iFrom].zDatabase); + sqliteFree(pSrc->a[iFrom].zName); + sqliteFree(pSrc->a[iFrom].zAlias); + if( nSubSrc>1 ){ + int extra = nSubSrc - 1; + for(i=1; i<nSubSrc; i++){ + pSrc = sqliteSrcListAppend(pSrc, 0, 0); + } + p->pSrc = pSrc; + for(i=pSrc->nSrc-1; i-extra>=iFrom; i--){ + pSrc->a[i] = pSrc->a[i-extra]; + } + } + for(i=0; i<nSubSrc; i++){ + pSrc->a[i+iFrom] = pSubSrc->a[i]; + memset(&pSubSrc->a[i], 0, sizeof(pSubSrc->a[i])); + } + pSrc->a[iFrom+nSubSrc-1].jointype = jointype; + } + + /* Now begin substituting subquery result set expressions for + ** references to the iParent in the outer query. + ** + ** Example: + ** + ** SELECT a+5, b*10 FROM (SELECT x*3 AS a, y+10 AS b FROM t1) WHERE a>b; + ** \ \_____________ subquery __________/ / + ** \_____________________ outer query ______________________________/ + ** + ** We look at every expression in the outer query and every place we see + ** "a" we substitute "x*3" and every place we see "b" we substitute "y+10". + */ + substExprList(p->pEList, iParent, pSub->pEList); + pList = p->pEList; + for(i=0; i<pList->nExpr; i++){ + Expr *pExpr; + if( pList->a[i].zName==0 && (pExpr = pList->a[i].pExpr)->span.z!=0 ){ + pList->a[i].zName = sqliteStrNDup(pExpr->span.z, pExpr->span.n); + } + } + if( isAgg ){ + substExprList(p->pGroupBy, iParent, pSub->pEList); + substExpr(p->pHaving, iParent, pSub->pEList); + } + if( pSub->pOrderBy ){ + assert( p->pOrderBy==0 ); + p->pOrderBy = pSub->pOrderBy; + pSub->pOrderBy = 0; + }else if( p->pOrderBy ){ + substExprList(p->pOrderBy, iParent, pSub->pEList); + } + if( pSub->pWhere ){ + pWhere = sqliteExprDup(pSub->pWhere); + }else{ + pWhere = 0; + } + if( subqueryIsAgg ){ + assert( p->pHaving==0 ); + p->pHaving = p->pWhere; + p->pWhere = pWhere; + substExpr(p->pHaving, iParent, pSub->pEList); + if( pSub->pHaving ){ + Expr *pHaving = sqliteExprDup(pSub->pHaving); + if( p->pHaving ){ + p->pHaving = sqliteExpr(TK_AND, p->pHaving, pHaving, 0); + }else{ + p->pHaving = pHaving; + } + } + assert( p->pGroupBy==0 ); + p->pGroupBy = sqliteExprListDup(pSub->pGroupBy); + }else if( p->pWhere==0 ){ + p->pWhere = pWhere; + }else{ + substExpr(p->pWhere, iParent, pSub->pEList); + if( pWhere ){ + p->pWhere = sqliteExpr(TK_AND, p->pWhere, pWhere, 0); + } + } + + /* The flattened query is distinct if either the inner or the + ** outer query is distinct. + */ + p->isDistinct = p->isDistinct || pSub->isDistinct; + + /* Transfer the limit expression from the subquery to the outer + ** query. + */ + if( pSub->nLimit>=0 ){ + if( p->nLimit<0 ){ + p->nLimit = pSub->nLimit; + }else if( p->nLimit+p->nOffset > pSub->nLimit+pSub->nOffset ){ + p->nLimit = pSub->nLimit + pSub->nOffset - p->nOffset; + } + } + p->nOffset += pSub->nOffset; + + /* Finially, delete what is left of the subquery and return + ** success. + */ + sqliteSelectDelete(pSub); + return 1; +} + +/* +** Analyze the SELECT statement passed in as an argument to see if it +** is a simple min() or max() query. If it is and this query can be +** satisfied using a single seek to the beginning or end of an index, +** then generate the code for this SELECT and return 1. If this is not a +** simple min() or max() query, then return 0; +** +** A simply min() or max() query looks like this: +** +** SELECT min(a) FROM table; +** SELECT max(a) FROM table; +** +** The query may have only a single table in its FROM argument. There +** can be no GROUP BY or HAVING or WHERE clauses. The result set must +** be the min() or max() of a single column of the table. The column +** in the min() or max() function must be indexed. +** +** The parameters to this routine are the same as for sqliteSelect(). +** See the header comment on that routine for additional information. +*/ +static int simpleMinMaxQuery(Parse *pParse, Select *p, int eDest, int iParm){ + Expr *pExpr; + int iCol; + Table *pTab; + Index *pIdx; + int base; + Vdbe *v; + int seekOp; + int cont; + ExprList *pEList, *pList, eList; + struct ExprList_item eListItem; + SrcList *pSrc; + + + /* Check to see if this query is a simple min() or max() query. Return + ** zero if it is not. + */ + if( p->pGroupBy || p->pHaving || p->pWhere ) return 0; + pSrc = p->pSrc; + if( pSrc->nSrc!=1 ) return 0; + pEList = p->pEList; + if( pEList->nExpr!=1 ) return 0; + pExpr = pEList->a[0].pExpr; + if( pExpr->op!=TK_AGG_FUNCTION ) return 0; + pList = pExpr->pList; + if( pList==0 || pList->nExpr!=1 ) return 0; + if( pExpr->token.n!=3 ) return 0; + if( sqliteStrNICmp(pExpr->token.z,"min",3)==0 ){ + seekOp = OP_Rewind; + }else if( sqliteStrNICmp(pExpr->token.z,"max",3)==0 ){ + seekOp = OP_Last; + }else{ + return 0; + } + pExpr = pList->a[0].pExpr; + if( pExpr->op!=TK_COLUMN ) return 0; + iCol = pExpr->iColumn; + pTab = pSrc->a[0].pTab; + + /* If we get to here, it means the query is of the correct form. + ** Check to make sure we have an index and make pIdx point to the + ** appropriate index. If the min() or max() is on an INTEGER PRIMARY + ** key column, no index is necessary so set pIdx to NULL. If no + ** usable index is found, return 0. + */ + if( iCol<0 ){ + pIdx = 0; + }else{ + for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){ + assert( pIdx->nColumn>=1 ); + if( pIdx->aiColumn[0]==iCol ) break; + } + if( pIdx==0 ) return 0; + } + + /* Identify column types if we will be using the callback. This + ** step is skipped if the output is going to a table or a memory cell. + ** The column names have already been generated in the calling function. + */ + v = sqliteGetVdbe(pParse); + if( v==0 ) return 0; + if( eDest==SRT_Callback ){ + generateColumnTypes(pParse, p->pSrc, p->pEList); + } + + /* If the output is destined for a temporary table, open that table. + */ + if( eDest==SRT_TempTable ){ + sqliteVdbeAddOp(v, OP_OpenTemp, iParm, 0); + } + + /* Generating code to find the min or the max. Basically all we have + ** to do is find the first or the last entry in the chosen index. If + ** the min() or max() is on the INTEGER PRIMARY KEY, then find the first + ** or last entry in the main table. + */ + sqliteCodeVerifySchema(pParse, pTab->iDb); + base = pSrc->a[0].iCursor; + computeLimitRegisters(pParse, p); + if( pSrc->a[0].pSelect==0 ){ + sqliteVdbeAddOp(v, OP_Integer, pTab->iDb, 0); + sqliteVdbeOp3(v, OP_OpenRead, base, pTab->tnum, pTab->zName, 0); + } + cont = sqliteVdbeMakeLabel(v); + if( pIdx==0 ){ + sqliteVdbeAddOp(v, seekOp, base, 0); + }else{ + sqliteVdbeAddOp(v, OP_Integer, pIdx->iDb, 0); + sqliteVdbeOp3(v, OP_OpenRead, base+1, pIdx->tnum, pIdx->zName, P3_STATIC); + if( seekOp==OP_Rewind ){ + sqliteVdbeAddOp(v, OP_String, 0, 0); + sqliteVdbeAddOp(v, OP_MakeKey, 1, 0); + sqliteVdbeAddOp(v, OP_IncrKey, 0, 0); + seekOp = OP_MoveTo; + } + sqliteVdbeAddOp(v, seekOp, base+1, 0); + sqliteVdbeAddOp(v, OP_IdxRecno, base+1, 0); + sqliteVdbeAddOp(v, OP_Close, base+1, 0); + sqliteVdbeAddOp(v, OP_MoveTo, base, 0); + } + eList.nExpr = 1; + memset(&eListItem, 0, sizeof(eListItem)); + eList.a = &eListItem; + eList.a[0].pExpr = pExpr; + selectInnerLoop(pParse, p, &eList, 0, 0, 0, -1, eDest, iParm, cont, cont); + sqliteVdbeResolveLabel(v, cont); + sqliteVdbeAddOp(v, OP_Close, base, 0); + + return 1; +} + +/* +** Generate code for the given SELECT statement. +** +** The results are distributed in various ways depending on the +** value of eDest and iParm. +** +** eDest Value Result +** ------------ ------------------------------------------- +** SRT_Callback Invoke the callback for each row of the result. +** +** SRT_Mem Store first result in memory cell iParm +** +** SRT_Set Store results as keys of a table with cursor iParm +** +** SRT_Union Store results as a key in a temporary table iParm +** +** SRT_Except Remove results from the temporary table iParm. +** +** SRT_Table Store results in temporary table iParm +** +** The table above is incomplete. Additional eDist value have be added +** since this comment was written. See the selectInnerLoop() function for +** a complete listing of the allowed values of eDest and their meanings. +** +** This routine returns the number of errors. If any errors are +** encountered, then an appropriate error message is left in +** pParse->zErrMsg. +** +** This routine does NOT free the Select structure passed in. The +** calling function needs to do that. +** +** The pParent, parentTab, and *pParentAgg fields are filled in if this +** SELECT is a subquery. This routine may try to combine this SELECT +** with its parent to form a single flat query. In so doing, it might +** change the parent query from a non-aggregate to an aggregate query. +** For that reason, the pParentAgg flag is passed as a pointer, so it +** can be changed. +** +** Example 1: The meaning of the pParent parameter. +** +** SELECT * FROM t1 JOIN (SELECT x, count(*) FROM t2) JOIN t3; +** \ \_______ subquery _______/ / +** \ / +** \____________________ outer query ___________________/ +** +** This routine is called for the outer query first. For that call, +** pParent will be NULL. During the processing of the outer query, this +** routine is called recursively to handle the subquery. For the recursive +** call, pParent will point to the outer query. Because the subquery is +** the second element in a three-way join, the parentTab parameter will +** be 1 (the 2nd value of a 0-indexed array.) +*/ +int sqliteSelect( + Parse *pParse, /* The parser context */ + Select *p, /* The SELECT statement being coded. */ + int eDest, /* How to dispose of the results */ + int iParm, /* A parameter used by the eDest disposal method */ + Select *pParent, /* Another SELECT for which this is a sub-query */ + int parentTab, /* Index in pParent->pSrc of this query */ + int *pParentAgg /* True if pParent uses aggregate functions */ +){ + int i; + WhereInfo *pWInfo; + Vdbe *v; + int isAgg = 0; /* True for select lists like "count(*)" */ + ExprList *pEList; /* List of columns to extract. */ + SrcList *pTabList; /* List of tables to select from */ + Expr *pWhere; /* The WHERE clause. May be NULL */ + ExprList *pOrderBy; /* The ORDER BY clause. May be NULL */ + ExprList *pGroupBy; /* The GROUP BY clause. May be NULL */ + Expr *pHaving; /* The HAVING clause. May be NULL */ + int isDistinct; /* True if the DISTINCT keyword is present */ + int distinct; /* Table to use for the distinct set */ + int rc = 1; /* Value to return from this function */ + + if( sqlite_malloc_failed || pParse->nErr || p==0 ) return 1; + if( sqliteAuthCheck(pParse, SQLITE_SELECT, 0, 0, 0) ) return 1; + + /* If there is are a sequence of queries, do the earlier ones first. + */ + if( p->pPrior ){ + return multiSelect(pParse, p, eDest, iParm); + } + + /* Make local copies of the parameters for this query. + */ + pTabList = p->pSrc; + pWhere = p->pWhere; + pOrderBy = p->pOrderBy; + pGroupBy = p->pGroupBy; + pHaving = p->pHaving; + isDistinct = p->isDistinct; + + /* Allocate VDBE cursors for each table in the FROM clause + */ + sqliteSrcListAssignCursors(pParse, pTabList); + + /* + ** Do not even attempt to generate any code if we have already seen + ** errors before this routine starts. + */ + if( pParse->nErr>0 ) goto select_end; + + /* Expand any "*" terms in the result set. (For example the "*" in + ** "SELECT * FROM t1") The fillInColumnlist() routine also does some + ** other housekeeping - see the header comment for details. + */ + if( fillInColumnList(pParse, p) ){ + goto select_end; + } + pWhere = p->pWhere; + pEList = p->pEList; + if( pEList==0 ) goto select_end; + + /* If writing to memory or generating a set + ** only a single column may be output. + */ + if( (eDest==SRT_Mem || eDest==SRT_Set) && pEList->nExpr>1 ){ + sqliteErrorMsg(pParse, "only a single result allowed for " + "a SELECT that is part of an expression"); + goto select_end; + } + + /* ORDER BY is ignored for some destinations. + */ + switch( eDest ){ + case SRT_Union: + case SRT_Except: + case SRT_Discard: + pOrderBy = 0; + break; + default: + break; + } + + /* At this point, we should have allocated all the cursors that we + ** need to handle subquerys and temporary tables. + ** + ** Resolve the column names and do a semantics check on all the expressions. + */ + for(i=0; i<pEList->nExpr; 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; i<pOrderBy->nExpr; 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; i<pGroupBy->nExpr; i++){ + int iCol; + Expr *pE = pGroupBy->a[i].pExpr; + if( sqliteExprIsInteger(pE, &iCol) && iCol>0 && iCol<=pEList->nExpr ){ + sqliteExprDelete(pE); + pE = pGroupBy->a[i].pExpr = sqliteExprDup(pEList->a[iCol-1].pExpr); + } + if( sqliteExprResolveIds(pParse, pTabList, pEList, pE) ){ + goto select_end; + } + if( sqliteExprCheck(pParse, pE, isAgg, 0) ){ + goto select_end; + } + if( sqliteExprIsConstant(pE) ){ + if( sqliteExprIsInteger(pE, &iCol)==0 ){ + sqliteErrorMsg(pParse, + "GROUP BY terms must not be non-integer constants"); + goto select_end; + }else if( iCol<=0 || iCol>pEList->nExpr ){ + sqliteErrorMsg(pParse, + "GROUP BY column number %d out of range - should be " + "between 1 and %d", iCol, pEList->nExpr); + goto select_end; + } + } + } + } + + /* Begin generating code. + */ + v = sqliteGetVdbe(pParse); + if( v==0 ) goto select_end; + + /* Identify column names if we will be using them in a callback. This + ** step is skipped if the output is going to some other destination. + */ + if( eDest==SRT_Callback ){ + generateColumnNames(pParse, pTabList, pEList); + } + + /* Generate code for all sub-queries in the FROM clause + */ + for(i=0; i<pTabList->nSrc; i++){ + const char *zSavedAuthContext; + int needRestoreContext; + + if( pTabList->a[i].pSelect==0 ) continue; + if( pTabList->a[i].zName!=0 ){ + zSavedAuthContext = pParse->zAuthContext; + pParse->zAuthContext = pTabList->a[i].zName; + needRestoreContext = 1; + }else{ + needRestoreContext = 0; + } + sqliteSelect(pParse, pTabList->a[i].pSelect, SRT_TempTable, + pTabList->a[i].iCursor, p, i, &isAgg); + if( needRestoreContext ){ + pParse->zAuthContext = zSavedAuthContext; + } + pTabList = p->pSrc; + pWhere = p->pWhere; + if( eDest!=SRT_Union && eDest!=SRT_Except && eDest!=SRT_Discard ){ + pOrderBy = p->pOrderBy; + } + pGroupBy = p->pGroupBy; + pHaving = p->pHaving; + isDistinct = p->isDistinct; + } + + /* Check for the special case of a min() or max() function by itself + ** in the result set. + */ + if( simpleMinMaxQuery(pParse, p, eDest, iParm) ){ + rc = 0; + goto select_end; + } + + /* Check to see if this is a subquery that can be "flattened" into its parent. + ** If flattening is a possiblity, do so and return immediately. + */ + if( pParent && pParentAgg && + flattenSubquery(pParse, pParent, parentTab, *pParentAgg, isAgg) ){ + if( isAgg ) *pParentAgg = 1; + return rc; + } + + /* Set the limiter. + */ + computeLimitRegisters(pParse, p); + + /* Identify column types if we will be using a callback. This + ** step is skipped if the output is going to a destination other + ** than a callback. + ** + ** We have to do this separately from the creation of column names + ** above because if the pTabList contains views then they will not + ** have been resolved and we will not know the column types until + ** now. + */ + if( eDest==SRT_Callback ){ + generateColumnTypes(pParse, pTabList, pEList); + } + + /* If the output is destined for a temporary table, open that table. + */ + if( eDest==SRT_TempTable ){ + sqliteVdbeAddOp(v, OP_OpenTemp, iParm, 0); + } + + /* Do an analysis of aggregate expressions. + */ + sqliteAggregateInfoReset(pParse); + if( isAgg || pGroupBy ){ + assert( pParse->nAgg==0 ); + isAgg = 1; + for(i=0; i<pEList->nExpr; i++){ + if( sqliteExprAnalyzeAggregates(pParse, pEList->a[i].pExpr) ){ + goto select_end; + } + } + if( pGroupBy ){ + for(i=0; i<pGroupBy->nExpr; i++){ + if( sqliteExprAnalyzeAggregates(pParse, pGroupBy->a[i].pExpr) ){ + goto select_end; + } + } + } + if( pHaving && sqliteExprAnalyzeAggregates(pParse, pHaving) ){ + goto select_end; + } + if( pOrderBy ){ + for(i=0; i<pOrderBy->nExpr; 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; i<pParse->nAgg; i++){ + FuncDef *pFunc; + if( (pFunc = pParse->aAgg[i].pFunc)!=0 && pFunc->xFinalize!=0 ){ + sqliteVdbeOp3(v, OP_AggInit, 0, i, (char*)pFunc, P3_POINTER); + } + } + if( pGroupBy==0 ){ + sqliteVdbeAddOp(v, OP_String, 0, 0); + sqliteVdbeAddOp(v, OP_AggFocus, 0, 0); + } + } + + /* Initialize the memory cell to NULL + */ + if( eDest==SRT_Mem ){ + sqliteVdbeAddOp(v, OP_String, 0, 0); + sqliteVdbeAddOp(v, OP_MemStore, iParm, 1); + } + + /* Open a temporary table to use for the distinct set. + */ + if( isDistinct ){ + distinct = pParse->nTab++; + sqliteVdbeAddOp(v, OP_OpenTemp, distinct, 1); + }else{ + distinct = -1; + } + + /* Begin the database scan + */ + pWInfo = sqliteWhereBegin(pParse, pTabList, pWhere, 0, + pGroupBy ? 0 : &pOrderBy); + if( pWInfo==0 ) goto select_end; + + /* Use the standard inner loop if we are not dealing with + ** aggregates + */ + if( !isAgg ){ + if( selectInnerLoop(pParse, p, pEList, 0, 0, pOrderBy, distinct, eDest, + iParm, pWInfo->iContinue, pWInfo->iBreak) ){ + goto select_end; + } + } + + /* If we are dealing with aggregates, then do the special aggregate + ** processing. + */ + else{ + AggExpr *pAgg; + if( pGroupBy ){ + int lbl1; + for(i=0; i<pGroupBy->nExpr; 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; i<pParse->nAgg; 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; i<pParse->nAgg; i++, pAgg++){ + Expr *pE; + int nExpr; + FuncDef *pDef; + if( !pAgg->isAgg ) continue; + assert( pAgg->pFunc!=0 ); + assert( pAgg->pFunc->xStep!=0 ); + pDef = pAgg->pFunc; + pE = pAgg->pExpr; + assert( pE!=0 ); + assert( pE->op==TK_AGG_FUNCTION ); + nExpr = sqliteExprCodeExprList(pParse, pE->pList, pDef->includeTypes); + sqliteVdbeAddOp(v, OP_Integer, i, 0); + sqliteVdbeOp3(v, OP_AggFunc, 0, nExpr, (char*)pDef, P3_POINTER); + } + } + + /* End the database scan loop. + */ + sqliteWhereEnd(pWInfo); + + /* If we are processing aggregates, we need to set up a second loop + ** over all of the aggregate values and process them. + */ + if( isAgg ){ + int endagg = sqliteVdbeMakeLabel(v); + int startagg; + startagg = sqliteVdbeAddOp(v, OP_AggNext, 0, endagg); + pParse->useAgg = 1; + if( pHaving ){ + sqliteExprIfFalse(pParse, pHaving, startagg, 1); + } + if( selectInnerLoop(pParse, p, pEList, 0, 0, pOrderBy, distinct, eDest, + iParm, startagg, endagg) ){ + goto select_end; + } + sqliteVdbeAddOp(v, OP_Goto, 0, startagg); + sqliteVdbeResolveLabel(v, endagg); + sqliteVdbeAddOp(v, OP_Noop, 0, 0); + pParse->useAgg = 0; + } + + /* If there is an ORDER BY clause, then we need to sort the results + ** and send them to the callback one by one. + */ + if( pOrderBy ){ + generateSortTail(p, v, pEList->nExpr, eDest, iParm); + } + + /* If this was a subquery, we have now converted the subquery into a + ** temporary table. So delete the subquery structure from the parent + ** to prevent this subquery from being evaluated again and to force the + ** the use of the temporary table. + */ + if( pParent ){ + assert( pParent->pSrc->nSrc>parentTab ); + assert( pParent->pSrc->a[parentTab].pSelect==p ); + sqliteSelectDelete(p); + pParent->pSrc->a[parentTab].pSelect = 0; + } + + /* The SELECT was successfully coded. Set the return code to 0 + ** to indicate no errors. + */ + rc = 0; + + /* Control jumps to here if an error is encountered above, or upon + ** successful coding of the SELECT. + */ +select_end: + sqliteAggregateInfoReset(pParse); + return rc; +} diff --git a/kexi/3rdparty/kexisql/src/shell.c b/kexi/3rdparty/kexisql/src/shell.c new file mode 100644 index 00000000..6dbed415 --- /dev/null +++ b/kexi/3rdparty/kexisql/src/shell.c @@ -0,0 +1,1424 @@ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains code to implement the "sqlite" command line +** utility for accessing SQLite databases. +** +** $Id: shell.c 410099 2005-05-06 17:52:07Z staniek $ +*/ +#include <stdlib.h> +#include <string.h> +#include <stdio.h> +#include "sqlite.h" +#include <ctype.h> + +#if defined(_WIN32) +# include <io.h> +#endif + +#if !defined(_WIN32) && !defined(WIN32) && !defined(__MACOS__) +# include <signal.h> +# include <pwd.h> +# include <unistd.h> +# include <sys/types.h> + +#define strnicmp strncasecmp +#define stricmp strcasecmp + +#endif + +#ifdef __MACOS__ +# include <console.h> +# include <signal.h> +# include <unistd.h> +# include <extras.h> +# include <Files.h> +# include <Folders.h> +#endif + +#if defined(HAVE_READLINE) && HAVE_READLINE==1 +# include <readline/readline.h> +# include <readline/history.h> +#else +# define readline(p) local_getline(p,stdin) +# define add_history(X) +# define read_history(X) +# define write_history(X) +# define stifle_history(X) +#endif + +/* js */ +char verboseDump = 0; +int nObjects = 0; /* used to count progress */ +int curObjects = 0; +/* \js */ + +/* Make sure isatty() has a prototype. +*/ +extern int isatty(); + +/* +** The following is the open SQLite database. We make a pointer +** to this database a static variable so that it can be accessed +** by the SIGINT handler to interrupt database processing. +*/ +static sqlite *db = 0; + +/* +** True if an interrupt (Control-C) has been received. +*/ +static int seenInterrupt = 0; + +/* +** This is the name of our program. It is set in main(), used +** in a number of other places, mostly for error messages. +*/ +static char *Argv0; + +/* +** Prompt strings. Initialized in main. Settable with +** .prompt main continue +*/ +static char mainPrompt[20]; /* First line prompt. default: "sqlite> "*/ +static char continuePrompt[20]; /* Continuation prompt. default: " ...> " */ + + +/* +** Determines if a string is a number of not. +*/ +/* extern int sqliteIsNumber(const char*); */ +static int isNumber(const unsigned char *z){ + if( *z=='-' || *z=='+' ) z++; + if( !isdigit(*z) ){ + return 0; + } + z++; + while( isdigit(*z) ){ z++; } + if( *z=='.' ){ + z++; + if( !isdigit(*z) ) return 0; + while( isdigit(*z) ){ z++; } + } + if( *z=='e' || *z=='E' ){ + z++; + if( *z=='+' || *z=='-' ) z++; + if( !isdigit(*z) ) return 0; + while( isdigit(*z) ){ z++; } + } + return *z==0; +} + + +/* +** This routine reads a line of text from standard input, 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. +** +** The interface is like "readline" but no command-line editing +** is done. +*/ +static char *local_getline(char *zPrompt, FILE *in){ + char *zLine; + int nLine; + int n; + int eol; + + if( zPrompt && *zPrompt ){ + printf("%s",zPrompt); + fflush(stdout); + } + nLine = 100; + zLine = malloc( nLine ); + if( zLine==0 ) return 0; + n = 0; + eol = 0; + while( !eol ){ + if( n+100>nLine ){ + nLine = nLine*2 + 100; + zLine = realloc(zLine, nLine); + if( zLine==0 ) return 0; + } + if( fgets(&zLine[n], nLine - n, in)==0 ){ + if( n==0 ){ + free(zLine); + return 0; + } + zLine[n] = 0; + eol = 1; + break; + } + while( zLine[n] ){ n++; } + if( n>0 && zLine[n-1]=='\n' ){ + n--; + zLine[n] = 0; + eol = 1; + } + } + zLine = realloc( zLine, n+1 ); + return zLine; +} + +/* +** Retrieve a single line of input text. "isatty" is true if text +** is coming from a terminal. In that case, we issue a prompt and +** attempt to use "readline" for command-line editing. If "isatty" +** is false, use "local_getline" instead of "readline" and issue no prompt. +** +** zPrior is a string of prior text retrieved. If not the empty +** string, then issue a continuation prompt. +*/ +static char *one_input_line(const char *zPrior, FILE *in){ + char *zPrompt; + char *zResult; + if( in!=0 ){ + return local_getline(0, in); + } + if( zPrior && zPrior[0] ){ + zPrompt = continuePrompt; + }else{ + zPrompt = mainPrompt; + } + zResult = readline(zPrompt); + if( zResult ) add_history(zResult); + return zResult; +} + +struct previous_mode_data { + int valid; /* Is there legit data in here? */ + int mode; + int showHeader; + int colWidth[100]; +}; +/* +** An pointer to an instance of this structure is passed from +** the main program to the callback. This is used to communicate +** state and mode information. +*/ +struct callback_data { + sqlite *db; /* The database */ + int echoOn; /* True to echo input commands */ + int cnt; /* Number of records displayed so far */ + FILE *out; /* Write results here */ + int mode; /* An output mode setting */ + int showHeader; /* True to show column names in List or Column mode */ + char *zDestTable; /* Name of destination table when MODE_Insert */ + char separator[20]; /* Separator character for MODE_List */ + int colWidth[100]; /* Requested width of each column when in column mode*/ + int actualWidth[100]; /* Actual width of each column */ + char nullvalue[20]; /* The text to print when a NULL comes back from + ** the database */ + struct previous_mode_data explainPrev; + /* Holds the mode information just before + ** .explain ON */ + char outfile[FILENAME_MAX]; /* Filename for *out */ + const char *zDbFilename; /* name of the database file */ + char *zKey; /* Encryption key */ +}; + +/* +** These are the allowed modes. +*/ +#define MODE_Line 0 /* One column per line. Blank line between records */ +#define MODE_Column 1 /* One record per line in neat columns */ +#define MODE_List 2 /* One record per line with a separator */ +#define MODE_Semi 3 /* Same as MODE_List but append ";" to each line */ +#define MODE_Html 4 /* Generate an XHTML table */ +#define MODE_Insert 5 /* Generate SQL "insert" statements */ +#define MODE_NUM_OF 6 /* The number of modes (not a mode itself) */ + +char *modeDescr[MODE_NUM_OF] = { + "line", + "column", + "list", + "semi", + "html", + "insert" +}; + +/* +** Number of elements in an array +*/ +#define ArraySize(X) (sizeof(X)/sizeof(X[0])) + +/* +** Output the given string as a quoted string using SQL quoting conventions. +*/ +static void output_quoted_string(FILE *out, const char *z){ + int i; + int nSingle = 0; + for(i=0; z[i]; i++){ + if( z[i]=='\'' ) nSingle++; + } + if( nSingle==0 ){ + fprintf(out,"'%s'",z); + }else{ + fprintf(out,"'"); + while( *z ){ + for(i=0; z[i] && z[i]!='\''; i++){} + if( i==0 ){ + fprintf(out,"''"); + z++; + }else if( z[i]=='\'' ){ + fprintf(out,"%.*s''",i,z); + z += i+1; + }else{ + fprintf(out,"%s",z); + break; + } + } + fprintf(out,"'"); + } +} + +/* +** Output the given string with characters that are special to +** HTML escaped. +*/ +static void output_html_string(FILE *out, const char *z){ + int i; + while( *z ){ + for(i=0; z[i] && z[i]!='<' && z[i]!='&'; i++){} + if( i>0 ){ + fprintf(out,"%.*s",i,z); + } + if( z[i]=='<' ){ + fprintf(out,"<"); + }else if( z[i]=='&' ){ + fprintf(out,"&"); + }else{ + break; + } + z += i + 1; + } +} + +/* +** This routine runs when the user presses Ctrl-C +*/ +static void interrupt_handler(int NotUsed){ + seenInterrupt = 1; + if( db ) sqlite_interrupt(db); +} + +/* +** This is the callback routine that the SQLite library +** invokes for each row of a query result. +*/ +static int callback(void *pArg, int nArg, char **azArg, char **azCol){ + int i; + struct callback_data *p = (struct callback_data*)pArg; + switch( p->mode ){ + case MODE_Line: { + int w = 5; + if( azArg==0 ) break; + for(i=0; i<nArg; i++){ + int len = strlen(azCol[i]); + if( len>w ) w = len; + } + if( p->cnt++>0 ) fprintf(p->out,"\n"); + for(i=0; i<nArg; i++){ + fprintf(p->out,"%*s = %s\n", w, azCol[i], + azArg[i] ? azArg[i] : p->nullvalue); + } + break; + } + case MODE_Column: { + if( p->cnt++==0 ){ + for(i=0; i<nArg; i++){ + int w, n; + if( i<ArraySize(p->colWidth) ){ + w = p->colWidth[i]; + }else{ + w = 0; + } + if( w<=0 ){ + w = strlen(azCol[i] ? azCol[i] : ""); + if( w<10 ) w = 10; + n = strlen(azArg && azArg[i] ? azArg[i] : p->nullvalue); + if( w<n ) w = n; + } + if( i<ArraySize(p->actualWidth) ){ + p->actualWidth[i] = w; + } + if( p->showHeader ){ + fprintf(p->out,"%-*.*s%s",w,w,azCol[i], i==nArg-1 ? "\n": " "); + } + } + if( p->showHeader ){ + for(i=0; i<nArg; i++){ + int w; + if( i<ArraySize(p->actualWidth) ){ + w = p->actualWidth[i]; + }else{ + w = 10; + } + fprintf(p->out,"%-*.*s%s",w,w,"-----------------------------------" + "----------------------------------------------------------", + i==nArg-1 ? "\n": " "); + } + } + } + if( azArg==0 ) break; + for(i=0; i<nArg; i++){ + int w; + if( i<ArraySize(p->actualWidth) ){ + w = p->actualWidth[i]; + }else{ + w = 10; + } + fprintf(p->out,"%-*.*s%s",w,w, + azArg[i] ? azArg[i] : p->nullvalue, i==nArg-1 ? "\n": " "); + } + break; + } + case MODE_Semi: + case MODE_List: { + if( p->cnt++==0 && p->showHeader ){ + for(i=0; i<nArg; i++){ + fprintf(p->out,"%s%s",azCol[i], i==nArg-1 ? "\n" : p->separator); + } + } + if( azArg==0 ) break; + for(i=0; i<nArg; i++){ + char *z = azArg[i]; + if( z==0 ) z = p->nullvalue; + fprintf(p->out, "%s", z); + if( i<nArg-1 ){ + fprintf(p->out, "%s", p->separator); + }else if( p->mode==MODE_Semi ){ + fprintf(p->out, ";\n"); + }else{ + fprintf(p->out, "\n"); + } + } + break; + } + case MODE_Html: { + if( p->cnt++==0 && p->showHeader ){ + fprintf(p->out,"<TR>"); + for(i=0; i<nArg; i++){ + fprintf(p->out,"<TH>%s</TH>",azCol[i]); + } + fprintf(p->out,"</TR>\n"); + } + if( azArg==0 ) break; + fprintf(p->out,"<TR>"); + for(i=0; i<nArg; i++){ + fprintf(p->out,"<TD>"); + output_html_string(p->out, azArg[i] ? azArg[i] : p->nullvalue); + fprintf(p->out,"</TD>\n"); + } + fprintf(p->out,"</TR>\n"); + break; + } + case MODE_Insert: { + if( azArg==0 ) break; + fprintf(p->out,"INSERT INTO %s VALUES(",p->zDestTable); + for(i=0; i<nArg; i++){ + char *zSep = i>0 ? ",": ""; + if( azArg[i]==0 ){ + fprintf(p->out,"%sNULL",zSep); + }else if( isNumber(azArg[i]) ){ + fprintf(p->out,"%s%s",zSep, azArg[i]); + }else{ + if( zSep[0] ) fprintf(p->out,"%s",zSep); + output_quoted_string(p->out, azArg[i]); + } + } + fprintf(p->out,");\n"); + break; + } + } + return 0; +} + +/* +** Set the destination table field of the callback_data structure to +** the name of the table given. Escape any quote characters in the +** table name. +*/ +static void set_table_name(struct callback_data *p, const char *zName){ + int i, n; + int needQuote; + char *z; + + if( p->zDestTable ){ + free(p->zDestTable); + p->zDestTable = 0; + } + if( zName==0 ) return; + needQuote = !isalpha(*zName) && *zName!='_'; + for(i=n=0; zName[i]; i++, n++){ + if( !isalnum(zName[i]) && zName[i]!='_' ){ + needQuote = 1; + if( zName[i]=='\'' ) n++; + } + } + if( needQuote ) n += 2; + z = p->zDestTable = malloc( n+1 ); + if( z==0 ){ + fprintf(stderr,"Out of memory!\n"); + exit(1); + } + n = 0; + if( needQuote ) z[n++] = '\''; + for(i=0; zName[i]; i++){ + z[n++] = zName[i]; + if( zName[i]=='\'' ) z[n++] = '\''; + } + if( needQuote ) z[n++] = '\''; + z[n] = 0; +} + +/* +** This is a different callback routine used for dumping the database. +** Each row received by this callback consists of a table name, +** the table type ("index" or "table") and SQL to create the table. +** This routine should print text sufficient to recreate the table. +*/ +static int dump_callback(void *pArg, int nArg, char **azArg, char **azCol){ + struct callback_data *p = (struct callback_data *)pArg; + struct callback_data d2; + if( nArg!=3 ) return 1; + fprintf(p->out, "%s;\n", azArg[2]); + if( strcmp(azArg[1],"table")==0 ){ +/* js */ + if (verboseDump) + fprintf(stderr, "%%%d\n", (++curObjects * 100 / nObjects)); +/* \js */ + 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); + } + return 0; +} + +/* +** 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" + ".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" + ".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" + ".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" + ".show Show the current values for various settings\n" + ".tables ?PATTERN? List names of tables matching a pattern\n" + ".timeout MS Try opening locked tables for MS milliseconds\n" + ".width NUM NUM ... Set column widths for \"column\" mode\n" +; + +/* Forward reference */ +static void process_input(struct callback_data *p, FILE *in); + +/* +** Make sure the database is open. If it is not, then open it. If +** the database fails to open, print an error message and exit. +*/ +static void open_db(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); + } + exit(1); + } + } +} + +/* +** If an input line begins with "." then invoke this routine to +** process that line. +** +** Return 1 to exit and 0 to continue. +*/ +static int do_meta_command(char *zLine, struct callback_data *p){ + int i = 1; + int nArg = 0; + int n, c; + int rc = 0; + char *azArg[50]; + +/* js */ + sqlite_vm *pVm; + char *errMsg; + int ncolumns; /* OUT: Number of columns in result */ + const char **pazValue; /* OUT: Column data */ + const char **pazColName; /* OUT: Column names and datatypes */ +/* \js */ + + /* Parse the input line into tokens. + */ + while( zLine[i] && nArg<ArraySize(azArg) ){ + while( isspace(zLine[i]) ){ i++; } + if( zLine[i]==0 ) break; + if( zLine[i]=='\'' || zLine[i]=='"' ){ + int delim = zLine[i++]; + azArg[nArg++] = &zLine[i]; + while( zLine[i] && zLine[i]!=delim ){ i++; } + if( zLine[i]==delim ){ + zLine[i++] = 0; + } + }else{ + azArg[nArg++] = &zLine[i]; + while( zLine[i] && !isspace(zLine[i]) ){ i++; } + if( zLine[i] ) zLine[i++] = 0; + } + } + + /* Process the input line. + */ + if( nArg==0 ) return rc; + n = strlen(azArg[0]); + c = azArg[0][0]; + if( c=='d' && n>1 && strncmp(azArg[0], "databases", n)==0 ){ + struct callback_data data; + char *zErrMsg = 0; + open_db(p); + memcpy(&data, p, sizeof(data)); + data.showHeader = 1; + data.mode = MODE_Column; + data.colWidth[0] = 3; + data.colWidth[1] = 15; + data.colWidth[2] = 58; + sqlite_exec(p->db, "PRAGMA database_list; ", callback, &data, &zErrMsg); + if( zErrMsg ){ + fprintf(stderr,"Error: %s\n", zErrMsg); + sqlite_freemem(zErrMsg); + } + }else + + if( c=='d' && strncmp(azArg[0], "dump", n)==0 ){ + char *zErrMsg = 0; + open_db(p); + +/* js */ +if (SQLITE_OK!=sqlite_compile(p->db, "SELECT COUNT(1) FROM sqlite_master", +0, &pVm, &errMsg)) { + fprintf(stderr, "%s\n", errMsg); + exit(1); +} +if (SQLITE_ROW!=sqlite_step( pVm, &ncolumns, &pazValue, &pazColName )) { + exit(1); +} +nObjects = atoi(pazValue[0]); + +if (SQLITE_OK!=sqlite_finalize( pVm, &errMsg)) { + fprintf(stderr, "%s\n", errMsg); + exit(1); +} +/* \js */ + + fprintf(p->out, "BEGIN TRANSACTION;\n"); + if( nArg==1 ){ + sqlite_exec(p->db, + "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 + ); + }else{ + int i; + for(i=1; i<nArg && zErrMsg==0; i++){ + sqlite_exec_printf(p->db, + "SELECT name, type, sql FROM sqlite_master " + "WHERE tbl_name LIKE '%q' AND type!='meta' AND sql NOT NULL " + "ORDER BY substr(type,2,1), name", + dump_callback, p, &zErrMsg, azArg[i] + ); + } + } + if( zErrMsg ){ + fprintf(stderr,"Error: %s\n", zErrMsg); + sqlite_freemem(zErrMsg); + }else{ + fprintf(p->out, "COMMIT;\n"); + } + }else + + if( c=='e' && strncmp(azArg[0], "echo", n)==0 && nArg>1 ){ + int j; + char *z = azArg[1]; + int val = atoi(azArg[1]); + for(j=0; z[j]; j++){ + if( isupper(z[j]) ) z[j] = tolower(z[j]); + } + if( strcmp(z,"on")==0 ){ + val = 1; + }else if( strcmp(z,"yes")==0 ){ + val = 1; + } + p->echoOn = val; + }else + + if( c=='e' && strncmp(azArg[0], "exit", n)==0 ){ + rc = 1; + }else + + if( c=='e' && strncmp(azArg[0], "explain", n)==0 ){ + int j; + char *z = nArg>=2 ? azArg[1] : "1"; + int val = atoi(z); + for(j=0; z[j]; j++){ + if( isupper(z[j]) ) z[j] = tolower(z[j]); + } + if( strcmp(z,"on")==0 ){ + val = 1; + }else if( strcmp(z,"yes")==0 ){ + val = 1; + } + if(val == 1) { + if(!p->explainPrev.valid) { + p->explainPrev.valid = 1; + p->explainPrev.mode = p->mode; + p->explainPrev.showHeader = p->showHeader; + memcpy(p->explainPrev.colWidth,p->colWidth,sizeof(p->colWidth)); + } + /* We could put this code under the !p->explainValid + ** condition so that it does not execute if we are already in + ** explain mode. However, always executing it allows us an easy + ** was to reset to explain mode in case the user previously + ** did an .explain followed by a .width, .mode or .header + ** command. + */ + p->mode = MODE_Column; + p->showHeader = 1; + memset(p->colWidth,0,ArraySize(p->colWidth)); + p->colWidth[0] = 4; + p->colWidth[1] = 12; + p->colWidth[2] = 10; + p->colWidth[3] = 10; + p->colWidth[4] = 35; + }else if (p->explainPrev.valid) { + p->explainPrev.valid = 0; + p->mode = p->explainPrev.mode; + p->showHeader = p->explainPrev.showHeader; + memcpy(p->colWidth,p->explainPrev.colWidth,sizeof(p->colWidth)); + } + }else + + if( c=='h' && (strncmp(azArg[0], "header", n)==0 + || + strncmp(azArg[0], "headers", n)==0 )&& nArg>1 ){ + int j; + char *z = azArg[1]; + int val = atoi(azArg[1]); + for(j=0; z[j]; j++){ + if( isupper(z[j]) ) z[j] = tolower(z[j]); + } + if( strcmp(z,"on")==0 ){ + val = 1; + }else if( strcmp(z,"yes")==0 ){ + val = 1; + } + p->showHeader = val; + }else + + if( c=='h' && strncmp(azArg[0], "help", n)==0 ){ + fprintf(stderr,zHelp); + }else + + if( c=='i' && strncmp(azArg[0], "indices", n)==0 && nArg>1 ){ + struct callback_data data; + char *zErrMsg = 0; + open_db(p); + memcpy(&data, p, sizeof(data)); + data.showHeader = 0; + data.mode = MODE_List; + sqlite_exec_printf(p->db, + "SELECT name FROM sqlite_master " + "WHERE type='index' AND tbl_name LIKE '%q' " + "UNION ALL " + "SELECT name FROM sqlite_temp_master " + "WHERE type='index' AND tbl_name LIKE '%q' " + "ORDER BY 1", + callback, &data, &zErrMsg, azArg[1], azArg[1] + ); + if( zErrMsg ){ + fprintf(stderr,"Error: %s\n", zErrMsg); + sqlite_freemem(zErrMsg); + } + }else + + if( c=='m' && strncmp(azArg[0], "mode", n)==0 && nArg>=2 ){ + int n2 = strlen(azArg[1]); + if( strncmp(azArg[1],"line",n2)==0 + || + strncmp(azArg[1],"lines",n2)==0 ){ + p->mode = MODE_Line; + }else if( strncmp(azArg[1],"column",n2)==0 + || + strncmp(azArg[1],"columns",n2)==0 ){ + p->mode = MODE_Column; + }else if( strncmp(azArg[1],"list",n2)==0 ){ + p->mode = MODE_List; + }else if( strncmp(azArg[1],"html",n2)==0 ){ + p->mode = MODE_Html; + }else if( strncmp(azArg[1],"insert",n2)==0 ){ + p->mode = MODE_Insert; + if( nArg>=3 ){ + set_table_name(p, azArg[2]); + }else{ + set_table_name(p, "table"); + } + }else { + fprintf(stderr,"mode should be on of: column html insert line list\n"); + } + }else + + if( c=='n' && strncmp(azArg[0], "nullvalue", n)==0 && nArg==2 ) { + sprintf(p->nullvalue, "%.*s", (int)ArraySize(p->nullvalue)-1, azArg[1]); + }else + + if( c=='o' && strncmp(azArg[0], "output", n)==0 && nArg==2 ){ + if( p->out!=stdout ){ + fclose(p->out); + } + if( strcmp(azArg[1],"stdout")==0 ){ + p->out = stdout; + strcpy(p->outfile,"stdout"); + }else{ + p->out = fopen(azArg[1], "wb"); + if( p->out==0 ){ + fprintf(stderr,"can't write to \"%s\"\n", azArg[1]); + p->out = stdout; + } else { + strcpy(p->outfile,azArg[1]); + } + } + }else + + if( c=='p' && strncmp(azArg[0], "prompt", n)==0 && (nArg==2 || nArg==3)){ + if( nArg >= 2) { + strncpy(mainPrompt,azArg[1],(int)ArraySize(mainPrompt)-1); + } + if( nArg >= 3) { + strncpy(continuePrompt,azArg[2],(int)ArraySize(continuePrompt)-1); + } + }else + + if( c=='q' && strncmp(azArg[0], "quit", n)==0 ){ + rc = 1; + }else + + if( c=='r' && strncmp(azArg[0], "read", n)==0 && nArg==2 ){ + FILE *alt = fopen(azArg[1], "rb"); + if( alt==0 ){ + fprintf(stderr,"can't open \"%s\"\n", azArg[1]); + }else{ + process_input(p, alt); + fclose(alt); + } + }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; + open_db(p); + memcpy(&data, p, sizeof(data)); + data.showHeader = 0; + data.mode = MODE_Semi; + if( nArg>1 ){ +/* extern int sqliteStrICmp(const char*,const char*); + if( sqliteStrICmp(azArg[1],"sqlite_master")==0 ){*/ + if( stricmp(azArg[1],"sqlite_master")==0 ){ + char *new_argv[2], *new_colv[2]; + new_argv[0] = "CREATE TABLE sqlite_master (\n" + " type text,\n" + " name text,\n" + " tbl_name text,\n" + " rootpage integer,\n" + " sql text\n" + ")"; + new_argv[1] = 0; + new_colv[0] = "sql"; + new_colv[1] = 0; + callback(&data, 1, new_argv, new_colv); +/* }else if( sqliteStrICmp(azArg[1],"sqlite_temp_master")==0 ){*/ + }else if( stricmp(azArg[1],"sqlite_temp_master")==0 ){ + char *new_argv[2], *new_colv[2]; + new_argv[0] = "CREATE TEMP TABLE sqlite_temp_master (\n" + " type text,\n" + " name text,\n" + " tbl_name text,\n" + " rootpage integer,\n" + " sql text\n" + ")"; + new_argv[1] = 0; + new_colv[0] = "sql"; + new_colv[1] = 0; + callback(&data, 1, new_argv, new_colv); + }else{ + sqlite_exec_printf(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 " + "ORDER BY substr(type,2,1), name", + callback, &data, &zErrMsg, azArg[1]); + } + }else{ + sqlite_exec(p->db, + "SELECT sql FROM " + " (SELECT * FROM sqlite_master UNION ALL" + " SELECT * FROM sqlite_temp_master) " + "WHERE type!='meta' AND sql NOTNULL " + "ORDER BY substr(type,2,1), name", + callback, &data, &zErrMsg + ); + } + if( zErrMsg ){ + fprintf(stderr,"Error: %s\n", zErrMsg); + sqlite_freemem(zErrMsg); + } + }else + + if( c=='s' && strncmp(azArg[0], "separator", n)==0 && nArg==2 ){ + sprintf(p->separator, "%.*s", (int)ArraySize(p->separator)-1, azArg[1]); + }else + + if( c=='s' && strncmp(azArg[0], "show", n)==0){ + int i; + fprintf(p->out,"%9.9s: %s\n","echo", p->echoOn ? "on" : "off"); + 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: %s\n","output", + strlen(p->outfile) ? p->outfile : "stdout"); + fprintf(p->out,"%9.9s: %s\n","separator", p->separator); + 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,"\n\n"); + }else + + if( c=='t' && n>1 && strncmp(azArg[0], "tables", n)==0 ){ + char **azResult; + int nRow, rc; + char *zErrMsg; + open_db(p); + if( nArg==1 ){ + rc = sqlite_get_table(p->db, + "SELECT name FROM sqlite_master " + "WHERE type IN ('table','view') " + "UNION ALL " + "SELECT name FROM sqlite_temp_master " + "WHERE type IN ('table','view') " + "ORDER BY 1", + &azResult, &nRow, 0, &zErrMsg + ); + }else{ + rc = sqlite_get_table_printf(p->db, + "SELECT name FROM sqlite_master " + "WHERE type IN ('table','view') AND name LIKE '%%%q%%' " + "UNION ALL " + "SELECT name FROM sqlite_temp_master " + "WHERE type IN ('table','view') AND name LIKE '%%%q%%' " + "ORDER BY 1", + &azResult, &nRow, 0, &zErrMsg, azArg[1], azArg[1] + ); + } + if( zErrMsg ){ + fprintf(stderr,"Error: %s\n", zErrMsg); + sqlite_freemem(zErrMsg); + } + if( rc==SQLITE_OK ){ + int len, maxlen = 0; + int i, j; + int nPrintCol, nPrintRow; + for(i=1; i<=nRow; i++){ + if( azResult[i]==0 ) continue; + len = strlen(azResult[i]); + if( len>maxlen ) maxlen = len; + } + nPrintCol = 80/(maxlen+2); + if( nPrintCol<1 ) nPrintCol = 1; + nPrintRow = (nRow + nPrintCol - 1)/nPrintCol; + for(i=0; i<nPrintRow; i++){ + for(j=i+1; j<=nRow; j+=nPrintRow){ + char *zSp = j<=nPrintRow ? "" : " "; + printf("%s%-*s", zSp, maxlen, azResult[j] ? azResult[j] : ""); + } + printf("\n"); + } + } + sqlite_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])); + }else + + if( c=='w' && strncmp(azArg[0], "width", n)==0 ){ + int j; + for(j=1; j<nArg && j<ArraySize(p->colWidth); j++){ + p->colWidth[j-1] = atoi(azArg[j]); + } + }else + + { + fprintf(stderr, "unknown command or invalid arguments: " + " \"%s\". Enter \".help\" for help\n", azArg[0]); + } + + return rc; +} + +/* +** Return TRUE if the last non-whitespace character in z[] is a semicolon. +** z[] is N characters long. +*/ +static int _ends_with_semicolon(const char *z, int N){ + while( N>0 && isspace(z[N-1]) ){ N--; } + return N>0 && z[N-1]==';'; +} + +/* +** Test to see if a line consists entirely of whitespace. +*/ +static int _all_whitespace(const char *z){ + for(; *z; z++){ + if( isspace(*z) ) continue; + if( *z=='/' && z[1]=='*' ){ + z += 2; + while( *z && (*z!='*' || z[1]!='/') ){ z++; } + if( *z==0 ) return 0; + z++; + continue; + } + if( *z=='-' && z[1]=='-' ){ + z += 2; + while( *z && *z!='\n' ){ z++; } + if( *z==0 ) return 1; + continue; + } + return 0; + } + return 1; +} + +/* +** Return TRUE if the line typed in is an SQL command terminator other +** than a semi-colon. The SQL Server style "go" command is understood +** as is the Oracle "/". +*/ +static int _is_command_terminator(const char *zLine){ +/* extern int sqliteStrNICmp(const char*,const char*,int); */ + while( isspace(*zLine) ){ zLine++; }; + if( zLine[0]=='/' && _all_whitespace(&zLine[1]) ) return 1; /* Oracle */ +/* if( sqliteStrNICmp(zLine,"go",2)==0 && _all_whitespace(&zLine[2]) ){ */ + if( strnicmp(zLine,"go",2)==0 && _all_whitespace(&zLine[2]) ){ + return 1; /* SQL Server */ + } + return 0; +} + +/* +** Read input from *in and process it. If *in==0 then input +** is interactive - the user is typing it it. Otherwise, input +** is coming from a file or device. A prompt is issued and history +** is saved only if input is interactive. An interrupt signal will +** cause this routine to exit immediately, unless input is interactive. +*/ +static void process_input(struct callback_data *p, FILE *in){ + char *zLine; + char *zSql = 0; + int nSql = 0; + char *zErrMsg; + int rc; + while( fflush(p->out), (zLine = one_input_line(zSql, in))!=0 ){ + if( seenInterrupt ){ + if( in!=0 ) break; + seenInterrupt = 0; + } + if( p->echoOn ) printf("%s\n", zLine); + if( (zSql==0 || zSql[0]==0) && _all_whitespace(zLine) ) continue; + if( zLine && zLine[0]=='.' && nSql==0 ){ + int rc = do_meta_command(zLine, p); + free(zLine); + if( rc ) break; + continue; + } + if( _is_command_terminator(zLine) ){ + strcpy(zLine,";"); + } + if( zSql==0 ){ + int i; + for(i=0; zLine[i] && isspace(zLine[i]); i++){} + if( zLine[i]!=0 ){ + nSql = strlen(zLine); + zSql = malloc( nSql+1 ); + strcpy(zSql, zLine); + } + }else{ + int len = strlen(zLine); + zSql = realloc( zSql, nSql + len + 2 ); + if( zSql==0 ){ + fprintf(stderr,"%s: out of memory!\n", Argv0); + exit(1); + } + strcpy(&zSql[nSql++], "\n"); + strcpy(&zSql[nSql], zLine); + nSql += len; + } + free(zLine); + if( zSql && _ends_with_semicolon(zSql, nSql) && sqlite_complete(zSql) ){ + p->cnt = 0; + open_db(p); + rc = sqlite_exec(p->db, zSql, callback, p, &zErrMsg); + if( rc || zErrMsg ){ + if( in!=0 && !p->echoOn ) printf("%s\n",zSql); + if( zErrMsg!=0 ){ + printf("SQL error: %s\n", zErrMsg); + sqlite_freemem(zErrMsg); + zErrMsg = 0; + }else{ + printf("SQL error: %s\n", sqlite_error_string(rc)); + } + } + free(zSql); + zSql = 0; + nSql = 0; + } + } + if( zSql ){ + if( !_all_whitespace(zSql) ) printf("Incomplete SQL: %s\n", zSql); + free(zSql); + } +} + +/* +** Return a pathname which is the user's home directory. A +** 0 return indicates an error of some kind. Space to hold the +** resulting string is obtained from malloc(). The calling +** function should free the result. +*/ +static char *find_home_dir(void){ + char *home_dir = NULL; + +#if !defined(_WIN32) && !defined(WIN32) && !defined(__MACOS__) + struct passwd *pwent; + uid_t uid = getuid(); + if( (pwent=getpwuid(uid)) != NULL) { + home_dir = pwent->pw_dir; + } +#endif + +#ifdef __MACOS__ + char home_path[_MAX_PATH+1]; + home_dir = getcwd(home_path, _MAX_PATH); +#endif + + if (!home_dir) { + home_dir = getenv("HOME"); + if (!home_dir) { + home_dir = getenv("HOMEPATH"); /* Windows? */ + } + } + +#if defined(_WIN32) || defined(WIN32) + if (!home_dir) { + home_dir = "c:"; + } +#endif + + if( home_dir ){ + char *z = malloc( strlen(home_dir)+1 ); + if( z ) strcpy(z, home_dir); + home_dir = z; + } + + return home_dir; +} + +/* +** Read input from the file given by sqliterc_override. Or if that +** parameter is NULL, take input from ~/.sqliterc +*/ +static void process_sqliterc( + struct callback_data *p, /* Configuration data */ + const char *sqliterc_override /* Name of config file. NULL to use default */ +){ + char *home_dir = NULL; + const char *sqliterc = sqliterc_override; + char *zBuf; + FILE *in = NULL; + + if (sqliterc == NULL) { + home_dir = find_home_dir(); + if( home_dir==0 ){ + fprintf(stderr,"%s: cannot locate your home directory!\n", Argv0); + return; + } + zBuf = malloc(strlen(home_dir) + 15); + if( zBuf==0 ){ + fprintf(stderr,"%s: out of memory!\n", Argv0); + exit(1); + } + sprintf(zBuf,"%s/.sqliterc",home_dir); + free(home_dir); + sqliterc = (const char*)zBuf; + } + in = fopen(sqliterc,"rb"); + if( in ){ + if( isatty(fileno(stdout)) ){ + printf("Loading resources from %s\n",sqliterc); + } + process_input(p,in); + fclose(in); + } + return; +} + +/* +** Show available command line options +*/ +static const char zOptions[] = + " -init filename read/process named file\n" + " -echo print commands before execution\n" + " -[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" + " -nullvalue 'text' set text string for NULL values\n" + " -version show SQLite version\n" + " -help show this text, also show dot-commands\n" +; +static void usage(int showDetail){ + fprintf(stderr, "Usage: %s [OPTIONS] FILENAME [SQL]\n", Argv0); + if( showDetail ){ + fprintf(stderr, "Options are:\n%s", zOptions); + }else{ + fprintf(stderr, "Use the -help option for additional information\n"); + } + exit(1); +} + +/* +** Initialize the state information in data +*/ +void main_init(struct callback_data *data) { + memset(data, 0, sizeof(*data)); + data->mode = MODE_List; + strcpy(data->separator,"|"); + data->showHeader = 0; + strcpy(mainPrompt,"sqlite> "); + strcpy(continuePrompt," ...> "); +} + +int main(int argc, char **argv){ + char *zErrMsg = 0; + struct callback_data data; + const char *zInitFile = 0; + char *zFirstCmd = 0; + int i; +/* extern int sqliteOsFileExists(const char*); */ + +#ifdef __MACOS__ + argc = ccommand(&argv); +#endif + + Argv0 = argv[0]; + main_init(&data); + + /* Make sure we have a valid signal handler early, before anything + ** else is done. + */ +#ifdef SIGINT + signal(SIGINT, interrupt_handler); +#endif + + /* Do an initial pass through the command-line argument to locate + ** the name of the database file, the name of the initialization file, + ** and the first command to execute. + */ + for(i=1; i<argc-1; i++){ + if( argv[i][0]!='-' ) break; + if( strcmp(argv[i],"-separator")==0 || strcmp(argv[i],"-nullvalue")==0 ){ + i++; + }else if( strcmp(argv[i],"-init")==0 ){ + i++; + zInitFile = argv[i]; + }else if( strcmp(argv[i],"-key")==0 ){ + i++; + data.zKey = sqlite_mprintf("%s",argv[i]); + } + } + if( i<argc ){ + data.zDbFilename = argv[i++]; + }else{ + data.zDbFilename = ":memory:"; + } + if( i<argc ){ + zFirstCmd = argv[i++]; + } + data.out = stdout; + + /* Go ahead and open the database file if it already exists. If the + ** file does not exist, delay opening it. This prevents empty database + ** files from being created if a user mistypes the database name argument + ** to the sqlite command-line tool. + */ + if( access(data.zDbFilename, 0)==0 ){ + open_db(&data); + } + + /* Process the initialization file if there is one. If no -init option + ** is given on the command line, look for a file named ~/.sqliterc and + ** try to process it. + */ + process_sqliterc(&data,zInitFile); + + /* Make a second pass through the command-line argument and set + ** options. This second pass is delayed until after the initialization + ** file is processed so that the command-line arguments will override + ** settings in the initialization file. + */ + for(i=1; i<argc && argv[i][0]=='-'; i++){ + char *z = argv[i]; + if( strcmp(z,"-init")==0 || strcmp(z,"-key")==0 ){ + i++; + }else if( strcmp(z,"-html")==0 ){ + data.mode = MODE_Html; + }else if( strcmp(z,"-list")==0 ){ + data.mode = MODE_List; + }else if( strcmp(z,"-line")==0 ){ + data.mode = MODE_Line; + }else if( strcmp(z,"-column")==0 ){ + data.mode = MODE_Column; + }else if( strcmp(z,"-separator")==0 ){ + i++; + sprintf(data.separator,"%.*s",(int)sizeof(data.separator)-1,argv[i]); + }else if( strcmp(z,"-nullvalue")==0 ){ + i++; + sprintf(data.nullvalue,"%.*s",(int)sizeof(data.nullvalue)-1,argv[i]); + }else if( strcmp(z,"-header")==0 ){ + data.showHeader = 1; + }else if( strcmp(z,"-noheader")==0 ){ + data.showHeader = 0; + }else if( strcmp(z,"-echo")==0 ){ + data.echoOn = 1; + }else if( strcmp(z,"-version")==0 ){ + printf("%s\n", sqlite_libversion()); + return 1; + }else if( strcmp(z,"-verbose-dump")==0 ){ + verboseDump = 1; + }else if( strcmp(z,"-help")==0 ){ + usage(1); + }else{ + fprintf(stderr,"%s: unknown option: %s\n", Argv0, z); + fprintf(stderr,"Use -help for a list of options.\n"); + return 1; + } + } + + if( zFirstCmd ){ + /* Run just the command that follows the database name + */ + if( zFirstCmd[0]=='.' ){ + do_meta_command(zFirstCmd, &data); + exit(0); + }else{ + int rc; + open_db(&data); + rc = sqlite_exec(data.db, zFirstCmd, callback, &data, &zErrMsg); + if( rc!=0 && zErrMsg!=0 ){ + fprintf(stderr,"SQL error: %s\n", zErrMsg); + exit(1); + } + } + }else{ + /* Run commands received from standard input + */ + if( isatty(fileno(stdout)) && isatty(fileno(stdin)) ){ + char *zHome; + char *zHistory = 0; + printf( + "SQLite version %s (bundled with Kexi)\n" + "Enter \".help\" for instructions\n", + sqlite_libversion() + ); + zHome = find_home_dir(); + if( zHome && (zHistory = malloc(strlen(zHome)+20))!=0 ){ + sprintf(zHistory,"%s/.sqlite_history", zHome); + } + if( zHistory ) read_history(zHistory); + process_input(&data, 0); + if( zHistory ){ + stifle_history(100); + write_history(zHistory); + } + }else{ + process_input(&data, stdin); + } + } + set_table_name(&data, 0); + if( db ) sqlite_close(db); + return 0; +} diff --git a/kexi/3rdparty/kexisql/src/sqlite.h b/kexi/3rdparty/kexisql/src/sqlite.h new file mode 100644 index 00000000..dd227cd0 --- /dev/null +++ b/kexi/3rdparty/kexisql/src/sqlite.h @@ -0,0 +1,868 @@ +/* +** 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: sqlite.h 410099 2005-05-06 17:52:07Z staniek $ +*/ +#ifndef _SQLITE_H_ +#define _SQLITE_H_ +#include <stdarg.h> /* 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. +*/ +#define SQLITE_VERSION "2.8.15" + +/* +** 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 *sqlite_open(const char *filename, int mode, char **errmsg); + +/* +** A function to close the database. +** +** Call this function with a pointer to a structure that was previously +** returned from sqlite_open() and the corresponding database will by closed. +*/ +void sqlite_close(sqlite *); + +/* +** The type for a callback function. +*/ +typedef int (*sqlite_callback)(void*,int,char**, char**); + +/* +** A function to executes one or more statements of SQL. +** +** If one or more of the SQL statements are queries, then +** the callback function specified by the 3rd parameter is +** invoked once for each row of the query result. This callback +** should normally return 0. If the callback returns a non-zero +** value then the query is aborted, all subsequent SQL statements +** are skipped and the sqlite_exec() function returns the SQLITE_ABORT. +** +** The 4th parameter is an arbitrary pointer that is passed +** to the callback function as its first parameter. +** +** The 2nd parameter to the callback function is the number of +** columns in the query result. The 3rd parameter to the callback +** is an array of strings holding the values for each column. +** The 4th parameter to the callback is an array of strings holding +** the names of each column. +** +** The callback function may be NULL, even for queries. A NULL +** callback is not an error. It just means that no callback +** will be invoked. +** +** If an error occurs while parsing or evaluating the SQL (but +** not while executing the callback) then an appropriate error +** message is written into memory obtained from malloc() and +** *errmsg is made to point to that message. The calling function +** is responsible for freeing the memory that holds the error +** message. Use sqlite_freemem() for this. If errmsg==NULL, +** then no error message is ever written. +** +** The return value is is SQLITE_OK if there are no errors and +** some other return code if there is an error. The particular +** return value depends on the type of error. +** +** If the query could not be executed because a database file is +** locked or busy, then this function returns SQLITE_BUSY. (This +** behavior can be modified somewhat using the sqlite_busy_handler() +** and sqlite_busy_timeout() functions below.) +*/ +int sqlite_exec( + sqlite*, /* An open database */ + const char *sql, /* SQL to be executed */ + sqlite_callback, /* Callback function */ + void *, /* 1st argument to callback function */ + char **errmsg /* Error msg written here */ +); + +/* +** Return values for sqlite_exec() and sqlite_step() +*/ +#define SQLITE_OK 0 /* Successful result */ +#define SQLITE_ERROR 1 /* SQL error or missing database */ +#define SQLITE_INTERNAL 2 /* An internal logic error in SQLite */ +#define SQLITE_PERM 3 /* Access permission denied */ +#define SQLITE_ABORT 4 /* Callback routine requested an abort */ +#define SQLITE_BUSY 5 /* The database file is locked */ +#define SQLITE_LOCKED 6 /* A table in the database is locked */ +#define SQLITE_NOMEM 7 /* A malloc() failed */ +#define SQLITE_READONLY 8 /* Attempt to write a readonly database */ +#define SQLITE_INTERRUPT 9 /* Operation terminated by sqlite_interrupt() */ +#define SQLITE_IOERR 10 /* Some kind of disk I/O error occurred */ +#define SQLITE_CORRUPT 11 /* The database disk image is malformed */ +#define SQLITE_NOTFOUND 12 /* (Internal Only) Table or record not found */ +#define SQLITE_FULL 13 /* Insertion failed because database is full */ +#define SQLITE_CANTOPEN 14 /* Unable to open the database file */ +#define SQLITE_PROTOCOL 15 /* Database lock protocol error */ +#define SQLITE_EMPTY 16 /* (Internal Only) Database table is empty */ +#define SQLITE_SCHEMA 17 /* The database schema changed */ +#define SQLITE_TOOBIG 18 /* Too much data for one row of a table */ +#define SQLITE_CONSTRAINT 19 /* Abort due to contraint violation */ +#define SQLITE_MISMATCH 20 /* Data type mismatch */ +#define SQLITE_MISUSE 21 /* Library used incorrectly */ +#define SQLITE_NOLFS 22 /* Uses OS features not supported on host */ +#define SQLITE_AUTH 23 /* Authorization denied */ +#define SQLITE_FORMAT 24 /* Auxiliary database format error */ +#define SQLITE_RANGE 25 /* 2nd parameter to sqlite_bind out of range */ +#define SQLITE_NOTADB 26 /* File opened that is not a database file */ +#define SQLITE_ROW 100 /* sqlite_step() has another row ready */ +#define SQLITE_DONE 101 /* sqlite_step() has finished executing */ + +/* +** Each entry in an SQLite table has a unique integer key. (The key is +** the value of the INTEGER PRIMARY KEY column if there is such a column, +** otherwise the key is generated at random. The unique key is always +** available as the ROWID, OID, or _ROWID_ column.) The following routine +** returns the integer key of the most recent insert in the database. +** +** This function is similar to the mysql_insert_id() function from MySQL. +*/ +int sqlite_last_insert_rowid(sqlite*); + +/* +** This function returns the number of database rows that were changed +** (or inserted or deleted) by the most recent called sqlite_exec(). +** +** All changes are counted, even if they were later undone by a +** ROLLBACK or ABORT. Except, changes associated with creating and +** dropping tables are not counted. +** +** If a callback invokes sqlite_exec() recursively, then the changes +** in the inner, recursive call are counted together with the changes +** in the outer call. +** +** SQLite implements the command "DELETE FROM table" without a WHERE clause +** by dropping and recreating the table. (This is much faster than going +** through and deleting individual elements form the table.) Because of +** this optimization, the change count for "DELETE FROM table" will be +** zero regardless of the number of elements that were originally in the +** table. To get an accurate count of the number of rows deleted, use +** "DELETE FROM table WHERE 1" instead. +*/ +int sqlite_changes(sqlite*); + +/* +** This function returns the number of database rows that were changed +** by the last INSERT, UPDATE, or DELETE statment executed by sqlite_exec(), +** or by the last VM to run to completion. The change count is not updated +** by SQL statements other than INSERT, UPDATE or DELETE. +** +** Changes are counted, even if they are later undone by a ROLLBACK or +** ABORT. Changes associated with trigger programs that execute as a +** result of the INSERT, UPDATE, or DELETE statement are not counted. +** +** If a callback invokes sqlite_exec() recursively, then the changes +** in the inner, recursive call are counted together with the changes +** in the outer call. +** +** SQLite implements the command "DELETE FROM table" without a WHERE clause +** by dropping and recreating the table. (This is much faster than going +** through and deleting individual elements form the table.) Because of +** this optimization, the change count for "DELETE FROM table" will be +** zero regardless of the number of elements that were originally in the +** table. To get an accurate count of the number of rows deleted, use +** "DELETE FROM table WHERE 1" instead. +** +******* THIS IS AN EXPERIMENTAL API AND IS SUBJECT TO CHANGE ****** +*/ +int sqlite_last_statement_changes(sqlite*); + +/* If the parameter to this routine is one of the return value constants +** defined above, then this routine returns a constant text string which +** descripts (in English) the meaning of the return value. +*/ +const char *sqlite_error_string(int); +#define sqliteErrStr sqlite_error_string /* Legacy. Do not use in new code. */ + +/* This function causes any pending database operation to abort and +** return at its earliest opportunity. This routine is typically +** called in response to a user action such as pressing "Cancel" +** or Ctrl-C where the user wants a long query operation to halt +** immediately. +*/ +void sqlite_interrupt(sqlite*); + + +/* This function returns true if the given input string comprises +** one or more complete SQL statements. +** +** The algorithm is simple. If the last token other than spaces +** and comments is a semicolon, then return true. otherwise return +** false. +*/ +int sqlite_complete(const char *sql); + +/* +** This routine identifies a callback function that is invoked +** whenever an attempt is made to open a database table that is +** currently locked by another process or thread. If the busy callback +** is NULL, then sqlite_exec() returns SQLITE_BUSY immediately if +** it finds a locked table. If the busy callback is not NULL, then +** sqlite_exec() invokes the callback with three arguments. The +** second argument is the name of the locked table and the third +** argument is the number of times the table has been busy. If the +** busy callback returns 0, then sqlite_exec() immediately returns +** SQLITE_BUSY. If the callback returns non-zero, then sqlite_exec() +** tries to open the table again and the cycle repeats. +** +** The default busy callback is NULL. +** +** Sqlite is re-entrant, so the busy handler may start a new query. +** (It is not clear why anyone would every want to do this, but it +** is allowed, in theory.) But the busy handler may not close the +** database. Closing the database from a busy handler will delete +** data structures out from under the executing query and will +** probably result in a coredump. +*/ +void sqlite_busy_handler(sqlite*, int(*)(void*,const char*,int), void*); + +/* +** This routine sets a busy handler that sleeps for a while when a +** table is locked. The handler will sleep multiple times until +** at least "ms" milleseconds of sleeping have been done. After +** "ms" milleseconds of sleeping, the handler returns 0 which +** causes sqlite_exec() to return SQLITE_BUSY. +** +** Calling this routine with an argument less than or equal to zero +** turns off all busy handlers. +*/ +void sqlite_busy_timeout(sqlite*, int ms); + +/* +** This next routine is really just a wrapper around sqlite_exec(). +** Instead of invoking a user-supplied callback for each row of the +** result, this routine remembers each row of the result in memory +** obtained from malloc(), then returns all of the result after the +** query has finished. +** +** As an example, suppose the query result where this table: +** +** Name | Age +** ----------------------- +** Alice | 43 +** Bob | 28 +** Cindy | 21 +** +** If the 3rd argument were &azResult then after the function returns +** azResult will contain the following data: +** +** azResult[0] = "Name"; +** azResult[1] = "Age"; +** azResult[2] = "Alice"; +** azResult[3] = "43"; +** azResult[4] = "Bob"; +** azResult[5] = "28"; +** azResult[6] = "Cindy"; +** azResult[7] = "21"; +** +** Notice that there is an extra row of data containing the column +** headers. But the *nrow return value is still 3. *ncolumn is +** set to 2. In general, the number of values inserted into azResult +** will be ((*nrow) + 1)*(*ncolumn). +** +** After the calling function has finished using the result, it should +** pass the result data pointer to sqlite_free_table() in order to +** release the memory that was malloc-ed. Because of the way the +** malloc() happens, the calling function must not try to call +** malloc() directly. Only sqlite_free_table() is able to release +** the memory properly and safely. +** +** The return value of this routine is the same as from sqlite_exec(). +*/ +int sqlite_get_table( + sqlite*, /* An open database */ + const char *sql, /* SQL to be executed */ + char ***resultp, /* Result written to a char *[] that this points to */ + int *nrow, /* Number of result rows written here */ + int *ncolumn, /* Number of result columns written here */ + char **errmsg /* Error msg written here */ +); + +/* +** Call this routine to free the memory that sqlite_get_table() allocated. +*/ +void sqlite_free_table(char **result); + +/* +** The following routines are wrappers around sqlite_exec() and +** sqlite_get_table(). The only difference between the routines that +** follow and the originals is that the second argument to the +** routines that follow is really a printf()-style format +** string describing the SQL to be executed. Arguments to the format +** string appear at the end of the argument list. +** +** All of the usual printf formatting options apply. In addition, there +** is a "%q" option. %q works like %s in that it substitutes a null-terminated +** string from the argument list. But %q also doubles every '\'' character. +** %q is designed for use inside a string literal. By doubling each '\'' +** character it escapes that character and allows it to be inserted into +** the string. +** +** For example, so some string variable contains text as follows: +** +** char *zText = "It's a happy day!"; +** +** We can use this text in an SQL statement as follows: +** +** sqlite_exec_printf(db, "INSERT INTO table VALUES('%q')", +** callback1, 0, 0, zText); +** +** Because the %q format string is used, the '\'' character in zText +** is escaped and the SQL generated is as follows: +** +** INSERT INTO table1 VALUES('It''s a happy day!') +** +** This is correct. Had we used %s instead of %q, the generated SQL +** would have looked like this: +** +** INSERT INTO table1 VALUES('It's a happy day!'); +** +** This second example is an SQL syntax error. As a general rule you +** should always use %q instead of %s when inserting text into a string +** literal. +*/ +int sqlite_exec_printf( + sqlite*, /* An open database */ + const char *sqlFormat, /* printf-style format string for the SQL */ + sqlite_callback, /* Callback function */ + void *, /* 1st argument to callback function */ + char **errmsg, /* Error msg written here */ + ... /* Arguments to the format string. */ +); +int sqlite_exec_vprintf( + sqlite*, /* An open database */ + const char *sqlFormat, /* printf-style format string for the SQL */ + sqlite_callback, /* Callback function */ + void *, /* 1st argument to callback function */ + char **errmsg, /* Error msg written here */ + va_list ap /* Arguments to the format string. */ +); +int sqlite_get_table_printf( + sqlite*, /* An open database */ + const char *sqlFormat, /* printf-style format string for the SQL */ + char ***resultp, /* Result written to a char *[] that this points to */ + int *nrow, /* Number of result rows written here */ + int *ncolumn, /* Number of result columns written here */ + char **errmsg, /* Error msg written here */ + ... /* Arguments to the format string */ +); +int sqlite_get_table_vprintf( + sqlite*, /* An open database */ + const char *sqlFormat, /* printf-style format string for the SQL */ + char ***resultp, /* Result written to a char *[] that this points to */ + int *nrow, /* Number of result rows written here */ + int *ncolumn, /* Number of result columns written here */ + char **errmsg, /* Error msg written here */ + va_list ap /* Arguments to the format string */ +); +char *sqlite_mprintf(const char*,...); +char *sqlite_vmprintf(const char*, va_list); + +/* +** Windows systems should call this routine to free memory that +** is returned in the in the errmsg parameter of sqlite_open() when +** SQLite is a DLL. For some reason, it does not work to call free() +** directly. +*/ +void sqlite_freemem(void *p); + +/* +** Windows systems need functions to call to return the sqlite_version +** and sqlite_encoding strings. +*/ +const char *sqlite_libversion(void); +const char *sqlite_libencoding(void); + +/* +** A pointer to the following structure is used to communicate with +** the implementations of user-defined functions. +*/ +typedef struct sqlite_func sqlite_func; + +/* +** Use the following routines to create new user-defined functions. See +** the documentation for details. +*/ +int sqlite_create_function( + sqlite*, /* Database where the new function is registered */ + const char *zName, /* Name of the new function */ + int nArg, /* Number of arguments. -1 means any number */ + void (*xFunc)(sqlite_func*,int,const char**), /* C code to implement */ + void *pUserData /* Available via the sqlite_user_data() call */ +); +int sqlite_create_aggregate( + sqlite*, /* Database where the new function is registered */ + const char *zName, /* Name of the function */ + int nArg, /* Number of arguments */ + void (*xStep)(sqlite_func*,int,const char**), /* Called for each row */ + void (*xFinalize)(sqlite_func*), /* Called once to get final result */ + void *pUserData /* Available via the sqlite_user_data() call */ +); + +/* +** Use the following routine to define the datatype returned by a +** user-defined function. The second argument can be one of the +** constants SQLITE_NUMERIC, SQLITE_TEXT, or SQLITE_ARGS or it +** can be an integer greater than or equal to zero. When the datatype +** parameter is non-negative, the type of the result will be the +** same as the datatype-th argument. If datatype==SQLITE_NUMERIC +** then the result is always numeric. If datatype==SQLITE_TEXT then +** the result is always text. If datatype==SQLITE_ARGS then the result +** is numeric if any argument is numeric and is text otherwise. +*/ +int sqlite_function_type( + sqlite *db, /* The database there the function is registered */ + const char *zName, /* Name of the function */ + int datatype /* The datatype for this function */ +); +#define SQLITE_NUMERIC (-1) +#define SQLITE_TEXT (-2) +#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 */ +); + +/* +** Encode a binary buffer "in" of size n bytes so that it contains +** no instances of characters '\'' or '\000'. The output is +** null-terminated and can be used as a string value in an INSERT +** or UPDATE statement. Use sqlite_decode_binary() to convert the +** string back into its original binary. +** +** The result is written into a preallocated output buffer "out". +** "out" must be able to hold at least 2 +(257*n)/254 bytes. +** In other words, the output will be expanded by as much as 3 +** bytes for every 254 bytes of input plus 2 bytes of fixed overhead. +** (This is approximately 2 + 1.0118*n or about a 1.2% size increase.) +** +** The return value is the number of characters in the encoded +** string, excluding the "\000" terminator. +** +** If out==NULL then no output is generated but the routine still returns +** the number of characters that would have been generated if out had +** not been NULL. +*/ +int sqlite_encode_binary(const unsigned char *in, int n, unsigned char *out); + +/* +** Decode the string "in" into binary data and write it into "out". +** This routine reverses the encoding created by sqlite_encode_binary(). +** The output will always be a few bytes less than the input. The number +** of bytes of output is returned. If the input is not a well-formed +** encoding, -1 is returned. +** +** The "in" and "out" parameters may point to the same buffer in order +** to decode a string in place. +*/ +int sqlite_decode_binary(const unsigned char *in, unsigned char *out); + +#ifdef __cplusplus +} /* End of the 'extern "C"' block */ +#endif + +#endif /* _SQLITE_H_ */ diff --git a/kexi/3rdparty/kexisql/src/sqliteInt.h b/kexi/3rdparty/kexisql/src/sqliteInt.h new file mode 100644 index 00000000..dd0710f9 --- /dev/null +++ b/kexi/3rdparty/kexisql/src/sqliteInt.h @@ -0,0 +1,1270 @@ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** Internal interface definitions for SQLite. +** +** @(#) $Id: sqliteInt.h 410297 2005-05-07 13:34:19Z staniek $ +*/ +#include "sqliteconfig.h" +#include "sqlite.h" +#include "hash.h" +#include "parse.h" +#include "btree.h" +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <assert.h> + +/* +** The maximum number of in-memory pages to use for the main database +** table and for temporary tables. +*/ +#define MAX_PAGES 2000 +#define TEMP_PAGES 500 + +/* +** If the following macro is set to 1, then NULL values are considered +** distinct for the SELECT DISTINCT statement and for UNION or EXCEPT +** compound queries. No other SQL database engine (among those tested) +** works this way except for OCELOT. But the SQL92 spec implies that +** this is how things should work. +** +** If the following macro is set to 0, then NULLs are indistinct for +** SELECT DISTINCT and for UNION. +*/ +#define NULL_ALWAYS_DISTINCT 0 + +/* +** If the following macro is set to 1, then NULL values are considered +** distinct when determining whether or not two entries are the same +** in a UNIQUE index. This is the way PostgreSQL, Oracle, DB2, MySQL, +** OCELOT, and Firebird all work. The SQL92 spec explicitly says this +** is the way things are suppose to work. +** +** If the following macro is set to 0, the NULLs are indistinct for +** a UNIQUE index. In this mode, you can only have a single NULL entry +** for a column declared UNIQUE. This is the way Informix and SQL Server +** work. +*/ +#define NULL_DISTINCT_FOR_UNIQUE 1 + +/* +** The maximum number of attached databases. This must be at least 2 +** in order to support the main database file (0) and the file used to +** hold temporary tables (1). And it must be less than 256 because +** an unsigned character is used to stored the database index. +*/ +#define MAX_ATTACHED 10 + +/* +** The next macro is used to determine where TEMP tables and indices +** are stored. Possible values: +** +** 0 Always use a temporary files +** 1 Use a file unless overridden by "PRAGMA temp_store" +** 2 Use memory unless overridden by "PRAGMA temp_store" +** 3 Always use memory +*/ +#ifndef TEMP_STORE +# define TEMP_STORE 1 +#endif + +/* +** When building SQLite for embedded systems where memory is scarce, +** you can define one or more of the following macros to omit extra +** features of the library and thus keep the size of the library to +** a minimum. +*/ +/* #define SQLITE_OMIT_AUTHORIZATION 1 */ +/* #define SQLITE_OMIT_INMEMORYDB 1 */ +/* #define SQLITE_OMIT_VACUUM 1 */ +/* #define SQLITE_OMIT_DATETIME_FUNCS 1 */ +/* #define SQLITE_OMIT_PROGRESS_CALLBACK 1 */ + +/* +** Integers of known sizes. These typedefs might change for architectures +** where the sizes very. Preprocessor macros are available so that the +** types can be conveniently redefined at compile-type. Like this: +** +** cc '-DUINTPTR_TYPE=long long int' ... +*/ +#ifndef UINT32_TYPE +# define UINT32_TYPE unsigned int +#endif +#ifndef UINT16_TYPE +# define UINT16_TYPE unsigned short int +#endif +#ifndef INT16_TYPE +# define INT16_TYPE short int +#endif +#ifndef UINT8_TYPE +# define UINT8_TYPE unsigned char +#endif +#ifndef INT8_TYPE +# define INT8_TYPE signed char +#endif +#ifndef INTPTR_TYPE +# if SQLITE_PTR_SZ==4 +# define INTPTR_TYPE int +# else +# define INTPTR_TYPE long long +# endif +#endif +typedef UINT32_TYPE u32; /* 4-byte unsigned integer */ +typedef UINT16_TYPE u16; /* 2-byte unsigned integer */ +typedef INT16_TYPE i16; /* 2-byte signed integer */ +typedef UINT8_TYPE u8; /* 1-byte unsigned integer */ +typedef UINT8_TYPE i8; /* 1-byte signed integer */ +typedef INTPTR_TYPE ptr; /* Big enough to hold a pointer */ +typedef unsigned INTPTR_TYPE uptr; /* Big enough to hold a pointer */ + +/* +** Defer sourcing vdbe.h until after the "u8" typedef is defined. +*/ +#include "vdbe.h" + +/* +** Most C compilers these days recognize "long double", don't they? +** Just in case we encounter one that does not, we will create a macro +** for long double so that it can be easily changed to just "double". +*/ +#ifndef LONGDOUBLE_TYPE +# define LONGDOUBLE_TYPE long double +#endif + +/* +** This macro casts a pointer to an integer. Useful for doing +** pointer arithmetic. +*/ +#define Addr(X) ((uptr)X) + +/* +** The maximum number of bytes of data that can be put into a single +** row of a single table. The upper bound on this limit is 16777215 +** bytes (or 16MB-1). We have arbitrarily set the limit to just 1MB +** here because the overflow page chain is inefficient for really big +** records and we want to discourage people from thinking that +** multi-megabyte records are OK. If your needs are different, you can +** change this define and recompile to increase or decrease the record +** size. +** +** The 16777198 is computed as follows: 238 bytes of payload on the +** original pages plus 16448 overflow pages each holding 1020 bytes of +** data. +*/ +#define MAX_BYTES_PER_ROW 1048576 +/* #define MAX_BYTES_PER_ROW 16777198 */ + +/* +** If memory allocation problems are found, recompile with +** +** -DMEMORY_DEBUG=1 +** +** to enable some sanity checking on malloc() and free(). To +** check for memory leaks, recompile with +** +** -DMEMORY_DEBUG=2 +** +** and a line of text will be written to standard error for +** each malloc() and free(). This output can be analyzed +** by an AWK script to determine if there are any leaks. +*/ +#ifdef MEMORY_DEBUG +# define sqliteMalloc(X) sqliteMalloc_(X,1,__FILE__,__LINE__) +# define sqliteMallocRaw(X) sqliteMalloc_(X,0,__FILE__,__LINE__) +# define sqliteFree(X) sqliteFree_(X,__FILE__,__LINE__) +# define sqliteRealloc(X,Y) sqliteRealloc_(X,Y,__FILE__,__LINE__) +# define sqliteStrDup(X) sqliteStrDup_(X,__FILE__,__LINE__) +# define sqliteStrNDup(X,Y) sqliteStrNDup_(X,Y,__FILE__,__LINE__) + void sqliteStrRealloc(char**); +#else +# define sqliteRealloc_(X,Y) sqliteRealloc(X,Y) +# define sqliteStrRealloc(X) +#endif + +/* +** This variable gets set if malloc() ever fails. After it gets set, +** the SQLite library shuts down permanently. +*/ +extern int sqlite_malloc_failed; + +/* +** The following global variables are used for testing and debugging +** only. They only work if MEMORY_DEBUG is defined. +*/ +#ifdef MEMORY_DEBUG +extern int sqlite_nMalloc; /* Number of sqliteMalloc() calls */ +extern int sqlite_nFree; /* Number of sqliteFree() calls */ +extern int sqlite_iMallocFail; /* Fail sqliteMalloc() after this many calls */ +#endif + +/* +** Name of the master database table. The master database table +** is a special table that holds the names and attributes of all +** user tables and indices. +*/ +#define MASTER_NAME "sqlite_master" +#define TEMP_MASTER_NAME "sqlite_temp_master" + +/* +** The name of the schema table. +*/ +#define SCHEMA_TABLE(x) (x?TEMP_MASTER_NAME:MASTER_NAME) + +/* +** A convenience macro that returns the number of elements in +** an array. +*/ +#define ArraySize(X) (sizeof(X)/sizeof(X[0])) + +/* +** Forward references to structures +*/ +typedef struct Column Column; +typedef struct Table Table; +typedef struct Index Index; +typedef struct Instruction Instruction; +typedef struct Expr Expr; +typedef struct ExprList ExprList; +typedef struct Parse Parse; +typedef struct Token Token; +typedef struct IdList IdList; +typedef struct SrcList SrcList; +typedef struct WhereInfo WhereInfo; +typedef struct WhereLevel WhereLevel; +typedef struct Select Select; +typedef struct AggExpr AggExpr; +typedef struct FuncDef FuncDef; +typedef struct Trigger Trigger; +typedef struct TriggerStep TriggerStep; +typedef struct TriggerStack TriggerStack; +typedef struct FKey FKey; +typedef struct Db Db; +typedef struct AuthContext AuthContext; + +/* +** Each database file to be accessed by the system is an instance +** of the following structure. There are normally two of these structures +** in the sqlite.aDb[] array. aDb[0] is the main database file and +** aDb[1] is the database file used to hold temporary tables. Additional +** databases may be attached. +*/ +struct Db { + char *zName; /* Name of this database */ + Btree *pBt; /* The B*Tree structure for this database file */ + int schema_cookie; /* Database schema version number for this file */ + Hash tblHash; /* All tables indexed by name */ + Hash idxHash; /* All (named) indices indexed by name */ + Hash trigHash; /* All triggers indexed by name */ + Hash aFKey; /* Foreign keys indexed by to-table */ + u8 inTrans; /* 0: not writable. 1: Transaction. 2: Checkpoint */ + u16 flags; /* Flags associated with this database */ + void *pAux; /* Auxiliary data. Usually NULL */ + void (*xFreeAux)(void*); /* Routine to free pAux */ +}; + +/* +** These macros can be used to test, set, or clear bits in the +** Db.flags field. +*/ +#define DbHasProperty(D,I,P) (((D)->aDb[I].flags&(P))==(P)) +#define DbHasAnyProperty(D,I,P) (((D)->aDb[I].flags&(P))!=0) +#define DbSetProperty(D,I,P) (D)->aDb[I].flags|=(P) +#define DbClearProperty(D,I,P) (D)->aDb[I].flags&=~(P) + +/* +** Allowed values for the DB.flags field. +** +** The DB_Locked flag is set when the first OP_Transaction or OP_Checkpoint +** opcode is emitted for a database. This prevents multiple occurances +** of those opcodes for the same database in the same program. Similarly, +** the DB_Cookie flag is set when the OP_VerifyCookie opcode is emitted, +** and prevents duplicate OP_VerifyCookies from taking up space and slowing +** down execution. +** +** The DB_SchemaLoaded flag is set after the database schema has been +** read into internal hash tables. +** +** DB_UnresetViews means that one or more views have column names that +** have been filled out. If the schema changes, these column names might +** changes and so the view will need to be reset. +*/ +#define DB_Locked 0x0001 /* OP_Transaction opcode has been emitted */ +#define DB_Cookie 0x0002 /* OP_VerifyCookie opcode has been emiited */ +#define DB_SchemaLoaded 0x0004 /* The schema has been loaded */ +#define DB_UnresetViews 0x0008 /* Some views have defined column names */ + + +/* +** Each database is an instance of the following structure. +** +** The sqlite.file_format is initialized by the database file +** and helps determines how the data in the database file is +** represented. This field allows newer versions of the library +** to read and write older databases. The various file formats +** are as follows: +** +** file_format==1 Version 2.1.0. +** file_format==2 Version 2.2.0. Add support for INTEGER PRIMARY KEY. +** file_format==3 Version 2.6.0. Fix empty-string index bug. +** file_format==4 Version 2.7.0. Add support for separate numeric and +** text datatypes. +** +** The sqlite.temp_store determines where temporary database files +** are stored. If 1, then a file is created to hold those tables. If +** 2, then they are held in memory. 0 means use the default value in +** the TEMP_STORE macro. +** +** The sqlite.lastRowid records the last insert rowid generated by an +** insert statement. Inserts on views do not affect its value. Each +** trigger has its own context, so that lastRowid can be updated inside +** triggers as usual. The previous value will be restored once the trigger +** exits. Upon entering a before or instead of trigger, lastRowid is no +** longer (since after version 2.8.12) reset to -1. +** +** The sqlite.nChange does not count changes within triggers and keeps no +** context. It is reset at start of sqlite_exec. +** The sqlite.lsChange represents the number of changes made by the last +** insert, update, or delete statement. It remains constant throughout the +** length of a statement and is then updated by OP_SetCounts. It keeps a +** context stack just like lastRowid so that the count of changes +** within a trigger is not seen outside the trigger. Changes to views do not +** affect the value of lsChange. +** The sqlite.csChange keeps track of the number of current changes (since +** the last statement) and is used to update sqlite_lsChange. +*/ +struct sqlite { + int nDb; /* Number of backends currently in use */ + Db *aDb; /* All backends */ + Db aDbStatic[2]; /* Static space for the 2 default backends */ + int flags; /* Miscellanous flags. See below */ + u8 file_format; /* What file format version is this database? */ + u8 safety_level; /* How aggressive at synching data to disk */ + u8 want_to_close; /* Close after all VDBEs are deallocated */ + u8 temp_store; /* 1=file, 2=memory, 0=compile-time default */ + u8 onError; /* Default conflict algorithm */ + int next_cookie; /* Next value of aDb[0].schema_cookie */ + int cache_size; /* Number of pages to use in the cache */ + int nTable; /* Number of tables in the database */ + void *pBusyArg; /* 1st Argument to the busy callback */ + int (*xBusyCallback)(void *,const char*,int); /* The busy callback */ + void *pCommitArg; /* Argument to xCommitCallback() */ + int (*xCommitCallback)(void*);/* Invoked at every commit. */ + Hash aFunc; /* All functions that can be in SQL exprs */ + int lastRowid; /* ROWID of most recent insert (see above) */ + int priorNewRowid; /* Last randomly generated ROWID */ + int magic; /* Magic number for detect library misuse */ + int nChange; /* Number of rows changed (see above) */ + int lsChange; /* Last statement change count (see above) */ + int csChange; /* Current statement change count (see above) */ + struct sqliteInitInfo { /* Information used during initialization */ + int iDb; /* When back is being initialized */ + int newTnum; /* Rootpage of table being initialized */ + u8 busy; /* TRUE if currently initializing */ + } init; + struct Vdbe *pVdbe; /* List of active virtual machines */ + void (*xTrace)(void*,const char*); /* Trace function */ + void *pTraceArg; /* Argument to the trace function */ +#ifndef SQLITE_OMIT_AUTHORIZATION + int (*xAuth)(void*,int,const char*,const char*,const char*,const char*); + /* Access authorization function */ + void *pAuthArg; /* 1st argument to the access auth function */ +#endif +#ifndef SQLITE_OMIT_PROGRESS_CALLBACK + int (*xProgress)(void *); /* The progress callback */ + void *pProgressArg; /* Argument to the progress callback */ + int nProgressOps; /* Number of opcodes for progress callback */ +#endif +}; + +/* +** Possible values for the sqlite.flags and or Db.flags fields. +** +** On sqlite.flags, the SQLITE_InTrans value means that we have +** executed a BEGIN. On Db.flags, SQLITE_InTrans means a statement +** transaction is active on that particular database file. +*/ +#define SQLITE_VdbeTrace 0x00000001 /* True to trace VDBE execution */ +#define SQLITE_Initialized 0x00000002 /* True after initialization */ +#define SQLITE_Interrupt 0x00000004 /* Cancel current operation */ +#define SQLITE_InTrans 0x00000008 /* True if in a transaction */ +#define SQLITE_InternChanges 0x00000010 /* Uncommitted Hash table changes */ +#define SQLITE_FullColNames 0x00000020 /* Show full column names on SELECT */ +#define SQLITE_ShortColNames 0x00000040 /* Show short columns names */ +#define SQLITE_CountRows 0x00000080 /* Count rows changed by INSERT, */ + /* DELETE, or UPDATE and return */ + /* the count using a callback. */ +#define SQLITE_NullCallback 0x00000100 /* Invoke the callback once if the */ + /* result set is empty */ +#define SQLITE_ReportTypes 0x00000200 /* Include information on datatypes */ + /* in 4th argument of callback */ + +/* +** Possible values for the sqlite.magic field. +** The numbers are obtained at random and have no special meaning, other +** than being distinct from one another. +*/ +#define SQLITE_MAGIC_OPEN 0xa029a697 /* Database is open */ +#define SQLITE_MAGIC_CLOSED 0x9f3c2d33 /* Database is closed */ +#define SQLITE_MAGIC_BUSY 0xf03b7906 /* Database currently in use */ +#define SQLITE_MAGIC_ERROR 0xb5357930 /* An SQLITE_MISUSE error occurred */ + +/* +** Each SQL function is defined by an instance of the following +** structure. A pointer to this structure is stored in the sqlite.aFunc +** hash table. When multiple functions have the same name, the hash table +** points to a linked list of these structures. +*/ +struct FuncDef { + void (*xFunc)(sqlite_func*,int,const char**); /* Regular function */ + void (*xStep)(sqlite_func*,int,const char**); /* Aggregate function step */ + void (*xFinalize)(sqlite_func*); /* Aggregate function finializer */ + signed char nArg; /* Number of arguments. -1 means unlimited */ + signed char dataType; /* Arg that determines datatype. -1=NUMERIC, */ + /* -2=TEXT. -3=SQLITE_ARGS */ + u8 includeTypes; /* Add datatypes to args of xFunc and xStep */ + void *pUserData; /* User data parameter */ + FuncDef *pNext; /* Next function with same name */ +}; + +/* +** information about each column of an SQL table is held in an instance +** of this structure. +*/ +struct Column { + char *zName; /* Name of this column */ + char *zDflt; /* Default value of this column */ + char *zType; /* Data type for this column */ + u8 notNull; /* True if there is a NOT NULL constraint */ + u8 isPrimKey; /* True if this column is part of the PRIMARY KEY */ + u8 sortOrder; /* Some combination of SQLITE_SO_... values */ + u8 dottedName; /* True if zName contains a "." character */ +}; + +/* +** The allowed sort orders. +** +** The TEXT and NUM values use bits that do not overlap with DESC and ASC. +** That way the two can be combined into a single number. +*/ +#define SQLITE_SO_UNK 0 /* Use the default collating type. (SCT_NUM) */ +#define SQLITE_SO_TEXT 2 /* Sort using memcmp() */ +#define SQLITE_SO_NUM 4 /* Sort using sqliteCompare() */ +#define SQLITE_SO_TYPEMASK 6 /* Mask to extract the collating sequence */ +#define SQLITE_SO_ASC 0 /* Sort in ascending order */ +#define SQLITE_SO_DESC 1 /* Sort in descending order */ +#define SQLITE_SO_DIRMASK 1 /* Mask to extract the sort direction */ + +/* +** Each SQL table is represented in memory by an instance of the +** following structure. +** +** Table.zName is the name of the table. The case of the original +** CREATE TABLE statement is stored, but case is not significant for +** comparisons. +** +** Table.nCol is the number of columns in this table. Table.aCol is a +** pointer to an array of Column structures, one for each column. +** +** If the table has an INTEGER PRIMARY KEY, then Table.iPKey is the index of +** the column that is that key. Otherwise Table.iPKey is negative. Note +** that the datatype of the PRIMARY KEY must be INTEGER for this field to +** be set. An INTEGER PRIMARY KEY is used as the rowid for each row of +** the table. If a table has no INTEGER PRIMARY KEY, then a random rowid +** is generated for each row of the table. Table.hasPrimKey is true if +** the table has any PRIMARY KEY, INTEGER or otherwise. +** +** Table.tnum is the page number for the root BTree page of the table in the +** database file. If Table.iDb is the index of the database table backend +** in sqlite.aDb[]. 0 is for the main database and 1 is for the file that +** holds temporary tables and indices. If Table.isTransient +** is true, then the table is stored in a file that is automatically deleted +** when the VDBE cursor to the table is closed. In this case Table.tnum +** refers VDBE cursor number that holds the table open, not to the root +** page number. Transient tables are used to hold the results of a +** sub-query that appears instead of a real table name in the FROM clause +** of a SELECT statement. +*/ +struct Table { + char *zName; /* Name of the table */ + int nCol; /* Number of columns in this table */ + Column *aCol; /* Information about each column */ + int iPKey; /* If not less then 0, use aCol[iPKey] as the primary key */ + Index *pIndex; /* List of SQL indexes on this table. */ + int tnum; /* Root BTree node for this table (see note above) */ + Select *pSelect; /* NULL for tables. Points to definition if a view. */ + u8 readOnly; /* True if this table should not be written by the user */ + u8 iDb; /* Index into sqlite.aDb[] of the backend for this table */ + u8 isTransient; /* True if automatically deleted when VDBE finishes */ + u8 hasPrimKey; /* True if there exists a primary key */ + u8 keyConf; /* What to do in case of uniqueness conflict on iPKey */ + Trigger *pTrigger; /* List of SQL triggers on this table */ + FKey *pFKey; /* Linked list of all foreign keys in this table */ +}; + +/* +** Each foreign key constraint is an instance of the following structure. +** +** A foreign key is associated with two tables. The "from" table is +** the table that contains the REFERENCES clause that creates the foreign +** key. The "to" table is the table that is named in the REFERENCES clause. +** Consider this example: +** +** CREATE TABLE ex1( +** a INTEGER PRIMARY KEY, +** b INTEGER CONSTRAINT fk1 REFERENCES ex2(x) +** ); +** +** For foreign key "fk1", the from-table is "ex1" and the to-table is "ex2". +** +** Each REFERENCES clause generates an instance of the following structure +** which is attached to the from-table. The to-table need not exist when +** the from-table is created. The existance of the to-table is not checked +** until an attempt is made to insert data into the from-table. +** +** The sqlite.aFKey hash table stores pointers to this structure +** given the name of a to-table. For each to-table, all foreign keys +** associated with that table are on a linked list using the FKey.pNextTo +** field. +*/ +struct FKey { + Table *pFrom; /* The table that constains the REFERENCES clause */ + FKey *pNextFrom; /* Next foreign key in pFrom */ + char *zTo; /* Name of table that the key points to */ + FKey *pNextTo; /* Next foreign key that points to zTo */ + int nCol; /* Number of columns in this key */ + struct sColMap { /* Mapping of columns in pFrom to columns in zTo */ + int iFrom; /* Index of column in pFrom */ + char *zCol; /* Name of column in zTo. If 0 use PRIMARY KEY */ + } *aCol; /* One entry for each of nCol column s */ + u8 isDeferred; /* True if constraint checking is deferred till COMMIT */ + u8 updateConf; /* How to resolve conflicts that occur on UPDATE */ + u8 deleteConf; /* How to resolve conflicts that occur on DELETE */ + u8 insertConf; /* How to resolve conflicts that occur on INSERT */ +}; + +/* +** SQLite supports many different ways to resolve a contraint +** error. ROLLBACK processing means that a constraint violation +** causes the operation in process to fail and for the current transaction +** to be rolled back. ABORT processing means the operation in process +** fails and any prior changes from that one operation are backed out, +** but the transaction is not rolled back. FAIL processing means that +** the operation in progress stops and returns an error code. But prior +** changes due to the same operation are not backed out and no rollback +** occurs. IGNORE means that the particular row that caused the constraint +** error is not inserted or updated. Processing continues and no error +** is returned. REPLACE means that preexisting database rows that caused +** a UNIQUE constraint violation are removed so that the new insert or +** update can proceed. Processing continues and no error is reported. +** +** RESTRICT, SETNULL, and CASCADE actions apply only to foreign keys. +** RESTRICT is the same as ABORT for IMMEDIATE foreign keys and the +** same as ROLLBACK for DEFERRED keys. SETNULL means that the foreign +** key is set to NULL. CASCADE means that a DELETE or UPDATE of the +** referenced table row is propagated into the row that holds the +** foreign key. +** +** The following symbolic values are used to record which type +** of action to take. +*/ +#define OE_None 0 /* There is no constraint to check */ +#define OE_Rollback 1 /* Fail the operation and rollback the transaction */ +#define OE_Abort 2 /* Back out changes but do no rollback transaction */ +#define OE_Fail 3 /* Stop the operation but leave all prior changes */ +#define OE_Ignore 4 /* Ignore the error. Do not do the INSERT or UPDATE */ +#define OE_Replace 5 /* Delete existing record, then do INSERT or UPDATE */ + +#define OE_Restrict 6 /* OE_Abort for IMMEDIATE, OE_Rollback for DEFERRED */ +#define OE_SetNull 7 /* Set the foreign key value to NULL */ +#define OE_SetDflt 8 /* Set the foreign key value to its default */ +#define OE_Cascade 9 /* Cascade the changes */ + +#define OE_Default 99 /* Do whatever the default action is */ + +/* +** Each SQL index is represented in memory by an +** instance of the following structure. +** +** The columns of the table that are to be indexed are described +** by the aiColumn[] field of this structure. For example, suppose +** we have the following table and index: +** +** CREATE TABLE Ex1(c1 int, c2 int, c3 text); +** CREATE INDEX Ex2 ON Ex1(c3,c1); +** +** In the Table structure describing Ex1, nCol==3 because there are +** three columns in the table. In the Index structure describing +** Ex2, nColumn==2 since 2 of the 3 columns of Ex1 are indexed. +** The value of aiColumn is {2, 0}. aiColumn[0]==2 because the +** first column to be indexed (c3) has an index of 2 in Ex1.aCol[]. +** The second column to be indexed (c1) has an index of 0 in +** Ex1.aCol[], hence Ex2.aiColumn[1]==0. +** +** The Index.onError field determines whether or not the indexed columns +** must be unique and what to do if they are not. When Index.onError=OE_None, +** it means this is not a unique index. Otherwise it is a unique index +** and the value of Index.onError indicate the which conflict resolution +** algorithm to employ whenever an attempt is made to insert a non-unique +** element. +*/ +struct Index { + char *zName; /* Name of this index */ + int nColumn; /* Number of columns in the table used by this index */ + int *aiColumn; /* Which columns are used by this index. 1st is 0 */ + Table *pTable; /* The SQL table being indexed */ + int tnum; /* Page containing root of this index in database file */ + u8 onError; /* OE_Abort, OE_Ignore, OE_Replace, or OE_None */ + u8 autoIndex; /* True if is automatically created (ex: by UNIQUE) */ + u8 iDb; /* Index in sqlite.aDb[] of where this index is stored */ + Index *pNext; /* The next index associated with the same table */ +}; + +/* +** Each token coming out of the lexer is an instance of +** this structure. Tokens are also used as part of an expression. +** +** Note if Token.z==0 then Token.dyn and Token.n are undefined and +** may contain random values. Do not make any assuptions about Token.dyn +** and Token.n when Token.z==0. +*/ +struct Token { + const char *z; /* Text of the token. Not NULL-terminated! */ + unsigned dyn : 1; /* True for malloced memory, false for static */ + unsigned n : 31; /* Number of characters in this token */ +}; + +/* +** Each node of an expression in the parse tree is an instance +** of this structure. +** +** Expr.op is the opcode. The integer parser token codes are reused +** as opcodes here. For example, the parser defines TK_GE to be an integer +** code representing the ">=" operator. This same integer code is reused +** to represent the greater-than-or-equal-to operator in the expression +** tree. +** +** Expr.pRight and Expr.pLeft are subexpressions. Expr.pList is a list +** of argument if the expression is a function. +** +** Expr.token is the operator token for this node. For some expressions +** that have subexpressions, Expr.token can be the complete text that gave +** rise to the Expr. In the latter case, the token is marked as being +** a compound token. +** +** An expression of the form ID or ID.ID refers to a column in a table. +** For such expressions, Expr.op is set to TK_COLUMN and Expr.iTable is +** the integer cursor number of a VDBE cursor pointing to that table and +** Expr.iColumn is the column number for the specific column. If the +** expression is used as a result in an aggregate SELECT, then the +** value is also stored in the Expr.iAgg column in the aggregate so that +** it can be accessed after all aggregates are computed. +** +** If the expression is a function, the Expr.iTable is an integer code +** representing which function. If the expression is an unbound variable +** marker (a question mark character '?' in the original SQL) then the +** Expr.iTable holds the index number for that variable. +** +** The Expr.pSelect field points to a SELECT statement. The SELECT might +** be the right operand of an IN operator. Or, if a scalar SELECT appears +** in an expression the opcode is TK_SELECT and Expr.pSelect is the only +** operand. +*/ +struct Expr { + u8 op; /* Operation performed by this node */ + u8 dataType; /* Either SQLITE_SO_TEXT or SQLITE_SO_NUM */ + u8 iDb; /* Database referenced by this expression */ + u8 flags; /* Various flags. See below */ + Expr *pLeft, *pRight; /* Left and right subnodes */ + ExprList *pList; /* A list of expressions used as function arguments + ** or in "<expr> IN (<expr-list)" */ + Token token; /* An operand token */ + Token span; /* Complete text of the expression */ + int iTable, iColumn; /* When op==TK_COLUMN, then this expr node means the + ** iColumn-th field of the iTable-th table. */ + int iAgg; /* When op==TK_COLUMN and pParse->useAgg==TRUE, pull + ** result from the iAgg-th element of the aggregator */ + Select *pSelect; /* When the expression is a sub-select. Also the + ** right side of "<expr> IN (<select>)" */ +}; + +/* +** The following are the meanings of bits in the Expr.flags field. +*/ +#define EP_FromJoin 0x0001 /* Originated in ON or USING clause of a join */ + +/* +** These macros can be used to test, set, or clear bits in the +** Expr.flags field. +*/ +#define ExprHasProperty(E,P) (((E)->flags&(P))==(P)) +#define ExprHasAnyProperty(E,P) (((E)->flags&(P))!=0) +#define ExprSetProperty(E,P) (E)->flags|=(P) +#define ExprClearProperty(E,P) (E)->flags&=~(P) + +/* +** A list of expressions. Each expression may optionally have a +** name. An expr/name combination can be used in several ways, such +** as the list of "expr AS ID" fields following a "SELECT" or in the +** list of "ID = expr" items in an UPDATE. A list of expressions can +** also be used as the argument to a function, in which case the a.zName +** field is not used. +*/ +struct ExprList { + int nExpr; /* Number of expressions on the list */ + int nAlloc; /* Number of entries allocated below */ + struct ExprList_item { + Expr *pExpr; /* The list of expressions */ + char *zName; /* Token associated with this expression */ + u8 sortOrder; /* 1 for DESC or 0 for ASC */ + u8 isAgg; /* True if this is an aggregate like count(*) */ + u8 done; /* A flag to indicate when processing is finished */ + } *a; /* One entry for each expression */ +}; + +/* +** An instance of this structure can hold a simple list of identifiers, +** such as the list "a,b,c" in the following statements: +** +** INSERT INTO t(a,b,c) VALUES ...; +** CREATE INDEX idx ON t(a,b,c); +** CREATE TRIGGER trig BEFORE UPDATE ON t(a,b,c) ...; +** +** The IdList.a.idx field is used when the IdList represents the list of +** column names after a table name in an INSERT statement. In the statement +** +** INSERT INTO t(a,b,c) ... +** +** If "a" is the k-th column of table "t", then IdList.a[0].idx==k. +*/ +struct IdList { + int nId; /* Number of identifiers on the list */ + int nAlloc; /* Number of entries allocated for a[] below */ + struct IdList_item { + char *zName; /* Name of the identifier */ + int idx; /* Index in some Table.aCol[] of a column named zName */ + } *a; +}; + +/* +** The following structure describes the FROM clause of a SELECT statement. +** Each table or subquery in the FROM clause is a separate element of +** the SrcList.a[] array. +** +** With the addition of multiple database support, the following structure +** can also be used to describe a particular table such as the table that +** is modified by an INSERT, DELETE, or UPDATE statement. In standard SQL, +** such a table must be a simple name: ID. But in SQLite, the table can +** now be identified by a database name, a dot, then the table name: ID.ID. +*/ +struct SrcList { + i16 nSrc; /* Number of tables or subqueries in the FROM clause */ + i16 nAlloc; /* Number of entries allocated in a[] below */ + struct SrcList_item { + char *zDatabase; /* Name of database holding this table */ + char *zName; /* Name of the table */ + char *zAlias; /* The "B" part of a "A AS B" phrase. zName is the "A" */ + Table *pTab; /* An SQL table corresponding to zName */ + Select *pSelect; /* A SELECT statement used in place of a table name */ + int jointype; /* Type of join between this table and the next */ + int iCursor; /* The VDBE cursor number used to access this table */ + Expr *pOn; /* The ON clause of a join */ + IdList *pUsing; /* The USING clause of a join */ + } a[1]; /* One entry for each identifier on the list */ +}; + +/* +** Permitted values of the SrcList.a.jointype field +*/ +#define JT_INNER 0x0001 /* Any kind of inner or cross join */ +#define JT_NATURAL 0x0002 /* True for a "natural" join */ +#define JT_LEFT 0x0004 /* Left outer join */ +#define JT_RIGHT 0x0008 /* Right outer join */ +#define JT_OUTER 0x0010 /* The "OUTER" keyword is present */ +#define JT_ERROR 0x0020 /* unknown or unsupported join type */ + +/* +** For each nested loop in a WHERE clause implementation, the WhereInfo +** structure contains a single instance of this structure. This structure +** is intended to be private the the where.c module and should not be +** access or modified by other modules. +*/ +struct WhereLevel { + int iMem; /* Memory cell used by this level */ + Index *pIdx; /* Index used */ + int iCur; /* Cursor number used for this index */ + int score; /* How well this indexed scored */ + int brk; /* Jump here to break out of the loop */ + int cont; /* Jump here to continue with the next loop cycle */ + int op, p1, p2; /* Opcode used to terminate the loop */ + int iLeftJoin; /* Memory cell used to implement LEFT OUTER JOIN */ + int top; /* First instruction of interior of the loop */ + int inOp, inP1, inP2;/* Opcode used to implement an IN operator */ + int bRev; /* Do the scan in the reverse direction */ +}; + +/* +** The WHERE clause processing routine has two halves. The +** first part does the start of the WHERE loop and the second +** half does the tail of the WHERE loop. An instance of +** this structure is returned by the first half and passed +** into the second half to give some continuity. +*/ +struct WhereInfo { + Parse *pParse; + SrcList *pTabList; /* List of tables in the join */ + int iContinue; /* Jump here to continue with next record */ + int iBreak; /* Jump here to break out of the loop */ + int nLevel; /* Number of nested loop */ + int savedNTab; /* Value of pParse->nTab before WhereBegin() */ + int peakNTab; /* Value of pParse->nTab after WhereBegin() */ + WhereLevel a[1]; /* Information about each nest loop in the WHERE */ +}; + +/* +** An instance of the following structure contains all information +** needed to generate code for a single SELECT statement. +** +** The zSelect field is used when the Select structure must be persistent. +** Normally, the expression tree points to tokens in the original input +** string that encodes the select. But if the Select structure must live +** longer than its input string (for example when it is used to describe +** a VIEW) we have to make a copy of the input string so that the nodes +** of the expression tree will have something to point to. zSelect is used +** to hold that copy. +** +** nLimit is set to -1 if there is no LIMIT clause. nOffset is set to 0. +** If there is a LIMIT clause, the parser sets nLimit to the value of the +** limit and nOffset to the value of the offset (or 0 if there is not +** offset). But later on, nLimit and nOffset become the memory locations +** in the VDBE that record the limit and offset counters. +*/ +struct Select { + ExprList *pEList; /* The fields of the result */ + u8 op; /* One of: TK_UNION TK_ALL TK_INTERSECT TK_EXCEPT */ + u8 isDistinct; /* True if the DISTINCT keyword is present */ + SrcList *pSrc; /* The FROM clause */ + Expr *pWhere; /* The WHERE clause */ + ExprList *pGroupBy; /* The GROUP BY clause */ + Expr *pHaving; /* The HAVING clause */ + ExprList *pOrderBy; /* The ORDER BY clause */ + Select *pPrior; /* Prior select in a compound select statement */ + int nLimit, nOffset; /* LIMIT and OFFSET values. -1 means not used */ + int iLimit, iOffset; /* Memory registers holding LIMIT & OFFSET counters */ + char *zSelect; /* Complete text of the SELECT command */ +}; + +/* +** The results of a select can be distributed in several ways. +*/ +#define SRT_Callback 1 /* Invoke a callback with each row of result */ +#define SRT_Mem 2 /* Store result in a memory cell */ +#define SRT_Set 3 /* Store result as unique keys in a table */ +#define SRT_Union 5 /* Store result as keys in a table */ +#define SRT_Except 6 /* Remove result from a UNION table */ +#define SRT_Table 7 /* Store result as data with a unique key */ +#define SRT_TempTable 8 /* Store result in a trasient table */ +#define SRT_Discard 9 /* Do not save the results anywhere */ +#define SRT_Sorter 10 /* Store results in the sorter */ +#define SRT_Subroutine 11 /* Call a subroutine to handle results */ + +/* +** When a SELECT uses aggregate functions (like "count(*)" or "avg(f1)") +** we have to do some additional analysis of expressions. An instance +** of the following structure holds information about a single subexpression +** somewhere in the SELECT statement. An array of these structures holds +** all the information we need to generate code for aggregate +** expressions. +** +** Note that when analyzing a SELECT containing aggregates, both +** non-aggregate field variables and aggregate functions are stored +** in the AggExpr array of the Parser structure. +** +** The pExpr field points to an expression that is part of either the +** field list, the GROUP BY clause, the HAVING clause or the ORDER BY +** clause. The expression will be freed when those clauses are cleaned +** up. Do not try to delete the expression attached to AggExpr.pExpr. +** +** If AggExpr.pExpr==0, that means the expression is "count(*)". +*/ +struct AggExpr { + int isAgg; /* if TRUE contains an aggregate function */ + Expr *pExpr; /* The expression */ + FuncDef *pFunc; /* Information about the aggregate function */ +}; + +/* +** An SQL parser context. A copy of this structure is passed through +** the parser and down into all the parser action routine in order to +** carry around information that is global to the entire parse. +*/ +struct Parse { + sqlite *db; /* The main database structure */ + int rc; /* Return code from execution */ + char *zErrMsg; /* An error message */ + Token sErrToken; /* The token at which the error occurred */ + Token sFirstToken; /* The first token parsed */ + Token sLastToken; /* The last token parsed */ + const char *zTail; /* All SQL text past the last semicolon parsed */ + Table *pNewTable; /* A table being constructed by CREATE TABLE */ + Vdbe *pVdbe; /* An engine for executing database bytecode */ + u8 colNamesSet; /* TRUE after OP_ColumnName has been issued to pVdbe */ + u8 explain; /* True if the EXPLAIN flag is found on the query */ + u8 nameClash; /* A permanent table name clashes with temp table name */ + u8 useAgg; /* If true, extract field values from the aggregator + ** while generating expressions. Normally false */ + int nErr; /* Number of errors seen */ + int nTab; /* Number of previously allocated VDBE cursors */ + int nMem; /* Number of memory cells used so far */ + int nSet; /* Number of sets used so far */ + int nAgg; /* Number of aggregate expressions */ + int nVar; /* Number of '?' variables seen in the SQL so far */ + AggExpr *aAgg; /* An array of aggregate expressions */ + const char *zAuthContext; /* The 6th parameter to db->xAuth callbacks */ + Trigger *pNewTrigger; /* Trigger under construct by a CREATE TRIGGER */ + TriggerStack *trigStack; /* Trigger actions being coded */ +}; + +/* +** An instance of the following structure can be declared on a stack and used +** to save the Parse.zAuthContext value so that it can be restored later. +*/ +struct AuthContext { + const char *zAuthContext; /* Put saved Parse.zAuthContext here */ + Parse *pParse; /* The Parse structure */ +}; + +/* +** Bitfield flags for P2 value in OP_PutIntKey and OP_Delete +*/ +#define OPFLAG_NCHANGE 1 /* Set to update db->nChange */ +#define OPFLAG_LASTROWID 2 /* Set to update db->lastRowid */ +#define OPFLAG_CSCHANGE 4 /* Set to update db->csChange */ + +/* + * Each trigger present in the database schema is stored as an instance of + * struct Trigger. + * + * Pointers to instances of struct Trigger are stored in two ways. + * 1. In the "trigHash" hash table (part of the sqlite* that represents the + * database). This allows Trigger structures to be retrieved by name. + * 2. All triggers associated with a single table form a linked list, using the + * pNext member of struct Trigger. A pointer to the first element of the + * linked list is stored as the "pTrigger" member of the associated + * struct Table. + * + * The "step_list" member points to the first element of a linked list + * containing the SQL statements specified as the trigger program. + */ +struct Trigger { + char *name; /* The name of the trigger */ + char *table; /* The table or view to which the trigger applies */ + u8 iDb; /* Database containing this trigger */ + u8 iTabDb; /* Database containing Trigger.table */ + u8 op; /* One of TK_DELETE, TK_UPDATE, TK_INSERT */ + u8 tr_tm; /* One of TK_BEFORE, TK_AFTER */ + Expr *pWhen; /* The WHEN clause of the expresion (may be NULL) */ + IdList *pColumns; /* If this is an UPDATE OF <column-list> trigger, + the <column-list> is stored here */ + int foreach; /* One of TK_ROW or TK_STATEMENT */ + Token nameToken; /* Token containing zName. Use during parsing only */ + + TriggerStep *step_list; /* Link list of trigger program steps */ + Trigger *pNext; /* Next trigger associated with the table */ +}; + +/* + * An instance of struct TriggerStep is used to store a single SQL statement + * that is a part of a trigger-program. + * + * Instances of struct TriggerStep are stored in a singly linked list (linked + * using the "pNext" member) referenced by the "step_list" member of the + * associated struct Trigger instance. The first element of the linked list is + * the first step of the trigger-program. + * + * The "op" member indicates whether this is a "DELETE", "INSERT", "UPDATE" or + * "SELECT" statement. The meanings of the other members is determined by the + * value of "op" as follows: + * + * (op == TK_INSERT) + * orconf -> stores the ON CONFLICT algorithm + * pSelect -> If this is an INSERT INTO ... SELECT ... statement, then + * this stores a pointer to the SELECT statement. Otherwise NULL. + * target -> A token holding the name of the table to insert into. + * pExprList -> If this is an INSERT INTO ... VALUES ... statement, then + * this stores values to be inserted. Otherwise NULL. + * pIdList -> If this is an INSERT INTO ... (<column-names>) VALUES ... + * statement, then this stores the column-names to be + * inserted into. + * + * (op == TK_DELETE) + * target -> A token holding the name of the table to delete from. + * pWhere -> The WHERE clause of the DELETE statement if one is specified. + * Otherwise NULL. + * + * (op == TK_UPDATE) + * target -> A token holding the name of the table to update rows of. + * pWhere -> The WHERE clause of the UPDATE statement if one is specified. + * Otherwise NULL. + * pExprList -> A list of the columns to update and the expressions to update + * them to. See sqliteUpdate() documentation of "pChanges" + * argument. + * + */ +struct TriggerStep { + int op; /* One of TK_DELETE, TK_UPDATE, TK_INSERT, TK_SELECT */ + int orconf; /* OE_Rollback etc. */ + Trigger *pTrig; /* The trigger that this step is a part of */ + + Select *pSelect; /* Valid for SELECT and sometimes + INSERT steps (when pExprList == 0) */ + Token target; /* Valid for DELETE, UPDATE, INSERT steps */ + Expr *pWhere; /* Valid for DELETE, UPDATE steps */ + ExprList *pExprList; /* Valid for UPDATE statements and sometimes + INSERT steps (when pSelect == 0) */ + IdList *pIdList; /* Valid for INSERT statements only */ + + TriggerStep * pNext; /* Next in the link-list */ +}; + +/* + * An instance of struct TriggerStack stores information required during code + * generation of a single trigger program. While the trigger program is being + * coded, its associated TriggerStack instance is pointed to by the + * "pTriggerStack" member of the Parse structure. + * + * The pTab member points to the table that triggers are being coded on. The + * newIdx member contains the index of the vdbe cursor that points at the temp + * table that stores the new.* references. If new.* references are not valid + * for the trigger being coded (for example an ON DELETE trigger), then newIdx + * is set to -1. The oldIdx member is analogous to newIdx, for old.* references. + * + * The ON CONFLICT policy to be used for the trigger program steps is stored + * as the orconf member. If this is OE_Default, then the ON CONFLICT clause + * specified for individual triggers steps is used. + * + * struct TriggerStack has a "pNext" member, to allow linked lists to be + * constructed. When coding nested triggers (triggers fired by other triggers) + * each nested trigger stores its parent trigger's TriggerStack as the "pNext" + * pointer. Once the nested trigger has been coded, the pNext value is restored + * to the pTriggerStack member of the Parse stucture and coding of the parent + * trigger continues. + * + * Before a nested trigger is coded, the linked list pointed to by the + * pTriggerStack is scanned to ensure that the trigger is not about to be coded + * recursively. If this condition is detected, the nested trigger is not coded. + */ +struct TriggerStack { + Table *pTab; /* Table that triggers are currently being coded on */ + int newIdx; /* Index of vdbe cursor to "new" temp table */ + int oldIdx; /* Index of vdbe cursor to "old" temp table */ + int orconf; /* Current orconf policy */ + int ignoreJump; /* where to jump to for a RAISE(IGNORE) */ + Trigger *pTrigger; /* The trigger currently being coded */ + TriggerStack *pNext; /* Next trigger down on the trigger stack */ +}; + +/* +** The following structure contains information used by the sqliteFix... +** routines as they walk the parse tree to make database references +** explicit. +*/ +typedef struct DbFixer DbFixer; +struct DbFixer { + Parse *pParse; /* The parsing context. Error messages written here */ + const char *zDb; /* Make sure all objects are contained in this database */ + const char *zType; /* Type of the container - used for error messages */ + const Token *pName; /* Name of the container - used for error messages */ +}; + +/* + * This global flag is set for performance testing of triggers. When it is set + * SQLite will perform the overhead of building new and old trigger references + * even when no triggers exist + */ +extern int always_code_trigger_setup; + +/* +** Internal function prototypes +*/ +int sqliteStrICmp(const char *, const char *); +int sqliteStrNICmp(const char *, const char *, int); +int sqliteHashNoCase(const char *, int); +int sqliteIsNumber(const char*); +int sqliteCompare(const char *, const char *); +int sqliteSortCompare(const char *, const char *); +void sqliteRealToSortable(double r, char *); +#ifdef MEMORY_DEBUG + void *sqliteMalloc_(int,int,char*,int); + void sqliteFree_(void*,char*,int); + void *sqliteRealloc_(void*,int,char*,int); + char *sqliteStrDup_(const char*,char*,int); + char *sqliteStrNDup_(const char*, int,char*,int); + void sqliteCheckMemory(void*,int); +#else + void *sqliteMalloc(int); + void *sqliteMallocRaw(int); + void sqliteFree(void*); + void *sqliteRealloc(void*,int); + char *sqliteStrDup(const char*); + char *sqliteStrNDup(const char*, int); +# define sqliteCheckMemory(a,b) +#endif +char *sqliteMPrintf(const char*, ...); +char *sqliteVMPrintf(const char*, va_list); +void sqliteSetString(char **, const char *, ...); +void sqliteSetNString(char **, ...); +void sqliteErrorMsg(Parse*, const char*, ...); +void sqliteDequote(char*); +int sqliteKeywordCode(const char*, int); +int sqliteRunParser(Parse*, const char*, char **); +void sqliteExec(Parse*); +Expr *sqliteExpr(int, Expr*, Expr*, Token*); +void sqliteExprSpan(Expr*,Token*,Token*); +Expr *sqliteExprFunction(ExprList*, Token*); +void sqliteExprDelete(Expr*); +ExprList *sqliteExprListAppend(ExprList*,Expr*,Token*); +void sqliteExprListDelete(ExprList*); +int sqliteInit(sqlite*, char**); +void sqlitePragma(Parse*,Token*,Token*,int); +void sqliteResetInternalSchema(sqlite*, int); +void sqliteBeginParse(Parse*,int); +void sqliteRollbackInternalChanges(sqlite*); +void sqliteCommitInternalChanges(sqlite*); +Table *sqliteResultSetOfSelect(Parse*,char*,Select*); +void sqliteOpenMasterTable(Vdbe *v, int); +void sqliteStartTable(Parse*,Token*,Token*,int,int); +void sqliteAddColumn(Parse*,Token*); +void sqliteAddNotNull(Parse*, int); +void sqliteAddPrimaryKey(Parse*, IdList*, int); +void sqliteAddColumnType(Parse*,Token*,Token*); +void sqliteAddDefaultValue(Parse*,Token*,int); +int sqliteCollateType(const char*, int); +void sqliteAddCollateType(Parse*, int); +void sqliteEndTable(Parse*,Token*,Select*); +void sqliteCreateView(Parse*,Token*,Token*,Select*,int); +int sqliteViewGetColumnNames(Parse*,Table*); +void sqliteDropTable(Parse*, Token*, int); +void sqliteDeleteTable(sqlite*, Table*); +void sqliteInsert(Parse*, SrcList*, ExprList*, Select*, IdList*, int); +IdList *sqliteIdListAppend(IdList*, Token*); +int sqliteIdListIndex(IdList*,const char*); +SrcList *sqliteSrcListAppend(SrcList*, Token*, Token*); +void sqliteSrcListAddAlias(SrcList*, Token*); +void sqliteSrcListAssignCursors(Parse*, SrcList*); +void sqliteIdListDelete(IdList*); +void sqliteSrcListDelete(SrcList*); +void sqliteCreateIndex(Parse*,Token*,SrcList*,IdList*,int,Token*,Token*); +void sqliteDropIndex(Parse*, SrcList*); +void sqliteAddKeyType(Vdbe*, ExprList*); +void sqliteAddIdxKeyType(Vdbe*, Index*); +int sqliteSelect(Parse*, Select*, int, int, Select*, int, int*); +Select *sqliteSelectNew(ExprList*,SrcList*,Expr*,ExprList*,Expr*,ExprList*, + int,int,int); +void sqliteSelectDelete(Select*); +void sqliteSelectUnbind(Select*); +Table *sqliteSrcListLookup(Parse*, SrcList*); +int sqliteIsReadOnly(Parse*, Table*, int); +void sqliteDeleteFrom(Parse*, SrcList*, Expr*); +void sqliteUpdate(Parse*, SrcList*, ExprList*, Expr*, int); +WhereInfo *sqliteWhereBegin(Parse*, SrcList*, Expr*, int, ExprList**); +void sqliteWhereEnd(WhereInfo*); +void sqliteExprCode(Parse*, Expr*); +int sqliteExprCodeExprList(Parse*, ExprList*, int); +void sqliteExprIfTrue(Parse*, Expr*, int, int); +void sqliteExprIfFalse(Parse*, Expr*, int, int); +Table *sqliteFindTable(sqlite*,const char*, const char*); +Table *sqliteLocateTable(Parse*,const char*, const char*); +Index *sqliteFindIndex(sqlite*,const char*, const char*); +void sqliteUnlinkAndDeleteIndex(sqlite*,Index*); +void sqliteCopy(Parse*, SrcList*, Token*, Token*, int); +void sqliteVacuum(Parse*, Token*); +int sqliteRunVacuum(char**, sqlite*); +int sqliteGlobCompare(const unsigned char*,const unsigned char*); +int sqliteLikeCompare(const unsigned char*,const unsigned char*); +char *sqliteTableNameFromToken(Token*); +int sqliteExprCheck(Parse*, Expr*, int, int*); +int sqliteExprType(Expr*); +int sqliteExprCompare(Expr*, Expr*); +int sqliteFuncId(Token*); +int sqliteExprResolveIds(Parse*, SrcList*, ExprList*, Expr*); +int sqliteExprAnalyzeAggregates(Parse*, Expr*); +Vdbe *sqliteGetVdbe(Parse*); +void sqliteRandomness(int, void*); +void sqliteRollbackAll(sqlite*); +void sqliteCodeVerifySchema(Parse*, int); +void sqliteBeginTransaction(Parse*, int); +void sqliteCommitTransaction(Parse*); +void sqliteRollbackTransaction(Parse*); +int sqliteExprIsConstant(Expr*); +int sqliteExprIsInteger(Expr*, int*); +int sqliteIsRowid(const char*); +void sqliteGenerateRowDelete(sqlite*, Vdbe*, Table*, int, int); +void sqliteGenerateRowIndexDelete(sqlite*, Vdbe*, Table*, int, char*); +void sqliteGenerateConstraintChecks(Parse*,Table*,int,char*,int,int,int,int); +void sqliteCompleteInsertion(Parse*, Table*, int, char*, int, int, int); +int sqliteOpenTableAndIndices(Parse*, Table*, int); +void sqliteBeginWriteOperation(Parse*, int, int); +void sqliteEndWriteOperation(Parse*); +Expr *sqliteExprDup(Expr*); +void sqliteTokenCopy(Token*, Token*); +ExprList *sqliteExprListDup(ExprList*); +SrcList *sqliteSrcListDup(SrcList*); +IdList *sqliteIdListDup(IdList*); +Select *sqliteSelectDup(Select*); +FuncDef *sqliteFindFunction(sqlite*,const char*,int,int,int); +void sqliteRegisterBuiltinFunctions(sqlite*); +void sqliteRegisterDateTimeFunctions(sqlite*); +int sqliteSafetyOn(sqlite*); +int sqliteSafetyOff(sqlite*); +int sqliteSafetyCheck(sqlite*); +void sqliteChangeCookie(sqlite*, Vdbe*); +void sqliteBeginTrigger(Parse*, Token*,int,int,IdList*,SrcList*,int,Expr*,int); +void sqliteFinishTrigger(Parse*, TriggerStep*, Token*); +void sqliteDropTrigger(Parse*, SrcList*); +void sqliteDropTriggerPtr(Parse*, Trigger*, int); +int sqliteTriggersExist(Parse* , Trigger* , int , int , int, ExprList*); +int sqliteCodeRowTrigger(Parse*, int, ExprList*, int, Table *, int, int, + int, int); +void sqliteViewTriggers(Parse*, Table*, Expr*, int, ExprList*); +void sqliteDeleteTriggerStep(TriggerStep*); +TriggerStep *sqliteTriggerSelectStep(Select*); +TriggerStep *sqliteTriggerInsertStep(Token*, IdList*, ExprList*, Select*, int); +TriggerStep *sqliteTriggerUpdateStep(Token*, ExprList*, Expr*, int); +TriggerStep *sqliteTriggerDeleteStep(Token*, Expr*); +void sqliteDeleteTrigger(Trigger*); +int sqliteJoinType(Parse*, Token*, Token*, Token*); +void sqliteCreateForeignKey(Parse*, IdList*, Token*, IdList*, int); +void sqliteDeferForeignKey(Parse*, int); +#ifndef SQLITE_OMIT_AUTHORIZATION + void sqliteAuthRead(Parse*,Expr*,SrcList*); + int sqliteAuthCheck(Parse*,int, const char*, const char*, const char*); + void sqliteAuthContextPush(Parse*, AuthContext*, const char*); + void sqliteAuthContextPop(AuthContext*); +#else +# define sqliteAuthRead(a,b,c) +# define sqliteAuthCheck(a,b,c,d,e) SQLITE_OK +# define sqliteAuthContextPush(a,b,c) +# define sqliteAuthContextPop(a) ((void)(a)) +#endif +void sqliteAttach(Parse*, Token*, Token*, Token*); +void sqliteDetach(Parse*, Token*); +int sqliteBtreeFactory(const sqlite *db, const char *zFilename, + int mode, int nPg, Btree **ppBtree); +int sqliteFixInit(DbFixer*, Parse*, int, const char*, const Token*); +int sqliteFixSrcList(DbFixer*, SrcList*); +int sqliteFixSelect(DbFixer*, Select*); +int sqliteFixExpr(DbFixer*, Expr*); +int sqliteFixExprList(DbFixer*, ExprList*); +int sqliteFixTriggerStep(DbFixer*, TriggerStep*); +double sqliteAtoF(const char *z, const char **); +char *sqlite_snprintf(int,char*,const char*,...); +int sqliteFitsIn32Bits(const char *); diff --git a/kexi/3rdparty/kexisql/src/sqliteconfig.h b/kexi/3rdparty/kexisql/src/sqliteconfig.h new file mode 100644 index 00000000..d34a85a4 --- /dev/null +++ b/kexi/3rdparty/kexisql/src/sqliteconfig.h @@ -0,0 +1,7 @@ +#ifdef _WIN32 +# define SQLITE_PTR_SZ 4 +#else +# include "../../../../config.h" +# define SQLITE_PTR_SZ SIZEOF_CHAR_P +#endif + diff --git a/kexi/3rdparty/kexisql/src/table.c b/kexi/3rdparty/kexisql/src/table.c new file mode 100644 index 00000000..48c852d4 --- /dev/null +++ b/kexi/3rdparty/kexisql/src/table.c @@ -0,0 +1,203 @@ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains the sqlite_get_table() and sqlite_free_table() +** interface routines. These are just wrappers around the main +** interface routine of sqlite_exec(). +** +** These routines are in a separate files so that they will not be linked +** if they are not used. +*/ +#include <stdlib.h> +#include <string.h> +#include "sqliteInt.h" + +/* +** This structure is used to pass data from sqlite_get_table() through +** to the callback function is uses to build the result. +*/ +typedef struct TabResult { + char **azResult; + char *zErrMsg; + int nResult; + int nAlloc; + int nRow; + int nColumn; + long nData; + int rc; +} TabResult; + +/* +** This routine is called once for each row in the result table. Its job +** is to fill in the TabResult structure appropriately, allocating new +** memory as necessary. +*/ +static int sqlite_get_table_cb(void *pArg, int nCol, char **argv, char **colv){ + TabResult *p = (TabResult*)pArg; + int need; + int i; + char *z; + + /* Make sure there is enough space in p->azResult to hold everything + ** we need to remember from this invocation of the callback. + */ + if( p->nRow==0 && argv!=0 ){ + need = nCol*2; + }else{ + need = nCol; + } + if( p->nData + need >= p->nAlloc ){ + char **azNew; + p->nAlloc = p->nAlloc*2 + need + 1; + azNew = realloc( p->azResult, sizeof(char*)*p->nAlloc ); + if( azNew==0 ){ + p->rc = SQLITE_NOMEM; + return 1; + } + p->azResult = azNew; + } + + /* If this is the first row, then generate an extra row containing + ** the names of all columns. + */ + if( p->nRow==0 ){ + p->nColumn = nCol; + for(i=0; i<nCol; i++){ + if( colv[i]==0 ){ + z = 0; + }else{ + z = malloc( strlen(colv[i])+1 ); + if( z==0 ){ + p->rc = SQLITE_NOMEM; + return 1; + } + strcpy(z, colv[i]); + } + p->azResult[p->nData++] = z; + } + }else if( p->nColumn!=nCol ){ + sqliteSetString(&p->zErrMsg, + "sqlite_get_table() called with two or more incompatible queries", + (char*)0); + p->rc = SQLITE_ERROR; + return 1; + } + + /* Copy over the row data + */ + if( argv!=0 ){ + for(i=0; i<nCol; i++){ + if( argv[i]==0 ){ + z = 0; + }else{ + z = malloc( strlen(argv[i])+1 ); + if( z==0 ){ + p->rc = SQLITE_NOMEM; + return 1; + } + strcpy(z, argv[i]); + } + p->azResult[p->nData++] = z; + } + p->nRow++; + } + return 0; +} + +/* +** Query the database. But instead of invoking a callback for each row, +** malloc() for space to hold the result and return the entire results +** at the conclusion of the call. +** +** The result that is written to ***pazResult is held in memory obtained +** from malloc(). But the caller cannot free this memory directly. +** Instead, the entire table should be passed to sqlite_free_table() when +** the calling procedure is finished using it. +*/ +int sqlite_get_table( + sqlite *db, /* The database on which the SQL executes */ + const char *zSql, /* The SQL to be executed */ + char ***pazResult, /* Write the result table here */ + int *pnRow, /* Write the number of rows in the result here */ + int *pnColumn, /* Write the number of columns of result here */ + char **pzErrMsg /* Write error messages here */ +){ + int rc; + TabResult res; + if( pazResult==0 ){ return SQLITE_ERROR; } + *pazResult = 0; + if( pnColumn ) *pnColumn = 0; + if( pnRow ) *pnRow = 0; + res.zErrMsg = 0; + res.nResult = 0; + res.nRow = 0; + res.nColumn = 0; + res.nData = 1; + res.nAlloc = 20; + res.rc = SQLITE_OK; + res.azResult = malloc( sizeof(char*)*res.nAlloc ); + if( res.azResult==0 ){ + return SQLITE_NOMEM; + } + res.azResult[0] = 0; + rc = sqlite_exec(db, zSql, sqlite_get_table_cb, &res, pzErrMsg); + if( res.azResult ){ + res.azResult[0] = (char*)res.nData; + } + if( rc==SQLITE_ABORT ){ + sqlite_free_table(&res.azResult[1]); + if( res.zErrMsg ){ + if( pzErrMsg ){ + free(*pzErrMsg); + *pzErrMsg = res.zErrMsg; + sqliteStrRealloc(pzErrMsg); + }else{ + sqliteFree(res.zErrMsg); + } + } + return res.rc; + } + sqliteFree(res.zErrMsg); + if( rc!=SQLITE_OK ){ + sqlite_free_table(&res.azResult[1]); + return rc; + } + if( res.nAlloc>res.nData ){ + char **azNew; + azNew = realloc( res.azResult, sizeof(char*)*(res.nData+1) ); + if( azNew==0 ){ + sqlite_free_table(&res.azResult[1]); + return SQLITE_NOMEM; + } + res.nAlloc = res.nData+1; + res.azResult = azNew; + } + *pazResult = &res.azResult[1]; + if( pnColumn ) *pnColumn = res.nColumn; + if( pnRow ) *pnRow = res.nRow; + return rc; +} + +/* +** This routine frees the space the sqlite_get_table() malloced. +*/ +void sqlite_free_table( + char **azResult /* Result returned from from sqlite_get_table() */ +){ + if( azResult ){ + int i, n; + azResult--; + if( azResult==0 ) return; + n = (int)(long)azResult[0]; + for(i=1; i<n; i++){ if( azResult[i] ) free(azResult[i]); } + free(azResult); + } +} diff --git a/kexi/3rdparty/kexisql/src/tclsqlite.c b/kexi/3rdparty/kexisql/src/tclsqlite.c new file mode 100644 index 00000000..fdc2f5e8 --- /dev/null +++ b/kexi/3rdparty/kexisql/src/tclsqlite.c @@ -0,0 +1,1293 @@ +/* +** 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. +** +************************************************************************* +** A TCL Interface to SQLite +** +** $Id: tclsqlite.c 410099 2005-05-06 17:52:07Z staniek $ +*/ +#ifndef NO_TCL /* Omit this whole file if TCL is unavailable */ + +#include "sqliteInt.h" +#include "tcl.h" +#include <stdlib.h> +#include <string.h> +#include <assert.h> + +/* +** If TCL uses UTF-8 and SQLite is configured to use iso8859, then we +** have to do a translation when going between the two. Set the +** UTF_TRANSLATION_NEEDED macro to indicate that we need to do +** this translation. +*/ +#if defined(TCL_UTF_MAX) && !defined(SQLITE_UTF8) +# define UTF_TRANSLATION_NEEDED 1 +#endif + +/* +** New SQL functions can be created as TCL scripts. Each such function +** is described by an instance of the following structure. +*/ +typedef struct SqlFunc SqlFunc; +struct SqlFunc { + Tcl_Interp *interp; /* The TCL interpret to execute the function */ + char *zScript; /* The script to be run */ + SqlFunc *pNext; /* Next function on the list of them all */ +}; + +/* +** There is one instance of this structure for each SQLite database +** that has been opened by the SQLite TCL interface. +*/ +typedef struct SqliteDb SqliteDb; +struct SqliteDb { + sqlite *db; /* The "real" database structure */ + Tcl_Interp *interp; /* The interpreter used for this database */ + char *zBusy; /* The busy callback routine */ + char *zCommit; /* The commit hook callback routine */ + char *zTrace; /* The trace callback routine */ + char *zProgress; /* The progress callback routine */ + char *zAuth; /* The authorization callback routine */ + SqlFunc *pFunc; /* List of SQL functions */ + int rc; /* Return code of most recent sqlite_exec() */ +}; + +/* +** An instance of this structure passes information thru the sqlite +** logic from the original TCL command into the callback routine. +*/ +typedef struct CallbackData CallbackData; +struct CallbackData { + Tcl_Interp *interp; /* The TCL interpreter */ + char *zArray; /* The array into which data is written */ + Tcl_Obj *pCode; /* The code to execute for each row */ + int once; /* Set for first callback only */ + int tcl_rc; /* Return code from TCL script */ + int nColName; /* Number of entries in the azColName[] array */ + char **azColName; /* Column names translated to UTF-8 */ +}; + +#ifdef UTF_TRANSLATION_NEEDED +/* +** Called for each row of the result. +** +** This version is used when TCL expects UTF-8 data but the database +** uses the ISO8859 format. A translation must occur from ISO8859 into +** UTF-8. +*/ +static int DbEvalCallback( + void *clientData, /* An instance of CallbackData */ + int nCol, /* Number of columns in the result */ + char ** azCol, /* Data for each column */ + char ** azN /* Name for each column */ +){ + CallbackData *cbData = (CallbackData*)clientData; + int i, rc; + Tcl_DString dCol; + Tcl_DStringInit(&dCol); + if( cbData->azColName==0 ){ + assert( cbData->once ); + cbData->once = 0; + if( cbData->zArray[0] ){ + Tcl_SetVar2(cbData->interp, cbData->zArray, "*", "", 0); + } + cbData->azColName = malloc( nCol*sizeof(char*) ); + if( cbData->azColName==0 ){ return 1; } + cbData->nColName = nCol; + for(i=0; i<nCol; i++){ + Tcl_ExternalToUtfDString(NULL, azN[i], -1, &dCol); + cbData->azColName[i] = malloc( Tcl_DStringLength(&dCol) + 1 ); + if( cbData->azColName[i] ){ + strcpy(cbData->azColName[i], Tcl_DStringValue(&dCol)); + }else{ + return 1; + } + if( cbData->zArray[0] ){ + Tcl_SetVar2(cbData->interp, cbData->zArray, "*", + Tcl_DStringValue(&dCol), TCL_LIST_ELEMENT|TCL_APPEND_VALUE); + if( azN[nCol]!=0 ){ + Tcl_DString dType; + Tcl_DStringInit(&dType); + Tcl_DStringAppend(&dType, "typeof:", -1); + Tcl_DStringAppend(&dType, Tcl_DStringValue(&dCol), -1); + Tcl_DStringFree(&dCol); + Tcl_ExternalToUtfDString(NULL, azN[i+nCol], -1, &dCol); + Tcl_SetVar2(cbData->interp, cbData->zArray, + Tcl_DStringValue(&dType), Tcl_DStringValue(&dCol), + TCL_LIST_ELEMENT|TCL_APPEND_VALUE); + Tcl_DStringFree(&dType); + } + } + + Tcl_DStringFree(&dCol); + } + } + if( azCol!=0 ){ + if( cbData->zArray[0] ){ + for(i=0; i<nCol; i++){ + char *z = azCol[i]; + if( z==0 ) z = ""; + Tcl_DStringInit(&dCol); + Tcl_ExternalToUtfDString(NULL, z, -1, &dCol); + Tcl_SetVar2(cbData->interp, cbData->zArray, cbData->azColName[i], + Tcl_DStringValue(&dCol), 0); + Tcl_DStringFree(&dCol); + } + }else{ + for(i=0; i<nCol; i++){ + char *z = azCol[i]; + if( z==0 ) z = ""; + Tcl_DStringInit(&dCol); + Tcl_ExternalToUtfDString(NULL, z, -1, &dCol); + Tcl_SetVar(cbData->interp, cbData->azColName[i], + Tcl_DStringValue(&dCol), 0); + Tcl_DStringFree(&dCol); + } + } + } + rc = Tcl_EvalObj(cbData->interp, cbData->pCode); + if( rc==TCL_CONTINUE ) rc = TCL_OK; + cbData->tcl_rc = rc; + return rc!=TCL_OK; +} +#endif /* UTF_TRANSLATION_NEEDED */ + +#ifndef UTF_TRANSLATION_NEEDED +/* +** Called for each row of the result. +** +** This version is used when either of the following is true: +** +** (1) This version of TCL uses UTF-8 and the data in the +** SQLite database is already in the UTF-8 format. +** +** (2) This version of TCL uses ISO8859 and the data in the +** SQLite database is already in the ISO8859 format. +*/ +static int DbEvalCallback( + void *clientData, /* An instance of CallbackData */ + int nCol, /* Number of columns in the result */ + char ** azCol, /* Data for each column */ + char ** azN /* Name for each column */ +){ + CallbackData *cbData = (CallbackData*)clientData; + int i, rc; + if( azCol==0 || (cbData->once && cbData->zArray[0]) ){ + Tcl_SetVar2(cbData->interp, cbData->zArray, "*", "", 0); + for(i=0; i<nCol; i++){ + Tcl_SetVar2(cbData->interp, cbData->zArray, "*", azN[i], + TCL_LIST_ELEMENT|TCL_APPEND_VALUE); + if( azN[nCol] ){ + char *z = sqlite_mprintf("typeof:%s", azN[i]); + Tcl_SetVar2(cbData->interp, cbData->zArray, z, azN[i+nCol], + TCL_LIST_ELEMENT|TCL_APPEND_VALUE); + sqlite_freemem(z); + } + } + cbData->once = 0; + } + if( azCol!=0 ){ + if( cbData->zArray[0] ){ + for(i=0; i<nCol; i++){ + char *z = azCol[i]; + if( z==0 ) z = ""; + Tcl_SetVar2(cbData->interp, cbData->zArray, azN[i], z, 0); + } + }else{ + for(i=0; i<nCol; i++){ + char *z = azCol[i]; + if( z==0 ) z = ""; + Tcl_SetVar(cbData->interp, azN[i], z, 0); + } + } + } + rc = Tcl_EvalObj(cbData->interp, cbData->pCode); + if( rc==TCL_CONTINUE ) rc = TCL_OK; + cbData->tcl_rc = rc; + return rc!=TCL_OK; +} +#endif + +/* +** This is an alternative callback for database queries. Instead +** of invoking a TCL script to handle the result, this callback just +** appends each column of the result to a list. After the query +** is complete, the list is returned. +*/ +static int DbEvalCallback2( + void *clientData, /* An instance of CallbackData */ + int nCol, /* Number of columns in the result */ + char ** azCol, /* Data for each column */ + char ** azN /* Name for each column */ +){ + Tcl_Obj *pList = (Tcl_Obj*)clientData; + int i; + if( azCol==0 ) return 0; + for(i=0; i<nCol; i++){ + Tcl_Obj *pElem; + if( azCol[i] && *azCol[i] ){ +#ifdef UTF_TRANSLATION_NEEDED + Tcl_DString dCol; + Tcl_DStringInit(&dCol); + Tcl_ExternalToUtfDString(NULL, azCol[i], -1, &dCol); + pElem = Tcl_NewStringObj(Tcl_DStringValue(&dCol), -1); + Tcl_DStringFree(&dCol); +#else + pElem = Tcl_NewStringObj(azCol[i], -1); +#endif + }else{ + pElem = Tcl_NewObj(); + } + Tcl_ListObjAppendElement(0, pList, pElem); + } + return 0; +} + +/* +** This is a second alternative callback for database queries. A the +** first column of the first row of the result is made the TCL result. +*/ +static int DbEvalCallback3( + void *clientData, /* An instance of CallbackData */ + int nCol, /* Number of columns in the result */ + char ** azCol, /* Data for each column */ + char ** azN /* Name for each column */ +){ + Tcl_Interp *interp = (Tcl_Interp*)clientData; + Tcl_Obj *pElem; + if( azCol==0 ) return 1; + if( nCol==0 ) return 1; +#ifdef UTF_TRANSLATION_NEEDED + { + Tcl_DString dCol; + Tcl_DStringInit(&dCol); + Tcl_ExternalToUtfDString(NULL, azCol[0], -1, &dCol); + pElem = Tcl_NewStringObj(Tcl_DStringValue(&dCol), -1); + Tcl_DStringFree(&dCol); + } +#else + pElem = Tcl_NewStringObj(azCol[0], -1); +#endif + Tcl_SetObjResult(interp, pElem); + return 1; +} + +/* +** Called when the command is deleted. +*/ +static void DbDeleteCmd(void *db){ + SqliteDb *pDb = (SqliteDb*)db; + sqlite_close(pDb->db); + while( pDb->pFunc ){ + SqlFunc *pFunc = pDb->pFunc; + pDb->pFunc = pFunc->pNext; + Tcl_Free((char*)pFunc); + } + if( pDb->zBusy ){ + Tcl_Free(pDb->zBusy); + } + if( pDb->zTrace ){ + Tcl_Free(pDb->zTrace); + } + if( pDb->zAuth ){ + Tcl_Free(pDb->zAuth); + } + Tcl_Free((char*)pDb); +} + +/* +** This routine is called when a database file is locked while trying +** to execute SQL. +*/ +static int DbBusyHandler(void *cd, const char *zTable, int nTries){ + SqliteDb *pDb = (SqliteDb*)cd; + int rc; + char zVal[30]; + char *zCmd; + Tcl_DString cmd; + + Tcl_DStringInit(&cmd); + Tcl_DStringAppend(&cmd, pDb->zBusy, -1); + Tcl_DStringAppendElement(&cmd, zTable); + sprintf(zVal, " %d", nTries); + Tcl_DStringAppend(&cmd, zVal, -1); + zCmd = Tcl_DStringValue(&cmd); + rc = Tcl_Eval(pDb->interp, zCmd); + Tcl_DStringFree(&cmd); + if( rc!=TCL_OK || atoi(Tcl_GetStringResult(pDb->interp)) ){ + return 0; + } + return 1; +} + +/* +** This routine is invoked as the 'progress callback' for the database. +*/ +static int DbProgressHandler(void *cd){ + SqliteDb *pDb = (SqliteDb*)cd; + int rc; + + assert( pDb->zProgress ); + rc = Tcl_Eval(pDb->interp, pDb->zProgress); + if( rc!=TCL_OK || atoi(Tcl_GetStringResult(pDb->interp)) ){ + return 1; + } + return 0; +} + +/* +** This routine is called by the SQLite trace handler whenever a new +** block of SQL is executed. The TCL script in pDb->zTrace is executed. +*/ +static void DbTraceHandler(void *cd, const char *zSql){ + SqliteDb *pDb = (SqliteDb*)cd; + Tcl_DString str; + + Tcl_DStringInit(&str); + Tcl_DStringAppend(&str, pDb->zTrace, -1); + Tcl_DStringAppendElement(&str, zSql); + Tcl_Eval(pDb->interp, Tcl_DStringValue(&str)); + Tcl_DStringFree(&str); + Tcl_ResetResult(pDb->interp); +} + +/* +** This routine is called when a transaction is committed. The +** TCL script in pDb->zCommit is executed. If it returns non-zero or +** if it throws an exception, the transaction is rolled back instead +** of being committed. +*/ +static int DbCommitHandler(void *cd){ + SqliteDb *pDb = (SqliteDb*)cd; + int rc; + + rc = Tcl_Eval(pDb->interp, pDb->zCommit); + if( rc!=TCL_OK || atoi(Tcl_GetStringResult(pDb->interp)) ){ + return 1; + } + return 0; +} + +/* +** This routine is called to evaluate an SQL function implemented +** using TCL script. +*/ +static void tclSqlFunc(sqlite_func *context, int argc, const char **argv){ + SqlFunc *p = sqlite_user_data(context); + Tcl_DString cmd; + int i; + int rc; + + Tcl_DStringInit(&cmd); + Tcl_DStringAppend(&cmd, p->zScript, -1); + for(i=0; i<argc; i++){ + Tcl_DStringAppendElement(&cmd, argv[i] ? argv[i] : ""); + } + rc = Tcl_Eval(p->interp, Tcl_DStringValue(&cmd)); + if( rc ){ + sqlite_set_result_error(context, Tcl_GetStringResult(p->interp), -1); + }else{ + sqlite_set_result_string(context, Tcl_GetStringResult(p->interp), -1); + } +} +#ifndef SQLITE_OMIT_AUTHORIZATION +/* +** This is the authentication function. It appends the authentication +** type code and the two arguments to zCmd[] then invokes the result +** on the interpreter. The reply is examined to determine if the +** authentication fails or succeeds. +*/ +static int auth_callback( + void *pArg, + int code, + const char *zArg1, + const char *zArg2, + const char *zArg3, + const char *zArg4 +){ + char *zCode; + Tcl_DString str; + int rc; + const char *zReply; + SqliteDb *pDb = (SqliteDb*)pArg; + + switch( code ){ + case SQLITE_COPY : zCode="SQLITE_COPY"; break; + case SQLITE_CREATE_INDEX : zCode="SQLITE_CREATE_INDEX"; break; + case SQLITE_CREATE_TABLE : zCode="SQLITE_CREATE_TABLE"; break; + case SQLITE_CREATE_TEMP_INDEX : zCode="SQLITE_CREATE_TEMP_INDEX"; break; + case SQLITE_CREATE_TEMP_TABLE : zCode="SQLITE_CREATE_TEMP_TABLE"; break; + case SQLITE_CREATE_TEMP_TRIGGER: zCode="SQLITE_CREATE_TEMP_TRIGGER"; break; + case SQLITE_CREATE_TEMP_VIEW : zCode="SQLITE_CREATE_TEMP_VIEW"; break; + case SQLITE_CREATE_TRIGGER : zCode="SQLITE_CREATE_TRIGGER"; break; + case SQLITE_CREATE_VIEW : zCode="SQLITE_CREATE_VIEW"; break; + case SQLITE_DELETE : zCode="SQLITE_DELETE"; break; + case SQLITE_DROP_INDEX : zCode="SQLITE_DROP_INDEX"; break; + case SQLITE_DROP_TABLE : zCode="SQLITE_DROP_TABLE"; break; + case SQLITE_DROP_TEMP_INDEX : zCode="SQLITE_DROP_TEMP_INDEX"; break; + case SQLITE_DROP_TEMP_TABLE : zCode="SQLITE_DROP_TEMP_TABLE"; break; + case SQLITE_DROP_TEMP_TRIGGER : zCode="SQLITE_DROP_TEMP_TRIGGER"; break; + case SQLITE_DROP_TEMP_VIEW : zCode="SQLITE_DROP_TEMP_VIEW"; break; + case SQLITE_DROP_TRIGGER : zCode="SQLITE_DROP_TRIGGER"; break; + case SQLITE_DROP_VIEW : zCode="SQLITE_DROP_VIEW"; break; + case SQLITE_INSERT : zCode="SQLITE_INSERT"; break; + case SQLITE_PRAGMA : zCode="SQLITE_PRAGMA"; break; + case SQLITE_READ : zCode="SQLITE_READ"; break; + case SQLITE_SELECT : zCode="SQLITE_SELECT"; break; + case SQLITE_TRANSACTION : zCode="SQLITE_TRANSACTION"; break; + case SQLITE_UPDATE : zCode="SQLITE_UPDATE"; break; + case SQLITE_ATTACH : zCode="SQLITE_ATTACH"; break; + case SQLITE_DETACH : zCode="SQLITE_DETACH"; break; + default : zCode="????"; break; + } + Tcl_DStringInit(&str); + Tcl_DStringAppend(&str, pDb->zAuth, -1); + Tcl_DStringAppendElement(&str, zCode); + Tcl_DStringAppendElement(&str, zArg1 ? zArg1 : ""); + Tcl_DStringAppendElement(&str, zArg2 ? zArg2 : ""); + Tcl_DStringAppendElement(&str, zArg3 ? zArg3 : ""); + Tcl_DStringAppendElement(&str, zArg4 ? zArg4 : ""); + rc = Tcl_GlobalEval(pDb->interp, Tcl_DStringValue(&str)); + Tcl_DStringFree(&str); + zReply = Tcl_GetStringResult(pDb->interp); + if( strcmp(zReply,"SQLITE_OK")==0 ){ + rc = SQLITE_OK; + }else if( strcmp(zReply,"SQLITE_DENY")==0 ){ + rc = SQLITE_DENY; + }else if( strcmp(zReply,"SQLITE_IGNORE")==0 ){ + rc = SQLITE_IGNORE; + }else{ + rc = 999; + } + return rc; +} +#endif /* SQLITE_OMIT_AUTHORIZATION */ + +/* +** The "sqlite" command below creates a new Tcl command for each +** connection it opens to an SQLite database. This routine is invoked +** whenever one of those connection-specific commands is executed +** in Tcl. For example, if you run Tcl code like this: +** +** sqlite db1 "my_database" +** db1 close +** +** The first command opens a connection to the "my_database" database +** and calls that connection "db1". The second command causes this +** subroutine to be invoked. +*/ +static int DbObjCmd(void *cd, Tcl_Interp *interp, int objc,Tcl_Obj *const*objv){ + SqliteDb *pDb = (SqliteDb*)cd; + int choice; + int rc = TCL_OK; + static const char *DB_strs[] = { + "authorizer", "busy", "changes", + "close", "commit_hook", "complete", + "errorcode", "eval", "function", + "last_insert_rowid", "last_statement_changes", "onecolumn", + "progress", "rekey", "timeout", + "trace", + 0 + }; + enum DB_enum { + DB_AUTHORIZER, DB_BUSY, DB_CHANGES, + DB_CLOSE, DB_COMMIT_HOOK, DB_COMPLETE, + DB_ERRORCODE, DB_EVAL, DB_FUNCTION, + DB_LAST_INSERT_ROWID, DB_LAST_STATEMENT_CHANGES, DB_ONECOLUMN, + DB_PROGRESS, DB_REKEY, DB_TIMEOUT, + DB_TRACE + }; + + if( objc<2 ){ + Tcl_WrongNumArgs(interp, 1, objv, "SUBCOMMAND ..."); + return TCL_ERROR; + } + if( Tcl_GetIndexFromObj(interp, objv[1], DB_strs, "option", 0, &choice) ){ + return TCL_ERROR; + } + + switch( (enum DB_enum)choice ){ + + /* $db authorizer ?CALLBACK? + ** + ** Invoke the given callback to authorize each SQL operation as it is + ** compiled. 5 arguments are appended to the callback before it is + ** invoked: + ** + ** (1) The authorization type (ex: SQLITE_CREATE_TABLE, SQLITE_INSERT, ...) + ** (2) First descriptive name (depends on authorization type) + ** (3) Second descriptive name + ** (4) Name of the database (ex: "main", "temp") + ** (5) Name of trigger that is doing the access + ** + ** The callback should return on of the following strings: SQLITE_OK, + ** SQLITE_IGNORE, or SQLITE_DENY. Any other return value is an error. + ** + ** If this method is invoked with no arguments, the current authorization + ** callback string is returned. + */ + case DB_AUTHORIZER: { + if( objc>3 ){ + Tcl_WrongNumArgs(interp, 2, objv, "?CALLBACK?"); + }else if( objc==2 ){ + if( pDb->zAuth ){ + Tcl_AppendResult(interp, pDb->zAuth, 0); + } + }else{ + char *zAuth; + int len; + if( pDb->zAuth ){ + Tcl_Free(pDb->zAuth); + } + zAuth = Tcl_GetStringFromObj(objv[2], &len); + if( zAuth && len>0 ){ + pDb->zAuth = Tcl_Alloc( len + 1 ); + strcpy(pDb->zAuth, zAuth); + }else{ + pDb->zAuth = 0; + } +#ifndef SQLITE_OMIT_AUTHORIZATION + if( pDb->zAuth ){ + pDb->interp = interp; + sqlite_set_authorizer(pDb->db, auth_callback, pDb); + }else{ + sqlite_set_authorizer(pDb->db, 0, 0); + } +#endif + } + break; + } + + /* $db busy ?CALLBACK? + ** + ** Invoke the given callback if an SQL statement attempts to open + ** a locked database file. + */ + case DB_BUSY: { + if( objc>3 ){ + Tcl_WrongNumArgs(interp, 2, objv, "CALLBACK"); + return TCL_ERROR; + }else if( objc==2 ){ + if( pDb->zBusy ){ + Tcl_AppendResult(interp, pDb->zBusy, 0); + } + }else{ + char *zBusy; + int len; + if( pDb->zBusy ){ + Tcl_Free(pDb->zBusy); + } + zBusy = Tcl_GetStringFromObj(objv[2], &len); + if( zBusy && len>0 ){ + pDb->zBusy = Tcl_Alloc( len + 1 ); + strcpy(pDb->zBusy, zBusy); + }else{ + pDb->zBusy = 0; + } + if( pDb->zBusy ){ + pDb->interp = interp; + sqlite_busy_handler(pDb->db, DbBusyHandler, pDb); + }else{ + sqlite_busy_handler(pDb->db, 0, 0); + } + } + break; + } + + /* $db progress ?N CALLBACK? + ** + ** Invoke the given callback every N virtual machine opcodes while executing + ** queries. + */ + case DB_PROGRESS: { + if( objc==2 ){ + if( pDb->zProgress ){ + Tcl_AppendResult(interp, pDb->zProgress, 0); + } + }else if( objc==4 ){ + char *zProgress; + int len; + int N; + if( TCL_OK!=Tcl_GetIntFromObj(interp, objv[2], &N) ){ + return TCL_ERROR; + }; + if( pDb->zProgress ){ + Tcl_Free(pDb->zProgress); + } + zProgress = Tcl_GetStringFromObj(objv[3], &len); + if( zProgress && len>0 ){ + pDb->zProgress = Tcl_Alloc( len + 1 ); + strcpy(pDb->zProgress, zProgress); + }else{ + pDb->zProgress = 0; + } +#ifndef SQLITE_OMIT_PROGRESS_CALLBACK + if( pDb->zProgress ){ + pDb->interp = interp; + sqlite_progress_handler(pDb->db, N, DbProgressHandler, pDb); + }else{ + sqlite_progress_handler(pDb->db, 0, 0, 0); + } +#endif + }else{ + Tcl_WrongNumArgs(interp, 2, objv, "N CALLBACK"); + return TCL_ERROR; + } + break; + } + + /* + ** $db changes + ** + ** Return the number of rows that were modified, inserted, or deleted by + ** the most recent "eval". + */ + case DB_CHANGES: { + Tcl_Obj *pResult; + int nChange; + if( objc!=2 ){ + Tcl_WrongNumArgs(interp, 2, objv, ""); + return TCL_ERROR; + } + nChange = sqlite_changes(pDb->db); + pResult = Tcl_GetObjResult(interp); + Tcl_SetIntObj(pResult, nChange); + break; + } + + /* + ** $db last_statement_changes + ** + ** Return the number of rows that were modified, inserted, or deleted by + ** the last statment to complete execution (excluding changes due to + ** triggers) + */ + case DB_LAST_STATEMENT_CHANGES: { + Tcl_Obj *pResult; + int lsChange; + if( objc!=2 ){ + Tcl_WrongNumArgs(interp, 2, objv, ""); + return TCL_ERROR; + } + lsChange = sqlite_last_statement_changes(pDb->db); + pResult = Tcl_GetObjResult(interp); + Tcl_SetIntObj(pResult, lsChange); + break; + } + + /* $db close + ** + ** Shutdown the database + */ + case DB_CLOSE: { + Tcl_DeleteCommand(interp, Tcl_GetStringFromObj(objv[0], 0)); + break; + } + + /* $db commit_hook ?CALLBACK? + ** + ** Invoke the given callback just before committing every SQL transaction. + ** If the callback throws an exception or returns non-zero, then the + ** transaction is aborted. If CALLBACK is an empty string, the callback + ** is disabled. + */ + case DB_COMMIT_HOOK: { + if( objc>3 ){ + Tcl_WrongNumArgs(interp, 2, objv, "?CALLBACK?"); + }else if( objc==2 ){ + if( pDb->zCommit ){ + Tcl_AppendResult(interp, pDb->zCommit, 0); + } + }else{ + char *zCommit; + int len; + if( pDb->zCommit ){ + Tcl_Free(pDb->zCommit); + } + zCommit = Tcl_GetStringFromObj(objv[2], &len); + if( zCommit && len>0 ){ + pDb->zCommit = Tcl_Alloc( len + 1 ); + strcpy(pDb->zCommit, zCommit); + }else{ + pDb->zCommit = 0; + } + if( pDb->zCommit ){ + pDb->interp = interp; + sqlite_commit_hook(pDb->db, DbCommitHandler, pDb); + }else{ + sqlite_commit_hook(pDb->db, 0, 0); + } + } + break; + } + + /* $db complete SQL + ** + ** Return TRUE if SQL is a complete SQL statement. Return FALSE if + ** additional lines of input are needed. This is similar to the + ** built-in "info complete" command of Tcl. + */ + case DB_COMPLETE: { + Tcl_Obj *pResult; + int isComplete; + if( objc!=3 ){ + Tcl_WrongNumArgs(interp, 2, objv, "SQL"); + return TCL_ERROR; + } + isComplete = sqlite_complete( Tcl_GetStringFromObj(objv[2], 0) ); + pResult = Tcl_GetObjResult(interp); + Tcl_SetBooleanObj(pResult, isComplete); + break; + } + + /* + ** $db errorcode + ** + ** Return the numeric error code that was returned by the most recent + ** call to sqlite_exec(). + */ + case DB_ERRORCODE: { + Tcl_SetObjResult(interp, Tcl_NewIntObj(pDb->rc)); + break; + } + + /* + ** $db eval $sql ?array { ...code... }? + ** + ** The SQL statement in $sql is evaluated. For each row, the values are + ** placed in elements of the array named "array" and ...code... is executed. + ** If "array" and "code" are omitted, then no callback is every invoked. + ** If "array" is an empty string, then the values are placed in variables + ** that have the same name as the fields extracted by the query. + */ + case DB_EVAL: { + CallbackData cbData; + char *zErrMsg; + char *zSql; +#ifdef UTF_TRANSLATION_NEEDED + Tcl_DString dSql; + int i; +#endif + + if( objc!=5 && objc!=3 ){ + Tcl_WrongNumArgs(interp, 2, objv, "SQL ?ARRAY-NAME CODE?"); + return TCL_ERROR; + } + pDb->interp = interp; + zSql = Tcl_GetStringFromObj(objv[2], 0); +#ifdef UTF_TRANSLATION_NEEDED + Tcl_DStringInit(&dSql); + Tcl_UtfToExternalDString(NULL, zSql, -1, &dSql); + zSql = Tcl_DStringValue(&dSql); +#endif + Tcl_IncrRefCount(objv[2]); + if( objc==5 ){ + cbData.interp = interp; + cbData.once = 1; + cbData.zArray = Tcl_GetStringFromObj(objv[3], 0); + cbData.pCode = objv[4]; + cbData.tcl_rc = TCL_OK; + cbData.nColName = 0; + cbData.azColName = 0; + zErrMsg = 0; + Tcl_IncrRefCount(objv[3]); + Tcl_IncrRefCount(objv[4]); + rc = sqlite_exec(pDb->db, zSql, DbEvalCallback, &cbData, &zErrMsg); + Tcl_DecrRefCount(objv[4]); + Tcl_DecrRefCount(objv[3]); + if( cbData.tcl_rc==TCL_BREAK ){ cbData.tcl_rc = TCL_OK; } + }else{ + Tcl_Obj *pList = Tcl_NewObj(); + cbData.tcl_rc = TCL_OK; + rc = sqlite_exec(pDb->db, zSql, DbEvalCallback2, pList, &zErrMsg); + Tcl_SetObjResult(interp, pList); + } + pDb->rc = rc; + if( rc==SQLITE_ABORT ){ + if( zErrMsg ) free(zErrMsg); + rc = cbData.tcl_rc; + }else if( zErrMsg ){ + Tcl_SetResult(interp, zErrMsg, TCL_VOLATILE); + free(zErrMsg); + rc = TCL_ERROR; + }else if( rc!=SQLITE_OK ){ + Tcl_AppendResult(interp, sqlite_error_string(rc), 0); + rc = TCL_ERROR; + }else{ + } + Tcl_DecrRefCount(objv[2]); +#ifdef UTF_TRANSLATION_NEEDED + Tcl_DStringFree(&dSql); + if( objc==5 && cbData.azColName ){ + for(i=0; i<cbData.nColName; i++){ + if( cbData.azColName[i] ) free(cbData.azColName[i]); + } + free(cbData.azColName); + cbData.azColName = 0; + } +#endif + return rc; + } + + /* + ** $db function NAME SCRIPT + ** + ** Create a new SQL function called NAME. Whenever that function is + ** called, invoke SCRIPT to evaluate the function. + */ + case DB_FUNCTION: { + SqlFunc *pFunc; + char *zName; + char *zScript; + int nScript; + if( objc!=4 ){ + Tcl_WrongNumArgs(interp, 2, objv, "NAME SCRIPT"); + return TCL_ERROR; + } + zName = Tcl_GetStringFromObj(objv[2], 0); + zScript = Tcl_GetStringFromObj(objv[3], &nScript); + pFunc = (SqlFunc*)Tcl_Alloc( sizeof(*pFunc) + nScript + 1 ); + if( pFunc==0 ) return TCL_ERROR; + pFunc->interp = interp; + pFunc->pNext = pDb->pFunc; + pFunc->zScript = (char*)&pFunc[1]; + strcpy(pFunc->zScript, zScript); + sqlite_create_function(pDb->db, zName, -1, tclSqlFunc, pFunc); + sqlite_function_type(pDb->db, zName, SQLITE_NUMERIC); + break; + } + + /* + ** $db last_insert_rowid + ** + ** Return an integer which is the ROWID for the most recent insert. + */ + case DB_LAST_INSERT_ROWID: { + Tcl_Obj *pResult; + int rowid; + if( objc!=2 ){ + Tcl_WrongNumArgs(interp, 2, objv, ""); + return TCL_ERROR; + } + rowid = sqlite_last_insert_rowid(pDb->db); + pResult = Tcl_GetObjResult(interp); + Tcl_SetIntObj(pResult, rowid); + break; + } + + /* + ** $db onecolumn SQL + ** + ** Return a single column from a single row of the given SQL query. + */ + case DB_ONECOLUMN: { + char *zSql; + char *zErrMsg = 0; + if( objc!=3 ){ + Tcl_WrongNumArgs(interp, 2, objv, "SQL"); + return TCL_ERROR; + } + zSql = Tcl_GetStringFromObj(objv[2], 0); + rc = sqlite_exec(pDb->db, zSql, DbEvalCallback3, interp, &zErrMsg); + if( rc==SQLITE_ABORT ){ + rc = SQLITE_OK; + }else if( zErrMsg ){ + Tcl_SetResult(interp, zErrMsg, TCL_VOLATILE); + free(zErrMsg); + rc = TCL_ERROR; + }else if( rc!=SQLITE_OK ){ + Tcl_AppendResult(interp, sqlite_error_string(rc), 0); + rc = TCL_ERROR; + } + break; + } + + /* + ** $db rekey KEY + ** + ** Change the encryption key on the currently open database. + */ + case DB_REKEY: { + int nKey; + void *pKey; + if( objc!=3 ){ + Tcl_WrongNumArgs(interp, 2, objv, "KEY"); + return TCL_ERROR; + } + pKey = Tcl_GetByteArrayFromObj(objv[2], &nKey); +#ifdef SQLITE_HAS_CODEC + rc = sqlite_rekey(pDb->db, pKey, nKey); + if( rc ){ + Tcl_AppendResult(interp, sqlite_error_string(rc), 0); + rc = TCL_ERROR; + } +#endif + break; + } + + /* + ** $db timeout MILLESECONDS + ** + ** Delay for the number of milliseconds specified when a file is locked. + */ + case DB_TIMEOUT: { + int ms; + if( objc!=3 ){ + Tcl_WrongNumArgs(interp, 2, objv, "MILLISECONDS"); + return TCL_ERROR; + } + if( Tcl_GetIntFromObj(interp, objv[2], &ms) ) return TCL_ERROR; + sqlite_busy_timeout(pDb->db, ms); + break; + } + + /* $db trace ?CALLBACK? + ** + ** Make arrangements to invoke the CALLBACK routine for each SQL statement + ** that is executed. The text of the SQL is appended to CALLBACK before + ** it is executed. + */ + case DB_TRACE: { + if( objc>3 ){ + Tcl_WrongNumArgs(interp, 2, objv, "?CALLBACK?"); + }else if( objc==2 ){ + if( pDb->zTrace ){ + Tcl_AppendResult(interp, pDb->zTrace, 0); + } + }else{ + char *zTrace; + int len; + if( pDb->zTrace ){ + Tcl_Free(pDb->zTrace); + } + zTrace = Tcl_GetStringFromObj(objv[2], &len); + if( zTrace && len>0 ){ + pDb->zTrace = Tcl_Alloc( len + 1 ); + strcpy(pDb->zTrace, zTrace); + }else{ + pDb->zTrace = 0; + } + if( pDb->zTrace ){ + pDb->interp = interp; + sqlite_trace(pDb->db, DbTraceHandler, pDb); + }else{ + sqlite_trace(pDb->db, 0, 0); + } + } + break; + } + + } /* End of the SWITCH statement */ + return rc; +} + +/* +** sqlite DBNAME FILENAME ?MODE? ?-key KEY? +** +** This is the main Tcl command. When the "sqlite" Tcl command is +** invoked, this routine runs to process that command. +** +** The first argument, DBNAME, is an arbitrary name for a new +** database connection. This command creates a new command named +** DBNAME that is used to control that connection. The database +** connection is deleted when the DBNAME command is deleted. +** +** The second argument is the name of the directory that contains +** the sqlite database that is to be accessed. +** +** For testing purposes, we also support the following: +** +** sqlite -encoding +** +** Return the encoding used by LIKE and GLOB operators. Choices +** are UTF-8 and iso8859. +** +** sqlite -version +** +** Return the version number of the SQLite library. +** +** sqlite -tcl-uses-utf +** +** Return "1" if compiled with a Tcl uses UTF-8. Return "0" if +** not. Used by tests to make sure the library was compiled +** correctly. +*/ +static int DbMain(void *cd, Tcl_Interp *interp, int objc,Tcl_Obj *const*objv){ + int mode; + SqliteDb *p; + void *pKey = 0; + int nKey = 0; + const char *zArg; + char *zErrMsg; + const char *zFile; + char zBuf[80]; + if( objc==2 ){ + zArg = Tcl_GetStringFromObj(objv[1], 0); + if( strcmp(zArg,"-encoding")==0 ){ + Tcl_AppendResult(interp,sqlite_encoding,0); + return TCL_OK; + } + if( strcmp(zArg,"-version")==0 ){ + Tcl_AppendResult(interp,sqlite_version,0); + return TCL_OK; + } + if( strcmp(zArg,"-has-codec")==0 ){ +#ifdef SQLITE_HAS_CODEC + Tcl_AppendResult(interp,"1",0); +#else + Tcl_AppendResult(interp,"0",0); +#endif + return TCL_OK; + } + if( strcmp(zArg,"-tcl-uses-utf")==0 ){ +#ifdef TCL_UTF_MAX + Tcl_AppendResult(interp,"1",0); +#else + Tcl_AppendResult(interp,"0",0); +#endif + return TCL_OK; + } + } + if( objc==5 || objc==6 ){ + zArg = Tcl_GetStringFromObj(objv[objc-2], 0); + if( strcmp(zArg,"-key")==0 ){ + pKey = Tcl_GetByteArrayFromObj(objv[objc-1], &nKey); + objc -= 2; + } + } + if( objc!=3 && objc!=4 ){ + Tcl_WrongNumArgs(interp, 1, objv, +#ifdef SQLITE_HAS_CODEC + "HANDLE FILENAME ?-key CODEC-KEY?" +#else + "HANDLE FILENAME ?MODE?" +#endif + ); + return TCL_ERROR; + } + if( objc==3 ){ + mode = 0666; + }else if( Tcl_GetIntFromObj(interp, objv[3], &mode)!=TCL_OK ){ + return TCL_ERROR; + } + zErrMsg = 0; + p = (SqliteDb*)Tcl_Alloc( sizeof(*p) ); + if( p==0 ){ + Tcl_SetResult(interp, "malloc failed", TCL_STATIC); + return TCL_ERROR; + } + memset(p, 0, sizeof(*p)); + zFile = Tcl_GetStringFromObj(objv[2], 0); +#ifdef SQLITE_HAS_CODEC + p->db = sqlite_open_encrypted(zFile, pKey, nKey, 0, &zErrMsg); +#else + p->db = sqlite_open(zFile, mode, &zErrMsg); +#endif + if( p->db==0 ){ + Tcl_SetResult(interp, zErrMsg, TCL_VOLATILE); + Tcl_Free((char*)p); + free(zErrMsg); + return TCL_ERROR; + } + zArg = Tcl_GetStringFromObj(objv[1], 0); + Tcl_CreateObjCommand(interp, zArg, DbObjCmd, (char*)p, DbDeleteCmd); + + /* The return value is the value of the sqlite* pointer + */ + sprintf(zBuf, "%p", p->db); + if( strncmp(zBuf,"0x",2) ){ + sprintf(zBuf, "0x%p", p->db); + } + Tcl_AppendResult(interp, zBuf, 0); + + /* If compiled with SQLITE_TEST turned on, then register the "md5sum" + ** SQL function. + */ +#ifdef SQLITE_TEST + { + extern void Md5_Register(sqlite*); + Md5_Register(p->db); + } +#endif + return TCL_OK; +} + +/* +** Provide a dummy Tcl_InitStubs if we are using this as a static +** library. +*/ +#ifndef USE_TCL_STUBS +# undef Tcl_InitStubs +# define Tcl_InitStubs(a,b,c) +#endif + +/* +** Initialize this module. +** +** This Tcl module contains only a single new Tcl command named "sqlite". +** (Hence there is no namespace. There is no point in using a namespace +** if the extension only supplies one new name!) The "sqlite" command is +** used to open a new SQLite database. See the DbMain() routine above +** for additional information. +*/ +int Sqlite_Init(Tcl_Interp *interp){ + Tcl_InitStubs(interp, "8.0", 0); + Tcl_CreateObjCommand(interp, "sqlite", (Tcl_ObjCmdProc*)DbMain, 0, 0); + Tcl_PkgProvide(interp, "sqlite", "2.0"); + return TCL_OK; +} +int Tclsqlite_Init(Tcl_Interp *interp){ + Tcl_InitStubs(interp, "8.0", 0); + Tcl_CreateObjCommand(interp, "sqlite", (Tcl_ObjCmdProc*)DbMain, 0, 0); + Tcl_PkgProvide(interp, "sqlite", "2.0"); + return TCL_OK; +} +int Sqlite_SafeInit(Tcl_Interp *interp){ + return TCL_OK; +} +int Tclsqlite_SafeInit(Tcl_Interp *interp){ + return TCL_OK; +} + +#if 0 +/* +** If compiled using mktclapp, this routine runs to initialize +** everything. +*/ +int Et_AppInit(Tcl_Interp *interp){ + return Sqlite_Init(interp); +} +#endif +/*************************************************************************** +** The remaining code is only included if the TCLSH macro is defined to +** be an integer greater than 0 +*/ +#if defined(TCLSH) && TCLSH>0 + +/* +** If the macro TCLSH is defined and is one, then put in code for the +** "main" routine that implement a interactive shell into which the user +** can type TCL commands. +*/ +#if TCLSH==1 +static char zMainloop[] = + "set line {}\n" + "while {![eof stdin]} {\n" + "if {$line!=\"\"} {\n" + "puts -nonewline \"> \"\n" + "} else {\n" + "puts -nonewline \"% \"\n" + "}\n" + "flush stdout\n" + "append line [gets stdin]\n" + "if {[info complete $line]} {\n" + "if {[catch {uplevel #0 $line} result]} {\n" + "puts stderr \"Error: $result\"\n" + "} elseif {$result!=\"\"} {\n" + "puts $result\n" + "}\n" + "set line {}\n" + "} else {\n" + "append line \\n\n" + "}\n" + "}\n" +; +#endif /* TCLSH==1 */ + +int Libsqlite_Init( Tcl_Interp *interp) { +#ifdef TCL_THREADS + if (Thread_Init(interp) == TCL_ERROR) { + return TCL_ERROR; + } +#endif + Sqlite_Init(interp); +#ifdef SQLITE_TEST + { + extern int Sqlitetest1_Init(Tcl_Interp*); + extern int Sqlitetest2_Init(Tcl_Interp*); + extern int Sqlitetest3_Init(Tcl_Interp*); + extern int Md5_Init(Tcl_Interp*); + Sqlitetest1_Init(interp); + Sqlitetest2_Init(interp); + Sqlitetest3_Init(interp); + Md5_Init(interp); + Tcl_StaticPackage(interp, "sqlite", Libsqlite_Init, Libsqlite_Init); + } +#endif + return TCL_OK; +} + +#define TCLSH_MAIN main /* Needed to fake out mktclapp */ +#if TCLSH==1 +int TCLSH_MAIN(int argc, char **argv){ +#ifndef TCL_THREADS + Tcl_Interp *interp; + Tcl_FindExecutable(argv[0]); + interp = Tcl_CreateInterp(); + Libsqlite_Init(interp); + if( argc>=2 ){ + int i; + Tcl_SetVar(interp,"argv0",argv[1],TCL_GLOBAL_ONLY); + Tcl_SetVar(interp,"argv", "", TCL_GLOBAL_ONLY); + for(i=2; i<argc; i++){ + Tcl_SetVar(interp, "argv", argv[i], + TCL_GLOBAL_ONLY | TCL_LIST_ELEMENT | TCL_APPEND_VALUE); + } + if( Tcl_EvalFile(interp, argv[1])!=TCL_OK ){ + const char *zInfo = Tcl_GetVar(interp, "errorInfo", TCL_GLOBAL_ONLY); + if( zInfo==0 ) zInfo = interp->result; + fprintf(stderr,"%s: %s\n", *argv, zInfo); + return TCL_ERROR; + } + }else{ + Tcl_GlobalEval(interp, zMainloop); + } + return 0; +#else + Tcl_Main(argc, argv, Libsqlite_Init); +#endif /* TCL_THREADS */ + return 0; +} +#endif /* TCLSH==1 */ + + +/* +** If the macro TCLSH is set to 2, then implement a space analysis tool. +*/ +#if TCLSH==2 +static char zAnalysis[] = +#include "spaceanal_tcl.h" +; + +int main(int argc, char **argv){ + Tcl_Interp *interp; + int i; + Tcl_FindExecutable(argv[0]); + interp = Tcl_CreateInterp(); + Libsqlite_Init(interp); + Tcl_SetVar(interp,"argv0",argv[0],TCL_GLOBAL_ONLY); + Tcl_SetVar(interp,"argv", "", TCL_GLOBAL_ONLY); + for(i=1; i<argc; i++){ + Tcl_SetVar(interp, "argv", argv[i], + TCL_GLOBAL_ONLY | TCL_LIST_ELEMENT | TCL_APPEND_VALUE); + } + if( Tcl_GlobalEval(interp, zAnalysis)!=TCL_OK ){ + const char *zInfo = Tcl_GetVar(interp, "errorInfo", TCL_GLOBAL_ONLY); + if( zInfo==0 ) zInfo = interp->result; + fprintf(stderr,"%s: %s\n", *argv, zInfo); + return TCL_ERROR; + } + return 0; +} +#endif /* TCLSH==2 */ + +#endif /* TCLSH */ + +#endif /* NO_TCL */ diff --git a/kexi/3rdparty/kexisql/src/threadtest.c b/kexi/3rdparty/kexisql/src/threadtest.c new file mode 100644 index 00000000..89c79a4c --- /dev/null +++ b/kexi/3rdparty/kexisql/src/threadtest.c @@ -0,0 +1,279 @@ +/* +** 2002 January 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 implements a simple standalone program used to test whether +** or not the SQLite library is threadsafe. +** +** Testing the thread safety of SQLite is difficult because there are very +** few places in the code that are even potentially unsafe, and those +** places execute for very short periods of time. So even if the library +** is compiled with its mutexes disabled, it is likely to work correctly +** in a multi-threaded program most of the time. +*/ +#include "sqlite.h" +#include <pthread.h> +#include <sched.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> + +/* +** Enable for tracing +*/ +static int verbose = 0; + +/* +** Come here to die. +*/ +static void Exit(int rc){ + exit(rc); +} + +extern char *sqlite_mprintf(const char *zFormat, ...); +extern char *sqlite_vmprintf(const char *zFormat, va_list); + +/* +** When a lock occurs, yield. +*/ +static int db_is_locked(void *NotUsed, const char *zNotUsed, int iNotUsed){ + /* sched_yield(); */ + if( verbose ) printf("BUSY %s\n", (char*)NotUsed); + usleep(100); + return 1; +} + +/* +** Used to accumulate query results by db_query() +*/ +struct QueryResult { + const char *zFile; /* Filename - used for error reporting */ + int nElem; /* Number of used entries in azElem[] */ + int nAlloc; /* Number of slots allocated for azElem[] */ + char **azElem; /* The result of the query */ +}; + +/* +** The callback function for db_query +*/ +static int db_query_callback( + void *pUser, /* Pointer to the QueryResult structure */ + int nArg, /* Number of columns in this result row */ + char **azArg, /* Text of data in all columns */ + char **NotUsed /* Names of the columns */ +){ + struct QueryResult *pResult = (struct QueryResult*)pUser; + int i; + if( pResult->nElem + nArg >= pResult->nAlloc ){ + if( pResult->nAlloc==0 ){ + pResult->nAlloc = nArg+1; + }else{ + pResult->nAlloc = pResult->nAlloc*2 + nArg + 1; + } + pResult->azElem = realloc( pResult->azElem, pResult->nAlloc*sizeof(char*)); + if( pResult->azElem==0 ){ + fprintf(stdout,"%s: malloc failed\n", pResult->zFile); + return 1; + } + } + if( azArg==0 ) return 0; + for(i=0; i<nArg; i++){ + pResult->azElem[pResult->nElem++] = + sqlite_mprintf("%s",azArg[i] ? azArg[i] : ""); + } + return 0; +} + +/* +** Execute a query against the database. NULL values are returned +** as an empty string. The list is terminated by a single NULL pointer. +*/ +char **db_query(sqlite *db, const char *zFile, const char *zFormat, ...){ + char *zSql; + int rc; + char *zErrMsg = 0; + va_list ap; + struct QueryResult sResult; + va_start(ap, zFormat); + zSql = sqlite_vmprintf(zFormat, ap); + va_end(ap); + memset(&sResult, 0, sizeof(sResult)); + sResult.zFile = zFile; + if( verbose ) printf("QUERY %s: %s\n", zFile, zSql); + rc = sqlite_exec(db, zSql, db_query_callback, &sResult, &zErrMsg); + if( rc==SQLITE_SCHEMA ){ + if( zErrMsg ) free(zErrMsg); + rc = sqlite_exec(db, zSql, db_query_callback, &sResult, &zErrMsg); + } + if( verbose ) printf("DONE %s %s\n", zFile, zSql); + if( zErrMsg ){ + fprintf(stdout,"%s: query failed: %s - %s\n", zFile, zSql, zErrMsg); + free(zErrMsg); + free(zSql); + Exit(1); + } + sqlite_freemem(zSql); + if( sResult.azElem==0 ){ + db_query_callback(&sResult, 0, 0, 0); + } + sResult.azElem[sResult.nElem] = 0; + return sResult.azElem; +} + +/* +** Execute an SQL statement. +*/ +void db_execute(sqlite *db, const char *zFile, const char *zFormat, ...){ + char *zSql; + int rc; + char *zErrMsg = 0; + va_list ap; + va_start(ap, zFormat); + zSql = sqlite_vmprintf(zFormat, ap); + va_end(ap); + if( verbose ) printf("EXEC %s: %s\n", zFile, zSql); + rc = sqlite_exec(db, zSql, 0, 0, &zErrMsg); + if( rc==SQLITE_SCHEMA ){ + if( zErrMsg ) free(zErrMsg); + rc = sqlite_exec(db, zSql, 0, 0, &zErrMsg); + } + if( verbose ) printf("DONE %s: %s\n", zFile, zSql); + if( zErrMsg ){ + fprintf(stdout,"%s: command failed: %s - %s\n", zFile, zSql, zErrMsg); + free(zErrMsg); + sqlite_freemem(zSql); + Exit(1); + } + sqlite_freemem(zSql); +} + +/* +** Free the results of a db_query() call. +*/ +void db_query_free(char **az){ + int i; + for(i=0; az[i]; i++){ + sqlite_freemem(az[i]); + } + free(az); +} + +/* +** Check results +*/ +void db_check(const char *zFile, const char *zMsg, char **az, ...){ + va_list ap; + int i; + char *z; + va_start(ap, az); + for(i=0; (z = va_arg(ap, char*))!=0; i++){ + if( az[i]==0 || strcmp(az[i],z)!=0 ){ + fprintf(stdout,"%s: %s: bad result in column %d: %s\n", + zFile, zMsg, i+1, az[i]); + db_query_free(az); + Exit(1); + } + } + va_end(ap); + db_query_free(az); +} + +pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER; +pthread_cond_t sig = PTHREAD_COND_INITIALIZER; +int thread_cnt = 0; + +static void *worker_bee(void *pArg){ + const char *zFilename = (char*)pArg; + char *azErr; + int i, cnt; + int t = atoi(zFilename); + char **az; + sqlite *db; + + pthread_mutex_lock(&lock); + thread_cnt++; + pthread_mutex_unlock(&lock); + printf("%s: START\n", zFilename); + fflush(stdout); + for(cnt=0; cnt<10; cnt++){ + db = sqlite_open(&zFilename[2], 0, &azErr); + if( db==0 ){ + fprintf(stdout,"%s: can't open\n", zFilename); + Exit(1); + } + sqlite_busy_handler(db, db_is_locked, zFilename); + db_execute(db, zFilename, "CREATE TABLE t%d(a,b,c);", t); + for(i=1; i<=100; i++){ + db_execute(db, zFilename, "INSERT INTO t%d VALUES(%d,%d,%d);", + t, i, i*2, i*i); + } + az = db_query(db, zFilename, "SELECT count(*) FROM t%d", t); + db_check(zFilename, "tX size", az, "100", 0); + az = db_query(db, zFilename, "SELECT avg(b) FROM t%d", t); + db_check(zFilename, "tX avg", az, "101", 0); + db_execute(db, zFilename, "DELETE FROM t%d WHERE a>50", t); + az = db_query(db, zFilename, "SELECT avg(b) FROM t%d", t); + db_check(zFilename, "tX avg2", az, "51", 0); + for(i=1; i<=50; i++){ + char z1[30], z2[30]; + az = db_query(db, zFilename, "SELECT b, c FROM t%d WHERE a=%d", t, i); + sprintf(z1, "%d", i*2); + sprintf(z2, "%d", i*i); + db_check(zFilename, "readback", az, z1, z2, 0); + } + db_execute(db, zFilename, "DROP TABLE t%d;", t); + sqlite_close(db); + } + printf("%s: END\n", zFilename); + /* unlink(zFilename); */ + fflush(stdout); + pthread_mutex_lock(&lock); + thread_cnt--; + if( thread_cnt<=0 ){ + pthread_cond_signal(&sig); + } + pthread_mutex_unlock(&lock); + return 0; +} + +int main(int argc, char **argv){ + char *zFile; + int i, n; + pthread_t id; + if( argc>2 && strcmp(argv[1], "-v")==0 ){ + verbose = 1; + argc--; + argv++; + } + if( argc<2 || (n=atoi(argv[1]))<1 ) n = 10; + for(i=0; i<n; i++){ + char zBuf[200]; + sprintf(zBuf, "testdb-%d", (i+1)/2); + unlink(zBuf); + } + for(i=0; i<n; i++){ + zFile = sqlite_mprintf("%d.testdb-%d", i%2+1, (i+2)/2); + unlink(zFile); + pthread_create(&id, 0, worker_bee, (void*)zFile); + pthread_detach(id); + } + pthread_mutex_lock(&lock); + while( thread_cnt>0 ){ + pthread_cond_wait(&sig, &lock); + } + pthread_mutex_unlock(&lock); + for(i=0; i<n; i++){ + char zBuf[200]; + sprintf(zBuf, "testdb-%d", (i+1)/2); + unlink(zBuf); + } + return 0; +} diff --git a/kexi/3rdparty/kexisql/src/tokenize.c b/kexi/3rdparty/kexisql/src/tokenize.c new file mode 100644 index 00000000..68cb9f99 --- /dev/null +++ b/kexi/3rdparty/kexisql/src/tokenize.c @@ -0,0 +1,679 @@ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** An tokenizer for SQL +** +** This file contains C code that splits an SQL input string up into +** individual tokens and sends those tokens one-by-one over to the +** parser for analysis. +** +** $Id: tokenize.c 410099 2005-05-06 17:52:07Z staniek $ +*/ +#include "sqliteInt.h" +#include "os.h" +#include <ctype.h> +#include <stdlib.h> + +/* +** All the keywords of the SQL language are stored as in a hash +** table composed of instances of the following structure. +*/ +typedef struct Keyword Keyword; +struct Keyword { + char *zName; /* The keyword name */ + u8 tokenType; /* Token value for this keyword */ + u8 len; /* Length of this keyword */ + u8 iNext; /* Index in aKeywordTable[] of next with same hash */ +}; + +/* +** These are the keywords +*/ +static Keyword aKeywordTable[] = { + { "ABORT", TK_ABORT, }, + { "AFTER", TK_AFTER, }, + { "ALL", TK_ALL, }, + { "AND", TK_AND, }, + { "AS", TK_AS, }, + { "ASC", TK_ASC, }, + { "ATTACH", TK_ATTACH, }, + { "BEFORE", TK_BEFORE, }, + { "BEGIN", TK_BEGIN, }, + { "BETWEEN", TK_BETWEEN, }, + { "BY", TK_BY, }, + { "CASCADE", TK_CASCADE, }, + { "CASE", TK_CASE, }, + { "CHECK", TK_CHECK, }, + { "CLUSTER", TK_CLUSTER, }, + { "COLLATE", TK_COLLATE, }, + { "COMMIT", TK_COMMIT, }, + { "CONFLICT", TK_CONFLICT, }, + { "CONSTRAINT", TK_CONSTRAINT, }, + { "COPY", TK_COPY, }, + { "CREATE", TK_CREATE, }, + { "CROSS", TK_JOIN_KW, }, + { "DATABASE", TK_DATABASE, }, + { "DEFAULT", TK_DEFAULT, }, + { "DEFERRED", TK_DEFERRED, }, + { "DEFERRABLE", TK_DEFERRABLE, }, + { "DELETE", TK_DELETE, }, + { "DELIMITERS", TK_DELIMITERS, }, + { "DESC", TK_DESC, }, + { "DETACH", TK_DETACH, }, + { "DISTINCT", TK_DISTINCT, }, + { "DROP", TK_DROP, }, + { "END", TK_END, }, + { "EACH", TK_EACH, }, + { "ELSE", TK_ELSE, }, + { "EXCEPT", TK_EXCEPT, }, + { "EXPLAIN", TK_EXPLAIN, }, + { "FAIL", TK_FAIL, }, + { "FOR", TK_FOR, }, + { "FOREIGN", TK_FOREIGN, }, + { "FROM", TK_FROM, }, + { "FULL", TK_JOIN_KW, }, + { "GLOB", TK_GLOB, }, + { "GROUP", TK_GROUP, }, + { "HAVING", TK_HAVING, }, + { "IGNORE", TK_IGNORE, }, + { "IMMEDIATE", TK_IMMEDIATE, }, + { "IN", TK_IN, }, + { "INDEX", TK_INDEX, }, + { "INITIALLY", TK_INITIALLY, }, + { "INNER", TK_JOIN_KW, }, + { "INSERT", TK_INSERT, }, + { "INSTEAD", TK_INSTEAD, }, + { "INTERSECT", TK_INTERSECT, }, + { "INTO", TK_INTO, }, + { "IS", TK_IS, }, + { "ISNULL", TK_ISNULL, }, + { "JOIN", TK_JOIN, }, + { "KEY", TK_KEY, }, + { "LEFT", TK_JOIN_KW, }, + { "LIKE", TK_LIKE, }, + { "LIMIT", TK_LIMIT, }, + { "MATCH", TK_MATCH, }, + { "NATURAL", TK_JOIN_KW, }, + { "NOT", TK_NOT, }, + { "NOTNULL", TK_NOTNULL, }, + { "NULL", TK_NULL, }, + { "OF", TK_OF, }, + { "OFFSET", TK_OFFSET, }, + { "ON", TK_ON, }, + { "OR", TK_OR, }, + { "ORDER", TK_ORDER, }, + { "OUTER", TK_JOIN_KW, }, + { "PRAGMA", TK_PRAGMA, }, + { "PRIMARY", TK_PRIMARY, }, + { "RAISE", TK_RAISE, }, + { "REFERENCES", TK_REFERENCES, }, + { "REPLACE", TK_REPLACE, }, + { "RESTRICT", TK_RESTRICT, }, + { "RIGHT", TK_JOIN_KW, }, + { "ROLLBACK", TK_ROLLBACK, }, + { "ROW", TK_ROW, }, + { "SELECT", TK_SELECT, }, + { "SET", TK_SET, }, + { "STATEMENT", TK_STATEMENT, }, + { "TABLE", TK_TABLE, }, + { "TEMP", TK_TEMP, }, + { "TEMPORARY", TK_TEMP, }, + { "THEN", TK_THEN, }, + { "TRANSACTION", TK_TRANSACTION, }, + { "TRIGGER", TK_TRIGGER, }, + { "UNION", TK_UNION, }, + { "UNIQUE", TK_UNIQUE, }, + { "UPDATE", TK_UPDATE, }, + { "USING", TK_USING, }, + { "VACUUM", TK_VACUUM, }, + { "VALUES", TK_VALUES, }, + { "VIEW", TK_VIEW, }, + { "WHEN", TK_WHEN, }, + { "WHERE", TK_WHERE, }, +}; + +/* +** This is the hash table +*/ +#define KEY_HASH_SIZE 101 +static u8 aiHashTable[KEY_HASH_SIZE]; + + +/* +** This function looks up an identifier to determine if it is a +** keyword. If it is a keyword, the token code of that keyword is +** returned. If the input is not a keyword, TK_ID is returned. +*/ +int sqliteKeywordCode(const char *z, int n){ + int h, i; + Keyword *p; + static char needInit = 1; + if( needInit ){ + /* Initialize the keyword hash table */ + sqliteOsEnterMutex(); + if( needInit ){ + int nk; + nk = sizeof(aKeywordTable)/sizeof(aKeywordTable[0]); + for(i=0; i<nk; i++){ + aKeywordTable[i].len = strlen(aKeywordTable[i].zName); + h = sqliteHashNoCase(aKeywordTable[i].zName, aKeywordTable[i].len); + h %= KEY_HASH_SIZE; + aKeywordTable[i].iNext = aiHashTable[h]; + aiHashTable[h] = i+1; + } + needInit = 0; + } + sqliteOsLeaveMutex(); + } + h = sqliteHashNoCase(z, n) % KEY_HASH_SIZE; + for(i=aiHashTable[h]; i; i=p->iNext){ + p = &aKeywordTable[i-1]; + if( p->len==n && sqliteStrNICmp(p->zName, z, n)==0 ){ + return p->tokenType; + } + } + return TK_ID; +} + + +/* +** If X is a character that can be used in an identifier and +** X&0x80==0 then isIdChar[X] will be 1. If X&0x80==0x80 then +** X is always an identifier character. (Hence all UTF-8 +** characters can be part of an identifier). isIdChar[X] will +** be 0 for every character in the lower 128 ASCII characters +** that cannot be used as part of an identifier. +** +** In this implementation, an identifier can be a string of +** alphabetic characters, digits, and "_" plus any character +** with the high-order bit set. The latter rule means that +** any sequence of UTF-8 characters or characters taken from +** an extended ISO8859 character set can form an identifier. +*/ +static const char isIdChar[] = { +/* x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xA xB xC xD xE xF */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 1x */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 2x */ + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, /* 3x */ + 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 4x */ + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, /* 5x */ + 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 6x */ + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, /* 7x */ +}; + + +/* +** Return the length of the token that begins at z[0]. +** Store the token type in *tokenType before returning. +*/ +static int sqliteGetToken(const unsigned char *z, int *tokenType){ + int i; + switch( *z ){ + case ' ': case '\t': case '\n': case '\f': case '\r': { + for(i=1; isspace(z[i]); i++){} + *tokenType = TK_SPACE; + return i; + } + case '-': { + if( z[1]=='-' ){ + for(i=2; z[i] && z[i]!='\n'; i++){} + *tokenType = TK_COMMENT; + return i; + } + *tokenType = TK_MINUS; + return 1; + } + case '(': { + *tokenType = TK_LP; + return 1; + } + case ')': { + *tokenType = TK_RP; + return 1; + } + case ';': { + *tokenType = TK_SEMI; + return 1; + } + case '+': { + *tokenType = TK_PLUS; + return 1; + } + case '*': { + *tokenType = TK_STAR; + return 1; + } + case '/': { + if( z[1]!='*' || z[2]==0 ){ + *tokenType = TK_SLASH; + return 1; + } + for(i=3; z[i] && (z[i]!='/' || z[i-1]!='*'); i++){} + if( z[i] ) i++; + *tokenType = TK_COMMENT; + return i; + } + case '%': { + *tokenType = TK_REM; + return 1; + } + case '=': { + *tokenType = TK_EQ; + return 1 + (z[1]=='='); + } + case '<': { + if( z[1]=='=' ){ + *tokenType = TK_LE; + return 2; + }else if( z[1]=='>' ){ + *tokenType = TK_NE; + return 2; + }else if( z[1]=='<' ){ + *tokenType = TK_LSHIFT; + return 2; + }else{ + *tokenType = TK_LT; + return 1; + } + } + case '>': { + if( z[1]=='=' ){ + *tokenType = TK_GE; + return 2; + }else if( z[1]=='>' ){ + *tokenType = TK_RSHIFT; + return 2; + }else{ + *tokenType = TK_GT; + return 1; + } + } + case '!': { + if( z[1]!='=' ){ + *tokenType = TK_ILLEGAL; + return 2; + }else{ + *tokenType = TK_NE; + return 2; + } + } + case '|': { + if( z[1]!='|' ){ + *tokenType = TK_BITOR; + return 1; + }else{ + *tokenType = TK_CONCAT; + return 2; + } + } + case ',': { + *tokenType = TK_COMMA; + return 1; + } + case '&': { + *tokenType = TK_BITAND; + return 1; + } + case '~': { + *tokenType = TK_BITNOT; + return 1; + } + case '\'': case '"': { + int delim = z[0]; + for(i=1; z[i]; i++){ + if( z[i]==delim ){ + if( z[i+1]==delim ){ + i++; + }else{ + break; + } + } + } + if( z[i] ) i++; + *tokenType = TK_STRING; + return i; + } + case '.': { + *tokenType = TK_DOT; + return 1; + } + case '0': case '1': case '2': case '3': case '4': + case '5': case '6': case '7': case '8': case '9': { + *tokenType = TK_INTEGER; + for(i=1; isdigit(z[i]); i++){} + if( z[i]=='.' && isdigit(z[i+1]) ){ + i += 2; + while( isdigit(z[i]) ){ i++; } + *tokenType = TK_FLOAT; + } + if( (z[i]=='e' || z[i]=='E') && + ( isdigit(z[i+1]) + || ((z[i+1]=='+' || z[i+1]=='-') && isdigit(z[i+2])) + ) + ){ + i += 2; + while( isdigit(z[i]) ){ i++; } + *tokenType = TK_FLOAT; + } + return i; + } + case '[': { + for(i=1; z[i] && z[i-1]!=']'; i++){} + *tokenType = TK_ID; + return i; + } + case '?': { + *tokenType = TK_VARIABLE; + return 1; + } + default: { + if( (*z&0x80)==0 && !isIdChar[*z] ){ + break; + } + for(i=1; (z[i]&0x80)!=0 || isIdChar[z[i]]; i++){} + *tokenType = sqliteKeywordCode((char*)z, i); + return i; + } + } + *tokenType = TK_ILLEGAL; + return 1; +} + +/* +** Run the parser on the given SQL string. The parser structure is +** passed in. An SQLITE_ status code is returned. If an error occurs +** and pzErrMsg!=NULL then an error message might be written into +** memory obtained from malloc() and *pzErrMsg made to point to that +** error message. Or maybe not. +*/ +int sqliteRunParser(Parse *pParse, const char *zSql, char **pzErrMsg){ + int nErr = 0; + int i; + void *pEngine; + int tokenType; + int lastTokenParsed = -1; + sqlite *db = pParse->db; + extern void *sqliteParserAlloc(void*(*)(int)); + extern void sqliteParserFree(void*, void(*)(void*)); + extern int sqliteParser(void*, int, Token, Parse*); + + db->flags &= ~SQLITE_Interrupt; + pParse->rc = SQLITE_OK; + i = 0; + pEngine = sqliteParserAlloc((void*(*)(int))malloc); + if( pEngine==0 ){ + sqliteSetString(pzErrMsg, "out of memory", (char*)0); + return 1; + } + pParse->sLastToken.dyn = 0; + pParse->zTail = zSql; + while( sqlite_malloc_failed==0 && zSql[i]!=0 ){ + assert( i>=0 ); + pParse->sLastToken.z = &zSql[i]; + assert( pParse->sLastToken.dyn==0 ); + pParse->sLastToken.n = sqliteGetToken((unsigned char*)&zSql[i], &tokenType); + i += pParse->sLastToken.n; + switch( tokenType ){ + case TK_SPACE: + case TK_COMMENT: { + if( (db->flags & SQLITE_Interrupt)!=0 ){ + pParse->rc = SQLITE_INTERRUPT; + sqliteSetString(pzErrMsg, "interrupt", (char*)0); + goto abort_parse; + } + break; + } + case TK_ILLEGAL: { + sqliteSetNString(pzErrMsg, "unrecognized token: \"", -1, + pParse->sLastToken.z, pParse->sLastToken.n, "\"", 1, 0); + nErr++; + goto abort_parse; + } + case TK_SEMI: { + pParse->zTail = &zSql[i]; + /* Fall thru into the default case */ + } + default: { + sqliteParser(pEngine, tokenType, pParse->sLastToken, pParse); + lastTokenParsed = tokenType; + if( pParse->rc!=SQLITE_OK ){ + goto abort_parse; + } + break; + } + } + } +abort_parse: + if( zSql[i]==0 && nErr==0 && pParse->rc==SQLITE_OK ){ + if( lastTokenParsed!=TK_SEMI ){ + sqliteParser(pEngine, TK_SEMI, pParse->sLastToken, pParse); + pParse->zTail = &zSql[i]; + } + sqliteParser(pEngine, 0, pParse->sLastToken, pParse); + } + sqliteParserFree(pEngine, free); + if( pParse->rc!=SQLITE_OK && pParse->rc!=SQLITE_DONE && pParse->zErrMsg==0 ){ + sqliteSetString(&pParse->zErrMsg, sqlite_error_string(pParse->rc), + (char*)0); + } + if( pParse->zErrMsg ){ + if( pzErrMsg && *pzErrMsg==0 ){ + *pzErrMsg = pParse->zErrMsg; + }else{ + sqliteFree(pParse->zErrMsg); + } + pParse->zErrMsg = 0; + if( !nErr ) nErr++; + } + if( pParse->pVdbe && pParse->nErr>0 ){ + sqliteVdbeDelete(pParse->pVdbe); + pParse->pVdbe = 0; + } + if( pParse->pNewTable ){ + sqliteDeleteTable(pParse->db, pParse->pNewTable); + pParse->pNewTable = 0; + } + if( pParse->pNewTrigger ){ + sqliteDeleteTrigger(pParse->pNewTrigger); + pParse->pNewTrigger = 0; + } + if( nErr>0 && (pParse->rc==SQLITE_OK || pParse->rc==SQLITE_DONE) ){ + pParse->rc = SQLITE_ERROR; + } + return nErr; +} + +/* +** Token types used by the sqlite_complete() routine. See the header +** comments on that procedure for additional information. +*/ +#define tkEXPLAIN 0 +#define tkCREATE 1 +#define tkTEMP 2 +#define tkTRIGGER 3 +#define tkEND 4 +#define tkSEMI 5 +#define tkWS 6 +#define tkOTHER 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) EXPLAIN The keyword EXPLAIN has been seen at the beginning of +** a statement. +** +** (2) CREATE The keyword CREATE has been seen at the beginning of a +** statement, possibly preceeded by EXPLAIN and/or followed by +** TEMP or TEMPORARY +** +** (3) NORMAL We are in the middle of statement which ends with a single +** semicolon. +** +** (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) tkEXPLAIN The "explain" keyword. +** (1) tkCREATE The "create" keyword. +** (2) tkTEMP The "temp" or "temporary" keyword. +** (3) tkTRIGGER The "trigger" keyword. +** (4) tkEND The "end" keyword. +** (5) tkSEMI A semicolon. +** (6) tkWS Whitespace +** (7) tkOTHER Any other SQL token. +** +** Whitespace never causes a state transition and is always ignored. +*/ +int sqlite_complete(const char *zSql){ + u8 state = 0; /* Current state, using numbers defined in header comment */ + u8 token; /* Value of the next token */ + + /* The following matrix defines the transition from one state to another + ** according to what token is seen. trans[state][token] returns the + ** next state. + */ + static const u8 trans[7][8] = { + /* Token: */ + /* State: ** EXPLAIN CREATE TEMP TRIGGER END SEMI WS OTHER */ + /* 0 START: */ { 1, 2, 3, 3, 3, 0, 0, 3, }, + /* 1 EXPLAIN: */ { 3, 2, 3, 3, 3, 0, 1, 3, }, + /* 2 CREATE: */ { 3, 3, 2, 4, 3, 0, 2, 3, }, + /* 3 NORMAL: */ { 3, 3, 3, 3, 3, 0, 3, 3, }, + /* 4 TRIGGER: */ { 4, 4, 4, 4, 4, 5, 4, 4, }, + /* 5 SEMI: */ { 4, 4, 4, 4, 6, 5, 5, 4, }, + /* 6 END: */ { 4, 4, 4, 4, 4, 0, 6, 4, }, + }; + + 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 '"': /* single- and double-quoted strings */ + case '\'': { + int c = *zSql; + zSql++; + while( *zSql && *zSql!=c ){ zSql++; } + if( *zSql==0 ) return 0; + token = tkOTHER; + break; + } + default: { + if( isIdChar[(u8)*zSql] ){ + /* Keywords and unquoted identifiers */ + int nId; + for(nId=1; isIdChar[(u8)zSql[nId]]; nId++){} + switch( *zSql ){ + case 'c': case 'C': { + if( nId==6 && sqliteStrNICmp(zSql, "create", 6)==0 ){ + token = tkCREATE; + }else{ + token = tkOTHER; + } + break; + } + case 't': case 'T': { + if( nId==7 && sqliteStrNICmp(zSql, "trigger", 7)==0 ){ + token = tkTRIGGER; + }else if( nId==4 && sqliteStrNICmp(zSql, "temp", 4)==0 ){ + token = tkTEMP; + }else if( nId==9 && sqliteStrNICmp(zSql, "temporary", 9)==0 ){ + token = tkTEMP; + }else{ + token = tkOTHER; + } + break; + } + case 'e': case 'E': { + if( nId==3 && sqliteStrNICmp(zSql, "end", 3)==0 ){ + token = tkEND; + }else if( nId==7 && sqliteStrNICmp(zSql, "explain", 7)==0 ){ + token = tkEXPLAIN; + }else{ + token = tkOTHER; + } + break; + } + default: { + token = tkOTHER; + break; + } + } + zSql += nId-1; + }else{ + /* Operators and special symbols */ + token = tkOTHER; + } + break; + } + } + state = trans[state][token]; + zSql++; + } + return state==0; +} diff --git a/kexi/3rdparty/kexisql/src/trigger.c b/kexi/3rdparty/kexisql/src/trigger.c new file mode 100644 index 00000000..8442bb5d --- /dev/null +++ b/kexi/3rdparty/kexisql/src/trigger.c @@ -0,0 +1,764 @@ +/* +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +* +*/ +#include "sqliteInt.h" + +/* +** Delete a linked list of TriggerStep structures. +*/ +void sqliteDeleteTriggerStep(TriggerStep *pTriggerStep){ + while( pTriggerStep ){ + TriggerStep * pTmp = pTriggerStep; + pTriggerStep = pTriggerStep->pNext; + + if( pTmp->target.dyn ) sqliteFree((char*)pTmp->target.z); + sqliteExprDelete(pTmp->pWhere); + sqliteExprListDelete(pTmp->pExprList); + sqliteSelectDelete(pTmp->pSelect); + sqliteIdListDelete(pTmp->pIdList); + + sqliteFree(pTmp); + } +} + +/* +** This is called by the parser when it sees a CREATE TRIGGER statement +** up to the point of the BEGIN before the trigger actions. A Trigger +** structure is generated based on the information available and stored +** in pParse->pNewTrigger. After the trigger actions have been parsed, the +** sqliteFinishTrigger() function is called to complete the trigger +** construction process. +*/ +void sqliteBeginTrigger( + Parse *pParse, /* The parse context of the CREATE TRIGGER statement */ + Token *pName, /* The name of the trigger */ + int tr_tm, /* One of TK_BEFORE, TK_AFTER, TK_INSTEAD */ + int op, /* One of TK_INSERT, TK_UPDATE, TK_DELETE */ + IdList *pColumns, /* column list if this is an UPDATE OF trigger */ + SrcList *pTableName,/* The name of the table/view the trigger applies to */ + int foreach, /* One of TK_ROW or TK_STATEMENT */ + Expr *pWhen, /* WHEN clause */ + int isTemp /* True if the TEMPORARY keyword is present */ +){ + Trigger *nt; + Table *tab; + char *zName = 0; /* Name of the trigger */ + sqlite *db = pParse->db; + int iDb; /* When database to store the trigger in */ + DbFixer sFix; + + /* Check that: + ** 1. the trigger name does not already exist. + ** 2. the table (or view) does exist in the same database as the trigger. + ** 3. that we are not trying to create a trigger on the sqlite_master table + ** 4. That we are not trying to create an INSTEAD OF trigger on a table. + ** 5. That we are not trying to create a BEFORE or AFTER trigger on a view. + */ + if( sqlite_malloc_failed ) goto trigger_cleanup; + assert( pTableName->nSrc==1 ); + if( db->init.busy + && sqliteFixInit(&sFix, pParse, db->init.iDb, "trigger", pName) + && sqliteFixSrcList(&sFix, pTableName) + ){ + goto trigger_cleanup; + } + tab = sqliteSrcListLookup(pParse, pTableName); + if( !tab ){ + goto trigger_cleanup; + } + iDb = isTemp ? 1 : tab->iDb; + if( iDb>=2 && !db->init.busy ){ + sqliteErrorMsg(pParse, "triggers may not be added to auxiliary " + "database %s", db->aDb[tab->iDb].zName); + goto trigger_cleanup; + } + + zName = sqliteStrNDup(pName->z, pName->n); + sqliteDequote(zName); + if( sqliteHashFind(&(db->aDb[iDb].trigHash), zName,pName->n+1) ){ + sqliteErrorMsg(pParse, "trigger %T already exists", pName); + goto trigger_cleanup; + } + if( sqliteStrNICmp(tab->zName, "sqlite_", 7)==0 ){ + sqliteErrorMsg(pParse, "cannot create trigger on system table"); + pParse->nErr++; + goto trigger_cleanup; + } + if( tab->pSelect && tr_tm != TK_INSTEAD ){ + sqliteErrorMsg(pParse, "cannot create %s trigger on view: %S", + (tr_tm == TK_BEFORE)?"BEFORE":"AFTER", pTableName, 0); + goto trigger_cleanup; + } + if( !tab->pSelect && tr_tm == TK_INSTEAD ){ + sqliteErrorMsg(pParse, "cannot create INSTEAD OF" + " trigger on table: %S", pTableName, 0); + goto trigger_cleanup; + } +#ifndef SQLITE_OMIT_AUTHORIZATION + { + int code = SQLITE_CREATE_TRIGGER; + const char *zDb = db->aDb[tab->iDb].zName; + const char *zDbTrig = isTemp ? db->aDb[1].zName : zDb; + if( tab->iDb==1 || isTemp ) code = SQLITE_CREATE_TEMP_TRIGGER; + if( sqliteAuthCheck(pParse, code, zName, tab->zName, zDbTrig) ){ + goto trigger_cleanup; + } + if( sqliteAuthCheck(pParse, SQLITE_INSERT, SCHEMA_TABLE(tab->iDb), 0, zDb)){ + goto trigger_cleanup; + } + } +#endif + + /* INSTEAD OF triggers can only appear on views and BEGIN triggers + ** cannot appear on views. So we might as well translate every + ** INSTEAD OF trigger into a BEFORE trigger. It simplifies code + ** elsewhere. + */ + if (tr_tm == TK_INSTEAD){ + tr_tm = TK_BEFORE; + } + + /* Build the Trigger object */ + nt = (Trigger*)sqliteMalloc(sizeof(Trigger)); + if( nt==0 ) goto trigger_cleanup; + nt->name = zName; + zName = 0; + nt->table = sqliteStrDup(pTableName->a[0].zName); + if( sqlite_malloc_failed ) goto trigger_cleanup; + nt->iDb = iDb; + nt->iTabDb = tab->iDb; + nt->op = op; + nt->tr_tm = tr_tm; + nt->pWhen = sqliteExprDup(pWhen); + nt->pColumns = sqliteIdListDup(pColumns); + nt->foreach = foreach; + sqliteTokenCopy(&nt->nameToken,pName); + assert( pParse->pNewTrigger==0 ); + pParse->pNewTrigger = nt; + +trigger_cleanup: + sqliteFree(zName); + sqliteSrcListDelete(pTableName); + sqliteIdListDelete(pColumns); + sqliteExprDelete(pWhen); +} + +/* +** This routine is called after all of the trigger actions have been parsed +** in order to complete the process of building the trigger. +*/ +void sqliteFinishTrigger( + Parse *pParse, /* Parser context */ + TriggerStep *pStepList, /* The triggered program */ + Token *pAll /* Token that describes the complete CREATE TRIGGER */ +){ + Trigger *nt = 0; /* The trigger whose construction is finishing up */ + sqlite *db = pParse->db; /* The database */ + DbFixer sFix; + + if( pParse->nErr || pParse->pNewTrigger==0 ) goto triggerfinish_cleanup; + nt = pParse->pNewTrigger; + pParse->pNewTrigger = 0; + nt->step_list = pStepList; + while( pStepList ){ + pStepList->pTrig = nt; + pStepList = pStepList->pNext; + } + if( sqliteFixInit(&sFix, pParse, nt->iDb, "trigger", &nt->nameToken) + && sqliteFixTriggerStep(&sFix, nt->step_list) ){ + goto triggerfinish_cleanup; + } + + /* if we are not initializing, and this trigger is not on a TEMP table, + ** build the sqlite_master entry + */ + if( !db->init.busy ){ + static VdbeOpList insertTrig[] = { + { OP_NewRecno, 0, 0, 0 }, + { OP_String, 0, 0, "trigger" }, + { OP_String, 0, 0, 0 }, /* 2: trigger name */ + { OP_String, 0, 0, 0 }, /* 3: table name */ + { OP_Integer, 0, 0, 0 }, + { OP_String, 0, 0, 0 }, /* 5: SQL */ + { OP_MakeRecord, 5, 0, 0 }, + { OP_PutIntKey, 0, 0, 0 }, + }; + int addr; + Vdbe *v; + + /* Make an entry in the sqlite_master table */ + v = sqliteGetVdbe(pParse); + if( v==0 ) goto triggerfinish_cleanup; + sqliteBeginWriteOperation(pParse, 0, 0); + sqliteOpenMasterTable(v, nt->iDb); + addr = sqliteVdbeAddOpList(v, ArraySize(insertTrig), insertTrig); + sqliteVdbeChangeP3(v, addr+2, nt->name, 0); + sqliteVdbeChangeP3(v, addr+3, nt->table, 0); + sqliteVdbeChangeP3(v, addr+5, pAll->z, pAll->n); + if( nt->iDb==0 ){ + sqliteChangeCookie(db, v); + } + sqliteVdbeAddOp(v, OP_Close, 0, 0); + sqliteEndWriteOperation(pParse); + } + + if( !pParse->explain ){ + Table *pTab; + sqliteHashInsert(&db->aDb[nt->iDb].trigHash, + nt->name, strlen(nt->name)+1, nt); + pTab = sqliteLocateTable(pParse, nt->table, db->aDb[nt->iTabDb].zName); + assert( pTab!=0 ); + nt->pNext = pTab->pTrigger; + pTab->pTrigger = nt; + nt = 0; + } + +triggerfinish_cleanup: + sqliteDeleteTrigger(nt); + sqliteDeleteTrigger(pParse->pNewTrigger); + pParse->pNewTrigger = 0; + sqliteDeleteTriggerStep(pStepList); +} + +/* +** Make a copy of all components of the given trigger step. This has +** the effect of copying all Expr.token.z values into memory obtained +** from sqliteMalloc(). As initially created, the Expr.token.z values +** all point to the input string that was fed to the parser. But that +** string is ephemeral - it will go away as soon as the sqlite_exec() +** call that started the parser exits. This routine makes a persistent +** copy of all the Expr.token.z strings so that the TriggerStep structure +** will be valid even after the sqlite_exec() call returns. +*/ +static void sqlitePersistTriggerStep(TriggerStep *p){ + if( p->target.z ){ + p->target.z = sqliteStrNDup(p->target.z, p->target.n); + p->target.dyn = 1; + } + if( p->pSelect ){ + Select *pNew = sqliteSelectDup(p->pSelect); + sqliteSelectDelete(p->pSelect); + p->pSelect = pNew; + } + if( p->pWhere ){ + Expr *pNew = sqliteExprDup(p->pWhere); + sqliteExprDelete(p->pWhere); + p->pWhere = pNew; + } + if( p->pExprList ){ + ExprList *pNew = sqliteExprListDup(p->pExprList); + sqliteExprListDelete(p->pExprList); + p->pExprList = pNew; + } + if( p->pIdList ){ + IdList *pNew = sqliteIdListDup(p->pIdList); + sqliteIdListDelete(p->pIdList); + p->pIdList = pNew; + } +} + +/* +** Turn a SELECT statement (that the pSelect parameter points to) into +** a trigger step. Return a pointer to a TriggerStep structure. +** +** The parser calls this routine when it finds a SELECT statement in +** body of a TRIGGER. +*/ +TriggerStep *sqliteTriggerSelectStep(Select *pSelect){ + TriggerStep *pTriggerStep = sqliteMalloc(sizeof(TriggerStep)); + if( pTriggerStep==0 ) return 0; + + pTriggerStep->op = TK_SELECT; + pTriggerStep->pSelect = pSelect; + pTriggerStep->orconf = OE_Default; + sqlitePersistTriggerStep(pTriggerStep); + + return pTriggerStep; +} + +/* +** Build a trigger step out of an INSERT statement. Return a pointer +** to the new trigger step. +** +** The parser calls this routine when it sees an INSERT inside the +** body of a trigger. +*/ +TriggerStep *sqliteTriggerInsertStep( + Token *pTableName, /* Name of the table into which we insert */ + IdList *pColumn, /* List of columns in pTableName to insert into */ + ExprList *pEList, /* The VALUE clause: a list of values to be inserted */ + Select *pSelect, /* A SELECT statement that supplies values */ + int orconf /* The conflict algorithm (OE_Abort, OE_Replace, etc.) */ +){ + TriggerStep *pTriggerStep = sqliteMalloc(sizeof(TriggerStep)); + if( pTriggerStep==0 ) return 0; + + assert(pEList == 0 || pSelect == 0); + assert(pEList != 0 || pSelect != 0); + + pTriggerStep->op = TK_INSERT; + pTriggerStep->pSelect = pSelect; + pTriggerStep->target = *pTableName; + pTriggerStep->pIdList = pColumn; + pTriggerStep->pExprList = pEList; + pTriggerStep->orconf = orconf; + sqlitePersistTriggerStep(pTriggerStep); + + return pTriggerStep; +} + +/* +** Construct a trigger step that implements an UPDATE statement and return +** a pointer to that trigger step. The parser calls this routine when it +** sees an UPDATE statement inside the body of a CREATE TRIGGER. +*/ +TriggerStep *sqliteTriggerUpdateStep( + Token *pTableName, /* Name of the table to be updated */ + ExprList *pEList, /* The SET clause: list of column and new values */ + Expr *pWhere, /* The WHERE clause */ + int orconf /* The conflict algorithm. (OE_Abort, OE_Ignore, etc) */ +){ + TriggerStep *pTriggerStep = sqliteMalloc(sizeof(TriggerStep)); + if( pTriggerStep==0 ) return 0; + + pTriggerStep->op = TK_UPDATE; + pTriggerStep->target = *pTableName; + pTriggerStep->pExprList = pEList; + pTriggerStep->pWhere = pWhere; + pTriggerStep->orconf = orconf; + sqlitePersistTriggerStep(pTriggerStep); + + return pTriggerStep; +} + +/* +** Construct a trigger step that implements a DELETE statement and return +** a pointer to that trigger step. The parser calls this routine when it +** sees a DELETE statement inside the body of a CREATE TRIGGER. +*/ +TriggerStep *sqliteTriggerDeleteStep(Token *pTableName, Expr *pWhere){ + TriggerStep *pTriggerStep = sqliteMalloc(sizeof(TriggerStep)); + if( pTriggerStep==0 ) return 0; + + pTriggerStep->op = TK_DELETE; + pTriggerStep->target = *pTableName; + pTriggerStep->pWhere = pWhere; + pTriggerStep->orconf = OE_Default; + sqlitePersistTriggerStep(pTriggerStep); + + return pTriggerStep; +} + +/* +** Recursively delete a Trigger structure +*/ +void sqliteDeleteTrigger(Trigger *pTrigger){ + if( pTrigger==0 ) return; + sqliteDeleteTriggerStep(pTrigger->step_list); + sqliteFree(pTrigger->name); + sqliteFree(pTrigger->table); + sqliteExprDelete(pTrigger->pWhen); + sqliteIdListDelete(pTrigger->pColumns); + if( pTrigger->nameToken.dyn ) sqliteFree((char*)pTrigger->nameToken.z); + sqliteFree(pTrigger); +} + +/* + * This function is called to drop a trigger from the database schema. + * + * This may be called directly from the parser and therefore identifies + * the trigger by name. The sqliteDropTriggerPtr() routine does the + * same job as this routine except it take a spointer to the trigger + * instead of the trigger name. + * + * Note that this function does not delete the trigger entirely. Instead it + * removes it from the internal schema and places it in the trigDrop hash + * table. This is so that the trigger can be restored into the database schema + * if the transaction is rolled back. + */ +void sqliteDropTrigger(Parse *pParse, SrcList *pName){ + Trigger *pTrigger; + int i; + const char *zDb; + const char *zName; + int nName; + sqlite *db = pParse->db; + + if( sqlite_malloc_failed ) goto drop_trigger_cleanup; + assert( pName->nSrc==1 ); + zDb = pName->a[0].zDatabase; + zName = pName->a[0].zName; + nName = strlen(zName); + for(i=0; i<db->nDb; i++){ + int j = (i<2) ? i^1 : i; /* Search TEMP before MAIN */ + if( zDb && sqliteStrICmp(db->aDb[j].zName, zDb) ) continue; + pTrigger = sqliteHashFind(&(db->aDb[j].trigHash), zName, nName+1); + if( pTrigger ) break; + } + if( !pTrigger ){ + sqliteErrorMsg(pParse, "no such trigger: %S", pName, 0); + goto drop_trigger_cleanup; + } + sqliteDropTriggerPtr(pParse, pTrigger, 0); + +drop_trigger_cleanup: + sqliteSrcListDelete(pName); +} + +/* +** Drop a trigger given a pointer to that trigger. If nested is false, +** then also generate code to remove the trigger from the SQLITE_MASTER +** table. +*/ +void sqliteDropTriggerPtr(Parse *pParse, Trigger *pTrigger, int nested){ + Table *pTable; + Vdbe *v; + sqlite *db = pParse->db; + + assert( pTrigger->iDb<db->nDb ); + if( pTrigger->iDb>=2 ){ + sqliteErrorMsg(pParse, "triggers may not be removed from " + "auxiliary database %s", db->aDb[pTrigger->iDb].zName); + return; + } + pTable = sqliteFindTable(db, pTrigger->table,db->aDb[pTrigger->iTabDb].zName); + assert(pTable); + assert( pTable->iDb==pTrigger->iDb || pTrigger->iDb==1 ); +#ifndef SQLITE_OMIT_AUTHORIZATION + { + int code = SQLITE_DROP_TRIGGER; + const char *zDb = db->aDb[pTrigger->iDb].zName; + const char *zTab = SCHEMA_TABLE(pTrigger->iDb); + if( pTrigger->iDb ) code = SQLITE_DROP_TEMP_TRIGGER; + if( sqliteAuthCheck(pParse, code, pTrigger->name, pTable->zName, zDb) || + sqliteAuthCheck(pParse, SQLITE_DELETE, zTab, 0, zDb) ){ + return; + } + } +#endif + + /* Generate code to destroy the database record of the trigger. + */ + if( pTable!=0 && !nested && (v = sqliteGetVdbe(pParse))!=0 ){ + int base; + static VdbeOpList dropTrigger[] = { + { OP_Rewind, 0, ADDR(9), 0}, + { OP_String, 0, 0, 0}, /* 1 */ + { OP_Column, 0, 1, 0}, + { OP_Ne, 0, ADDR(8), 0}, + { OP_String, 0, 0, "trigger"}, + { OP_Column, 0, 0, 0}, + { OP_Ne, 0, ADDR(8), 0}, + { OP_Delete, 0, 0, 0}, + { OP_Next, 0, ADDR(1), 0}, /* 8 */ + }; + + sqliteBeginWriteOperation(pParse, 0, 0); + sqliteOpenMasterTable(v, pTrigger->iDb); + base = sqliteVdbeAddOpList(v, ArraySize(dropTrigger), dropTrigger); + sqliteVdbeChangeP3(v, base+1, pTrigger->name, 0); + if( pTrigger->iDb==0 ){ + sqliteChangeCookie(db, v); + } + sqliteVdbeAddOp(v, OP_Close, 0, 0); + sqliteEndWriteOperation(pParse); + } + + /* + * If this is not an "explain", then delete the trigger structure. + */ + if( !pParse->explain ){ + const char *zName = pTrigger->name; + int nName = strlen(zName); + if( pTable->pTrigger == pTrigger ){ + pTable->pTrigger = pTrigger->pNext; + }else{ + Trigger *cc = pTable->pTrigger; + while( cc ){ + if( cc->pNext == pTrigger ){ + cc->pNext = cc->pNext->pNext; + break; + } + cc = cc->pNext; + } + assert(cc); + } + sqliteHashInsert(&(db->aDb[pTrigger->iDb].trigHash), zName, nName+1, 0); + sqliteDeleteTrigger(pTrigger); + } +} + +/* +** pEList is the SET clause of an UPDATE statement. Each entry +** in pEList is of the format <id>=<expr>. If any of the entries +** in pEList have an <id> which matches an identifier in pIdList, +** then return TRUE. If pIdList==NULL, then it is considered a +** wildcard that matches anything. Likewise if pEList==NULL then +** it matches anything so always return true. Return false only +** if there is no match. +*/ +static int checkColumnOverLap(IdList *pIdList, ExprList *pEList){ + int e; + if( !pIdList || !pEList ) return 1; + for(e=0; e<pEList->nExpr; e++){ + if( sqliteIdListIndex(pIdList, pEList->a[e].zName)>=0 ) return 1; + } + return 0; +} + +/* A global variable that is TRUE if we should always set up temp tables for + * for triggers, even if there are no triggers to code. This is used to test + * how much overhead the triggers algorithm is causing. + * + * This flag can be set or cleared using the "trigger_overhead_test" pragma. + * The pragma is not documented since it is not really part of the interface + * to SQLite, just the test procedure. +*/ +int always_code_trigger_setup = 0; + +/* + * Returns true if a trigger matching op, tr_tm and foreach that is NOT already + * on the Parse objects trigger-stack (to prevent recursive trigger firing) is + * found in the list specified as pTrigger. + */ +int sqliteTriggersExist( + Parse *pParse, /* Used to check for recursive triggers */ + Trigger *pTrigger, /* A list of triggers associated with a table */ + int op, /* one of TK_DELETE, TK_INSERT, TK_UPDATE */ + int tr_tm, /* one of TK_BEFORE, TK_AFTER */ + int foreach, /* one of TK_ROW or TK_STATEMENT */ + ExprList *pChanges /* Columns that change in an UPDATE statement */ +){ + Trigger * pTriggerCursor; + + if( always_code_trigger_setup ){ + return 1; + } + + pTriggerCursor = pTrigger; + while( pTriggerCursor ){ + if( pTriggerCursor->op == op && + pTriggerCursor->tr_tm == tr_tm && + pTriggerCursor->foreach == foreach && + checkColumnOverLap(pTriggerCursor->pColumns, pChanges) ){ + TriggerStack * ss; + ss = pParse->trigStack; + while( ss && ss->pTrigger != pTrigger ){ + ss = ss->pNext; + } + if( !ss )return 1; + } + pTriggerCursor = pTriggerCursor->pNext; + } + + return 0; +} + +/* +** Convert the pStep->target token into a SrcList and return a pointer +** to that SrcList. +** +** This routine adds a specific database name, if needed, to the target when +** forming the SrcList. This prevents a trigger in one database from +** referring to a target in another database. An exception is when the +** trigger is in TEMP in which case it can refer to any other database it +** wants. +*/ +static SrcList *targetSrcList( + Parse *pParse, /* The parsing context */ + TriggerStep *pStep /* The trigger containing the target token */ +){ + Token sDb; /* Dummy database name token */ + int iDb; /* Index of the database to use */ + SrcList *pSrc; /* SrcList to be returned */ + + iDb = pStep->pTrig->iDb; + if( iDb==0 || iDb>=2 ){ + assert( iDb<pParse->db->nDb ); + sDb.z = pParse->db->aDb[iDb].zName; + sDb.n = strlen(sDb.z); + pSrc = sqliteSrcListAppend(0, &sDb, &pStep->target); + } else { + pSrc = sqliteSrcListAppend(0, &pStep->target, 0); + } + return pSrc; +} + +/* +** Generate VDBE code for zero or more statements inside the body of a +** trigger. +*/ +static int codeTriggerProgram( + Parse *pParse, /* The parser context */ + TriggerStep *pStepList, /* List of statements inside the trigger body */ + int orconfin /* Conflict algorithm. (OE_Abort, etc) */ +){ + TriggerStep * pTriggerStep = pStepList; + int orconf; + + while( pTriggerStep ){ + int saveNTab = pParse->nTab; + + orconf = (orconfin == OE_Default)?pTriggerStep->orconf:orconfin; + pParse->trigStack->orconf = orconf; + switch( pTriggerStep->op ){ + case TK_SELECT: { + Select * ss = sqliteSelectDup(pTriggerStep->pSelect); + assert(ss); + assert(ss->pSrc); + sqliteSelect(pParse, ss, SRT_Discard, 0, 0, 0, 0); + sqliteSelectDelete(ss); + break; + } + case TK_UPDATE: { + SrcList *pSrc; + pSrc = targetSrcList(pParse, pTriggerStep); + sqliteVdbeAddOp(pParse->pVdbe, OP_ListPush, 0, 0); + sqliteUpdate(pParse, pSrc, + sqliteExprListDup(pTriggerStep->pExprList), + sqliteExprDup(pTriggerStep->pWhere), orconf); + sqliteVdbeAddOp(pParse->pVdbe, OP_ListPop, 0, 0); + break; + } + case TK_INSERT: { + SrcList *pSrc; + pSrc = targetSrcList(pParse, pTriggerStep); + sqliteInsert(pParse, pSrc, + sqliteExprListDup(pTriggerStep->pExprList), + sqliteSelectDup(pTriggerStep->pSelect), + sqliteIdListDup(pTriggerStep->pIdList), orconf); + break; + } + case TK_DELETE: { + SrcList *pSrc; + sqliteVdbeAddOp(pParse->pVdbe, OP_ListPush, 0, 0); + pSrc = targetSrcList(pParse, pTriggerStep); + sqliteDeleteFrom(pParse, pSrc, sqliteExprDup(pTriggerStep->pWhere)); + sqliteVdbeAddOp(pParse->pVdbe, OP_ListPop, 0, 0); + break; + } + default: + assert(0); + } + pParse->nTab = saveNTab; + pTriggerStep = pTriggerStep->pNext; + } + + return 0; +} + +/* +** This is called to code FOR EACH ROW triggers. +** +** When the code that this function generates is executed, the following +** must be true: +** +** 1. No cursors may be open in the main database. (But newIdx and oldIdx +** can be indices of cursors in temporary tables. See below.) +** +** 2. If the triggers being coded are ON INSERT or ON UPDATE triggers, then +** a temporary vdbe cursor (index newIdx) must be open and pointing at +** a row containing values to be substituted for new.* expressions in the +** trigger program(s). +** +** 3. If the triggers being coded are ON DELETE or ON UPDATE triggers, then +** a temporary vdbe cursor (index oldIdx) must be open and pointing at +** a row containing values to be substituted for old.* expressions in the +** trigger program(s). +** +*/ +int sqliteCodeRowTrigger( + Parse *pParse, /* Parse context */ + int op, /* One of TK_UPDATE, TK_INSERT, TK_DELETE */ + ExprList *pChanges, /* Changes list for any UPDATE OF triggers */ + int tr_tm, /* One of TK_BEFORE, TK_AFTER */ + Table *pTab, /* The table to code triggers from */ + int newIdx, /* The indice of the "new" row to access */ + int oldIdx, /* The indice of the "old" row to access */ + int orconf, /* ON CONFLICT policy */ + int ignoreJump /* Instruction to jump to for RAISE(IGNORE) */ +){ + Trigger * pTrigger; + TriggerStack * pTriggerStack; + + assert(op == TK_UPDATE || op == TK_INSERT || op == TK_DELETE); + assert(tr_tm == TK_BEFORE || tr_tm == TK_AFTER ); + + assert(newIdx != -1 || oldIdx != -1); + + pTrigger = pTab->pTrigger; + while( pTrigger ){ + int fire_this = 0; + + /* determine whether we should code this trigger */ + if( pTrigger->op == op && pTrigger->tr_tm == tr_tm && + pTrigger->foreach == TK_ROW ){ + fire_this = 1; + pTriggerStack = pParse->trigStack; + while( pTriggerStack ){ + if( pTriggerStack->pTrigger == pTrigger ){ + fire_this = 0; + } + pTriggerStack = pTriggerStack->pNext; + } + if( op == TK_UPDATE && pTrigger->pColumns && + !checkColumnOverLap(pTrigger->pColumns, pChanges) ){ + fire_this = 0; + } + } + + if( fire_this && (pTriggerStack = sqliteMalloc(sizeof(TriggerStack)))!=0 ){ + int endTrigger; + SrcList dummyTablist; + Expr * whenExpr; + AuthContext sContext; + + dummyTablist.nSrc = 0; + + /* Push an entry on to the trigger stack */ + pTriggerStack->pTrigger = pTrigger; + pTriggerStack->newIdx = newIdx; + pTriggerStack->oldIdx = oldIdx; + pTriggerStack->pTab = pTab; + pTriggerStack->pNext = pParse->trigStack; + pTriggerStack->ignoreJump = ignoreJump; + pParse->trigStack = pTriggerStack; + sqliteAuthContextPush(pParse, &sContext, pTrigger->name); + + /* code the WHEN clause */ + endTrigger = sqliteVdbeMakeLabel(pParse->pVdbe); + whenExpr = sqliteExprDup(pTrigger->pWhen); + if( sqliteExprResolveIds(pParse, &dummyTablist, 0, whenExpr) ){ + pParse->trigStack = pParse->trigStack->pNext; + sqliteFree(pTriggerStack); + sqliteExprDelete(whenExpr); + return 1; + } + sqliteExprIfFalse(pParse, whenExpr, endTrigger, 1); + sqliteExprDelete(whenExpr); + + sqliteVdbeAddOp(pParse->pVdbe, OP_ContextPush, 0, 0); + codeTriggerProgram(pParse, pTrigger->step_list, orconf); + sqliteVdbeAddOp(pParse->pVdbe, OP_ContextPop, 0, 0); + + /* Pop the entry off the trigger stack */ + pParse->trigStack = pParse->trigStack->pNext; + sqliteAuthContextPop(&sContext); + sqliteFree(pTriggerStack); + + sqliteVdbeResolveLabel(pParse->pVdbe, endTrigger); + } + pTrigger = pTrigger->pNext; + } + + return 0; +} diff --git a/kexi/3rdparty/kexisql/src/update.c b/kexi/3rdparty/kexisql/src/update.c new file mode 100644 index 00000000..1dc32826 --- /dev/null +++ b/kexi/3rdparty/kexisql/src/update.c @@ -0,0 +1,459 @@ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains C code routines that are called by the parser +** to handle UPDATE statements. +** +** $Id: update.c 410099 2005-05-06 17:52:07Z staniek $ +*/ +#include "sqliteInt.h" + +/* +** Process an UPDATE statement. +** +** UPDATE OR IGNORE table_wxyz SET a=b, c=d WHERE e<5 AND f NOT NULL; +** \_______/ \________/ \______/ \________________/ +* onError pTabList pChanges pWhere +*/ +void sqliteUpdate( + Parse *pParse, /* The parser context */ + SrcList *pTabList, /* The table in which we should change things */ + ExprList *pChanges, /* Things to be changed */ + Expr *pWhere, /* The WHERE clause. May be null */ + int onError /* How to handle constraint errors */ +){ + int i, j; /* Loop counters */ + Table *pTab; /* The table to be updated */ + int loopStart; /* VDBE instruction address of the start of the loop */ + int jumpInst; /* Addr of VDBE instruction to jump out of loop */ + WhereInfo *pWInfo; /* Information about the WHERE clause */ + Vdbe *v; /* The virtual database engine */ + Index *pIdx; /* For looping over indices */ + int nIdx; /* Number of indices that need updating */ + int nIdxTotal; /* Total number of indices */ + int iCur; /* VDBE Cursor number of pTab */ + sqlite *db; /* The database structure */ + Index **apIdx = 0; /* An array of indices that need updating too */ + char *aIdxUsed = 0; /* aIdxUsed[i]==1 if the i-th index is used */ + int *aXRef = 0; /* aXRef[i] is the index in pChanges->a[] of the + ** an expression for the i-th column of the table. + ** aXRef[i]==-1 if the i-th column is not changed. */ + int chngRecno; /* True if the record number is being changed */ + Expr *pRecnoExpr; /* Expression defining the new record number */ + int openAll; /* True if all indices need to be opened */ + int isView; /* Trying to update a view */ + int iStackDepth; /* Index of memory cell holding stack depth */ + AuthContext sContext; /* The authorization context */ + + int before_triggers; /* True if there are any BEFORE triggers */ + int after_triggers; /* True if there are any AFTER triggers */ + int row_triggers_exist = 0; /* True if any row triggers exist */ + + int newIdx = -1; /* index of trigger "new" temp table */ + int oldIdx = -1; /* index of trigger "old" temp table */ + + sContext.pParse = 0; + if( pParse->nErr || sqlite_malloc_failed ) goto update_cleanup; + db = pParse->db; + assert( pTabList->nSrc==1 ); + iStackDepth = pParse->nMem++; + + /* Locate the table which we want to update. + */ + pTab = sqliteSrcListLookup(pParse, pTabList); + if( pTab==0 ) goto update_cleanup; + before_triggers = sqliteTriggersExist(pParse, pTab->pTrigger, + TK_UPDATE, TK_BEFORE, TK_ROW, pChanges); + after_triggers = sqliteTriggersExist(pParse, pTab->pTrigger, + TK_UPDATE, TK_AFTER, TK_ROW, pChanges); + row_triggers_exist = before_triggers || after_triggers; + isView = pTab->pSelect!=0; + if( sqliteIsReadOnly(pParse, pTab, before_triggers) ){ + goto update_cleanup; + } + if( isView ){ + if( sqliteViewGetColumnNames(pParse, pTab) ){ + goto update_cleanup; + } + } + aXRef = sqliteMalloc( sizeof(int) * pTab->nCol ); + if( aXRef==0 ) goto update_cleanup; + for(i=0; i<pTab->nCol; i++) aXRef[i] = -1; + + /* If there are FOR EACH ROW triggers, allocate cursors for the + ** special OLD and NEW tables + */ + if( row_triggers_exist ){ + newIdx = pParse->nTab++; + oldIdx = pParse->nTab++; + } + + /* Allocate a cursors for the main database table and for all indices. + ** The index cursors might not be used, but if they are used they + ** need to occur right after the database cursor. So go ahead and + ** allocate enough space, just in case. + */ + pTabList->a[0].iCursor = iCur = pParse->nTab++; + for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){ + pParse->nTab++; + } + + /* Resolve the column names in all the expressions of the + ** of the UPDATE statement. Also find the column index + ** for each column to be updated in the pChanges array. For each + ** column to be updated, make sure we have authorization to change + ** that column. + */ + chngRecno = 0; + for(i=0; i<pChanges->nExpr; i++){ + if( sqliteExprResolveIds(pParse, pTabList, 0, pChanges->a[i].pExpr) ){ + goto update_cleanup; + } + if( sqliteExprCheck(pParse, pChanges->a[i].pExpr, 0, 0) ){ + goto update_cleanup; + } + for(j=0; j<pTab->nCol; j++){ + if( sqliteStrICmp(pTab->aCol[j].zName, pChanges->a[i].zName)==0 ){ + if( j==pTab->iPKey ){ + chngRecno = 1; + pRecnoExpr = pChanges->a[i].pExpr; + } + aXRef[j] = i; + break; + } + } + if( j>=pTab->nCol ){ + if( sqliteIsRowid(pChanges->a[i].zName) ){ + chngRecno = 1; + pRecnoExpr = pChanges->a[i].pExpr; + }else{ + sqliteErrorMsg(pParse, "no such column: %s", pChanges->a[i].zName); + goto update_cleanup; + } + } +#ifndef SQLITE_OMIT_AUTHORIZATION + { + int rc; + rc = sqliteAuthCheck(pParse, SQLITE_UPDATE, pTab->zName, + pTab->aCol[j].zName, db->aDb[pTab->iDb].zName); + if( rc==SQLITE_DENY ){ + goto update_cleanup; + }else if( rc==SQLITE_IGNORE ){ + aXRef[j] = -1; + } + } +#endif + } + + /* Allocate memory for the array apIdx[] and fill it with pointers to every + ** index that needs to be updated. Indices only need updating if their + ** key includes one of the columns named in pChanges or if the record + ** number of the original table entry is changing. + */ + for(nIdx=nIdxTotal=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdxTotal++){ + if( chngRecno ){ + i = 0; + }else { + for(i=0; i<pIdx->nColumn; i++){ + if( aXRef[pIdx->aiColumn[i]]>=0 ) break; + } + } + if( i<pIdx->nColumn ) nIdx++; + } + if( nIdxTotal>0 ){ + apIdx = sqliteMalloc( sizeof(Index*) * nIdx + nIdxTotal ); + if( apIdx==0 ) goto update_cleanup; + aIdxUsed = (char*)&apIdx[nIdx]; + } + for(nIdx=j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){ + if( chngRecno ){ + i = 0; + }else{ + for(i=0; i<pIdx->nColumn; i++){ + if( aXRef[pIdx->aiColumn[i]]>=0 ) break; + } + } + if( i<pIdx->nColumn ){ + apIdx[nIdx++] = pIdx; + aIdxUsed[j] = 1; + }else{ + aIdxUsed[j] = 0; + } + } + + /* Resolve the column names in all the expressions in the + ** WHERE clause. + */ + if( pWhere ){ + if( sqliteExprResolveIds(pParse, pTabList, 0, pWhere) ){ + goto update_cleanup; + } + if( sqliteExprCheck(pParse, pWhere, 0, 0) ){ + goto update_cleanup; + } + } + + /* Start the view context + */ + if( isView ){ + sqliteAuthContextPush(pParse, &sContext, pTab->zName); + } + + /* Begin generating code. + */ + v = sqliteGetVdbe(pParse); + if( v==0 ) goto update_cleanup; + sqliteBeginWriteOperation(pParse, 1, pTab->iDb); + + /* If we are trying to update a view, construct that view into + ** a temporary table. + */ + if( isView ){ + Select *pView; + pView = sqliteSelectDup(pTab->pSelect); + sqliteSelect(pParse, pView, SRT_TempTable, iCur, 0, 0, 0); + sqliteSelectDelete(pView); + } + + /* Begin the database scan + */ + pWInfo = sqliteWhereBegin(pParse, pTabList, pWhere, 1, 0); + if( pWInfo==0 ) goto update_cleanup; + + /* Remember the index of every item to be updated. + */ + sqliteVdbeAddOp(v, OP_ListWrite, 0, 0); + + /* End the database scan loop. + */ + sqliteWhereEnd(pWInfo); + + /* Initialize the count of updated rows + */ + if( db->flags & SQLITE_CountRows && !pParse->trigStack ){ + sqliteVdbeAddOp(v, OP_Integer, 0, 0); + } + + if( row_triggers_exist ){ + /* Create pseudo-tables for NEW and OLD + */ + sqliteVdbeAddOp(v, OP_OpenPseudo, oldIdx, 0); + sqliteVdbeAddOp(v, OP_OpenPseudo, newIdx, 0); + + /* The top of the update loop for when there are triggers. + */ + sqliteVdbeAddOp(v, OP_ListRewind, 0, 0); + sqliteVdbeAddOp(v, OP_StackDepth, 0, 0); + sqliteVdbeAddOp(v, OP_MemStore, iStackDepth, 1); + loopStart = sqliteVdbeAddOp(v, OP_MemLoad, iStackDepth, 0); + sqliteVdbeAddOp(v, OP_StackReset, 0, 0); + jumpInst = sqliteVdbeAddOp(v, OP_ListRead, 0, 0); + sqliteVdbeAddOp(v, OP_Dup, 0, 0); + + /* Open a cursor and make it point to the record that is + ** being updated. + */ + sqliteVdbeAddOp(v, OP_Dup, 0, 0); + if( !isView ){ + sqliteVdbeAddOp(v, OP_Integer, pTab->iDb, 0); + sqliteVdbeAddOp(v, OP_OpenRead, iCur, pTab->tnum); + } + sqliteVdbeAddOp(v, OP_MoveTo, iCur, 0); + + /* Generate the OLD table + */ + sqliteVdbeAddOp(v, OP_Recno, iCur, 0); + sqliteVdbeAddOp(v, OP_RowData, iCur, 0); + sqliteVdbeAddOp(v, OP_PutIntKey, oldIdx, 0); + + /* Generate the NEW table + */ + if( chngRecno ){ + sqliteExprCode(pParse, pRecnoExpr); + }else{ + sqliteVdbeAddOp(v, OP_Recno, iCur, 0); + } + for(i=0; i<pTab->nCol; i++){ + if( i==pTab->iPKey ){ + sqliteVdbeAddOp(v, OP_String, 0, 0); + continue; + } + j = aXRef[i]; + if( j<0 ){ + sqliteVdbeAddOp(v, OP_Column, iCur, i); + }else{ + sqliteExprCode(pParse, pChanges->a[j].pExpr); + } + } + sqliteVdbeAddOp(v, OP_MakeRecord, pTab->nCol, 0); + sqliteVdbeAddOp(v, OP_PutIntKey, newIdx, 0); + if( !isView ){ + sqliteVdbeAddOp(v, OP_Close, iCur, 0); + } + + /* Fire the BEFORE and INSTEAD OF triggers + */ + if( sqliteCodeRowTrigger(pParse, TK_UPDATE, pChanges, TK_BEFORE, pTab, + newIdx, oldIdx, onError, loopStart) ){ + goto update_cleanup; + } + } + + if( !isView ){ + /* + ** Open every index that needs updating. Note that if any + ** index could potentially invoke a REPLACE conflict resolution + ** action, then we need to open all indices because we might need + ** to be deleting some records. + */ + sqliteVdbeAddOp(v, OP_Integer, pTab->iDb, 0); + sqliteVdbeAddOp(v, OP_OpenWrite, iCur, pTab->tnum); + if( onError==OE_Replace ){ + openAll = 1; + }else{ + openAll = 0; + for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){ + if( pIdx->onError==OE_Replace ){ + openAll = 1; + break; + } + } + } + for(i=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){ + if( openAll || aIdxUsed[i] ){ + sqliteVdbeAddOp(v, OP_Integer, pIdx->iDb, 0); + sqliteVdbeAddOp(v, OP_OpenWrite, iCur+i+1, pIdx->tnum); + assert( pParse->nTab>iCur+i+1 ); + } + } + + /* Loop over every record that needs updating. We have to load + ** the old data for each record to be updated because some columns + ** might not change and we will need to copy the old value. + ** Also, the old data is needed to delete the old index entires. + ** So make the cursor point at the old record. + */ + if( !row_triggers_exist ){ + sqliteVdbeAddOp(v, OP_ListRewind, 0, 0); + jumpInst = loopStart = sqliteVdbeAddOp(v, OP_ListRead, 0, 0); + sqliteVdbeAddOp(v, OP_Dup, 0, 0); + } + sqliteVdbeAddOp(v, OP_NotExists, iCur, loopStart); + + /* If the record number will change, push the record number as it + ** will be after the update. (The old record number is currently + ** on top of the stack.) + */ + if( chngRecno ){ + sqliteExprCode(pParse, pRecnoExpr); + sqliteVdbeAddOp(v, OP_MustBeInt, 0, 0); + } + + /* Compute new data for this record. + */ + for(i=0; i<pTab->nCol; i++){ + if( i==pTab->iPKey ){ + sqliteVdbeAddOp(v, OP_String, 0, 0); + continue; + } + j = aXRef[i]; + if( j<0 ){ + sqliteVdbeAddOp(v, OP_Column, iCur, i); + }else{ + sqliteExprCode(pParse, pChanges->a[j].pExpr); + } + } + + /* Do constraint checks + */ + sqliteGenerateConstraintChecks(pParse, pTab, iCur, aIdxUsed, chngRecno, 1, + onError, loopStart); + + /* Delete the old indices for the current record. + */ + sqliteGenerateRowIndexDelete(db, v, pTab, iCur, aIdxUsed); + + /* If changing the record number, delete the old record. + */ + if( chngRecno ){ + sqliteVdbeAddOp(v, OP_Delete, iCur, 0); + } + + /* Create the new index entries and the new record. + */ + sqliteCompleteInsertion(pParse, pTab, iCur, aIdxUsed, chngRecno, 1, -1); + } + + /* Increment the row counter + */ + if( db->flags & SQLITE_CountRows && !pParse->trigStack){ + sqliteVdbeAddOp(v, OP_AddImm, 1, 0); + } + + /* If there are triggers, close all the cursors after each iteration + ** through the loop. The fire the after triggers. + */ + if( row_triggers_exist ){ + if( !isView ){ + for(i=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){ + if( openAll || aIdxUsed[i] ) + sqliteVdbeAddOp(v, OP_Close, iCur+i+1, 0); + } + sqliteVdbeAddOp(v, OP_Close, iCur, 0); + pParse->nTab = iCur; + } + if( sqliteCodeRowTrigger(pParse, TK_UPDATE, pChanges, TK_AFTER, pTab, + newIdx, oldIdx, onError, loopStart) ){ + goto update_cleanup; + } + } + + /* Repeat the above with the next record to be updated, until + ** all record selected by the WHERE clause have been updated. + */ + sqliteVdbeAddOp(v, OP_Goto, 0, loopStart); + sqliteVdbeChangeP2(v, jumpInst, sqliteVdbeCurrentAddr(v)); + sqliteVdbeAddOp(v, OP_ListReset, 0, 0); + + /* Close all tables if there were no FOR EACH ROW triggers */ + if( !row_triggers_exist ){ + for(i=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){ + if( openAll || aIdxUsed[i] ){ + sqliteVdbeAddOp(v, OP_Close, iCur+i+1, 0); + } + } + sqliteVdbeAddOp(v, OP_Close, iCur, 0); + pParse->nTab = iCur; + }else{ + sqliteVdbeAddOp(v, OP_Close, newIdx, 0); + sqliteVdbeAddOp(v, OP_Close, oldIdx, 0); + } + + sqliteVdbeAddOp(v, OP_SetCounts, 0, 0); + sqliteEndWriteOperation(pParse); + + /* + ** Return the number of rows that were changed. + */ + if( db->flags & SQLITE_CountRows && !pParse->trigStack ){ + sqliteVdbeOp3(v, OP_ColumnName, 0, 1, "rows updated", P3_STATIC); + sqliteVdbeAddOp(v, OP_Callback, 1, 0); + } + +update_cleanup: + sqliteAuthContextPop(&sContext); + sqliteFree(apIdx); + sqliteFree(aXRef); + sqliteSrcListDelete(pTabList); + sqliteExprListDelete(pChanges); + sqliteExprDelete(pWhere); + return; +} diff --git a/kexi/3rdparty/kexisql/src/util.c b/kexi/3rdparty/kexisql/src/util.c new file mode 100644 index 00000000..09a13c7b --- /dev/null +++ b/kexi/3rdparty/kexisql/src/util.c @@ -0,0 +1,1135 @@ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** Utility functions used throughout sqlite. +** +** This file contains functions for allocating memory, comparing +** strings, and stuff like that. +** +** $Id: util.c 410099 2005-05-06 17:52:07Z staniek $ +*/ +#include "sqliteInt.h" +#include <stdarg.h> +#include <ctype.h> + +/* +** If malloc() ever fails, this global variable gets set to 1. +** This causes the library to abort and never again function. +*/ +int sqlite_malloc_failed = 0; + +/* +** If MEMORY_DEBUG is defined, then use versions of malloc() and +** free() that track memory usage and check for buffer overruns. +*/ +#ifdef MEMORY_DEBUG + +/* +** For keeping track of the number of mallocs and frees. This +** is used to check for memory leaks. +*/ +int sqlite_nMalloc; /* Number of sqliteMalloc() calls */ +int sqlite_nFree; /* Number of sqliteFree() calls */ +int sqlite_iMallocFail; /* Fail sqliteMalloc() after this many calls */ +#if MEMORY_DEBUG>1 +static int memcnt = 0; +#endif + +/* +** Number of 32-bit guard words +*/ +#define N_GUARD 1 + +/* +** Allocate new memory and set it to zero. Return NULL if +** no memory is available. +*/ +void *sqliteMalloc_(int n, int bZero, char *zFile, int line){ + void *p; + int *pi; + int i, k; + if( sqlite_iMallocFail>=0 ){ + sqlite_iMallocFail--; + if( sqlite_iMallocFail==0 ){ + sqlite_malloc_failed++; +#if MEMORY_DEBUG>1 + fprintf(stderr,"**** failed to allocate %d bytes at %s:%d\n", + n, zFile,line); +#endif + sqlite_iMallocFail--; + return 0; + } + } + if( n==0 ) return 0; + k = (n+sizeof(int)-1)/sizeof(int); + pi = malloc( (N_GUARD*2+1+k)*sizeof(int)); + if( pi==0 ){ + sqlite_malloc_failed++; + return 0; + } + sqlite_nMalloc++; + for(i=0; i<N_GUARD; i++) pi[i] = 0xdead1122; + pi[N_GUARD] = n; + for(i=0; i<N_GUARD; i++) pi[k+1+N_GUARD+i] = 0xdead3344; + p = &pi[N_GUARD+1]; + memset(p, bZero==0, n); +#if MEMORY_DEBUG>1 + fprintf(stderr,"%06d malloc %d bytes at 0x%x from %s:%d\n", + ++memcnt, n, (int)p, zFile,line); +#endif + return p; +} + +/* +** Check to see if the given pointer was obtained from sqliteMalloc() +** and is able to hold at least N bytes. Raise an exception if this +** is not the case. +** +** This routine is used for testing purposes only. +*/ +void sqliteCheckMemory(void *p, int N){ + int *pi = p; + int n, i, k; + pi -= N_GUARD+1; + for(i=0; i<N_GUARD; i++){ + assert( pi[i]==0xdead1122 ); + } + n = pi[N_GUARD]; + assert( N>=0 && N<n ); + k = (n+sizeof(int)-1)/sizeof(int); + for(i=0; i<N_GUARD; i++){ + assert( pi[k+N_GUARD+1+i]==0xdead3344 ); + } +} + +/* +** Free memory previously obtained from sqliteMalloc() +*/ +void sqliteFree_(void *p, char *zFile, int line){ + if( p ){ + int *pi, i, k, n; + pi = p; + pi -= N_GUARD+1; + sqlite_nFree++; + for(i=0; i<N_GUARD; i++){ + if( pi[i]!=0xdead1122 ){ + fprintf(stderr,"Low-end memory corruption at 0x%x\n", (int)p); + return; + } + } + n = pi[N_GUARD]; + k = (n+sizeof(int)-1)/sizeof(int); + for(i=0; i<N_GUARD; i++){ + if( pi[k+N_GUARD+1+i]!=0xdead3344 ){ + fprintf(stderr,"High-end memory corruption at 0x%x\n", (int)p); + return; + } + } + memset(pi, 0xff, (k+N_GUARD*2+1)*sizeof(int)); +#if MEMORY_DEBUG>1 + fprintf(stderr,"%06d free %d bytes at 0x%x from %s:%d\n", + ++memcnt, n, (int)p, zFile,line); +#endif + free(pi); + } +} + +/* +** Resize a prior allocation. If p==0, then this routine +** works just like sqliteMalloc(). If n==0, then this routine +** works just like sqliteFree(). +*/ +void *sqliteRealloc_(void *oldP, int n, char *zFile, int line){ + int *oldPi, *pi, i, k, oldN, oldK; + void *p; + if( oldP==0 ){ + return sqliteMalloc_(n,1,zFile,line); + } + if( n==0 ){ + sqliteFree_(oldP,zFile,line); + return 0; + } + oldPi = oldP; + oldPi -= N_GUARD+1; + if( oldPi[0]!=0xdead1122 ){ + fprintf(stderr,"Low-end memory corruption in realloc at 0x%x\n", (int)oldP); + return 0; + } + oldN = oldPi[N_GUARD]; + oldK = (oldN+sizeof(int)-1)/sizeof(int); + for(i=0; i<N_GUARD; i++){ + if( oldPi[oldK+N_GUARD+1+i]!=0xdead3344 ){ + fprintf(stderr,"High-end memory corruption in realloc at 0x%x\n", + (int)oldP); + return 0; + } + } + k = (n + sizeof(int) - 1)/sizeof(int); + pi = malloc( (k+N_GUARD*2+1)*sizeof(int) ); + if( pi==0 ){ + sqlite_malloc_failed++; + return 0; + } + for(i=0; i<N_GUARD; i++) pi[i] = 0xdead1122; + pi[N_GUARD] = n; + for(i=0; i<N_GUARD; i++) pi[k+N_GUARD+1+i] = 0xdead3344; + p = &pi[N_GUARD+1]; + memcpy(p, oldP, n>oldN ? oldN : n); + if( n>oldN ){ + memset(&((char*)p)[oldN], 0, n-oldN); + } + memset(oldPi, 0xab, (oldK+N_GUARD+2)*sizeof(int)); + free(oldPi); +#if MEMORY_DEBUG>1 + fprintf(stderr,"%06d realloc %d to %d bytes at 0x%x to 0x%x at %s:%d\n", + ++memcnt, oldN, n, (int)oldP, (int)p, zFile, line); +#endif + return p; +} + +/* +** Make a duplicate of a string into memory obtained from malloc() +** Free the original string using sqliteFree(). +** +** This routine is called on all strings that are passed outside of +** the SQLite library. That way clients can free the string using free() +** rather than having to call sqliteFree(). +*/ +void sqliteStrRealloc(char **pz){ + char *zNew; + if( pz==0 || *pz==0 ) return; + zNew = malloc( strlen(*pz) + 1 ); + if( zNew==0 ){ + sqlite_malloc_failed++; + sqliteFree(*pz); + *pz = 0; + } + strcpy(zNew, *pz); + sqliteFree(*pz); + *pz = zNew; +} + +/* +** Make a copy of a string in memory obtained from sqliteMalloc() +*/ +char *sqliteStrDup_(const char *z, char *zFile, int line){ + char *zNew; + if( z==0 ) return 0; + zNew = sqliteMalloc_(strlen(z)+1, 0, zFile, line); + if( zNew ) strcpy(zNew, z); + return zNew; +} +char *sqliteStrNDup_(const char *z, int n, char *zFile, int line){ + char *zNew; + if( z==0 ) return 0; + zNew = sqliteMalloc_(n+1, 0, zFile, line); + if( zNew ){ + memcpy(zNew, z, n); + zNew[n] = 0; + } + return zNew; +} +#endif /* MEMORY_DEBUG */ + +/* +** The following versions of malloc() and free() are for use in a +** normal build. +*/ +#if !defined(MEMORY_DEBUG) + +/* +** Allocate new memory and set it to zero. Return NULL if +** no memory is available. See also sqliteMallocRaw(). +*/ +void *sqliteMalloc(int n){ + void *p; + if( (p = malloc(n))==0 ){ + if( n>0 ) sqlite_malloc_failed++; + }else{ + memset(p, 0, n); + } + return p; +} + +/* +** Allocate new memory but do not set it to zero. Return NULL if +** no memory is available. See also sqliteMalloc(). +*/ +void *sqliteMallocRaw(int n){ + void *p; + if( (p = malloc(n))==0 ){ + if( n>0 ) sqlite_malloc_failed++; + } + return p; +} + +/* +** Free memory previously obtained from sqliteMalloc() +*/ +void sqliteFree(void *p){ + if( p ){ + free(p); + } +} + +/* +** Resize a prior allocation. If p==0, then this routine +** works just like sqliteMalloc(). If n==0, then this routine +** works just like sqliteFree(). +*/ +void *sqliteRealloc(void *p, int n){ + void *p2; + if( p==0 ){ + return sqliteMalloc(n); + } + if( n==0 ){ + sqliteFree(p); + return 0; + } + p2 = realloc(p, n); + if( p2==0 ){ + sqlite_malloc_failed++; + } + return p2; +} + +/* +** Make a copy of a string in memory obtained from sqliteMalloc() +*/ +char *sqliteStrDup(const char *z){ + char *zNew; + if( z==0 ) return 0; + zNew = sqliteMallocRaw(strlen(z)+1); + if( zNew ) strcpy(zNew, z); + return zNew; +} +char *sqliteStrNDup(const char *z, int n){ + char *zNew; + if( z==0 ) return 0; + zNew = sqliteMallocRaw(n+1); + if( zNew ){ + memcpy(zNew, z, n); + zNew[n] = 0; + } + return zNew; +} +#endif /* !defined(MEMORY_DEBUG) */ + +/* +** Create a string from the 2nd and subsequent arguments (up to the +** first NULL argument), store the string in memory obtained from +** sqliteMalloc() and make the pointer indicated by the 1st argument +** point to that string. The 1st argument must either be NULL or +** point to memory obtained from sqliteMalloc(). +*/ +void sqliteSetString(char **pz, const char *zFirst, ...){ + va_list ap; + int nByte; + const char *z; + char *zResult; + + if( pz==0 ) return; + nByte = strlen(zFirst) + 1; + va_start(ap, zFirst); + while( (z = va_arg(ap, const char*))!=0 ){ + nByte += strlen(z); + } + va_end(ap); + sqliteFree(*pz); + *pz = zResult = sqliteMallocRaw( nByte ); + if( zResult==0 ){ + return; + } + strcpy(zResult, zFirst); + zResult += strlen(zResult); + va_start(ap, zFirst); + while( (z = va_arg(ap, const char*))!=0 ){ + strcpy(zResult, z); + zResult += strlen(zResult); + } + va_end(ap); +#ifdef MEMORY_DEBUG +#if MEMORY_DEBUG>1 + fprintf(stderr,"string at 0x%x is %s\n", (int)*pz, *pz); +#endif +#endif +} + +/* +** Works like sqliteSetString, but each string is now followed by +** a length integer which specifies how much of the source string +** to copy (in bytes). -1 means use the whole string. The 1st +** argument must either be NULL or point to memory obtained from +** sqliteMalloc(). +*/ +void sqliteSetNString(char **pz, ...){ + va_list ap; + int nByte; + const char *z; + char *zResult; + int n; + + if( pz==0 ) return; + nByte = 0; + va_start(ap, pz); + while( (z = va_arg(ap, const char*))!=0 ){ + n = va_arg(ap, int); + if( n<=0 ) n = strlen(z); + nByte += n; + } + va_end(ap); + sqliteFree(*pz); + *pz = zResult = sqliteMallocRaw( nByte + 1 ); + if( zResult==0 ) return; + va_start(ap, pz); + while( (z = va_arg(ap, const char*))!=0 ){ + n = va_arg(ap, int); + if( n<=0 ) n = strlen(z); + strncpy(zResult, z, n); + zResult += n; + } + *zResult = 0; +#ifdef MEMORY_DEBUG +#if MEMORY_DEBUG>1 + fprintf(stderr,"string at 0x%x is %s\n", (int)*pz, *pz); +#endif +#endif + va_end(ap); +} + +/* +** Add an error message to pParse->zErrMsg and increment pParse->nErr. +** The following formatting characters are allowed: +** +** %s Insert a string +** %z A string that should be freed after use +** %d Insert an integer +** %T Insert a token +** %S Insert the first element of a SrcList +*/ +void sqliteErrorMsg(Parse *pParse, const char *zFormat, ...){ + va_list ap; + pParse->nErr++; + sqliteFree(pParse->zErrMsg); + va_start(ap, zFormat); + pParse->zErrMsg = sqliteVMPrintf(zFormat, ap); + va_end(ap); +} + +/* +** Convert an SQL-style quoted string into a normal string by removing +** the quote characters. The conversion is done in-place. If the +** input does not begin with a quote character, then this routine +** is a no-op. +** +** 2002-Feb-14: This routine is extended to remove MS-Access style +** brackets from around identifers. For example: "[a-b-c]" becomes +** "a-b-c". +*/ +void sqliteDequote(char *z){ + int quote; + int i, j; + if( z==0 ) return; + quote = z[0]; + switch( quote ){ + case '\'': break; + case '"': break; + case '[': quote = ']'; break; + default: return; + } + for(i=1, j=0; z[i]; i++){ + if( z[i]==quote ){ + if( z[i+1]==quote ){ + z[j++] = quote; + i++; + }else{ + z[j++] = 0; + break; + } + }else{ + z[j++] = z[i]; + } + } +} + +/* An array to map all upper-case characters into their corresponding +** lower-case character. +*/ +static unsigned char UpperToLower[] = { + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, + 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, + 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 97, 98, 99,100,101,102,103, + 104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121, + 122, 91, 92, 93, 94, 95, 96, 97, 98, 99,100,101,102,103,104,105,106,107, + 108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125, + 126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143, + 144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161, + 162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179, + 180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197, + 198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215, + 216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233, + 234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251, + 252,253,254,255 +}; + +/* +** This function computes a hash on the name of a keyword. +** Case is not significant. +*/ +int sqliteHashNoCase(const char *z, int n){ + int h = 0; + if( n<=0 ) n = strlen(z); + while( n > 0 ){ + h = (h<<3) ^ h ^ UpperToLower[(unsigned char)*z++]; + n--; + } + return h & 0x7fffffff; +} + +/* +** Some systems have stricmp(). Others have strcasecmp(). Because +** there is no consistency, we will define our own. +*/ +int sqliteStrICmp(const char *zLeft, const char *zRight){ + register unsigned char *a, *b; + a = (unsigned char *)zLeft; + b = (unsigned char *)zRight; + while( *a!=0 && UpperToLower[*a]==UpperToLower[*b]){ a++; b++; } + return UpperToLower[*a] - UpperToLower[*b]; +} +int sqliteStrNICmp(const char *zLeft, const char *zRight, int N){ + register unsigned char *a, *b; + a = (unsigned char *)zLeft; + b = (unsigned char *)zRight; + while( N-- > 0 && *a!=0 && UpperToLower[*a]==UpperToLower[*b]){ a++; b++; } + return N<0 ? 0 : UpperToLower[*a] - UpperToLower[*b]; +} + +/* +** Return TRUE if z is a pure numeric string. Return FALSE if the +** string contains any character which is not part of a number. +** +** Am empty string is considered non-numeric. +*/ +int sqliteIsNumber(const char *z){ + if( *z=='-' || *z=='+' ) z++; + if( !isdigit(*z) ){ + return 0; + } + z++; + while( isdigit(*z) ){ z++; } + if( *z=='.' ){ + z++; + if( !isdigit(*z) ) return 0; + while( isdigit(*z) ){ z++; } + } + if( *z=='e' || *z=='E' ){ + z++; + if( *z=='+' || *z=='-' ) z++; + if( !isdigit(*z) ) return 0; + while( isdigit(*z) ){ z++; } + } + return *z==0; +} + +/* +** The string z[] is an ascii representation of a real number. +** Convert this string to a double. +** +** This routine assumes that z[] really is a valid number. If it +** is not, the result is undefined. +** +** This routine is used instead of the library atof() function because +** the library atof() might want to use "," as the decimal point instead +** of "." depending on how locale is set. But that would cause problems +** for SQL. So this routine always uses "." regardless of locale. +*/ +double sqliteAtoF(const char *z, const char **pzEnd){ + int sign = 1; + LONGDOUBLE_TYPE v1 = 0.0; + if( *z=='-' ){ + sign = -1; + z++; + }else if( *z=='+' ){ + z++; + } + while( isdigit(*z) ){ + v1 = v1*10.0 + (*z - '0'); + z++; + } + if( *z=='.' ){ + LONGDOUBLE_TYPE divisor = 1.0; + z++; + while( isdigit(*z) ){ + v1 = v1*10.0 + (*z - '0'); + divisor *= 10.0; + z++; + } + v1 /= divisor; + } + if( *z=='e' || *z=='E' ){ + int esign = 1; + int eval = 0; + LONGDOUBLE_TYPE scale = 1.0; + z++; + if( *z=='-' ){ + esign = -1; + z++; + }else if( *z=='+' ){ + z++; + } + while( isdigit(*z) ){ + eval = eval*10 + *z - '0'; + z++; + } + while( eval>=64 ){ scale *= 1.0e+64; eval -= 64; } + while( eval>=16 ){ scale *= 1.0e+16; eval -= 16; } + while( eval>=4 ){ scale *= 1.0e+4; eval -= 4; } + while( eval>=1 ){ scale *= 1.0e+1; eval -= 1; } + if( esign<0 ){ + v1 /= scale; + }else{ + v1 *= scale; + } + } + if( pzEnd ) *pzEnd = z; + return sign<0 ? -v1 : v1; +} + +/* +** The string zNum represents an integer. There might be some other +** information following the integer too, but that part is ignored. +** If the integer that the prefix of zNum represents will fit in a +** 32-bit signed integer, return TRUE. Otherwise return FALSE. +** +** This routine returns FALSE for the string -2147483648 even that +** that number will, in theory fit in a 32-bit integer. But positive +** 2147483648 will not fit in 32 bits. So it seems safer to return +** false. +*/ +int sqliteFitsIn32Bits(const char *zNum){ + int i, c; + if( *zNum=='-' || *zNum=='+' ) zNum++; + for(i=0; (c=zNum[i])>='0' && c<='9'; i++){} + return i<10 || (i==10 && memcmp(zNum,"2147483647",10)<=0); +} + +/* This comparison routine is what we use for comparison operations +** between numeric values in an SQL expression. "Numeric" is a little +** bit misleading here. What we mean is that the strings have a +** type of "numeric" from the point of view of SQL. The strings +** do not necessarily contain numbers. They could contain text. +** +** If the input strings both look like actual numbers then they +** compare in numerical order. Numerical strings are always less +** than non-numeric strings so if one input string looks like a +** number and the other does not, then the one that looks like +** a number is the smaller. Non-numeric strings compare in +** lexigraphical order (the same order as strcmp()). +*/ +int sqliteCompare(const char *atext, const char *btext){ + int result; + int isNumA, isNumB; + if( atext==0 ){ + return -1; + }else if( btext==0 ){ + return 1; + } + isNumA = sqliteIsNumber(atext); + isNumB = sqliteIsNumber(btext); + if( isNumA ){ + if( !isNumB ){ + result = -1; + }else{ + double rA, rB; + rA = sqliteAtoF(atext, 0); + rB = sqliteAtoF(btext, 0); + if( rA<rB ){ + result = -1; + }else if( rA>rB ){ + result = +1; + }else{ + result = 0; + } + } + }else if( isNumB ){ + result = +1; + }else { + result = strcmp(atext, btext); + } + return result; +} + +/* +** This routine is used for sorting. Each key is a list of one or more +** null-terminated elements. The list is terminated by two nulls in +** a row. For example, the following text is a key with three elements +** +** Aone\000Dtwo\000Athree\000\000 +** +** All elements begin with one of the characters "+-AD" and end with "\000" +** with zero or more text elements in between. Except, NULL elements +** consist of the special two-character sequence "N\000". +** +** Both arguments will have the same number of elements. This routine +** returns negative, zero, or positive if the first argument is less +** than, equal to, or greater than the first. (Result is a-b). +** +** Each element begins with one of the characters "+", "-", "A", "D". +** This character determines the sort order and collating sequence: +** +** + Sort numerically in ascending order +** - Sort numerically in descending order +** A Sort as strings in ascending order +** D Sort as strings in descending order. +** +** For the "+" and "-" sorting, pure numeric strings (strings for which the +** isNum() function above returns TRUE) always compare less than strings +** that are not pure numerics. Non-numeric strings compare in memcmp() +** order. This is the same sort order as the sqliteCompare() function +** above generates. +** +** The last point is a change from version 2.6.3 to version 2.7.0. In +** version 2.6.3 and earlier, substrings of digits compare in numerical +** and case was used only to break a tie. +** +** Elements that begin with 'A' or 'D' compare in memcmp() order regardless +** of whether or not they look like a number. +** +** Note that the sort order imposed by the rules above is the same +** from the ordering defined by the "<", "<=", ">", and ">=" operators +** of expressions and for indices. This was not the case for version +** 2.6.3 and earlier. +*/ +int sqliteSortCompare(const char *a, const char *b){ + int res = 0; + int isNumA, isNumB; + int dir = 0; + + while( res==0 && *a && *b ){ + if( a[0]=='N' || b[0]=='N' ){ + if( a[0]==b[0] ){ + a += 2; + b += 2; + continue; + } + if( a[0]=='N' ){ + dir = b[0]; + res = -1; + }else{ + dir = a[0]; + res = +1; + } + break; + } + assert( a[0]==b[0] ); + if( (dir=a[0])=='A' || a[0]=='D' ){ + res = strcmp(&a[1],&b[1]); + if( res ) break; + }else{ + isNumA = sqliteIsNumber(&a[1]); + isNumB = sqliteIsNumber(&b[1]); + if( isNumA ){ + double rA, rB; + if( !isNumB ){ + res = -1; + break; + } + rA = sqliteAtoF(&a[1], 0); + rB = sqliteAtoF(&b[1], 0); + if( rA<rB ){ + res = -1; + break; + } + if( rA>rB ){ + res = +1; + break; + } + }else if( isNumB ){ + res = +1; + break; + }else{ + res = strcmp(&a[1],&b[1]); + if( res ) break; + } + } + a += strlen(&a[1]) + 2; + b += strlen(&b[1]) + 2; + } + if( dir=='-' || dir=='D' ) res = -res; + return res; +} + +/* +** Some powers of 64. These constants are needed in the +** sqliteRealToSortable() routine below. +*/ +#define _64e3 (64.0 * 64.0 * 64.0) +#define _64e4 (64.0 * 64.0 * 64.0 * 64.0) +#define _64e15 (_64e3 * _64e4 * _64e4 * _64e4) +#define _64e16 (_64e4 * _64e4 * _64e4 * _64e4) +#define _64e63 (_64e15 * _64e16 * _64e16 * _64e16) +#define _64e64 (_64e16 * _64e16 * _64e16 * _64e16) + +/* +** The following procedure converts a double-precision floating point +** number into a string. The resulting string has the property that +** two such strings comparied using strcmp() or memcmp() will give the +** same results as a numeric comparison of the original floating point +** numbers. +** +** This routine is used to generate database keys from floating point +** numbers such that the keys sort in the same order as the original +** floating point numbers even though the keys are compared using +** memcmp(). +** +** The calling function should have allocated at least 14 characters +** of space for the buffer z[]. +*/ +void sqliteRealToSortable(double r, char *z){ + int neg; + int exp; + int cnt = 0; + + /* This array maps integers between 0 and 63 into base-64 digits. + ** The digits must be chosen such at their ASCII codes are increasing. + ** This means we can not use the traditional base-64 digit set. */ + static const char zDigit[] = + "0123456789" + "ABCDEFGHIJKLMNOPQRSTUVWXYZ" + "abcdefghijklmnopqrstuvwxyz" + "|~"; + if( r<0.0 ){ + neg = 1; + r = -r; + *z++ = '-'; + } else { + neg = 0; + *z++ = '0'; + } + exp = 0; + + if( r==0.0 ){ + exp = -1024; + }else if( r<(0.5/64.0) ){ + while( r < 0.5/_64e64 && exp > -961 ){ r *= _64e64; exp -= 64; } + while( r < 0.5/_64e16 && exp > -1009 ){ r *= _64e16; exp -= 16; } + while( r < 0.5/_64e4 && exp > -1021 ){ r *= _64e4; exp -= 4; } + while( r < 0.5/64.0 && exp > -1024 ){ r *= 64.0; exp -= 1; } + }else if( r>=0.5 ){ + while( r >= 0.5*_64e63 && exp < 960 ){ r *= 1.0/_64e64; exp += 64; } + while( r >= 0.5*_64e15 && exp < 1008 ){ r *= 1.0/_64e16; exp += 16; } + while( r >= 0.5*_64e3 && exp < 1020 ){ r *= 1.0/_64e4; exp += 4; } + while( r >= 0.5 && exp < 1023 ){ r *= 1.0/64.0; exp += 1; } + } + if( neg ){ + exp = -exp; + r = -r; + } + exp += 1024; + r += 0.5; + if( exp<0 ) return; + if( exp>=2048 || r>=1.0 ){ + strcpy(z, "~~~~~~~~~~~~"); + return; + } + *z++ = zDigit[(exp>>6)&0x3f]; + *z++ = zDigit[exp & 0x3f]; + while( r>0.0 && cnt<10 ){ + int digit; + r *= 64.0; + digit = (int)r; + assert( digit>=0 && digit<64 ); + *z++ = zDigit[digit & 0x3f]; + r -= digit; + cnt++; + } + *z = 0; +} + +#ifdef SQLITE_UTF8 +/* +** X is a pointer to the first byte of a UTF-8 character. Increment +** X so that it points to the next character. This only works right +** if X points to a well-formed UTF-8 string. +*/ +#define sqliteNextChar(X) while( (0xc0&*++(X))==0x80 ){} +#define sqliteCharVal(X) sqlite_utf8_to_int(X) + +#else /* !defined(SQLITE_UTF8) */ +/* +** For iso8859 encoding, the next character is just the next byte. +*/ +#define sqliteNextChar(X) (++(X)); +#define sqliteCharVal(X) ((int)*(X)) + +#endif /* defined(SQLITE_UTF8) */ + + +#ifdef SQLITE_UTF8 +/* +** Convert the UTF-8 character to which z points into a 31-bit +** UCS character. This only works right if z points to a well-formed +** UTF-8 string. +*/ +static int sqlite_utf8_to_int(const unsigned char *z){ + int c; + static const int initVal[] = { + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, + 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, + 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, + 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, + 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, + 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, + 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, + 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, + 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, + 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, + 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, + 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 0, 1, 2, + 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, + 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 0, + 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 0, 1, 254, + 255, + }; + c = initVal[*(z++)]; + while( (0xc0&*z)==0x80 ){ + c = (c<<6) | (0x3f&*(z++)); + } + return c; +} +#endif + +/* +** Compare two UTF-8 strings for equality where the first string can +** potentially be a "glob" expression. Return true (1) if they +** are the same and false (0) if they are different. +** +** Globbing rules: +** +** '*' Matches any sequence of zero or more characters. +** +** '?' Matches exactly one character. +** +** [...] Matches one character from the enclosed list of +** characters. +** +** [^...] Matches one character not in the enclosed list. +** +** With the [...] and [^...] matching, a ']' character can be included +** in the list by making it the first character after '[' or '^'. A +** range of characters can be specified using '-'. Example: +** "[a-z]" matches any single lower-case letter. To match a '-', make +** it the last character in the list. +** +** This routine is usually quick, but can be N**2 in the worst case. +** +** Hints: to match '*' or '?', put them in "[]". Like this: +** +** abc[*]xyz Matches "abc*xyz" only +*/ +int +sqliteGlobCompare(const unsigned char *zPattern, const unsigned char *zString){ + register int c; + int invert; + int seen; + int c2; + + while( (c = *zPattern)!=0 ){ + switch( c ){ + case '*': + while( (c=zPattern[1]) == '*' || c == '?' ){ + if( c=='?' ){ + if( *zString==0 ) return 0; + sqliteNextChar(zString); + } + zPattern++; + } + if( c==0 ) return 1; + if( c=='[' ){ + while( *zString && sqliteGlobCompare(&zPattern[1],zString)==0 ){ + sqliteNextChar(zString); + } + return *zString!=0; + }else{ + while( (c2 = *zString)!=0 ){ + while( c2 != 0 && c2 != c ){ c2 = *++zString; } + if( c2==0 ) return 0; + if( sqliteGlobCompare(&zPattern[1],zString) ) return 1; + sqliteNextChar(zString); + } + return 0; + } + case '?': { + if( *zString==0 ) return 0; + sqliteNextChar(zString); + zPattern++; + break; + } + case '[': { + int prior_c = 0; + 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++; + break; + } + default: { + if( c != *zString ) return 0; + zPattern++; + zString++; + break; + } + } + } + return *zString==0; +} + +/* +** Compare two UTF-8 strings for equality using the "LIKE" operator of +** SQL. The '%' character matches any sequence of 0 or more +** characters and '_' matches any single character. Case is +** not significant. +** +** This routine is just an adaptation of the sqliteGlobCompare() +** routine above. +*/ +int +sqliteLikeCompare(const unsigned char *zPattern, const unsigned char *zString){ + register int c; + int c2; + + while( (c = UpperToLower[*zPattern])!=0 ){ + switch( c ){ + case '%': { + while( (c=zPattern[1]) == '%' || c == '_' ){ + if( c=='_' ){ + if( *zString==0 ) return 0; + sqliteNextChar(zString); + } + zPattern++; + } + if( c==0 ) return 1; + c = UpperToLower[c]; + while( (c2=UpperToLower[*zString])!=0 ){ + while( c2 != 0 && c2 != c ){ c2 = UpperToLower[*++zString]; } + if( c2==0 ) return 0; + if( sqliteLikeCompare(&zPattern[1],zString) ) return 1; + sqliteNextChar(zString); + } + return 0; + } + case '_': { + if( *zString==0 ) return 0; + sqliteNextChar(zString); + zPattern++; + break; + } + default: { + if( c != UpperToLower[*zString] ) return 0; + zPattern++; + zString++; + break; + } + } + } + return *zString==0; +} + +/* +** Change the sqlite.magic from SQLITE_MAGIC_OPEN to SQLITE_MAGIC_BUSY. +** Return an error (non-zero) if the magic was not SQLITE_MAGIC_OPEN +** when this routine is called. +** +** This routine is a attempt to detect if two threads use the +** same sqlite* pointer at the same time. There is a race +** condition so it is possible that the error is not detected. +** But usually the problem will be seen. The result will be an +** error which can be used to debug the application that is +** using SQLite incorrectly. +** +** Ticket #202: If db->magic is not a valid open value, take care not +** to modify the db structure at all. It could be that db is a stale +** pointer. In other words, it could be that there has been a prior +** call to sqlite_close(db) and db has been deallocated. And we do +** not want to write into deallocated memory. +*/ +int sqliteSafetyOn(sqlite *db){ + if( db->magic==SQLITE_MAGIC_OPEN ){ + db->magic = SQLITE_MAGIC_BUSY; + return 0; + }else if( db->magic==SQLITE_MAGIC_BUSY || db->magic==SQLITE_MAGIC_ERROR + || db->want_to_close ){ + db->magic = SQLITE_MAGIC_ERROR; + db->flags |= SQLITE_Interrupt; + } + return 1; +} + +/* +** Change the magic from SQLITE_MAGIC_BUSY to SQLITE_MAGIC_OPEN. +** Return an error (non-zero) if the magic was not SQLITE_MAGIC_BUSY +** when this routine is called. +*/ +int sqliteSafetyOff(sqlite *db){ + if( db->magic==SQLITE_MAGIC_BUSY ){ + db->magic = SQLITE_MAGIC_OPEN; + return 0; + }else if( db->magic==SQLITE_MAGIC_OPEN || db->magic==SQLITE_MAGIC_ERROR + || db->want_to_close ){ + db->magic = SQLITE_MAGIC_ERROR; + db->flags |= SQLITE_Interrupt; + } + return 1; +} + +/* +** Check to make sure we are not currently executing an sqlite_exec(). +** If we are currently in an sqlite_exec(), return true and set +** sqlite.magic to SQLITE_MAGIC_ERROR. This will cause a complete +** shutdown of the database. +** +** This routine is used to try to detect when API routines are called +** at the wrong time or in the wrong sequence. +*/ +int sqliteSafetyCheck(sqlite *db){ + if( db->pVdbe!=0 ){ + db->magic = SQLITE_MAGIC_ERROR; + return 1; + } + return 0; +} diff --git a/kexi/3rdparty/kexisql/src/vacuum.c b/kexi/3rdparty/kexisql/src/vacuum.c new file mode 100644 index 00000000..be01ad95 --- /dev/null +++ b/kexi/3rdparty/kexisql/src/vacuum.c @@ -0,0 +1,327 @@ +/* +** 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 VACUUM command. +** +** Most of the code in this file may be omitted by defining the +** SQLITE_OMIT_VACUUM macro. +** +** $Id: vacuum.c 410099 2005-05-06 17:52:07Z staniek $ +*/ +#include "sqliteInt.h" +#include "os.h" + +/* +** A structure for holding a dynamic string - a string that can grow +** without bound. +*/ +typedef struct dynStr dynStr; +struct dynStr { + char *z; /* Text of the string in space obtained from sqliteMalloc() */ + int nAlloc; /* Amount of space allocated to z[] */ + int nUsed; /* Next unused slot in z[] */ +}; + +/* +** A structure that holds the vacuum context +*/ +typedef struct vacuumStruct vacuumStruct; +struct vacuumStruct { + sqlite *dbOld; /* Original database */ + sqlite *dbNew; /* New database */ + char **pzErrMsg; /* Write errors here */ + int rc; /* Set to non-zero on an error */ + const char *zTable; /* Name of a table being copied */ + const char *zPragma; /* Pragma to execute with results */ + dynStr s1, s2; /* Two dynamic strings */ +}; + +#if !defined(SQLITE_OMIT_VACUUM) || SQLITE_OMIT_VACUUM +/* +** Append text to a dynamic string +*/ +static void appendText(dynStr *p, const char *zText, int nText){ + if( nText<0 ) nText = strlen(zText); + if( p->z==0 || p->nUsed + nText + 1 >= p->nAlloc ){ + char *zNew; + p->nAlloc = p->nUsed + nText + 1000; + zNew = sqliteRealloc(p->z, p->nAlloc); + if( zNew==0 ){ + sqliteFree(p->z); + memset(p, 0, sizeof(*p)); + return; + } + p->z = zNew; + } + memcpy(&p->z[p->nUsed], zText, nText+1); + p->nUsed += nText; +} + +/* +** Append text to a dynamic string, having first put the text in quotes. +*/ +static void appendQuoted(dynStr *p, const char *zText){ + int i, j; + appendText(p, "'", 1); + for(i=j=0; zText[i]; i++){ + if( zText[i]=='\'' ){ + appendText(p, &zText[j], i-j+1); + j = i + 1; + appendText(p, "'", 1); + } + } + if( j<i ){ + appendText(p, &zText[j], i-j); + } + appendText(p, "'", 1); +} + +/* +** Execute statements of SQL. If an error occurs, write the error +** message into *pzErrMsg and return non-zero. +*/ +static int execsql(char **pzErrMsg, sqlite *db, const char *zSql){ + char *zErrMsg = 0; + int rc; + + /* printf("***** executing *****\n%s\n", zSql); */ + rc = sqlite_exec(db, zSql, 0, 0, &zErrMsg); + if( zErrMsg ){ + sqliteSetString(pzErrMsg, zErrMsg, (char*)0); + sqlite_freemem(zErrMsg); + } + return rc; +} + +/* +** This is the second stage callback. Each invocation contains all the +** data for a single row of a single table in the original database. This +** routine must write that information into the new database. +*/ +static int vacuumCallback2(void *pArg, int argc, char **argv, char **NotUsed){ + vacuumStruct *p = (vacuumStruct*)pArg; + const char *zSep = "("; + int i; + + if( argv==0 ) return 0; + p->s2.nUsed = 0; + appendText(&p->s2, "INSERT INTO ", -1); + appendQuoted(&p->s2, p->zTable); + appendText(&p->s2, " VALUES", -1); + for(i=0; i<argc; i++){ + appendText(&p->s2, zSep, 1); + zSep = ","; + if( argv[i]==0 ){ + appendText(&p->s2, "NULL", 4); + }else{ + appendQuoted(&p->s2, argv[i]); + } + } + appendText(&p->s2,")", 1); + p->rc = execsql(p->pzErrMsg, p->dbNew, p->s2.z); + return p->rc; +} + +/* +** This is the first stage callback. Each invocation contains three +** arguments where are taken from the SQLITE_MASTER table of the original +** database: (1) the entry type, (2) the entry name, and (3) the SQL for +** the entry. In all cases, execute the SQL of the third argument. +** For tables, run a query to select all entries in that table and +** transfer them to the second-stage callback. +*/ +static int vacuumCallback1(void *pArg, int argc, char **argv, char **NotUsed){ + vacuumStruct *p = (vacuumStruct*)pArg; + int rc = 0; + assert( argc==3 ); + if( argv==0 ) return 0; + assert( argv[0]!=0 ); + assert( argv[1]!=0 ); + assert( argv[2]!=0 ); + rc = execsql(p->pzErrMsg, p->dbNew, argv[2]); + if( rc==SQLITE_OK && strcmp(argv[0],"table")==0 ){ + char *zErrMsg = 0; + p->s1.nUsed = 0; + appendText(&p->s1, "SELECT * FROM ", -1); + appendQuoted(&p->s1, argv[1]); + p->zTable = argv[1]; + rc = sqlite_exec(p->dbOld, p->s1.z, vacuumCallback2, p, &zErrMsg); + if( zErrMsg ){ + sqliteSetString(p->pzErrMsg, zErrMsg, (char*)0); + sqlite_freemem(zErrMsg); + } + } + if( rc!=SQLITE_ABORT ) p->rc = rc; + return rc; +} + +/* +** This callback is used to transfer PRAGMA settings from one database +** to the other. The value in argv[0] should be passed to a pragma +** identified by ((vacuumStruct*)pArg)->zPragma. +*/ +static int vacuumCallback3(void *pArg, int argc, char **argv, char **NotUsed){ + vacuumStruct *p = (vacuumStruct*)pArg; + char zBuf[200]; + assert( argc==1 ); + if( argv==0 ) return 0; + assert( argv[0]!=0 ); + assert( strlen(p->zPragma)<100 ); + assert( strlen(argv[0])<30 ); + sprintf(zBuf,"PRAGMA %s=%s;", p->zPragma, argv[0]); + p->rc = execsql(p->pzErrMsg, p->dbNew, zBuf); + return p->rc; +} + +/* +** Generate a random name of 20 character in length. +*/ +static void randomName(unsigned char *zBuf){ + static const unsigned char zChars[] = + "abcdefghijklmnopqrstuvwxyz" + "0123456789"; + int i; + sqliteRandomness(20, zBuf); + for(i=0; i<20; i++){ + zBuf[i] = zChars[ zBuf[i]%(sizeof(zChars)-1) ]; + } +} +#endif + +/* +** The non-standard VACUUM command is used to clean up the database, +** collapse free space, etc. It is modelled after the VACUUM command +** in PostgreSQL. +** +** In version 1.0.x of SQLite, the VACUUM command would call +** gdbm_reorganize() on all the database tables. But beginning +** with 2.0.0, SQLite no longer uses GDBM so this command has +** become a no-op. +*/ +void sqliteVacuum(Parse *pParse, Token *pTableName){ + Vdbe *v = sqliteGetVdbe(pParse); + sqliteVdbeAddOp(v, OP_Vacuum, 0, 0); + return; +} + +/* +** This routine implements the OP_Vacuum opcode of the VDBE. +*/ +int sqliteRunVacuum(char **pzErrMsg, sqlite *db){ +#if !defined(SQLITE_OMIT_VACUUM) || SQLITE_OMIT_VACUUM + const char *zFilename; /* full pathname of the database file */ + int nFilename; /* number of characters in zFilename[] */ + char *zTemp = 0; /* a temporary file in same directory as zFilename */ + sqlite *dbNew = 0; /* The new vacuumed database */ + int rc = SQLITE_OK; /* Return code from service routines */ + int i; /* Loop counter */ + char *zErrMsg; /* Error message */ + vacuumStruct sVac; /* Information passed to callbacks */ + + /* These are all of the pragmas that need to be transferred over + ** to the new database */ + static const char *zPragma[] = { + "default_synchronous", + "default_cache_size", + /* "default_temp_store", */ + }; + + if( db->flags & SQLITE_InTrans ){ + sqliteSetString(pzErrMsg, "cannot VACUUM from within a transaction", + (char*)0); + return SQLITE_ERROR; + } + if( db->flags & SQLITE_Interrupt ){ + return SQLITE_INTERRUPT; + } + memset(&sVac, 0, sizeof(sVac)); + + /* Get the full pathname of the database file and create two + ** temporary filenames in the same directory as the original file. + */ + zFilename = sqliteBtreeGetFilename(db->aDb[0].pBt); + if( zFilename==0 ){ + /* This only happens with the in-memory database. VACUUM is a no-op + ** there, so just return */ + return SQLITE_OK; + } + nFilename = strlen(zFilename); + zTemp = sqliteMalloc( nFilename+100 ); + if( zTemp==0 ) return SQLITE_NOMEM; + strcpy(zTemp, zFilename); + for(i=0; i<10; i++){ + zTemp[nFilename] = '-'; + randomName((unsigned char*)&zTemp[nFilename+1]); + if( !sqliteOsFileExists(zTemp) ) break; + } + if( i>=10 ){ + sqliteSetString(pzErrMsg, "unable to create a temporary database file " + "in the same directory as the original database", (char*)0); + goto end_of_vacuum; + } + + + dbNew = sqlite_open(zTemp, 0, &zErrMsg); + if( dbNew==0 ){ + sqliteSetString(pzErrMsg, "unable to open a temporary database at ", + zTemp, " - ", zErrMsg, (char*)0); + goto end_of_vacuum; + } + if( (rc = execsql(pzErrMsg, db, "BEGIN"))!=0 ) goto end_of_vacuum; + if( (rc = execsql(pzErrMsg, dbNew, "PRAGMA synchronous=off; BEGIN"))!=0 ){ + goto end_of_vacuum; + } + + sVac.dbOld = db; + sVac.dbNew = dbNew; + sVac.pzErrMsg = pzErrMsg; + for(i=0; rc==SQLITE_OK && i<sizeof(zPragma)/sizeof(zPragma[0]); i++){ + char zBuf[200]; + assert( strlen(zPragma[i])<100 ); + sprintf(zBuf, "PRAGMA %s;", zPragma[i]); + sVac.zPragma = zPragma[i]; + rc = sqlite_exec(db, zBuf, vacuumCallback3, &sVac, &zErrMsg); + } + if( rc==SQLITE_OK ){ + rc = sqlite_exec(db, + "SELECT type, name, sql FROM sqlite_master " + "WHERE sql NOT NULL AND type!='view' " + "UNION ALL " + "SELECT type, name, sql FROM sqlite_master " + "WHERE sql NOT NULL AND type=='view'", + vacuumCallback1, &sVac, &zErrMsg); + } + if( rc==SQLITE_OK ){ + rc = sqliteBtreeCopyFile(db->aDb[0].pBt, dbNew->aDb[0].pBt); + sqlite_exec(db, "COMMIT", 0, 0, 0); + sqliteResetInternalSchema(db, 0); + } + +end_of_vacuum: + if( rc && zErrMsg!=0 ){ + sqliteSetString(pzErrMsg, "unable to vacuum database - ", + zErrMsg, (char*)0); + } + sqlite_exec(db, "ROLLBACK", 0, 0, 0); + if( (dbNew && (dbNew->flags & SQLITE_Interrupt)) + || (db->flags & SQLITE_Interrupt) ){ + rc = SQLITE_INTERRUPT; + } + if( dbNew ) sqlite_close(dbNew); + sqliteOsDelete(zTemp); + sqliteFree(zTemp); + sqliteFree(sVac.s1.z); + sqliteFree(sVac.s2.z); + if( zErrMsg ) sqlite_freemem(zErrMsg); + if( rc==SQLITE_ABORT && sVac.rc!=SQLITE_INTERRUPT ) sVac.rc = SQLITE_ERROR; + return sVac.rc; +#endif +} diff --git a/kexi/3rdparty/kexisql/src/vdbe.c b/kexi/3rdparty/kexisql/src/vdbe.c new file mode 100644 index 00000000..fb52ef38 --- /dev/null +++ b/kexi/3rdparty/kexisql/src/vdbe.c @@ -0,0 +1,4917 @@ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** The code in this file implements execution method of the +** Virtual Database Engine (VDBE). A separate file ("vdbeaux.c") +** handles housekeeping details such as creating and deleting +** VDBE instances. This file is solely interested in executing +** the VDBE program. +** +** In the external interface, an "sqlite_vm*" is an opaque pointer +** to a VDBE. +** +** The SQL parser generates a program which is then executed by +** the VDBE to do the work of the SQL statement. VDBE programs are +** similar in form to assembly language. The program consists of +** a linear sequence of operations. Each operation has an opcode +** and 3 operands. Operands P1 and P2 are integers. Operand P3 +** is a null-terminated string. The P2 operand must be non-negative. +** Opcodes will typically ignore one or more operands. Many opcodes +** ignore all three operands. +** +** Computation results are stored on a stack. Each entry on the +** stack is either an integer, a null-terminated string, a floating point +** number, or the SQL "NULL" value. An inplicit conversion from one +** type to the other occurs as necessary. +** +** Most of the code in this file is taken up by the sqliteVdbeExec() +** function which does the work of interpreting a VDBE program. +** But other routines are also provided to help in building up +** a program instruction by instruction. +** +** Various scripts scan this source file in order to generate HTML +** documentation, headers files, or other derived files. The formatting +** of the code in this file is, therefore, important. See other comments +** in this file for details. If in doubt, do not deviate from existing +** commenting and indentation practices when changing or adding code. +** +** $Id: vdbe.c 410099 2005-05-06 17:52:07Z staniek $ +*/ +#include "sqliteInt.h" +#include "os.h" +#include <ctype.h> +#include "vdbeInt.h" + +/* +** The following global variable is incremented every time a cursor +** moves, either by the OP_MoveTo or the OP_Next opcode. The test +** procedures use this information to make sure that indices are +** working correctly. This variable has no function other than to +** help verify the correct operation of the library. +*/ +int sqlite_search_count = 0; + +/* +** When this global variable is positive, it gets decremented once before +** each instruction in the VDBE. When reaches zero, the SQLITE_Interrupt +** of the db.flags field is set in order to simulate an interrupt. +** +** This facility is used for testing purposes only. It does not function +** in an ordinary build. +*/ +int sqlite_interrupt_count = 0; + +/* +** Advance the virtual machine to the next output row. +** +** The return vale will be either SQLITE_BUSY, SQLITE_DONE, +** SQLITE_ROW, SQLITE_ERROR, or SQLITE_MISUSE. +** +** SQLITE_BUSY means that the virtual machine attempted to open +** a locked database and there is no busy callback registered. +** Call sqlite_step() again to retry the open. *pN is set to 0 +** and *pazColName and *pazValue are both set to NULL. +** +** SQLITE_DONE means that the virtual machine has finished +** executing. sqlite_step() should not be called again on this +** virtual machine. *pN and *pazColName are set appropriately +** but *pazValue is set to NULL. +** +** SQLITE_ROW means that the virtual machine has generated another +** row of the result set. *pN is set to the number of columns in +** the row. *pazColName is set to the names of the columns followed +** by the column datatypes. *pazValue is set to the values of each +** column in the row. The value of the i-th column is (*pazValue)[i]. +** The name of the i-th column is (*pazColName)[i] and the datatype +** of the i-th column is (*pazColName)[i+*pN]. +** +** SQLITE_ERROR means that a run-time error (such as a constraint +** violation) has occurred. The details of the error will be returned +** by the next call to sqlite_finalize(). sqlite_step() should not +** be called again on the VM. +** +** 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 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 */ +){ + Vdbe *p = (Vdbe*)pVm; + sqlite *db; + int rc; + + if( p->magic!=VDBE_MAGIC_RUN ){ + return SQLITE_MISUSE; + } + db = p->db; + if( sqliteSafetyOn(db) ){ + p->rc = SQLITE_MISUSE; + return SQLITE_MISUSE; + } + if( p->explain ){ + rc = sqliteVdbeList(p); + }else{ + rc = sqliteVdbeExec(p); + } + if( rc==SQLITE_DONE || rc==SQLITE_ROW ){ + if( pazColName ) *pazColName = (const char**)p->azColName; + if( pN ) *pN = p->nResColumn; + }else{ + if( pazColName) *pazColName = 0; + if( pN ) *pN = 0; + } + if( pazValue ){ + if( rc==SQLITE_ROW ){ + *pazValue = (const char**)p->azResColumn; + }else{ + *pazValue = 0; + } + } + if( sqliteSafetyOff(db) ){ + return SQLITE_MISUSE; + } + return rc; +} + +/* +** Insert a new aggregate element and make it the element that +** has focus. +** +** Return 0 on success and 1 if memory is exhausted. +*/ +static int AggInsert(Agg *p, char *zKey, int nKey){ + AggElem *pElem, *pOld; + int i; + Mem *pMem; + pElem = sqliteMalloc( sizeof(AggElem) + nKey + + (p->nMem-1)*sizeof(pElem->aMem[0]) ); + if( pElem==0 ) return 1; + pElem->zKey = (char*)&pElem->aMem[p->nMem]; + memcpy(pElem->zKey, zKey, nKey); + pElem->nKey = nKey; + pOld = sqliteHashInsert(&p->hash, pElem->zKey, pElem->nKey, pElem); + if( pOld!=0 ){ + assert( pOld==pElem ); /* Malloc failed on insert */ + sqliteFree(pOld); + return 0; + } + for(i=0, pMem=pElem->aMem; i<p->nMem; i++, pMem++){ + pMem->flags = MEM_Null; + } + p->pCurrent = pElem; + return 0; +} + +/* +** Get the AggElem currently in focus +*/ +#define AggInFocus(P) ((P).pCurrent ? (P).pCurrent : _AggInFocus(&(P))) +static AggElem *_AggInFocus(Agg *p){ + HashElem *pElem = sqliteHashFirst(&p->hash); + if( pElem==0 ){ + AggInsert(p,"",1); + pElem = sqliteHashFirst(&p->hash); + } + return pElem ? sqliteHashData(pElem) : 0; +} + +/* +** Convert the given stack entity into a string if it isn't one +** already. +*/ +#define Stringify(P) if(((P)->flags & MEM_Str)==0){hardStringify(P);} +static int hardStringify(Mem *pStack){ + int fg = pStack->flags; + if( fg & MEM_Real ){ + sqlite_snprintf(sizeof(pStack->zShort),pStack->zShort,"%.15g",pStack->r); + }else if( fg & MEM_Int ){ + sqlite_snprintf(sizeof(pStack->zShort),pStack->zShort,"%d",pStack->i); + }else{ + pStack->zShort[0] = 0; + } + pStack->z = pStack->zShort; + pStack->n = strlen(pStack->zShort)+1; + pStack->flags = MEM_Str | MEM_Short; + return 0; +} + +/* +** Convert the given stack entity into a string that has been obtained +** from sqliteMalloc(). This is different from Stringify() above in that +** Stringify() will use the NBFS bytes of static string space if the string +** will fit but this routine always mallocs for space. +** Return non-zero if we run out of memory. +*/ +#define Dynamicify(P) (((P)->flags & MEM_Dyn)==0 ? hardDynamicify(P):0) +static int hardDynamicify(Mem *pStack){ + int fg = pStack->flags; + char *z; + if( (fg & MEM_Str)==0 ){ + hardStringify(pStack); + } + assert( (fg & MEM_Dyn)==0 ); + z = sqliteMallocRaw( pStack->n ); + if( z==0 ) return 1; + memcpy(z, pStack->z, pStack->n); + pStack->z = z; + pStack->flags |= MEM_Dyn; + return 0; +} + +/* +** An ephemeral string value (signified by the MEM_Ephem flag) contains +** a pointer to a dynamically allocated string where some other entity +** is responsible for deallocating that string. Because the stack entry +** does not control the string, it might be deleted without the stack +** entry knowing it. +** +** This routine converts an ephemeral string into a dynamically allocated +** string that the stack entry itself controls. In other words, it +** converts an MEM_Ephem string into an MEM_Dyn string. +*/ +#define Deephemeralize(P) \ + if( ((P)->flags&MEM_Ephem)!=0 && hardDeephem(P) ){ goto no_mem;} +static int hardDeephem(Mem *pStack){ + char *z; + assert( (pStack->flags & MEM_Ephem)!=0 ); + z = sqliteMallocRaw( pStack->n ); + if( z==0 ) return 1; + memcpy(z, pStack->z, pStack->n); + pStack->z = z; + pStack->flags &= ~MEM_Ephem; + pStack->flags |= MEM_Dyn; + return 0; +} + +/* +** Release the memory associated with the given stack level. This +** leaves the Mem.flags field in an inconsistent state. +*/ +#define Release(P) if((P)->flags&MEM_Dyn){ sqliteFree((P)->z); } + +/* +** Pop the stack N times. +*/ +static void popStack(Mem **ppTos, int N){ + Mem *pTos = *ppTos; + while( N>0 ){ + N--; + Release(pTos); + pTos--; + } + *ppTos = pTos; +} + +/* +** Return TRUE if zNum is a 32-bit signed integer and write +** the value of the integer into *pNum. If zNum is not an integer +** or is an integer that is too large to be expressed with just 32 +** bits, then return false. +** +** Under Linux (RedHat 7.2) this routine is much faster than atoi() +** for converting strings into integers. +*/ +static int toInt(const char *zNum, int *pNum){ + int v = 0; + int neg; + int i, c; + if( *zNum=='-' ){ + neg = 1; + zNum++; + }else if( *zNum=='+' ){ + neg = 0; + zNum++; + }else{ + neg = 0; + } + for(i=0; (c=zNum[i])>='0' && c<='9'; i++){ + v = v*10 + c - '0'; + } + *pNum = neg ? -v : v; + return c==0 && i>0 && (i<10 || (i==10 && memcmp(zNum,"2147483647",10)<=0)); +} + +/* +** Convert the given stack entity into a integer if it isn't one +** already. +** +** Any prior string or real representation is invalidated. +** NULLs are converted into 0. +*/ +#define Integerify(P) if(((P)->flags&MEM_Int)==0){ hardIntegerify(P); } +static void hardIntegerify(Mem *pStack){ + if( pStack->flags & MEM_Real ){ + pStack->i = (int)pStack->r; + Release(pStack); + }else if( pStack->flags & MEM_Str ){ + toInt(pStack->z, &pStack->i); + Release(pStack); + }else{ + pStack->i = 0; + } + pStack->flags = MEM_Int; +} + +/* +** Get a valid Real representation for the given stack element. +** +** Any prior string or integer representation is retained. +** NULLs are converted into 0.0. +*/ +#define Realify(P) if(((P)->flags&MEM_Real)==0){ hardRealify(P); } +static void hardRealify(Mem *pStack){ + if( pStack->flags & MEM_Str ){ + pStack->r = sqliteAtoF(pStack->z, 0); + }else if( pStack->flags & MEM_Int ){ + pStack->r = pStack->i; + }else{ + pStack->r = 0.0; + } + pStack->flags |= MEM_Real; +} + +/* +** The parameters are pointers to the head of two sorted lists +** of Sorter structures. Merge these two lists together and return +** a single sorted list. This routine forms the core of the merge-sort +** algorithm. +** +** In the case of a tie, left sorts in front of right. +*/ +static Sorter *Merge(Sorter *pLeft, Sorter *pRight){ + Sorter sHead; + Sorter *pTail; + pTail = &sHead; + pTail->pNext = 0; + while( pLeft && pRight ){ + int c = sqliteSortCompare(pLeft->zKey, pRight->zKey); + if( c<=0 ){ + pTail->pNext = pLeft; + pLeft = pLeft->pNext; + }else{ + pTail->pNext = pRight; + pRight = pRight->pNext; + } + pTail = pTail->pNext; + } + if( pLeft ){ + pTail->pNext = pLeft; + }else if( pRight ){ + pTail->pNext = pRight; + } + return sHead.pNext; +} + +/* +** The following routine works like a replacement for the standard +** library routine fgets(). The difference is in how end-of-line (EOL) +** is handled. Standard fgets() uses LF for EOL under unix, CRLF +** under windows, and CR under mac. This routine accepts any of these +** character sequences as an EOL mark. The EOL mark is replaced by +** a single LF character in zBuf. +*/ +static char *vdbe_fgets(char *zBuf, int nBuf, FILE *in){ + int i, c; + for(i=0; i<nBuf-1 && (c=getc(in))!=EOF; i++){ + zBuf[i] = c; + if( c=='\r' || c=='\n' ){ + if( c=='\r' ){ + zBuf[i] = '\n'; + c = getc(in); + if( c!=EOF && c!='\n' ) ungetc(c, in); + } + i++; + break; + } + } + zBuf[i] = 0; + return i>0 ? zBuf : 0; +} + +/* +** Make sure there is space in the Vdbe structure to hold at least +** mxCursor cursors. If there is not currently enough space, then +** allocate more. +** +** If a memory allocation error occurs, return 1. Return 0 if +** everything works. +*/ +static int expandCursorArraySize(Vdbe *p, int mxCursor){ + if( mxCursor>=p->nCursor ){ + Cursor *aCsr = sqliteRealloc( p->aCsr, (mxCursor+1)*sizeof(Cursor) ); + if( aCsr==0 ) return 1; + p->aCsr = aCsr; + memset(&p->aCsr[p->nCursor], 0, sizeof(Cursor)*(mxCursor+1-p->nCursor)); + p->nCursor = mxCursor+1; + } + return 0; +} + +#ifdef VDBE_PROFILE +/* +** The following routine only works on pentium-class processors. +** It uses the RDTSC opcode to read cycle count value out of the +** processor and returns that value. This can be used for high-res +** profiling. +*/ +__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; +} +#endif + +/* +** The CHECK_FOR_INTERRUPT macro defined here looks to see if the +** sqlite_interrupt() routine has been called. If it has been, then +** processing of the VDBE program is interrupted. +** +** This macro added to every instruction that does a jump in order to +** implement a loop. This test used to be on every single instruction, +** but that meant we more testing that we needed. By only testing the +** flag on jump instructions, we get a (small) speed improvement. +*/ +#define CHECK_FOR_INTERRUPT \ + if( db->flags & SQLITE_Interrupt ) goto abort_due_to_interrupt; + + +/* +** Execute as much of a VDBE program as we can then return. +** +** sqliteVdbeMakeReady() must be called before this routine in order to +** close the program with a final OP_Halt and to set up the callbacks +** and the error message pointer. +** +** Whenever a row or result data is available, this routine will either +** invoke the result callback (if there is one) or return with +** SQLITE_ROW. +** +** If an attempt is made to open a locked database, then this routine +** will either invoke the busy callback (if there is one) or it will +** return SQLITE_BUSY. +** +** If an error occurs, an error message is written to memory obtained +** from sqliteMalloc() and p->zErrMsg is made to point to that memory. +** The error code is stored in p->rc and this routine returns SQLITE_ERROR. +** +** If the callback ever returns non-zero, then the program exits +** immediately. There will be no error message but the p->rc field is +** set to SQLITE_ABORT and this routine will return SQLITE_ERROR. +** +** A memory allocation error causes p->rc to be set to SQLITE_NOMEM and this +** routine to return SQLITE_ERROR. +** +** Other fatal errors return SQLITE_ERROR. +** +** After this routine has finished, sqliteVdbeFinalize() should be +** used to clean up the mess that was left behind. +*/ +int sqliteVdbeExec( + Vdbe *p /* The VDBE */ +){ + int pc; /* The program counter */ + Op *pOp; /* Current operation */ + int rc = SQLITE_OK; /* Value to return */ + sqlite *db = p->db; /* The database */ + Mem *pTos; /* Top entry in the operand stack */ + char zBuf[100]; /* Space to sprintf() an integer */ +#ifdef VDBE_PROFILE + unsigned long long start; /* CPU clock count at start of opcode */ + int origPc; /* Program counter at start of opcode */ +#endif +#ifndef SQLITE_OMIT_PROGRESS_CALLBACK + int nProgressOps = 0; /* Opcodes executed since progress callback. */ +#endif + + if( p->magic!=VDBE_MAGIC_RUN ) return SQLITE_MISUSE; + assert( db->magic==SQLITE_MAGIC_BUSY ); + assert( p->rc==SQLITE_OK || p->rc==SQLITE_BUSY ); + p->rc = SQLITE_OK; + assert( p->explain==0 ); + if( sqlite_malloc_failed ) goto no_mem; + pTos = p->pTos; + if( p->popStack ){ + popStack(&pTos, p->popStack); + p->popStack = 0; + } + CHECK_FOR_INTERRUPT; + for(pc=p->pc; rc==SQLITE_OK; pc++){ + assert( pc>=0 && pc<p->nOp ); + assert( pTos<=&p->aStack[pc] ); +#ifdef VDBE_PROFILE + origPc = pc; + start = hwtime(); +#endif + pOp = &p->aOp[pc]; + + /* Only allow tracing if NDEBUG is not defined. + */ +#ifndef NDEBUG + if( p->trace ){ + sqliteVdbePrintOp(p->trace, pc, pOp); + } +#endif + + /* Check to see if we need to simulate an interrupt. This only happens + ** if we have a special test build. + */ +#ifdef SQLITE_TEST + if( sqlite_interrupt_count>0 ){ + sqlite_interrupt_count--; + if( sqlite_interrupt_count==0 ){ + sqlite_interrupt(db); + } + } +#endif + +#ifndef SQLITE_OMIT_PROGRESS_CALLBACK + /* Call the progress callback if it is configured and the required number + ** of VDBE ops have been executed (either since this invocation of + ** sqliteVdbeExec() or since last time the progress callback was called). + ** If the progress callback returns non-zero, exit the virtual machine with + ** a return code SQLITE_ABORT. + */ + if( db->xProgress ){ + if( db->nProgressOps==nProgressOps ){ + if( db->xProgress(db->pProgressArg)!=0 ){ + rc = SQLITE_ABORT; + continue; /* skip to the next iteration of the for loop */ + } + nProgressOps = 0; + } + nProgressOps++; + } +#endif + + switch( pOp->opcode ){ + +/***************************************************************************** +** What follows is a massive switch statement where each case implements a +** separate instruction in the virtual machine. If we follow the usual +** indentation conventions, each case should be indented by 6 spaces. But +** that is a lot of wasted space on the left margin. So the code within +** the switch statement will break with convention and be flush-left. Another +** big comment (similar to this one) will mark the point in the code where +** we transition back to normal indentation. +** +** The formatting of each case is important. The makefile for SQLite +** generates two C files "opcodes.h" and "opcodes.c" by scanning this +** file looking for lines that begin with "case OP_". The opcodes.h files +** will be filled with #defines that give unique integer values to each +** opcode and the opcodes.c file is filled with an array of strings where +** each string is the symbolic name for the corresponding opcode. +** +** Documentation about VDBE opcodes is generated by scanning this file +** for lines of that contain "Opcode:". That line and all subsequent +** comment lines are used in the generation of the opcode.html documentation +** file. +** +** SUMMARY: +** +** Formatting is important to scripts that scan this file. +** Do not deviate from the formatting style currently in use. +** +*****************************************************************************/ + +/* Opcode: Goto * P2 * +** +** An unconditional jump to address P2. +** The next instruction executed will be +** the one at index P2 from the beginning of +** the program. +*/ +case OP_Goto: { + CHECK_FOR_INTERRUPT; + pc = pOp->p2 - 1; + break; +} + +/* Opcode: Gosub * P2 * +** +** Push the current address plus 1 onto the return address stack +** and then jump to address P2. +** +** The return address stack is of limited depth. If too many +** OP_Gosub operations occur without intervening OP_Returns, then +** the return address stack will fill up and processing will abort +** with a fatal error. +*/ +case OP_Gosub: { + if( p->returnDepth>=sizeof(p->returnStack)/sizeof(p->returnStack[0]) ){ + sqliteSetString(&p->zErrMsg, "return address stack overflow", (char*)0); + p->rc = SQLITE_INTERNAL; + return SQLITE_ERROR; + } + p->returnStack[p->returnDepth++] = pc+1; + pc = pOp->p2 - 1; + break; +} + +/* Opcode: Return * * * +** +** Jump immediately to the next instruction after the last unreturned +** OP_Gosub. If an OP_Return has occurred for all OP_Gosubs, then +** processing aborts with a fatal error. +*/ +case OP_Return: { + if( p->returnDepth<=0 ){ + sqliteSetString(&p->zErrMsg, "return address stack underflow", (char*)0); + p->rc = SQLITE_INTERNAL; + return SQLITE_ERROR; + } + p->returnDepth--; + pc = p->returnStack[p->returnDepth] - 1; + break; +} + +/* Opcode: Halt P1 P2 * +** +** Exit immediately. All open cursors, Lists, Sorts, etc are closed +** automatically. +** +** P1 is the result code returned by sqlite_exec(). For a normal +** halt, this should be SQLITE_OK (0). For errors, it can be some +** other value. If P1!=0 then P2 will determine whether or not to +** rollback the current transaction. Do not rollback if P2==OE_Fail. +** Do the rollback if P2==OE_Rollback. If P2==OE_Abort, then back +** out all changes that have occurred during this execution of the +** VDBE, but do not rollback the transaction. +** +** There is an implied "Halt 0 0 0" instruction inserted at the very end of +** every program. So a jump past the last instruction of the program +** is the same as executing Halt. +*/ +case OP_Halt: { + p->magic = VDBE_MAGIC_HALT; + p->pTos = pTos; + if( pOp->p1!=SQLITE_OK ){ + p->rc = pOp->p1; + p->errorAction = pOp->p2; + if( pOp->p3 ){ + sqliteSetString(&p->zErrMsg, pOp->p3, (char*)0); + } + return SQLITE_ERROR; + }else{ + p->rc = SQLITE_OK; + return SQLITE_DONE; + } +} + +/* Opcode: Integer P1 * P3 +** +** The integer value P1 is pushed onto the stack. If P3 is not zero +** then it is assumed to be a string representation of the same integer. +*/ +case OP_Integer: { + pTos++; + pTos->i = pOp->p1; + pTos->flags = MEM_Int; + if( pOp->p3 ){ + pTos->z = pOp->p3; + pTos->flags |= MEM_Str | MEM_Static; + pTos->n = strlen(pOp->p3)+1; + } + break; +} + +/* Opcode: String * * P3 +** +** The string value P3 is pushed onto the stack. If P3==0 then a +** NULL is pushed onto the stack. +*/ +case OP_String: { + char *z = pOp->p3; + pTos++; + if( z==0 ){ + pTos->flags = MEM_Null; + }else{ + pTos->z = z; + pTos->n = strlen(z) + 1; + pTos->flags = MEM_Str | MEM_Static; + } + break; +} + +/* Opcode: Variable P1 * * +** +** Push the value of variable P1 onto the stack. A variable is +** an unknown in the original SQL string as handed to sqlite_compile(). +** Any occurance of the '?' character in the original SQL is considered +** a variable. Variables in the SQL string are number from left to +** right beginning with 1. The values of variables are set using the +** sqlite_bind() API. +*/ +case OP_Variable: { + int j = pOp->p1 - 1; + pTos++; + if( j>=0 && j<p->nVar && p->azVar[j]!=0 ){ + pTos->z = p->azVar[j]; + pTos->n = p->anVar[j]; + pTos->flags = MEM_Str | MEM_Static; + }else{ + pTos->flags = MEM_Null; + } + break; +} + +/* Opcode: Pop P1 * * +** +** P1 elements are popped off of the top of stack and discarded. +*/ +case OP_Pop: { + assert( pOp->p1>=0 ); + popStack(&pTos, pOp->p1); + assert( pTos>=&p->aStack[-1] ); + break; +} + +/* Opcode: Dup P1 P2 * +** +** A copy of the P1-th element of the stack +** is made and pushed onto the top of the stack. +** The top of the stack is element 0. So the +** instruction "Dup 0 0 0" will make a copy of the +** top of the stack. +** +** If the content of the P1-th element is a dynamically +** allocated string, then a new copy of that string +** is made if P2==0. If P2!=0, then just a pointer +** to the string is copied. +** +** Also see the Pull instruction. +*/ +case OP_Dup: { + Mem *pFrom = &pTos[-pOp->p1]; + assert( pFrom<=pTos && pFrom>=p->aStack ); + pTos++; + memcpy(pTos, pFrom, sizeof(*pFrom)-NBFS); + if( pTos->flags & MEM_Str ){ + if( pOp->p2 && (pTos->flags & (MEM_Dyn|MEM_Ephem)) ){ + pTos->flags &= ~MEM_Dyn; + pTos->flags |= MEM_Ephem; + }else if( pTos->flags & MEM_Short ){ + memcpy(pTos->zShort, pFrom->zShort, pTos->n); + pTos->z = pTos->zShort; + }else if( (pTos->flags & MEM_Static)==0 ){ + pTos->z = sqliteMallocRaw(pFrom->n); + if( sqlite_malloc_failed ) goto no_mem; + memcpy(pTos->z, pFrom->z, pFrom->n); + pTos->flags &= ~(MEM_Static|MEM_Ephem|MEM_Short); + pTos->flags |= MEM_Dyn; + } + } + break; +} + +/* Opcode: Pull P1 * * +** +** The P1-th element is removed from its current location on +** the stack and pushed back on top of the stack. The +** top of the stack is element 0, so "Pull 0 0 0" is +** a no-op. "Pull 1 0 0" swaps the top two elements of +** the stack. +** +** See also the Dup instruction. +*/ +case OP_Pull: { + Mem *pFrom = &pTos[-pOp->p1]; + int i; + Mem ts; + + ts = *pFrom; + Deephemeralize(pTos); + for(i=0; i<pOp->p1; i++, pFrom++){ + Deephemeralize(&pFrom[1]); + *pFrom = pFrom[1]; + assert( (pFrom->flags & MEM_Ephem)==0 ); + if( pFrom->flags & MEM_Short ){ + assert( pFrom->flags & MEM_Str ); + assert( pFrom->z==pFrom[1].zShort ); + pFrom->z = pFrom->zShort; + } + } + *pTos = ts; + if( pTos->flags & MEM_Short ){ + assert( pTos->flags & MEM_Str ); + assert( pTos->z==pTos[-pOp->p1].zShort ); + pTos->z = pTos->zShort; + } + break; +} + +/* Opcode: Push P1 * * +** +** Overwrite the value of the P1-th element down on the +** stack (P1==0 is the top of the stack) with the value +** of the top of the stack. Then pop the top of the stack. +*/ +case OP_Push: { + Mem *pTo = &pTos[-pOp->p1]; + + assert( pTo>=p->aStack ); + Deephemeralize(pTos); + Release(pTo); + *pTo = *pTos; + if( pTo->flags & MEM_Short ){ + assert( pTo->z==pTos->zShort ); + pTo->z = pTo->zShort; + } + pTos--; + break; +} + + +/* Opcode: ColumnName P1 P2 P3 +** +** P3 becomes the P1-th column name (first is 0). An array of pointers +** to all column names is passed as the 4th parameter to the callback. +** If P2==1 then this is the last column in the result set and thus the +** number of columns in the result set will be P1. There must be at least +** one OP_ColumnName with a P2==1 before invoking OP_Callback and the +** number of columns specified in OP_Callback must one more than the P1 +** value of the OP_ColumnName that has P2==1. +*/ +case OP_ColumnName: { + assert( pOp->p1>=0 && pOp->p1<p->nOp ); + p->azColName[pOp->p1] = pOp->p3; + p->nCallback = 0; + if( pOp->p2 ) p->nResColumn = pOp->p1+1; + break; +} + +/* Opcode: Callback P1 * * +** +** Pop P1 values off the stack and form them into an array. Then +** invoke the callback function using the newly formed array as the +** 3rd parameter. +*/ +case OP_Callback: { + int i; + char **azArgv = p->zArgv; + Mem *pCol; + + pCol = &pTos[1-pOp->p1]; + assert( pCol>=p->aStack ); + for(i=0; i<pOp->p1; i++, pCol++){ + if( pCol->flags & MEM_Null ){ + azArgv[i] = 0; + }else{ + Stringify(pCol); + azArgv[i] = pCol->z; + } + } + azArgv[i] = 0; + p->nCallback++; + p->azResColumn = azArgv; + assert( p->nResColumn==pOp->p1 ); + p->popStack = pOp->p1; + p->pc = pc + 1; + p->pTos = pTos; + return SQLITE_ROW; +} + +/* Opcode: Concat P1 P2 P3 +** +** Look at the first P1 elements of the stack. Append them all +** together with the lowest element first. Use P3 as a separator. +** Put the result on the top of the stack. The original P1 elements +** are popped from the stack if P2==0 and retained if P2==1. If +** any element of the stack is NULL, then the result is NULL. +** +** If P3 is NULL, then use no separator. When P1==1, this routine +** makes a copy of the top stack element into memory obtained +** from sqliteMalloc(). +*/ +case OP_Concat: { + char *zNew; + int nByte; + int nField; + int i, j; + char *zSep; + int nSep; + Mem *pTerm; + + nField = pOp->p1; + zSep = pOp->p3; + if( zSep==0 ) zSep = ""; + nSep = strlen(zSep); + assert( &pTos[1-nField] >= p->aStack ); + nByte = 1 - nSep; + pTerm = &pTos[1-nField]; + for(i=0; i<nField; i++, pTerm++){ + if( pTerm->flags & MEM_Null ){ + nByte = -1; + break; + }else{ + Stringify(pTerm); + nByte += pTerm->n - 1 + nSep; + } + } + if( nByte<0 ){ + if( pOp->p2==0 ){ + popStack(&pTos, nField); + } + pTos++; + pTos->flags = MEM_Null; + break; + } + zNew = sqliteMallocRaw( nByte ); + if( zNew==0 ) goto no_mem; + j = 0; + pTerm = &pTos[1-nField]; + for(i=j=0; i<nField; i++, pTerm++){ + assert( pTerm->flags & MEM_Str ); + memcpy(&zNew[j], pTerm->z, pTerm->n-1); + j += pTerm->n-1; + if( nSep>0 && i<nField-1 ){ + memcpy(&zNew[j], zSep, nSep); + j += nSep; + } + } + zNew[j] = 0; + if( pOp->p2==0 ){ + popStack(&pTos, nField); + } + pTos++; + pTos->n = nByte; + pTos->flags = MEM_Str|MEM_Dyn; + pTos->z = zNew; + break; +} + +/* Opcode: Add * * * +** +** Pop the top two elements from the stack, add them together, +** and push the result back onto the stack. If either element +** is a string then it is converted to a double using the atof() +** function before the addition. +** If either operand is NULL, the result is NULL. +*/ +/* Opcode: Multiply * * * +** +** Pop the top two elements from the stack, multiply them together, +** and push the result back onto the stack. If either element +** is a string then it is converted to a double using the atof() +** function before the multiplication. +** If either operand is NULL, the result is NULL. +*/ +/* Opcode: Subtract * * * +** +** Pop the top two elements from the stack, subtract the +** first (what was on top of the stack) from the second (the +** next on stack) +** and push the result back onto the stack. If either element +** is a string then it is converted to a double using the atof() +** function before the subtraction. +** If either operand is NULL, the result is NULL. +*/ +/* Opcode: Divide * * * +** +** Pop the top two elements from the stack, divide the +** first (what was on top of the stack) from the second (the +** next on stack) +** and push the result back onto the stack. If either element +** is a string then it is converted to a double using the atof() +** function before the division. Division by zero returns NULL. +** If either operand is NULL, the result is NULL. +*/ +/* Opcode: Remainder * * * +** +** Pop the top two elements from the stack, divide the +** first (what was on top of the stack) from the second (the +** next on stack) +** and push the remainder after division onto the stack. If either element +** is a string then it is converted to a double using the atof() +** function before the division. Division by zero returns NULL. +** If either operand is NULL, the result is NULL. +*/ +case OP_Add: +case OP_Subtract: +case OP_Multiply: +case OP_Divide: +case OP_Remainder: { + Mem *pNos = &pTos[-1]; + assert( pNos>=p->aStack ); + if( ((pTos->flags | pNos->flags) & MEM_Null)!=0 ){ + Release(pTos); + pTos--; + Release(pTos); + pTos->flags = MEM_Null; + }else if( (pTos->flags & pNos->flags & MEM_Int)==MEM_Int ){ + int a, b; + a = pTos->i; + b = pNos->i; + switch( pOp->opcode ){ + case OP_Add: b += a; break; + case OP_Subtract: b -= a; break; + case OP_Multiply: b *= a; break; + case OP_Divide: { + if( a==0 ) goto divide_by_zero; + b /= a; + break; + } + default: { + if( a==0 ) goto divide_by_zero; + b %= a; + break; + } + } + Release(pTos); + pTos--; + Release(pTos); + pTos->i = b; + pTos->flags = MEM_Int; + }else{ + double a, b; + Realify(pTos); + Realify(pNos); + a = pTos->r; + b = pNos->r; + switch( pOp->opcode ){ + case OP_Add: b += a; break; + case OP_Subtract: b -= a; break; + case OP_Multiply: b *= a; break; + case OP_Divide: { + if( a==0.0 ) goto divide_by_zero; + b /= a; + break; + } + default: { + int ia = (int)a; + int ib = (int)b; + if( ia==0.0 ) goto divide_by_zero; + b = ib % ia; + break; + } + } + Release(pTos); + pTos--; + Release(pTos); + pTos->r = b; + pTos->flags = MEM_Real; + } + break; + +divide_by_zero: + Release(pTos); + pTos--; + Release(pTos); + pTos->flags = MEM_Null; + break; +} + +/* Opcode: Function P1 * P3 +** +** Invoke a user function (P3 is a pointer to a Function structure that +** defines the function) with P1 string arguments taken from the stack. +** Pop all arguments from the stack and push back the result. +** +** See also: AggFunc +*/ +case OP_Function: { + int n, i; + Mem *pArg; + char **azArgv; + sqlite_func ctx; + + n = pOp->p1; + pArg = &pTos[1-n]; + azArgv = p->zArgv; + for(i=0; i<n; i++, pArg++){ + if( pArg->flags & MEM_Null ){ + azArgv[i] = 0; + }else{ + Stringify(pArg); + azArgv[i] = pArg->z; + } + } + ctx.pFunc = (FuncDef*)pOp->p3; + ctx.s.flags = MEM_Null; + ctx.s.z = 0; + ctx.isError = 0; + ctx.isStep = 0; + if( sqliteSafetyOff(db) ) goto abort_due_to_misuse; + (*ctx.pFunc->xFunc)(&ctx, n, (const char**)azArgv); + if( sqliteSafetyOn(db) ) goto abort_due_to_misuse; + popStack(&pTos, n); + pTos++; + *pTos = ctx.s; + if( pTos->flags & MEM_Short ){ + pTos->z = pTos->zShort; + } + if( ctx.isError ){ + sqliteSetString(&p->zErrMsg, + (pTos->flags & MEM_Str)!=0 ? pTos->z : "user function error", (char*)0); + rc = SQLITE_ERROR; + } + break; +} + +/* Opcode: BitAnd * * * +** +** Pop the top two elements from the stack. Convert both elements +** to integers. Push back onto the stack the bit-wise AND of the +** two elements. +** If either operand is NULL, the result is NULL. +*/ +/* Opcode: BitOr * * * +** +** Pop the top two elements from the stack. Convert both elements +** to integers. Push back onto the stack the bit-wise OR of the +** two elements. +** If either operand is NULL, the result is NULL. +*/ +/* Opcode: ShiftLeft * * * +** +** Pop the top two elements from the stack. Convert both elements +** to integers. Push back onto the stack the top element shifted +** left by N bits where N is the second element on the stack. +** If either operand is NULL, the result is NULL. +*/ +/* Opcode: ShiftRight * * * +** +** Pop the top two elements from the stack. Convert both elements +** to integers. Push back onto the stack the top element shifted +** right by N bits where N is the second element on the stack. +** If either operand is NULL, the result is NULL. +*/ +case OP_BitAnd: +case OP_BitOr: +case OP_ShiftLeft: +case OP_ShiftRight: { + Mem *pNos = &pTos[-1]; + int a, b; + + assert( pNos>=p->aStack ); + if( (pTos->flags | pNos->flags) & MEM_Null ){ + popStack(&pTos, 2); + pTos++; + pTos->flags = MEM_Null; + break; + } + Integerify(pTos); + Integerify(pNos); + a = pTos->i; + b = pNos->i; + switch( pOp->opcode ){ + case OP_BitAnd: a &= b; break; + case OP_BitOr: a |= b; break; + case OP_ShiftLeft: a <<= b; break; + case OP_ShiftRight: a >>= b; break; + default: /* CANT HAPPEN */ break; + } + assert( (pTos->flags & MEM_Dyn)==0 ); + assert( (pNos->flags & MEM_Dyn)==0 ); + pTos--; + Release(pTos); + pTos->i = a; + pTos->flags = MEM_Int; + break; +} + +/* Opcode: AddImm P1 * * +** +** Add the value P1 to whatever is on top of the stack. The result +** is always an integer. +** +** To force the top of the stack to be an integer, just add 0. +*/ +case OP_AddImm: { + assert( pTos>=p->aStack ); + Integerify(pTos); + pTos->i += pOp->p1; + break; +} + +/* Opcode: ForceInt P1 P2 * +** +** Convert the top of the stack into an integer. If the current top of +** the stack is not numeric (meaning that is is a NULL or a string that +** does not look like an integer or floating point number) then pop the +** stack and jump to P2. If the top of the stack is numeric then +** convert it into the least integer that is greater than or equal to its +** current value if P1==0, or to the least integer that is strictly +** greater than its current value if P1==1. +*/ +case OP_ForceInt: { + int v; + assert( pTos>=p->aStack ); + if( (pTos->flags & (MEM_Int|MEM_Real))==0 + && ((pTos->flags & MEM_Str)==0 || sqliteIsNumber(pTos->z)==0) ){ + Release(pTos); + pTos--; + pc = pOp->p2 - 1; + break; + } + if( pTos->flags & MEM_Int ){ + v = pTos->i + (pOp->p1!=0); + }else{ + Realify(pTos); + v = (int)pTos->r; + if( pTos->r>(double)v ) v++; + if( pOp->p1 && pTos->r==(double)v ) v++; + } + Release(pTos); + pTos->i = v; + pTos->flags = MEM_Int; + break; +} + +/* Opcode: MustBeInt P1 P2 * +** +** Force the top of the stack to be an integer. If the top of the +** stack is not an integer and cannot be converted into an integer +** with out data loss, then jump immediately to P2, or if P2==0 +** raise an SQLITE_MISMATCH exception. +** +** If the top of the stack is not an integer and P2 is not zero and +** P1 is 1, then the stack is popped. In all other cases, the depth +** of the stack is unchanged. +*/ +case OP_MustBeInt: { + assert( pTos>=p->aStack ); + if( pTos->flags & MEM_Int ){ + /* Do nothing */ + }else if( pTos->flags & MEM_Real ){ + int i = (int)pTos->r; + double r = (double)i; + if( r!=pTos->r ){ + goto mismatch; + } + pTos->i = i; + }else if( pTos->flags & MEM_Str ){ + int v; + if( !toInt(pTos->z, &v) ){ + double r; + if( !sqliteIsNumber(pTos->z) ){ + goto mismatch; + } + Realify(pTos); + v = (int)pTos->r; + r = (double)v; + if( r!=pTos->r ){ + goto mismatch; + } + } + pTos->i = v; + }else{ + goto mismatch; + } + Release(pTos); + pTos->flags = MEM_Int; + break; + +mismatch: + if( pOp->p2==0 ){ + rc = SQLITE_MISMATCH; + goto abort_due_to_error; + }else{ + if( pOp->p1 ) popStack(&pTos, 1); + pc = pOp->p2 - 1; + } + break; +} + +/* Opcode: Eq P1 P2 * +** +** Pop the top two elements from the stack. If they are equal, then +** jump to instruction P2. Otherwise, continue to the next instruction. +** +** If either operand is NULL (and thus if the result is unknown) then +** take the jump if P1 is true. +** +** If both values are numeric, they are converted to doubles using atof() +** and compared for equality that way. Otherwise the strcmp() library +** routine is used for the comparison. For a pure text comparison +** use OP_StrEq. +** +** If P2 is zero, do not jump. Instead, push an integer 1 onto the +** stack if the jump would have been taken, or a 0 if not. Push a +** NULL if either operand was NULL. +*/ +/* Opcode: Ne P1 P2 * +** +** Pop the top two elements from the stack. If they are not equal, then +** jump to instruction P2. Otherwise, continue to the next instruction. +** +** If either operand is NULL (and thus if the result is unknown) then +** take the jump if P1 is true. +** +** If both values are numeric, they are converted to doubles using atof() +** and compared in that format. Otherwise the strcmp() library +** routine is used for the comparison. For a pure text comparison +** use OP_StrNe. +** +** If P2 is zero, do not jump. Instead, push an integer 1 onto the +** stack if the jump would have been taken, or a 0 if not. Push a +** NULL if either operand was NULL. +*/ +/* Opcode: Lt P1 P2 * +** +** Pop the top two elements from the stack. If second element (the +** next on stack) is less than the first (the top of stack), then +** jump to instruction P2. Otherwise, continue to the next instruction. +** In other words, jump if NOS<TOS. +** +** If either operand is NULL (and thus if the result is unknown) then +** take the jump if P1 is true. +** +** If both values are numeric, they are converted to doubles using atof() +** and compared in that format. Numeric values are always less than +** non-numeric values. If both operands are non-numeric, the strcmp() library +** routine is used for the comparison. For a pure text comparison +** use OP_StrLt. +** +** If P2 is zero, do not jump. Instead, push an integer 1 onto the +** stack if the jump would have been taken, or a 0 if not. Push a +** NULL if either operand was NULL. +*/ +/* Opcode: Le P1 P2 * +** +** Pop the top two elements from the stack. If second element (the +** next on stack) is less than or equal to the first (the top of stack), +** then jump to instruction P2. In other words, jump if NOS<=TOS. +** +** If either operand is NULL (and thus if the result is unknown) then +** take the jump if P1 is true. +** +** If both values are numeric, they are converted to doubles using atof() +** and compared in that format. Numeric values are always less than +** non-numeric values. If both operands are non-numeric, the strcmp() library +** routine is used for the comparison. For a pure text comparison +** use OP_StrLe. +** +** If P2 is zero, do not jump. Instead, push an integer 1 onto the +** stack if the jump would have been taken, or a 0 if not. Push a +** NULL if either operand was NULL. +*/ +/* Opcode: Gt P1 P2 * +** +** Pop the top two elements from the stack. If second element (the +** next on stack) is greater than the first (the top of stack), +** then jump to instruction P2. In other words, jump if NOS>TOS. +** +** If either operand is NULL (and thus if the result is unknown) then +** take the jump if P1 is true. +** +** If both values are numeric, they are converted to doubles using atof() +** and compared in that format. Numeric values are always less than +** non-numeric values. If both operands are non-numeric, the strcmp() library +** routine is used for the comparison. For a pure text comparison +** use OP_StrGt. +** +** If P2 is zero, do not jump. Instead, push an integer 1 onto the +** stack if the jump would have been taken, or a 0 if not. Push a +** NULL if either operand was NULL. +*/ +/* Opcode: Ge P1 P2 * +** +** Pop the top two elements from the stack. If second element (the next +** on stack) is greater than or equal to the first (the top of stack), +** then jump to instruction P2. In other words, jump if NOS>=TOS. +** +** If either operand is NULL (and thus if the result is unknown) then +** take the jump if P1 is true. +** +** If both values are numeric, they are converted to doubles using atof() +** and compared in that format. Numeric values are always less than +** non-numeric values. If both operands are non-numeric, the strcmp() library +** routine is used for the comparison. For a pure text comparison +** use OP_StrGe. +** +** If P2 is zero, do not jump. Instead, push an integer 1 onto the +** stack if the jump would have been taken, or a 0 if not. Push a +** NULL if either operand was NULL. +*/ +case OP_Eq: +case OP_Ne: +case OP_Lt: +case OP_Le: +case OP_Gt: +case OP_Ge: { + Mem *pNos = &pTos[-1]; + int c, v; + int ft, fn; + assert( pNos>=p->aStack ); + ft = pTos->flags; + fn = pNos->flags; + if( (ft | fn) & MEM_Null ){ + popStack(&pTos, 2); + if( pOp->p2 ){ + if( pOp->p1 ) pc = pOp->p2-1; + }else{ + pTos++; + pTos->flags = MEM_Null; + } + break; + }else if( (ft & fn & MEM_Int)==MEM_Int ){ + c = pNos->i - pTos->i; + }else if( (ft & MEM_Int)!=0 && (fn & MEM_Str)!=0 && toInt(pNos->z,&v) ){ + c = v - pTos->i; + }else if( (fn & MEM_Int)!=0 && (ft & MEM_Str)!=0 && toInt(pTos->z,&v) ){ + c = pNos->i - v; + }else{ + Stringify(pTos); + Stringify(pNos); + c = sqliteCompare(pNos->z, pTos->z); + } + switch( pOp->opcode ){ + case OP_Eq: c = c==0; break; + case OP_Ne: c = c!=0; break; + case OP_Lt: c = c<0; break; + case OP_Le: c = c<=0; break; + case OP_Gt: c = c>0; break; + default: c = c>=0; break; + } + popStack(&pTos, 2); + if( pOp->p2 ){ + if( c ) pc = pOp->p2-1; + }else{ + pTos++; + pTos->i = c; + pTos->flags = MEM_Int; + } + break; +} +/* INSERT NO CODE HERE! +** +** The opcode numbers are extracted from this source file by doing +** +** grep '^case OP_' vdbe.c | ... >opcodes.h +** +** The opcodes are numbered in the order that they appear in this file. +** But in order for the expression generating code to work right, the +** string comparison operators that follow must be numbered exactly 6 +** greater than the numeric comparison opcodes above. So no other +** cases can appear between the two. +*/ +/* Opcode: StrEq P1 P2 * +** +** Pop the top two elements from the stack. If they are equal, then +** jump to instruction P2. Otherwise, continue to the next instruction. +** +** If either operand is NULL (and thus if the result is unknown) then +** take the jump if P1 is true. +** +** The strcmp() library routine is used for the comparison. For a +** numeric comparison, use OP_Eq. +** +** If P2 is zero, do not jump. Instead, push an integer 1 onto the +** stack if the jump would have been taken, or a 0 if not. Push a +** NULL if either operand was NULL. +*/ +/* Opcode: StrNe P1 P2 * +** +** Pop the top two elements from the stack. If they are not equal, then +** jump to instruction P2. Otherwise, continue to the next instruction. +** +** If either operand is NULL (and thus if the result is unknown) then +** take the jump if P1 is true. +** +** The strcmp() library routine is used for the comparison. For a +** numeric comparison, use OP_Ne. +** +** If P2 is zero, do not jump. Instead, push an integer 1 onto the +** stack if the jump would have been taken, or a 0 if not. Push a +** NULL if either operand was NULL. +*/ +/* Opcode: StrLt P1 P2 * +** +** Pop the top two elements from the stack. If second element (the +** next on stack) is less than the first (the top of stack), then +** jump to instruction P2. Otherwise, continue to the next instruction. +** In other words, jump if NOS<TOS. +** +** If either operand is NULL (and thus if the result is unknown) then +** take the jump if P1 is true. +** +** The strcmp() library routine is used for the comparison. For a +** numeric comparison, use OP_Lt. +** +** If P2 is zero, do not jump. Instead, push an integer 1 onto the +** stack if the jump would have been taken, or a 0 if not. Push a +** NULL if either operand was NULL. +*/ +/* Opcode: StrLe P1 P2 * +** +** Pop the top two elements from the stack. If second element (the +** next on stack) is less than or equal to the first (the top of stack), +** then jump to instruction P2. In other words, jump if NOS<=TOS. +** +** If either operand is NULL (and thus if the result is unknown) then +** take the jump if P1 is true. +** +** The strcmp() library routine is used for the comparison. For a +** numeric comparison, use OP_Le. +** +** If P2 is zero, do not jump. Instead, push an integer 1 onto the +** stack if the jump would have been taken, or a 0 if not. Push a +** NULL if either operand was NULL. +*/ +/* Opcode: StrGt P1 P2 * +** +** Pop the top two elements from the stack. If second element (the +** next on stack) is greater than the first (the top of stack), +** then jump to instruction P2. In other words, jump if NOS>TOS. +** +** If either operand is NULL (and thus if the result is unknown) then +** take the jump if P1 is true. +** +** The strcmp() library routine is used for the comparison. For a +** numeric comparison, use OP_Gt. +** +** If P2 is zero, do not jump. Instead, push an integer 1 onto the +** stack if the jump would have been taken, or a 0 if not. Push a +** NULL if either operand was NULL. +*/ +/* Opcode: StrGe P1 P2 * +** +** Pop the top two elements from the stack. If second element (the next +** on stack) is greater than or equal to the first (the top of stack), +** then jump to instruction P2. In other words, jump if NOS>=TOS. +** +** If either operand is NULL (and thus if the result is unknown) then +** take the jump if P1 is true. +** +** The strcmp() library routine is used for the comparison. For a +** numeric comparison, use OP_Ge. +** +** If P2 is zero, do not jump. Instead, push an integer 1 onto the +** stack if the jump would have been taken, or a 0 if not. Push a +** NULL if either operand was NULL. +*/ +case OP_StrEq: +case OP_StrNe: +case OP_StrLt: +case OP_StrLe: +case OP_StrGt: +case OP_StrGe: { + Mem *pNos = &pTos[-1]; + int c; + assert( pNos>=p->aStack ); + if( (pNos->flags | pTos->flags) & MEM_Null ){ + popStack(&pTos, 2); + if( pOp->p2 ){ + if( pOp->p1 ) pc = pOp->p2-1; + }else{ + pTos++; + pTos->flags = MEM_Null; + } + break; + }else{ + Stringify(pTos); + Stringify(pNos); + c = strcmp(pNos->z, pTos->z); + } + /* The asserts on each case of the following switch are there to verify + ** that string comparison opcodes are always exactly 6 greater than the + ** corresponding numeric comparison opcodes. The code generator depends + ** on this fact. + */ + switch( pOp->opcode ){ + case OP_StrEq: c = c==0; assert( pOp->opcode-6==OP_Eq ); break; + case OP_StrNe: c = c!=0; assert( pOp->opcode-6==OP_Ne ); break; + case OP_StrLt: c = c<0; assert( pOp->opcode-6==OP_Lt ); break; + case OP_StrLe: c = c<=0; assert( pOp->opcode-6==OP_Le ); break; + case OP_StrGt: c = c>0; assert( pOp->opcode-6==OP_Gt ); break; + default: c = c>=0; assert( pOp->opcode-6==OP_Ge ); break; + } + popStack(&pTos, 2); + if( pOp->p2 ){ + if( c ) pc = pOp->p2-1; + }else{ + pTos++; + pTos->flags = MEM_Int; + pTos->i = c; + } + break; +} + +/* Opcode: And * * * +** +** Pop two values off the stack. Take the logical AND of the +** two values and push the resulting boolean value back onto the +** stack. +*/ +/* Opcode: Or * * * +** +** Pop two values off the stack. Take the logical OR of the +** two values and push the resulting boolean value back onto the +** stack. +*/ +case OP_And: +case OP_Or: { + Mem *pNos = &pTos[-1]; + int v1, v2; /* 0==TRUE, 1==FALSE, 2==UNKNOWN or NULL */ + + assert( pNos>=p->aStack ); + if( pTos->flags & MEM_Null ){ + v1 = 2; + }else{ + Integerify(pTos); + v1 = pTos->i==0; + } + if( pNos->flags & MEM_Null ){ + v2 = 2; + }else{ + Integerify(pNos); + v2 = pNos->i==0; + } + if( pOp->opcode==OP_And ){ + static const unsigned char and_logic[] = { 0, 1, 2, 1, 1, 1, 2, 1, 2 }; + v1 = and_logic[v1*3+v2]; + }else{ + static const unsigned char or_logic[] = { 0, 0, 0, 0, 1, 2, 0, 2, 2 }; + v1 = or_logic[v1*3+v2]; + } + popStack(&pTos, 2); + pTos++; + if( v1==2 ){ + pTos->flags = MEM_Null; + }else{ + pTos->i = v1==0; + pTos->flags = MEM_Int; + } + break; +} + +/* Opcode: Negative * * * +** +** Treat the top of the stack as a numeric quantity. Replace it +** with its additive inverse. If the top of the stack is NULL +** its value is unchanged. +*/ +/* Opcode: AbsValue * * * +** +** Treat the top of the stack as a numeric quantity. Replace it +** with its absolute value. If the top of the stack is NULL +** its value is unchanged. +*/ +case OP_Negative: +case OP_AbsValue: { + assert( pTos>=p->aStack ); + if( pTos->flags & MEM_Real ){ + Release(pTos); + if( pOp->opcode==OP_Negative || pTos->r<0.0 ){ + pTos->r = -pTos->r; + } + pTos->flags = MEM_Real; + }else if( pTos->flags & MEM_Int ){ + Release(pTos); + if( pOp->opcode==OP_Negative || pTos->i<0 ){ + pTos->i = -pTos->i; + } + pTos->flags = MEM_Int; + }else if( pTos->flags & MEM_Null ){ + /* Do nothing */ + }else{ + Realify(pTos); + Release(pTos); + if( pOp->opcode==OP_Negative || pTos->r<0.0 ){ + pTos->r = -pTos->r; + } + pTos->flags = MEM_Real; + } + break; +} + +/* Opcode: Not * * * +** +** Interpret the top of the stack as a boolean value. Replace it +** with its complement. If the top of the stack is NULL its value +** is unchanged. +*/ +case OP_Not: { + assert( pTos>=p->aStack ); + if( pTos->flags & MEM_Null ) break; /* Do nothing to NULLs */ + Integerify(pTos); + Release(pTos); + pTos->i = !pTos->i; + pTos->flags = MEM_Int; + break; +} + +/* Opcode: BitNot * * * +** +** Interpret the top of the stack as an value. Replace it +** with its ones-complement. If the top of the stack is NULL its +** value is unchanged. +*/ +case OP_BitNot: { + assert( pTos>=p->aStack ); + if( pTos->flags & MEM_Null ) break; /* Do nothing to NULLs */ + Integerify(pTos); + Release(pTos); + pTos->i = ~pTos->i; + pTos->flags = MEM_Int; + break; +} + +/* Opcode: Noop * * * +** +** Do nothing. This instruction is often useful as a jump +** destination. +*/ +case OP_Noop: { + break; +} + +/* Opcode: If P1 P2 * +** +** Pop a single boolean from the stack. If the boolean popped is +** true, then jump to p2. Otherwise continue to the next instruction. +** An integer is false if zero and true otherwise. A string is +** false if it has zero length and true otherwise. +** +** If the value popped of the stack is NULL, then take the jump if P1 +** is true and fall through if P1 is false. +*/ +/* Opcode: IfNot P1 P2 * +** +** Pop a single boolean from the stack. If the boolean popped is +** false, then jump to p2. Otherwise continue to the next instruction. +** An integer is false if zero and true otherwise. A string is +** false if it has zero length and true otherwise. +** +** If the value popped of the stack is NULL, then take the jump if P1 +** is true and fall through if P1 is false. +*/ +case OP_If: +case OP_IfNot: { + int c; + assert( pTos>=p->aStack ); + if( pTos->flags & MEM_Null ){ + c = pOp->p1; + }else{ + Integerify(pTos); + c = pTos->i; + if( pOp->opcode==OP_IfNot ) c = !c; + } + assert( (pTos->flags & MEM_Dyn)==0 ); + pTos--; + if( c ) pc = pOp->p2-1; + break; +} + +/* Opcode: IsNull P1 P2 * +** +** If any of the top abs(P1) values on the stack are NULL, then jump +** to P2. Pop the stack P1 times if P1>0. If P1<0 leave the stack +** unchanged. +*/ +case OP_IsNull: { + int i, cnt; + Mem *pTerm; + cnt = pOp->p1; + if( cnt<0 ) cnt = -cnt; + pTerm = &pTos[1-cnt]; + assert( pTerm>=p->aStack ); + for(i=0; i<cnt; i++, pTerm++){ + if( pTerm->flags & MEM_Null ){ + pc = pOp->p2-1; + break; + } + } + if( pOp->p1>0 ) popStack(&pTos, cnt); + break; +} + +/* Opcode: NotNull P1 P2 * +** +** Jump to P2 if the top P1 values on the stack are all not NULL. Pop the +** stack if P1 times if P1 is greater than zero. If P1 is less than +** zero then leave the stack unchanged. +*/ +case OP_NotNull: { + int i, cnt; + cnt = pOp->p1; + if( cnt<0 ) cnt = -cnt; + assert( &pTos[1-cnt] >= p->aStack ); + for(i=0; i<cnt && (pTos[1+i-cnt].flags & MEM_Null)==0; i++){} + if( i>=cnt ) pc = pOp->p2-1; + if( pOp->p1>0 ) popStack(&pTos, cnt); + break; +} + +/* Opcode: MakeRecord P1 P2 * +** +** Convert the top P1 entries of the stack into a single entry +** suitable for use as a data record in a database table. The +** details of the format are irrelavant as long as the OP_Column +** opcode can decode the record later. Refer to source code +** comments for the details of the record format. +** +** If P2 is true (non-zero) and one or more of the P1 entries +** that go into building the record is NULL, then add some extra +** bytes to the record to make it distinct for other entries created +** during the same run of the VDBE. The extra bytes added are a +** counter that is reset with each run of the VDBE, so records +** created this way will not necessarily be distinct across runs. +** But they should be distinct for transient tables (created using +** OP_OpenTemp) which is what they are intended for. +** +** (Later:) The P2==1 option was intended to make NULLs distinct +** for the UNION operator. But I have since discovered that NULLs +** are indistinct for UNION. So this option is never used. +*/ +case OP_MakeRecord: { + char *zNewRecord; + int nByte; + int nField; + int i, j; + int idxWidth; + u32 addr; + Mem *pRec; + int addUnique = 0; /* True to cause bytes to be added to make the + ** generated record distinct */ + char zTemp[NBFS]; /* Temp space for small records */ + + /* Assuming the record contains N fields, the record format looks + ** like this: + ** + ** ------------------------------------------------------------------- + ** | idx0 | idx1 | ... | idx(N-1) | idx(N) | data0 | ... | data(N-1) | + ** ------------------------------------------------------------------- + ** + ** All data fields are converted to strings before being stored and + ** are stored with their null terminators. NULL entries omit the + ** null terminator. Thus an empty string uses 1 byte and a NULL uses + ** zero bytes. Data(0) is taken from the lowest element of the stack + ** and data(N-1) is the top of the stack. + ** + ** Each of the idx() entries is either 1, 2, or 3 bytes depending on + ** how big the total record is. Idx(0) contains the offset to the start + ** of data(0). Idx(k) contains the offset to the start of data(k). + ** Idx(N) contains the total number of bytes in the record. + */ + nField = pOp->p1; + pRec = &pTos[1-nField]; + assert( pRec>=p->aStack ); + nByte = 0; + for(i=0; i<nField; i++, pRec++){ + if( pRec->flags & MEM_Null ){ + addUnique = pOp->p2; + }else{ + Stringify(pRec); + nByte += pRec->n; + } + } + if( addUnique ) nByte += sizeof(p->uniqueCnt); + if( nByte + nField + 1 < 256 ){ + idxWidth = 1; + }else if( nByte + 2*nField + 2 < 65536 ){ + idxWidth = 2; + }else{ + idxWidth = 3; + } + nByte += idxWidth*(nField + 1); + if( nByte>MAX_BYTES_PER_ROW ){ + rc = SQLITE_TOOBIG; + goto abort_due_to_error; + } + if( nByte<=NBFS ){ + zNewRecord = zTemp; + }else{ + zNewRecord = sqliteMallocRaw( nByte ); + if( zNewRecord==0 ) goto no_mem; + } + j = 0; + addr = idxWidth*(nField+1) + addUnique*sizeof(p->uniqueCnt); + for(i=0, pRec=&pTos[1-nField]; i<nField; i++, pRec++){ + zNewRecord[j++] = addr & 0xff; + if( idxWidth>1 ){ + zNewRecord[j++] = (addr>>8)&0xff; + if( idxWidth>2 ){ + zNewRecord[j++] = (addr>>16)&0xff; + } + } + if( (pRec->flags & MEM_Null)==0 ){ + addr += pRec->n; + } + } + zNewRecord[j++] = addr & 0xff; + if( idxWidth>1 ){ + zNewRecord[j++] = (addr>>8)&0xff; + if( idxWidth>2 ){ + zNewRecord[j++] = (addr>>16)&0xff; + } + } + if( addUnique ){ + memcpy(&zNewRecord[j], &p->uniqueCnt, sizeof(p->uniqueCnt)); + p->uniqueCnt++; + j += sizeof(p->uniqueCnt); + } + for(i=0, pRec=&pTos[1-nField]; i<nField; i++, pRec++){ + if( (pRec->flags & MEM_Null)==0 ){ + memcpy(&zNewRecord[j], pRec->z, pRec->n); + j += pRec->n; + } + } + popStack(&pTos, nField); + pTos++; + pTos->n = nByte; + if( nByte<=NBFS ){ + assert( zNewRecord==zTemp ); + memcpy(pTos->zShort, zTemp, nByte); + pTos->z = pTos->zShort; + pTos->flags = MEM_Str | MEM_Short; + }else{ + assert( zNewRecord!=zTemp ); + pTos->z = zNewRecord; + pTos->flags = MEM_Str | MEM_Dyn; + } + break; +} + +/* Opcode: MakeKey P1 P2 P3 +** +** Convert the top P1 entries of the stack into a single entry suitable +** for use as the key in an index. The top P1 records are +** converted to strings and merged. The null-terminators +** are retained and used as separators. +** The lowest entry in the stack is the first field and the top of the +** stack becomes the last. +** +** If P2 is not zero, then the original entries remain on the stack +** and the new key is pushed on top. If P2 is zero, the original +** data is popped off the stack first then the new key is pushed +** back in its place. +** +** P3 is a string that is P1 characters long. Each character is either +** an 'n' or a 't' to indicates if the argument should be intepreted as +** numeric or text type. The first character of P3 corresponds to the +** lowest element on the stack. If P3 is NULL then all arguments are +** assumed to be of the numeric type. +** +** The type makes a difference in that text-type fields may not be +** introduced by 'b' (as described in the next paragraph). The +** first character of a text-type field must be either 'a' (if it is NULL) +** or 'c'. Numeric fields will be introduced by 'b' if their content +** looks like a well-formed number. Otherwise the 'a' or 'c' will be +** used. +** +** The key is a concatenation of fields. Each field is terminated by +** a single 0x00 character. A NULL field is introduced by an 'a' and +** is followed immediately by its 0x00 terminator. A numeric field is +** introduced by a single character 'b' and is followed by a sequence +** of characters that represent the number such that a comparison of +** the character string using memcpy() sorts the numbers in numerical +** order. The character strings for numbers are generated using the +** sqliteRealToSortable() function. A text field is introduced by a +** 'c' character and is followed by the exact text of the field. The +** use of an 'a', 'b', or 'c' character at the beginning of each field +** guarantees that NULLs sort before numbers and that numbers sort +** before text. 0x00 characters do not occur except as separators +** between fields. +** +** See also: MakeIdxKey, SortMakeKey +*/ +/* Opcode: MakeIdxKey P1 P2 P3 +** +** Convert the top P1 entries of the stack into a single entry suitable +** for use as the key in an index. In addition, take one additional integer +** off of the stack, treat that integer as a four-byte record number, and +** append the four bytes to the key. Thus a total of P1+1 entries are +** popped from the stack for this instruction and a single entry is pushed +** back. The first P1 entries that are popped are strings and the last +** entry (the lowest on the stack) is an integer record number. +** +** The converstion of the first P1 string entries occurs just like in +** MakeKey. Each entry is separated from the others by a null. +** The entire concatenation is null-terminated. The lowest entry +** in the stack is the first field and the top of the stack becomes the +** last. +** +** If P2 is not zero and one or more of the P1 entries that go into the +** generated key is NULL, then jump to P2 after the new key has been +** pushed on the stack. In other words, jump to P2 if the key is +** guaranteed to be unique. This jump can be used to skip a subsequent +** uniqueness test. +** +** P3 is a string that is P1 characters long. Each character is either +** an 'n' or a 't' to indicates if the argument should be numeric or +** text. The first character corresponds to the lowest element on the +** stack. If P3 is null then all arguments are assumed to be numeric. +** +** See also: MakeKey, SortMakeKey +*/ +case OP_MakeIdxKey: +case OP_MakeKey: { + char *zNewKey; + int nByte; + int nField; + int addRowid; + int i, j; + int containsNull = 0; + Mem *pRec; + char zTemp[NBFS]; + + addRowid = pOp->opcode==OP_MakeIdxKey; + nField = pOp->p1; + pRec = &pTos[1-nField]; + assert( pRec>=p->aStack ); + nByte = 0; + for(j=0, i=0; i<nField; i++, j++, pRec++){ + int flags = pRec->flags; + int len; + char *z; + if( flags & MEM_Null ){ + nByte += 2; + containsNull = 1; + }else if( pOp->p3 && pOp->p3[j]=='t' ){ + Stringify(pRec); + pRec->flags &= ~(MEM_Int|MEM_Real); + nByte += pRec->n+1; + }else if( (flags & (MEM_Real|MEM_Int))!=0 || sqliteIsNumber(pRec->z) ){ + if( (flags & (MEM_Real|MEM_Int))==MEM_Int ){ + pRec->r = pRec->i; + }else if( (flags & (MEM_Real|MEM_Int))==0 ){ + pRec->r = sqliteAtoF(pRec->z, 0); + } + Release(pRec); + z = pRec->zShort; + sqliteRealToSortable(pRec->r, z); + len = strlen(z); + pRec->z = 0; + pRec->flags = MEM_Real; + pRec->n = len+1; + nByte += pRec->n+1; + }else{ + nByte += pRec->n+1; + } + } + if( nByte+sizeof(u32)>MAX_BYTES_PER_ROW ){ + rc = SQLITE_TOOBIG; + goto abort_due_to_error; + } + if( addRowid ) nByte += sizeof(u32); + if( nByte<=NBFS ){ + zNewKey = zTemp; + }else{ + zNewKey = sqliteMallocRaw( nByte ); + if( zNewKey==0 ) goto no_mem; + } + j = 0; + pRec = &pTos[1-nField]; + for(i=0; i<nField; i++, pRec++){ + if( pRec->flags & MEM_Null ){ + zNewKey[j++] = 'a'; + zNewKey[j++] = 0; + }else if( pRec->flags==MEM_Real ){ + zNewKey[j++] = 'b'; + memcpy(&zNewKey[j], pRec->zShort, pRec->n); + j += pRec->n; + }else{ + assert( pRec->flags & MEM_Str ); + zNewKey[j++] = 'c'; + memcpy(&zNewKey[j], pRec->z, pRec->n); + j += pRec->n; + } + } + if( addRowid ){ + u32 iKey; + pRec = &pTos[-nField]; + assert( pRec>=p->aStack ); + Integerify(pRec); + iKey = intToKey(pRec->i); + memcpy(&zNewKey[j], &iKey, sizeof(u32)); + popStack(&pTos, nField+1); + if( pOp->p2 && containsNull ) pc = pOp->p2 - 1; + }else{ + if( pOp->p2==0 ) popStack(&pTos, nField); + } + pTos++; + pTos->n = nByte; + if( nByte<=NBFS ){ + assert( zNewKey==zTemp ); + pTos->z = pTos->zShort; + memcpy(pTos->zShort, zTemp, nByte); + pTos->flags = MEM_Str | MEM_Short; + }else{ + pTos->z = zNewKey; + pTos->flags = MEM_Str | MEM_Dyn; + } + break; +} + +/* Opcode: IncrKey * * * +** +** The top of the stack should contain an index key generated by +** The MakeKey opcode. This routine increases the least significant +** byte of that key by one. This is used so that the MoveTo opcode +** will move to the first entry greater than the key rather than to +** the key itself. +*/ +case OP_IncrKey: { + assert( pTos>=p->aStack ); + /* The IncrKey opcode is only applied to keys generated by + ** MakeKey or MakeIdxKey and the results of those operands + ** are always dynamic strings or zShort[] strings. So we + ** are always free to modify the string in place. + */ + assert( pTos->flags & (MEM_Dyn|MEM_Short) ); + pTos->z[pTos->n-1]++; + break; +} + +/* Opcode: Checkpoint P1 * * +** +** Begin a checkpoint. A checkpoint is the beginning of a operation that +** is part of a larger transaction but which might need to be rolled back +** itself without effecting the containing transaction. A checkpoint will +** be automatically committed or rollback when the VDBE halts. +** +** The checkpoint is begun on the database file with index P1. The main +** database file has an index of 0 and the file used for temporary tables +** has an index of 1. +*/ +case OP_Checkpoint: { + int i = pOp->p1; + if( i>=0 && i<db->nDb && db->aDb[i].pBt && db->aDb[i].inTrans==1 ){ + rc = sqliteBtreeBeginCkpt(db->aDb[i].pBt); + if( rc==SQLITE_OK ) db->aDb[i].inTrans = 2; + } + break; +} + +/* Opcode: Transaction P1 * * +** +** Begin a transaction. The transaction ends when a Commit or Rollback +** opcode is encountered. Depending on the ON CONFLICT setting, the +** transaction might also be rolled back if an error is encountered. +** +** P1 is the index of the database file on which the transaction is +** started. Index 0 is the main database file and index 1 is the +** file used for temporary tables. +** +** A write lock is obtained on the database file when a transaction is +** started. No other process can read or write the file while the +** transaction is underway. Starting a transaction also creates a +** rollback journal. A transaction must be started before any changes +** can be made to the database. +*/ +case OP_Transaction: { + int busy = 1; + int i = pOp->p1; + assert( i>=0 && i<db->nDb ); + if( db->aDb[i].inTrans ) break; + while( db->aDb[i].pBt!=0 && busy ){ + rc = sqliteBtreeBeginTrans(db->aDb[i].pBt); + switch( rc ){ + case SQLITE_BUSY: { + if( db->xBusyCallback==0 ){ + p->pc = pc; + p->undoTransOnError = 1; + p->rc = SQLITE_BUSY; + p->pTos = pTos; + return SQLITE_BUSY; + }else if( (*db->xBusyCallback)(db->pBusyArg, "", busy++)==0 ){ + sqliteSetString(&p->zErrMsg, sqlite_error_string(rc), (char*)0); + busy = 0; + } + break; + } + case SQLITE_READONLY: { + rc = SQLITE_OK; + /* Fall thru into the next case */ + } + case SQLITE_OK: { + p->inTempTrans = 0; + busy = 0; + break; + } + default: { + goto abort_due_to_error; + } + } + } + db->aDb[i].inTrans = 1; + p->undoTransOnError = 1; + break; +} + +/* Opcode: Commit * * * +** +** Cause all modifications to the database that have been made since the +** last Transaction to actually take effect. No additional modifications +** are allowed until another transaction is started. The Commit instruction +** deletes the journal file and releases the write lock on the database. +** A read lock continues to be held if there are still cursors open. +*/ +case OP_Commit: { + int i; + if( db->xCommitCallback!=0 ){ + if( sqliteSafetyOff(db) ) goto abort_due_to_misuse; + if( db->xCommitCallback(db->pCommitArg)!=0 ){ + rc = SQLITE_CONSTRAINT; + } + if( sqliteSafetyOn(db) ) goto abort_due_to_misuse; + } + for(i=0; rc==SQLITE_OK && i<db->nDb; i++){ + if( db->aDb[i].inTrans ){ + rc = sqliteBtreeCommit(db->aDb[i].pBt); + db->aDb[i].inTrans = 0; + } + } + if( rc==SQLITE_OK ){ + sqliteCommitInternalChanges(db); + }else{ + sqliteRollbackAll(db); + } + break; +} + +/* Opcode: Rollback P1 * * +** +** Cause all modifications to the database that have been made since the +** last Transaction to be undone. The database is restored to its state +** before the Transaction opcode was executed. No additional modifications +** are allowed until another transaction is started. +** +** P1 is the index of the database file that is committed. An index of 0 +** is used for the main database and an index of 1 is used for the file used +** to hold temporary tables. +** +** This instruction automatically closes all cursors and releases both +** the read and write locks on the indicated database. +*/ +case OP_Rollback: { + sqliteRollbackAll(db); + break; +} + +/* Opcode: ReadCookie P1 P2 * +** +** Read cookie number P2 from database P1 and push it onto the stack. +** P2==0 is the schema version. P2==1 is the database format. +** P2==2 is the recommended pager cache size, and so forth. P1==0 is +** the main database file and P1==1 is the database file used to store +** temporary tables. +** +** There must be a read-lock on the database (either a transaction +** must be started or there must be an open cursor) before +** executing this instruction. +*/ +case OP_ReadCookie: { + int aMeta[SQLITE_N_BTREE_META]; + assert( pOp->p2<SQLITE_N_BTREE_META ); + assert( pOp->p1>=0 && pOp->p1<db->nDb ); + assert( db->aDb[pOp->p1].pBt!=0 ); + rc = sqliteBtreeGetMeta(db->aDb[pOp->p1].pBt, aMeta); + pTos++; + pTos->i = aMeta[1+pOp->p2]; + pTos->flags = MEM_Int; + break; +} + +/* Opcode: SetCookie P1 P2 * +** +** Write the top of the stack into cookie number P2 of database P1. +** P2==0 is the schema version. P2==1 is the database format. +** P2==2 is the recommended pager cache size, and so forth. P1==0 is +** the main database file and P1==1 is the database file used to store +** temporary tables. +** +** A transaction must be started before executing this opcode. +*/ +case OP_SetCookie: { + int aMeta[SQLITE_N_BTREE_META]; + assert( pOp->p2<SQLITE_N_BTREE_META ); + assert( pOp->p1>=0 && pOp->p1<db->nDb ); + assert( db->aDb[pOp->p1].pBt!=0 ); + assert( pTos>=p->aStack ); + Integerify(pTos) + rc = sqliteBtreeGetMeta(db->aDb[pOp->p1].pBt, aMeta); + if( rc==SQLITE_OK ){ + aMeta[1+pOp->p2] = pTos->i; + rc = sqliteBtreeUpdateMeta(db->aDb[pOp->p1].pBt, aMeta); + } + Release(pTos); + pTos--; + break; +} + +/* Opcode: VerifyCookie P1 P2 * +** +** Check the value of global database parameter number 0 (the +** schema version) and make sure it is equal to P2. +** P1 is the database number which is 0 for the main database file +** and 1 for the file holding temporary tables and some higher number +** for auxiliary databases. +** +** The cookie changes its value whenever the database schema changes. +** This operation is used to detect when that the cookie has changed +** and that the current process needs to reread the schema. +** +** Either a transaction needs to have been started or an OP_Open needs +** to be executed (to establish a read lock) before this opcode is +** invoked. +*/ +case OP_VerifyCookie: { + int aMeta[SQLITE_N_BTREE_META]; + assert( pOp->p1>=0 && pOp->p1<db->nDb ); + rc = sqliteBtreeGetMeta(db->aDb[pOp->p1].pBt, aMeta); + if( rc==SQLITE_OK && aMeta[1]!=pOp->p2 ){ + sqliteSetString(&p->zErrMsg, "database schema has changed", (char*)0); + rc = SQLITE_SCHEMA; + } + break; +} + +/* Opcode: OpenRead P1 P2 P3 +** +** Open a read-only cursor for the database table whose root page is +** P2 in a database file. The database file is determined by an +** integer from the top of the stack. 0 means the main database and +** 1 means the database used for temporary tables. Give the new +** cursor an identifier of P1. The P1 values need not be contiguous +** but all P1 values should be small integers. It is an error for +** P1 to be negative. +** +** If P2==0 then take the root page number from the next of the stack. +** +** There will be a read lock on the database whenever there is an +** open cursor. If the database was unlocked prior to this instruction +** then a read lock is acquired as part of this instruction. A read +** lock allows other processes to read the database but prohibits +** any other process from modifying the database. The read lock is +** released when all cursors are closed. If this instruction attempts +** to get a read lock but fails, the script terminates with an +** SQLITE_BUSY error code. +** +** The P3 value is the name of the table or index being opened. +** The P3 value is not actually used by this opcode and may be +** omitted. But the code generator usually inserts the index or +** table name into P3 to make the code easier to read. +** +** See also OpenWrite. +*/ +/* Opcode: OpenWrite P1 P2 P3 +** +** Open a read/write cursor named P1 on the table or index whose root +** page is P2. If P2==0 then take the root page number from the stack. +** +** The P3 value is the name of the table or index being opened. +** The P3 value is not actually used by this opcode and may be +** omitted. But the code generator usually inserts the index or +** table name into P3 to make the code easier to read. +** +** This instruction works just like OpenRead except that it opens the cursor +** in read/write mode. For a given table, there can be one or more read-only +** cursors or a single read/write cursor but not both. +** +** See also OpenRead. +*/ +case OP_OpenRead: +case OP_OpenWrite: { + int busy = 0; + int i = pOp->p1; + int p2 = pOp->p2; + int wrFlag; + Btree *pX; + int iDb; + + assert( pTos>=p->aStack ); + Integerify(pTos); + iDb = pTos->i; + pTos--; + assert( iDb>=0 && iDb<db->nDb ); + pX = db->aDb[iDb].pBt; + assert( pX!=0 ); + wrFlag = pOp->opcode==OP_OpenWrite; + if( p2<=0 ){ + assert( pTos>=p->aStack ); + Integerify(pTos); + p2 = pTos->i; + pTos--; + if( p2<2 ){ + sqliteSetString(&p->zErrMsg, "root page number less than 2", (char*)0); + rc = SQLITE_INTERNAL; + break; + } + } + assert( i>=0 ); + if( expandCursorArraySize(p, i) ) goto no_mem; + sqliteVdbeCleanupCursor(&p->aCsr[i]); + memset(&p->aCsr[i], 0, sizeof(Cursor)); + p->aCsr[i].nullRow = 1; + if( pX==0 ) break; + do{ + rc = sqliteBtreeCursor(pX, p2, wrFlag, &p->aCsr[i].pCursor); + switch( rc ){ + case SQLITE_BUSY: { + if( db->xBusyCallback==0 ){ + p->pc = pc; + p->rc = SQLITE_BUSY; + p->pTos = &pTos[1 + (pOp->p2<=0)]; /* Operands must remain on stack */ + return SQLITE_BUSY; + }else if( (*db->xBusyCallback)(db->pBusyArg, pOp->p3, ++busy)==0 ){ + sqliteSetString(&p->zErrMsg, sqlite_error_string(rc), (char*)0); + busy = 0; + } + break; + } + case SQLITE_OK: { + busy = 0; + break; + } + default: { + goto abort_due_to_error; + } + } + }while( busy ); + break; +} + +/* Opcode: OpenTemp P1 P2 * +** +** Open a new cursor to a transient table. +** The transient cursor is always opened read/write even if +** the main database is read-only. The transient table is deleted +** automatically when the cursor is closed. +** +** The cursor points to a BTree table if P2==0 and to a BTree index +** if P2==1. A BTree table must have an integer key and can have arbitrary +** data. A BTree index has no data but can have an arbitrary key. +** +** This opcode is used for tables that exist for the duration of a single +** SQL statement only. Tables created using CREATE TEMPORARY TABLE +** are opened using OP_OpenRead or OP_OpenWrite. "Temporary" in the +** context of this opcode means for the duration of a single SQL statement +** whereas "Temporary" in the context of CREATE TABLE means for the duration +** of the connection to the database. Same word; different meanings. +*/ +case OP_OpenTemp: { + int i = pOp->p1; + Cursor *pCx; + assert( i>=0 ); + if( expandCursorArraySize(p, i) ) goto no_mem; + pCx = &p->aCsr[i]; + sqliteVdbeCleanupCursor(pCx); + memset(pCx, 0, sizeof(*pCx)); + pCx->nullRow = 1; + rc = sqliteBtreeFactory(db, 0, 1, TEMP_PAGES, &pCx->pBt); + + if( rc==SQLITE_OK ){ + rc = sqliteBtreeBeginTrans(pCx->pBt); + } + if( rc==SQLITE_OK ){ + if( pOp->p2 ){ + int pgno; + rc = sqliteBtreeCreateIndex(pCx->pBt, &pgno); + if( rc==SQLITE_OK ){ + rc = sqliteBtreeCursor(pCx->pBt, pgno, 1, &pCx->pCursor); + } + }else{ + rc = sqliteBtreeCursor(pCx->pBt, 2, 1, &pCx->pCursor); + } + } + break; +} + +/* Opcode: OpenPseudo P1 * * +** +** Open a new cursor that points to a fake table that contains a single +** row of data. Any attempt to write a second row of data causes the +** first row to be deleted. All data is deleted when the cursor is +** closed. +** +** A pseudo-table created by this opcode is useful for holding the +** NEW or OLD tables in a trigger. +*/ +case OP_OpenPseudo: { + int i = pOp->p1; + Cursor *pCx; + assert( i>=0 ); + if( expandCursorArraySize(p, i) ) goto no_mem; + pCx = &p->aCsr[i]; + sqliteVdbeCleanupCursor(pCx); + memset(pCx, 0, sizeof(*pCx)); + pCx->nullRow = 1; + pCx->pseudoTable = 1; + break; +} + +/* Opcode: Close P1 * * +** +** Close a cursor previously opened as P1. If P1 is not +** currently open, this instruction is a no-op. +*/ +case OP_Close: { + int i = pOp->p1; + if( i>=0 && i<p->nCursor ){ + sqliteVdbeCleanupCursor(&p->aCsr[i]); + } + break; +} + +/* Opcode: MoveTo P1 P2 * +** +** Pop the top of the stack and use its value as a key. Reposition +** cursor P1 so that it points to an entry with a matching key. If +** the table contains no record with a matching key, then the cursor +** is left pointing at the first record that is greater than the key. +** If there are no records greater than the key and P2 is not zero, +** then an immediate jump to P2 is made. +** +** See also: Found, NotFound, Distinct, MoveLt +*/ +/* Opcode: MoveLt P1 P2 * +** +** Pop the top of the stack and use its value as a key. Reposition +** cursor P1 so that it points to the entry with the largest key that is +** less than the key popped from the stack. +** If there are no records less than than the key and P2 +** is not zero then an immediate jump to P2 is made. +** +** See also: MoveTo +*/ +case OP_MoveLt: +case OP_MoveTo: { + int i = pOp->p1; + Cursor *pC; + + assert( pTos>=p->aStack ); + assert( i>=0 && i<p->nCursor ); + pC = &p->aCsr[i]; + if( pC->pCursor!=0 ){ + int res, oc; + pC->nullRow = 0; + if( pTos->flags & MEM_Int ){ + int iKey = intToKey(pTos->i); + if( pOp->p2==0 && pOp->opcode==OP_MoveTo ){ + pC->movetoTarget = iKey; + pC->deferredMoveto = 1; + Release(pTos); + pTos--; + break; + } + sqliteBtreeMoveto(pC->pCursor, (char*)&iKey, sizeof(int), &res); + pC->lastRecno = pTos->i; + pC->recnoIsValid = res==0; + }else{ + Stringify(pTos); + sqliteBtreeMoveto(pC->pCursor, pTos->z, pTos->n, &res); + pC->recnoIsValid = 0; + } + pC->deferredMoveto = 0; + sqlite_search_count++; + oc = pOp->opcode; + if( oc==OP_MoveTo && res<0 ){ + sqliteBtreeNext(pC->pCursor, &res); + pC->recnoIsValid = 0; + if( res && pOp->p2>0 ){ + pc = pOp->p2 - 1; + } + }else if( oc==OP_MoveLt ){ + if( res>=0 ){ + sqliteBtreePrevious(pC->pCursor, &res); + pC->recnoIsValid = 0; + }else{ + /* res might be negative because the table is empty. Check to + ** see if this is the case. + */ + int keysize; + res = sqliteBtreeKeySize(pC->pCursor,&keysize)!=0 || keysize==0; + } + if( res && pOp->p2>0 ){ + pc = pOp->p2 - 1; + } + } + } + Release(pTos); + pTos--; + break; +} + +/* Opcode: Distinct P1 P2 * +** +** Use the top of the stack as a string key. If a record with that key does +** not exist in the table of cursor P1, then jump to P2. If the record +** does already exist, then fall thru. The cursor is left pointing +** at the record if it exists. The key is not popped from the stack. +** +** This operation is similar to NotFound except that this operation +** does not pop the key from the stack. +** +** See also: Found, NotFound, MoveTo, IsUnique, NotExists +*/ +/* Opcode: Found P1 P2 * +** +** Use the top of the stack as a string key. If a record with that key +** does exist in table of P1, then jump to P2. If the record +** does not exist, then fall thru. The cursor is left pointing +** to the record if it exists. The key is popped from the stack. +** +** See also: Distinct, NotFound, MoveTo, IsUnique, NotExists +*/ +/* Opcode: NotFound P1 P2 * +** +** Use the top of the stack as a string key. If a record with that key +** does not exist in table of P1, then jump to P2. If the record +** does exist, then fall thru. The cursor is left pointing to the +** record if it exists. The key is popped from the stack. +** +** The difference between this operation and Distinct is that +** Distinct does not pop the key from the stack. +** +** See also: Distinct, Found, MoveTo, NotExists, IsUnique +*/ +case OP_Distinct: +case OP_NotFound: +case OP_Found: { + int i = pOp->p1; + int alreadyExists = 0; + Cursor *pC; + assert( pTos>=p->aStack ); + assert( i>=0 && i<p->nCursor ); + if( (pC = &p->aCsr[i])->pCursor!=0 ){ + int res, rx; + Stringify(pTos); + rx = sqliteBtreeMoveto(pC->pCursor, pTos->z, pTos->n, &res); + alreadyExists = rx==SQLITE_OK && res==0; + pC->deferredMoveto = 0; + } + if( pOp->opcode==OP_Found ){ + if( alreadyExists ) pc = pOp->p2 - 1; + }else{ + if( !alreadyExists ) pc = pOp->p2 - 1; + } + if( pOp->opcode!=OP_Distinct ){ + Release(pTos); + pTos--; + } + break; +} + +/* Opcode: IsUnique P1 P2 * +** +** The top of the stack is an integer record number. Call this +** record number R. The next on the stack is an index key created +** using MakeIdxKey. Call it K. This instruction pops R from the +** stack but it leaves K unchanged. +** +** P1 is an index. So all but the last four bytes of K are an +** index string. The last four bytes of K are a record number. +** +** This instruction asks if there is an entry in P1 where the +** index string matches K but the record number is different +** from R. If there is no such entry, then there is an immediate +** jump to P2. If any entry does exist where the index string +** matches K but the record number is not R, then the record +** number for that entry is pushed onto the stack and control +** falls through to the next instruction. +** +** See also: Distinct, NotFound, NotExists, Found +*/ +case OP_IsUnique: { + int i = pOp->p1; + Mem *pNos = &pTos[-1]; + BtCursor *pCrsr; + int R; + + /* Pop the value R off the top of the stack + */ + assert( pNos>=p->aStack ); + Integerify(pTos); + R = pTos->i; + pTos--; + assert( i>=0 && i<=p->nCursor ); + if( (pCrsr = p->aCsr[i].pCursor)!=0 ){ + int res, rc; + int v; /* The record number on the P1 entry that matches K */ + char *zKey; /* The value of K */ + int nKey; /* Number of bytes in K */ + + /* Make sure K is a string and make zKey point to K + */ + Stringify(pNos); + zKey = pNos->z; + nKey = pNos->n; + assert( nKey >= 4 ); + + /* Search for an entry in P1 where all but the last four bytes match K. + ** If there is no such entry, jump immediately to P2. + */ + assert( p->aCsr[i].deferredMoveto==0 ); + rc = sqliteBtreeMoveto(pCrsr, zKey, nKey-4, &res); + if( rc!=SQLITE_OK ) goto abort_due_to_error; + if( res<0 ){ + rc = sqliteBtreeNext(pCrsr, &res); + if( res ){ + pc = pOp->p2 - 1; + break; + } + } + rc = sqliteBtreeKeyCompare(pCrsr, zKey, nKey-4, 4, &res); + if( rc!=SQLITE_OK ) goto abort_due_to_error; + if( res>0 ){ + pc = pOp->p2 - 1; + break; + } + + /* At this point, pCrsr is pointing to an entry in P1 where all but + ** the last for bytes of the key match K. Check to see if the last + ** four bytes of the key are different from R. If the last four + ** bytes equal R then jump immediately to P2. + */ + sqliteBtreeKey(pCrsr, nKey - 4, 4, (char*)&v); + v = keyToInt(v); + if( v==R ){ + pc = pOp->p2 - 1; + break; + } + + /* The last four bytes of the key are different from R. Convert the + ** last four bytes of the key into an integer and push it onto the + ** stack. (These bytes are the record number of an entry that + ** violates a UNIQUE constraint.) + */ + pTos++; + pTos->i = v; + pTos->flags = MEM_Int; + } + break; +} + +/* Opcode: NotExists P1 P2 * +** +** Use the top of the stack as a integer key. If a record with that key +** does not exist in table of P1, then jump to P2. If the record +** does exist, then fall thru. The cursor is left pointing to the +** record if it exists. The integer key is popped from the stack. +** +** The difference between this operation and NotFound is that this +** operation assumes the key is an integer and NotFound assumes it +** is a string. +** +** See also: Distinct, Found, MoveTo, NotFound, IsUnique +*/ +case OP_NotExists: { + int i = pOp->p1; + BtCursor *pCrsr; + assert( pTos>=p->aStack ); + assert( i>=0 && i<p->nCursor ); + if( (pCrsr = p->aCsr[i].pCursor)!=0 ){ + int res, rx, iKey; + assert( pTos->flags & MEM_Int ); + iKey = intToKey(pTos->i); + rx = sqliteBtreeMoveto(pCrsr, (char*)&iKey, sizeof(int), &res); + p->aCsr[i].lastRecno = pTos->i; + p->aCsr[i].recnoIsValid = res==0; + p->aCsr[i].nullRow = 0; + if( rx!=SQLITE_OK || res!=0 ){ + pc = pOp->p2 - 1; + p->aCsr[i].recnoIsValid = 0; + } + } + Release(pTos); + pTos--; + break; +} + +/* Opcode: NewRecno P1 * * +** +** Get a new integer record number used as the key to a table. +** The record number is not previously used as a key in the database +** table that cursor P1 points to. The new record number is pushed +** onto the stack. +*/ +case OP_NewRecno: { + int i = pOp->p1; + int v = 0; + Cursor *pC; + assert( i>=0 && i<p->nCursor ); + if( (pC = &p->aCsr[i])->pCursor==0 ){ + v = 0; + }else{ + /* The next rowid or record number (different terms for the same + ** thing) is obtained in a two-step algorithm. + ** + ** First we attempt to find the largest existing rowid and add one + ** to that. But if the largest existing rowid is already the maximum + ** positive integer, we have to fall through to the second + ** probabilistic algorithm + ** + ** The second algorithm is to select a rowid at random and see if + ** it already exists in the table. If it does not exist, we have + ** succeeded. If the random rowid does exist, we select a new one + ** and try again, up to 1000 times. + ** + ** For a table with less than 2 billion entries, the probability + ** of not finding a unused rowid is about 1.0e-300. This is a + ** non-zero probability, but it is still vanishingly small and should + ** never cause a problem. You are much, much more likely to have a + ** hardware failure than for this algorithm to fail. + ** + ** The analysis in the previous paragraph assumes that you have a good + ** source of random numbers. Is a library function like lrand48() + ** good enough? Maybe. Maybe not. It's hard to know whether there + ** might be subtle bugs is some implementations of lrand48() that + ** could cause problems. To avoid uncertainty, SQLite uses its own + ** random number generator based on the RC4 algorithm. + ** + ** To promote locality of reference for repetitive inserts, the + ** first few attempts at chosing a random rowid pick values just a little + ** larger than the previous rowid. This has been shown experimentally + ** to double the speed of the COPY operation. + */ + int res, rx, cnt, x; + cnt = 0; + if( !pC->useRandomRowid ){ + if( pC->nextRowidValid ){ + v = pC->nextRowid; + }else{ + rx = sqliteBtreeLast(pC->pCursor, &res); + if( res ){ + v = 1; + }else{ + sqliteBtreeKey(pC->pCursor, 0, sizeof(v), (void*)&v); + v = keyToInt(v); + if( v==0x7fffffff ){ + pC->useRandomRowid = 1; + }else{ + v++; + } + } + } + if( v<0x7fffffff ){ + pC->nextRowidValid = 1; + pC->nextRowid = v+1; + }else{ + pC->nextRowidValid = 0; + } + } + if( pC->useRandomRowid ){ + v = db->priorNewRowid; + cnt = 0; + do{ + if( v==0 || cnt>2 ){ + sqliteRandomness(sizeof(v), &v); + if( cnt<5 ) v &= 0xffffff; + }else{ + unsigned char r; + sqliteRandomness(1, &r); + v += r + 1; + } + if( v==0 ) continue; + x = intToKey(v); + rx = sqliteBtreeMoveto(pC->pCursor, &x, sizeof(int), &res); + cnt++; + }while( cnt<1000 && rx==SQLITE_OK && res==0 ); + db->priorNewRowid = v; + if( rx==SQLITE_OK && res==0 ){ + rc = SQLITE_FULL; + goto abort_due_to_error; + } + } + pC->recnoIsValid = 0; + pC->deferredMoveto = 0; + } + pTos++; + pTos->i = v; + pTos->flags = MEM_Int; + break; +} + +/* Opcode: PutIntKey P1 P2 * +** +** Write an entry into the table of cursor P1. A new entry is +** created if it doesn't already exist or the data for an existing +** entry is overwritten. The data is the value on the top of the +** stack. The key is the next value down on the stack. The key must +** be an integer. The stack is popped twice by this instruction. +** +** If the OPFLAG_NCHANGE flag of P2 is set, then the row change count is +** incremented (otherwise not). If the OPFLAG_CSCHANGE flag is set, +** then the current statement change count is incremented (otherwise not). +** If the OPFLAG_LASTROWID flag of P2 is set, then rowid is +** stored for subsequent return by the sqlite_last_insert_rowid() function +** (otherwise it's unmodified). +*/ +/* Opcode: PutStrKey P1 * * +** +** Write an entry into the table of cursor P1. A new entry is +** created if it doesn't already exist or the data for an existing +** entry is overwritten. The data is the value on the top of the +** stack. The key is the next value down on the stack. The key must +** be a string. The stack is popped twice by this instruction. +** +** P1 may not be a pseudo-table opened using the OpenPseudo opcode. +*/ +case OP_PutIntKey: +case OP_PutStrKey: { + Mem *pNos = &pTos[-1]; + int i = pOp->p1; + Cursor *pC; + assert( pNos>=p->aStack ); + assert( i>=0 && i<p->nCursor ); + if( ((pC = &p->aCsr[i])->pCursor!=0 || pC->pseudoTable) ){ + char *zKey; + int nKey, iKey; + if( pOp->opcode==OP_PutStrKey ){ + Stringify(pNos); + nKey = pNos->n; + zKey = pNos->z; + }else{ + assert( pNos->flags & MEM_Int ); + nKey = sizeof(int); + iKey = intToKey(pNos->i); + zKey = (char*)&iKey; + if( pOp->p2 & OPFLAG_NCHANGE ) db->nChange++; + if( pOp->p2 & OPFLAG_LASTROWID ) db->lastRowid = pNos->i; + if( pOp->p2 & OPFLAG_CSCHANGE ) db->csChange++; + if( pC->nextRowidValid && pTos->i>=pC->nextRowid ){ + pC->nextRowidValid = 0; + } + } + if( pTos->flags & MEM_Null ){ + pTos->z = 0; + pTos->n = 0; + }else{ + assert( pTos->flags & MEM_Str ); + } + if( pC->pseudoTable ){ + /* PutStrKey does not work for pseudo-tables. + ** The following assert makes sure we are not trying to use + ** PutStrKey on a pseudo-table + */ + assert( pOp->opcode==OP_PutIntKey ); + sqliteFree(pC->pData); + pC->iKey = iKey; + pC->nData = pTos->n; + if( pTos->flags & MEM_Dyn ){ + pC->pData = pTos->z; + pTos->flags = MEM_Null; + }else{ + pC->pData = sqliteMallocRaw( pC->nData ); + if( pC->pData ){ + memcpy(pC->pData, pTos->z, pC->nData); + } + } + pC->nullRow = 0; + }else{ + rc = sqliteBtreeInsert(pC->pCursor, zKey, nKey, pTos->z, pTos->n); + } + pC->recnoIsValid = 0; + pC->deferredMoveto = 0; + } + popStack(&pTos, 2); + break; +} + +/* Opcode: Delete P1 P2 * +** +** Delete the record at which the P1 cursor is currently pointing. +** +** The cursor will be left pointing at either the next or the previous +** record in the table. If it is left pointing at the next record, then +** the next Next instruction will be a no-op. Hence it is OK to delete +** a record from within an Next loop. +** +** If the OPFLAG_NCHANGE flag of P2 is set, then the row change count is +** incremented (otherwise not). If OPFLAG_CSCHANGE flag is set, +** then the current statement change count is incremented (otherwise not). +** +** If P1 is a pseudo-table, then this instruction is a no-op. +*/ +case OP_Delete: { + int i = pOp->p1; + Cursor *pC; + assert( i>=0 && i<p->nCursor ); + pC = &p->aCsr[i]; + if( pC->pCursor!=0 ){ + sqliteVdbeCursorMoveto(pC); + rc = sqliteBtreeDelete(pC->pCursor); + pC->nextRowidValid = 0; + } + if( pOp->p2 & OPFLAG_NCHANGE ) db->nChange++; + if( pOp->p2 & OPFLAG_CSCHANGE ) db->csChange++; + break; +} + +/* Opcode: SetCounts * * * +** +** Called at end of statement. Updates lsChange (last statement change count) +** and resets csChange (current statement change count) to 0. +*/ +case OP_SetCounts: { + db->lsChange=db->csChange; + db->csChange=0; + break; +} + +/* Opcode: KeyAsData P1 P2 * +** +** Turn the key-as-data mode for cursor P1 either on (if P2==1) or +** off (if P2==0). In key-as-data mode, the OP_Column opcode pulls +** data off of the key rather than the data. This is used for +** processing compound selects. +*/ +case OP_KeyAsData: { + int i = pOp->p1; + assert( i>=0 && i<p->nCursor ); + p->aCsr[i].keyAsData = pOp->p2; + break; +} + +/* Opcode: RowData P1 * * +** +** Push onto the stack the complete row data for cursor P1. +** There is no interpretation of the data. It is just copied +** onto the stack exactly as it is found in the database file. +** +** If the cursor is not pointing to a valid row, a NULL is pushed +** onto the stack. +*/ +/* Opcode: RowKey P1 * * +** +** Push onto the stack the complete row key for cursor P1. +** There is no interpretation of the key. It is just copied +** onto the stack exactly as it is found in the database file. +** +** If the cursor is not pointing to a valid row, a NULL is pushed +** onto the stack. +*/ +case OP_RowKey: +case OP_RowData: { + int i = pOp->p1; + Cursor *pC; + int n; + + pTos++; + assert( i>=0 && i<p->nCursor ); + pC = &p->aCsr[i]; + if( pC->nullRow ){ + pTos->flags = MEM_Null; + }else if( pC->pCursor!=0 ){ + BtCursor *pCrsr = pC->pCursor; + sqliteVdbeCursorMoveto(pC); + if( pC->nullRow ){ + pTos->flags = MEM_Null; + break; + }else if( pC->keyAsData || pOp->opcode==OP_RowKey ){ + sqliteBtreeKeySize(pCrsr, &n); + }else{ + sqliteBtreeDataSize(pCrsr, &n); + } + pTos->n = n; + if( n<=NBFS ){ + pTos->flags = MEM_Str | MEM_Short; + pTos->z = pTos->zShort; + }else{ + char *z = sqliteMallocRaw( n ); + if( z==0 ) goto no_mem; + pTos->flags = MEM_Str | MEM_Dyn; + pTos->z = z; + } + if( pC->keyAsData || pOp->opcode==OP_RowKey ){ + sqliteBtreeKey(pCrsr, 0, n, pTos->z); + }else{ + sqliteBtreeData(pCrsr, 0, n, pTos->z); + } + }else if( pC->pseudoTable ){ + pTos->n = pC->nData; + pTos->z = pC->pData; + pTos->flags = MEM_Str|MEM_Ephem; + }else{ + pTos->flags = MEM_Null; + } + break; +} + +/* Opcode: Column P1 P2 * +** +** Interpret the data that cursor P1 points to as +** a structure built using the MakeRecord instruction. +** (See the MakeRecord opcode for additional information about +** the format of the data.) +** Push onto the stack the value of the P2-th column contained +** in the data. +** +** If the KeyAsData opcode has previously executed on this cursor, +** then the field might be extracted from the key rather than the +** data. +** +** If P1 is negative, then the record is stored on the stack rather +** than in a table. For P1==-1, the top of the stack is used. +** For P1==-2, the next on the stack is used. And so forth. The +** value pushed is always just a pointer into the record which is +** stored further down on the stack. The column value is not copied. +*/ +case OP_Column: { + int amt, offset, end, payloadSize; + int i = pOp->p1; + int p2 = pOp->p2; + Cursor *pC; + char *zRec; + BtCursor *pCrsr; + int idxWidth; + unsigned char aHdr[10]; + + assert( i<p->nCursor ); + pTos++; + if( i<0 ){ + assert( &pTos[i]>=p->aStack ); + assert( pTos[i].flags & MEM_Str ); + zRec = pTos[i].z; + payloadSize = pTos[i].n; + }else if( (pC = &p->aCsr[i])->pCursor!=0 ){ + sqliteVdbeCursorMoveto(pC); + zRec = 0; + pCrsr = pC->pCursor; + if( pC->nullRow ){ + payloadSize = 0; + }else if( pC->keyAsData ){ + sqliteBtreeKeySize(pCrsr, &payloadSize); + }else{ + sqliteBtreeDataSize(pCrsr, &payloadSize); + } + }else if( pC->pseudoTable ){ + payloadSize = pC->nData; + zRec = pC->pData; + assert( payloadSize==0 || zRec!=0 ); + }else{ + payloadSize = 0; + } + + /* Figure out how many bytes in the column data and where the column + ** data begins. + */ + if( payloadSize==0 ){ + pTos->flags = MEM_Null; + break; + }else if( payloadSize<256 ){ + idxWidth = 1; + }else if( payloadSize<65536 ){ + idxWidth = 2; + }else{ + idxWidth = 3; + } + + /* Figure out where the requested column is stored and how big it is. + */ + if( payloadSize < idxWidth*(p2+1) ){ + rc = SQLITE_CORRUPT; + goto abort_due_to_error; + } + if( zRec ){ + memcpy(aHdr, &zRec[idxWidth*p2], idxWidth*2); + }else if( pC->keyAsData ){ + sqliteBtreeKey(pCrsr, idxWidth*p2, idxWidth*2, (char*)aHdr); + }else{ + sqliteBtreeData(pCrsr, idxWidth*p2, idxWidth*2, (char*)aHdr); + } + offset = aHdr[0]; + end = aHdr[idxWidth]; + if( idxWidth>1 ){ + offset |= aHdr[1]<<8; + end |= aHdr[idxWidth+1]<<8; + if( idxWidth>2 ){ + offset |= aHdr[2]<<16; + end |= aHdr[idxWidth+2]<<16; + } + } + amt = end - offset; + if( amt<0 || offset<0 || end>payloadSize ){ + rc = SQLITE_CORRUPT; + goto abort_due_to_error; + } + + /* amt and offset now hold the offset to the start of data and the + ** amount of data. Go get the data and put it on the stack. + */ + pTos->n = amt; + if( amt==0 ){ + pTos->flags = MEM_Null; + }else if( zRec ){ + pTos->flags = MEM_Str | MEM_Ephem; + pTos->z = &zRec[offset]; + }else{ + if( amt<=NBFS ){ + pTos->flags = MEM_Str | MEM_Short; + pTos->z = pTos->zShort; + }else{ + char *z = sqliteMallocRaw( amt ); + if( z==0 ) goto no_mem; + pTos->flags = MEM_Str | MEM_Dyn; + pTos->z = z; + } + if( pC->keyAsData ){ + sqliteBtreeKey(pCrsr, offset, amt, pTos->z); + }else{ + sqliteBtreeData(pCrsr, offset, amt, pTos->z); + } + } + break; +} + +/* Opcode: Recno P1 * * +** +** Push onto the stack an integer which is the first 4 bytes of the +** the key to the current entry in a sequential scan of the database +** file P1. The sequential scan should have been started using the +** Next opcode. +*/ +case OP_Recno: { + int i = pOp->p1; + Cursor *pC; + int v; + + assert( i>=0 && i<p->nCursor ); + pC = &p->aCsr[i]; + sqliteVdbeCursorMoveto(pC); + pTos++; + if( pC->recnoIsValid ){ + v = pC->lastRecno; + }else if( pC->pseudoTable ){ + v = keyToInt(pC->iKey); + }else if( pC->nullRow || pC->pCursor==0 ){ + pTos->flags = MEM_Null; + break; + }else{ + assert( pC->pCursor!=0 ); + sqliteBtreeKey(pC->pCursor, 0, sizeof(u32), (char*)&v); + v = keyToInt(v); + } + pTos->i = v; + pTos->flags = MEM_Int; + break; +} + +/* Opcode: FullKey P1 * * +** +** Extract the complete key from the record that cursor P1 is currently +** pointing to and push the key onto the stack as a string. +** +** Compare this opcode to Recno. The Recno opcode extracts the first +** 4 bytes of the key and pushes those bytes onto the stack as an +** integer. This instruction pushes the entire key as a string. +** +** This opcode may not be used on a pseudo-table. +*/ +case OP_FullKey: { + int i = pOp->p1; + BtCursor *pCrsr; + + assert( p->aCsr[i].keyAsData ); + assert( !p->aCsr[i].pseudoTable ); + assert( i>=0 && i<p->nCursor ); + pTos++; + if( (pCrsr = p->aCsr[i].pCursor)!=0 ){ + int amt; + char *z; + + sqliteVdbeCursorMoveto(&p->aCsr[i]); + sqliteBtreeKeySize(pCrsr, &amt); + if( amt<=0 ){ + rc = SQLITE_CORRUPT; + goto abort_due_to_error; + } + if( amt>NBFS ){ + z = sqliteMallocRaw( amt ); + if( z==0 ) goto no_mem; + pTos->flags = MEM_Str | MEM_Dyn; + }else{ + z = pTos->zShort; + pTos->flags = MEM_Str | MEM_Short; + } + sqliteBtreeKey(pCrsr, 0, amt, z); + pTos->z = z; + pTos->n = amt; + } + break; +} + +/* Opcode: NullRow P1 * * +** +** Move the cursor P1 to a null row. Any OP_Column operations +** that occur while the cursor is on the null row will always push +** a NULL onto the stack. +*/ +case OP_NullRow: { + int i = pOp->p1; + + assert( i>=0 && i<p->nCursor ); + p->aCsr[i].nullRow = 1; + p->aCsr[i].recnoIsValid = 0; + break; +} + +/* Opcode: Last P1 P2 * +** +** The next use of the Recno or Column or Next instruction for P1 +** will refer to the last entry in the database table or index. +** If the table or index is empty and P2>0, then jump immediately to P2. +** If P2 is 0 or if the table or index is not empty, fall through +** to the following instruction. +*/ +case OP_Last: { + int i = pOp->p1; + Cursor *pC; + BtCursor *pCrsr; + + assert( i>=0 && i<p->nCursor ); + pC = &p->aCsr[i]; + if( (pCrsr = pC->pCursor)!=0 ){ + int res; + rc = sqliteBtreeLast(pCrsr, &res); + pC->nullRow = res; + pC->deferredMoveto = 0; + if( res && pOp->p2>0 ){ + pc = pOp->p2 - 1; + } + }else{ + pC->nullRow = 0; + } + break; +} + +/* Opcode: Rewind P1 P2 * +** +** The next use of the Recno or Column or Next instruction for P1 +** will refer to the first entry in the database table or index. +** If the table or index is empty and P2>0, then jump immediately to P2. +** If P2 is 0 or if the table or index is not empty, fall through +** to the following instruction. +*/ +case OP_Rewind: { + int i = pOp->p1; + Cursor *pC; + BtCursor *pCrsr; + + assert( i>=0 && i<p->nCursor ); + pC = &p->aCsr[i]; + if( (pCrsr = pC->pCursor)!=0 ){ + int res; + rc = sqliteBtreeFirst(pCrsr, &res); + pC->atFirst = res==0; + pC->nullRow = res; + pC->deferredMoveto = 0; + if( res && pOp->p2>0 ){ + pc = pOp->p2 - 1; + } + }else{ + pC->nullRow = 0; + } + break; +} + +/* Opcode: Next P1 P2 * +** +** Advance cursor P1 so that it points to the next key/data pair in its +** table or index. If there are no more key/value pairs then fall through +** to the following instruction. But if the cursor advance was successful, +** jump immediately to P2. +** +** See also: Prev +*/ +/* Opcode: Prev P1 P2 * +** +** Back up cursor P1 so that it points to the previous key/data pair in its +** table or index. If there is no previous key/value pairs then fall through +** to the following instruction. But if the cursor backup was successful, +** jump immediately to P2. +*/ +case OP_Prev: +case OP_Next: { + Cursor *pC; + BtCursor *pCrsr; + + CHECK_FOR_INTERRUPT; + assert( pOp->p1>=0 && pOp->p1<p->nCursor ); + pC = &p->aCsr[pOp->p1]; + if( (pCrsr = pC->pCursor)!=0 ){ + int res; + if( pC->nullRow ){ + res = 1; + }else{ + assert( pC->deferredMoveto==0 ); + rc = pOp->opcode==OP_Next ? sqliteBtreeNext(pCrsr, &res) : + sqliteBtreePrevious(pCrsr, &res); + pC->nullRow = res; + } + if( res==0 ){ + pc = pOp->p2 - 1; + sqlite_search_count++; + } + }else{ + pC->nullRow = 1; + } + pC->recnoIsValid = 0; + break; +} + +/* Opcode: IdxPut P1 P2 P3 +** +** The top of the stack holds a SQL index key made using the +** MakeIdxKey instruction. This opcode writes that key into the +** index P1. Data for the entry is nil. +** +** If P2==1, then the key must be unique. If the key is not unique, +** the program aborts with a SQLITE_CONSTRAINT error and the database +** is rolled back. If P3 is not null, then it becomes part of the +** error message returned with the SQLITE_CONSTRAINT. +*/ +case OP_IdxPut: { + int i = pOp->p1; + BtCursor *pCrsr; + assert( pTos>=p->aStack ); + assert( i>=0 && i<p->nCursor ); + assert( pTos->flags & MEM_Str ); + if( (pCrsr = p->aCsr[i].pCursor)!=0 ){ + int nKey = pTos->n; + const char *zKey = pTos->z; + if( pOp->p2 ){ + int res, n; + assert( nKey >= 4 ); + rc = sqliteBtreeMoveto(pCrsr, zKey, nKey-4, &res); + if( rc!=SQLITE_OK ) goto abort_due_to_error; + while( res!=0 ){ + int c; + sqliteBtreeKeySize(pCrsr, &n); + if( n==nKey + && sqliteBtreeKeyCompare(pCrsr, zKey, nKey-4, 4, &c)==SQLITE_OK + && c==0 + ){ + rc = SQLITE_CONSTRAINT; + if( pOp->p3 && pOp->p3[0] ){ + sqliteSetString(&p->zErrMsg, pOp->p3, (char*)0); + } + goto abort_due_to_error; + } + if( res<0 ){ + sqliteBtreeNext(pCrsr, &res); + res = +1; + }else{ + break; + } + } + } + rc = sqliteBtreeInsert(pCrsr, zKey, nKey, "", 0); + assert( p->aCsr[i].deferredMoveto==0 ); + } + Release(pTos); + pTos--; + break; +} + +/* Opcode: IdxDelete P1 * * +** +** The top of the stack is an index key built using the MakeIdxKey opcode. +** This opcode removes that entry from the index. +*/ +case OP_IdxDelete: { + int i = pOp->p1; + BtCursor *pCrsr; + assert( pTos>=p->aStack ); + assert( pTos->flags & MEM_Str ); + assert( i>=0 && i<p->nCursor ); + if( (pCrsr = p->aCsr[i].pCursor)!=0 ){ + int rx, res; + rx = sqliteBtreeMoveto(pCrsr, pTos->z, pTos->n, &res); + if( rx==SQLITE_OK && res==0 ){ + rc = sqliteBtreeDelete(pCrsr); + } + assert( p->aCsr[i].deferredMoveto==0 ); + } + Release(pTos); + pTos--; + break; +} + +/* Opcode: IdxRecno P1 * * +** +** Push onto the stack an integer which is the last 4 bytes of the +** the key to the current entry in index P1. These 4 bytes should +** be the record number of the table entry to which this index entry +** points. +** +** See also: Recno, MakeIdxKey. +*/ +case OP_IdxRecno: { + int i = pOp->p1; + BtCursor *pCrsr; + + assert( i>=0 && i<p->nCursor ); + pTos++; + if( (pCrsr = p->aCsr[i].pCursor)!=0 ){ + int v; + int sz; + assert( p->aCsr[i].deferredMoveto==0 ); + sqliteBtreeKeySize(pCrsr, &sz); + if( sz<sizeof(u32) ){ + pTos->flags = MEM_Null; + }else{ + sqliteBtreeKey(pCrsr, sz - sizeof(u32), sizeof(u32), (char*)&v); + v = keyToInt(v); + pTos->i = v; + pTos->flags = MEM_Int; + } + }else{ + pTos->flags = MEM_Null; + } + break; +} + +/* Opcode: IdxGT P1 P2 * +** +** Compare the top of the stack against the key on the index entry that +** cursor P1 is currently pointing to. Ignore the last 4 bytes of the +** index entry. If the index entry is greater than the top of the stack +** then jump to P2. Otherwise fall through to the next instruction. +** In either case, the stack is popped once. +*/ +/* Opcode: IdxGE P1 P2 * +** +** Compare the top of the stack against the key on the index entry that +** cursor P1 is currently pointing to. Ignore the last 4 bytes of the +** index entry. If the index entry is greater than or equal to +** the top of the stack +** then jump to P2. Otherwise fall through to the next instruction. +** In either case, the stack is popped once. +*/ +/* Opcode: IdxLT P1 P2 * +** +** Compare the top of the stack against the key on the index entry that +** cursor P1 is currently pointing to. Ignore the last 4 bytes of the +** index entry. If the index entry is less than the top of the stack +** then jump to P2. Otherwise fall through to the next instruction. +** In either case, the stack is popped once. +*/ +case OP_IdxLT: +case OP_IdxGT: +case OP_IdxGE: { + int i= pOp->p1; + BtCursor *pCrsr; + + assert( i>=0 && i<p->nCursor ); + assert( pTos>=p->aStack ); + if( (pCrsr = p->aCsr[i].pCursor)!=0 ){ + int res, rc; + + Stringify(pTos); + assert( p->aCsr[i].deferredMoveto==0 ); + rc = sqliteBtreeKeyCompare(pCrsr, pTos->z, pTos->n, 4, &res); + if( rc!=SQLITE_OK ){ + break; + } + if( pOp->opcode==OP_IdxLT ){ + res = -res; + }else if( pOp->opcode==OP_IdxGE ){ + res++; + } + if( res>0 ){ + pc = pOp->p2 - 1 ; + } + } + Release(pTos); + pTos--; + break; +} + +/* Opcode: IdxIsNull P1 P2 * +** +** The top of the stack contains an index entry such as might be generated +** by the MakeIdxKey opcode. This routine looks at the first P1 fields of +** that key. If any of the first P1 fields are NULL, then a jump is made +** to address P2. Otherwise we fall straight through. +** +** The index entry is always popped from the stack. +*/ +case OP_IdxIsNull: { + int i = pOp->p1; + int k, n; + const char *z; + + assert( pTos>=p->aStack ); + assert( pTos->flags & MEM_Str ); + z = pTos->z; + n = pTos->n; + for(k=0; k<n && i>0; i--){ + if( z[k]=='a' ){ + pc = pOp->p2-1; + break; + } + while( k<n && z[k] ){ k++; } + k++; + } + Release(pTos); + pTos--; + break; +} + +/* Opcode: Destroy P1 P2 * +** +** Delete an entire database table or index whose root page in the database +** file is given by P1. +** +** The table being destroyed is in the main database file if P2==0. If +** P2==1 then the table to be clear is in the auxiliary database file +** that is used to store tables create using CREATE TEMPORARY TABLE. +** +** See also: Clear +*/ +case OP_Destroy: { + rc = sqliteBtreeDropTable(db->aDb[pOp->p2].pBt, pOp->p1); + break; +} + +/* Opcode: Clear P1 P2 * +** +** Delete all contents of the database table or index whose root page +** in the database file is given by P1. But, unlike Destroy, do not +** remove the table or index from the database file. +** +** The table being clear is in the main database file if P2==0. If +** P2==1 then the table to be clear is in the auxiliary database file +** that is used to store tables create using CREATE TEMPORARY TABLE. +** +** See also: Destroy +*/ +case OP_Clear: { + rc = sqliteBtreeClearTable(db->aDb[pOp->p2].pBt, pOp->p1); + break; +} + +/* Opcode: CreateTable * P2 P3 +** +** Allocate a new table in the main database file if P2==0 or in the +** auxiliary database file if P2==1. Push the page number +** for the root page of the new table onto the stack. +** +** The root page number is also written to a memory location that P3 +** points to. This is the mechanism is used to write the root page +** number into the parser's internal data structures that describe the +** new table. +** +** The difference between a table and an index is this: A table must +** have a 4-byte integer key and can have arbitrary data. An index +** has an arbitrary key but no data. +** +** See also: CreateIndex +*/ +/* Opcode: CreateIndex * P2 P3 +** +** Allocate a new index in the main database file if P2==0 or in the +** auxiliary database file if P2==1. Push the page number of the +** root page of the new index onto the stack. +** +** See documentation on OP_CreateTable for additional information. +*/ +case OP_CreateIndex: +case OP_CreateTable: { + int pgno; + assert( pOp->p3!=0 && pOp->p3type==P3_POINTER ); + assert( pOp->p2>=0 && pOp->p2<db->nDb ); + assert( db->aDb[pOp->p2].pBt!=0 ); + if( pOp->opcode==OP_CreateTable ){ + rc = sqliteBtreeCreateTable(db->aDb[pOp->p2].pBt, &pgno); + }else{ + rc = sqliteBtreeCreateIndex(db->aDb[pOp->p2].pBt, &pgno); + } + pTos++; + if( rc==SQLITE_OK ){ + pTos->i = pgno; + pTos->flags = MEM_Int; + *(u32*)pOp->p3 = pgno; + pOp->p3 = 0; + }else{ + pTos->flags = MEM_Null; + } + break; +} + +/* Opcode: IntegrityCk P1 P2 * +** +** Do an analysis of the currently open database. Push onto the +** stack the text of an error message describing any problems. +** If there are no errors, push a "ok" onto the stack. +** +** P1 is the index of a set that contains the root page numbers +** for all tables and indices in the main database file. The set +** is cleared by this opcode. In other words, after this opcode +** has executed, the set will be empty. +** +** If P2 is not zero, the check is done on the auxiliary database +** file, not the main database file. +** +** This opcode is used for testing purposes only. +*/ +case OP_IntegrityCk: { + int nRoot; + int *aRoot; + int iSet = pOp->p1; + Set *pSet; + int j; + HashElem *i; + char *z; + + assert( iSet>=0 && iSet<p->nSet ); + pTos++; + pSet = &p->aSet[iSet]; + nRoot = sqliteHashCount(&pSet->hash); + aRoot = sqliteMallocRaw( sizeof(int)*(nRoot+1) ); + if( aRoot==0 ) goto no_mem; + for(j=0, i=sqliteHashFirst(&pSet->hash); i; i=sqliteHashNext(i), j++){ + toInt((char*)sqliteHashKey(i), &aRoot[j]); + } + aRoot[j] = 0; + sqliteHashClear(&pSet->hash); + pSet->prev = 0; + z = sqliteBtreeIntegrityCheck(db->aDb[pOp->p2].pBt, aRoot, nRoot); + if( z==0 || z[0]==0 ){ + if( z ) sqliteFree(z); + pTos->z = "ok"; + pTos->n = 3; + pTos->flags = MEM_Str | MEM_Static; + }else{ + pTos->z = z; + pTos->n = strlen(z) + 1; + pTos->flags = MEM_Str | MEM_Dyn; + } + sqliteFree(aRoot); + break; +} + +/* Opcode: ListWrite * * * +** +** Write the integer on the top of the stack +** into the temporary storage list. +*/ +case OP_ListWrite: { + Keylist *pKeylist; + assert( pTos>=p->aStack ); + pKeylist = p->pList; + if( pKeylist==0 || pKeylist->nUsed>=pKeylist->nKey ){ + pKeylist = sqliteMallocRaw( sizeof(Keylist)+999*sizeof(pKeylist->aKey[0]) ); + if( pKeylist==0 ) goto no_mem; + pKeylist->nKey = 1000; + pKeylist->nRead = 0; + pKeylist->nUsed = 0; + pKeylist->pNext = p->pList; + p->pList = pKeylist; + } + Integerify(pTos); + pKeylist->aKey[pKeylist->nUsed++] = pTos->i; + Release(pTos); + pTos--; + break; +} + +/* Opcode: ListRewind * * * +** +** Rewind the temporary buffer back to the beginning. +*/ +case OP_ListRewind: { + /* What this opcode codes, really, is reverse the order of the + ** linked list of Keylist structures so that they are read out + ** in the same order that they were read in. */ + Keylist *pRev, *pTop; + pRev = 0; + while( p->pList ){ + pTop = p->pList; + p->pList = pTop->pNext; + pTop->pNext = pRev; + pRev = pTop; + } + p->pList = pRev; + break; +} + +/* Opcode: ListRead * P2 * +** +** Attempt to read an integer from the temporary storage buffer +** and push it onto the stack. If the storage buffer is empty, +** push nothing but instead jump to P2. +*/ +case OP_ListRead: { + Keylist *pKeylist; + CHECK_FOR_INTERRUPT; + pKeylist = p->pList; + if( pKeylist!=0 ){ + assert( pKeylist->nRead>=0 ); + assert( pKeylist->nRead<pKeylist->nUsed ); + assert( pKeylist->nRead<pKeylist->nKey ); + pTos++; + pTos->i = pKeylist->aKey[pKeylist->nRead++]; + pTos->flags = MEM_Int; + if( pKeylist->nRead>=pKeylist->nUsed ){ + p->pList = pKeylist->pNext; + sqliteFree(pKeylist); + } + }else{ + pc = pOp->p2 - 1; + } + break; +} + +/* Opcode: ListReset * * * +** +** Reset the temporary storage buffer so that it holds nothing. +*/ +case OP_ListReset: { + if( p->pList ){ + sqliteVdbeKeylistFree(p->pList); + p->pList = 0; + } + break; +} + +/* Opcode: ListPush * * * +** +** Save the current Vdbe list such that it can be restored by a ListPop +** opcode. The list is empty after this is executed. +*/ +case OP_ListPush: { + p->keylistStackDepth++; + assert(p->keylistStackDepth > 0); + p->keylistStack = sqliteRealloc(p->keylistStack, + sizeof(Keylist *) * p->keylistStackDepth); + if( p->keylistStack==0 ) goto no_mem; + p->keylistStack[p->keylistStackDepth - 1] = p->pList; + p->pList = 0; + break; +} + +/* Opcode: ListPop * * * +** +** Restore the Vdbe list to the state it was in when ListPush was last +** executed. +*/ +case OP_ListPop: { + assert(p->keylistStackDepth > 0); + p->keylistStackDepth--; + sqliteVdbeKeylistFree(p->pList); + p->pList = p->keylistStack[p->keylistStackDepth]; + p->keylistStack[p->keylistStackDepth] = 0; + if( p->keylistStackDepth == 0 ){ + sqliteFree(p->keylistStack); + p->keylistStack = 0; + } + break; +} + +/* Opcode: ContextPush * * * +** +** Save the current Vdbe context such that it can be restored by a ContextPop +** opcode. The context stores the last insert row id, the last statement change +** count, and the current statement change count. +*/ +case OP_ContextPush: { + p->contextStackDepth++; + assert(p->contextStackDepth > 0); + p->contextStack = sqliteRealloc(p->contextStack, + sizeof(Context) * p->contextStackDepth); + if( p->contextStack==0 ) goto no_mem; + p->contextStack[p->contextStackDepth - 1].lastRowid = p->db->lastRowid; + p->contextStack[p->contextStackDepth - 1].lsChange = p->db->lsChange; + p->contextStack[p->contextStackDepth - 1].csChange = p->db->csChange; + break; +} + +/* Opcode: ContextPop * * * +** +** Restore the Vdbe context to the state it was in when contextPush was last +** executed. The context stores the last insert row id, the last statement +** change count, and the current statement change count. +*/ +case OP_ContextPop: { + assert(p->contextStackDepth > 0); + p->contextStackDepth--; + p->db->lastRowid = p->contextStack[p->contextStackDepth].lastRowid; + p->db->lsChange = p->contextStack[p->contextStackDepth].lsChange; + p->db->csChange = p->contextStack[p->contextStackDepth].csChange; + if( p->contextStackDepth == 0 ){ + sqliteFree(p->contextStack); + p->contextStack = 0; + } + break; +} + +/* Opcode: SortPut * * * +** +** The TOS is the key and the NOS is the data. Pop both from the stack +** and put them on the sorter. The key and data should have been +** made using SortMakeKey and SortMakeRec, respectively. +*/ +case OP_SortPut: { + Mem *pNos = &pTos[-1]; + Sorter *pSorter; + assert( pNos>=p->aStack ); + if( Dynamicify(pTos) || Dynamicify(pNos) ) goto no_mem; + pSorter = sqliteMallocRaw( sizeof(Sorter) ); + if( pSorter==0 ) goto no_mem; + pSorter->pNext = p->pSort; + p->pSort = pSorter; + assert( pTos->flags & MEM_Dyn ); + pSorter->nKey = pTos->n; + pSorter->zKey = pTos->z; + assert( pNos->flags & MEM_Dyn ); + pSorter->nData = pNos->n; + pSorter->pData = pNos->z; + pTos -= 2; + break; +} + +/* Opcode: SortMakeRec P1 * * +** +** The top P1 elements are the arguments to a callback. Form these +** elements into a single data entry that can be stored on a sorter +** using SortPut and later fed to a callback using SortCallback. +*/ +case OP_SortMakeRec: { + char *z; + char **azArg; + int nByte; + int nField; + int i; + Mem *pRec; + + nField = pOp->p1; + pRec = &pTos[1-nField]; + assert( pRec>=p->aStack ); + nByte = 0; + for(i=0; i<nField; i++, pRec++){ + if( (pRec->flags & MEM_Null)==0 ){ + Stringify(pRec); + nByte += pRec->n; + } + } + nByte += sizeof(char*)*(nField+1); + azArg = sqliteMallocRaw( nByte ); + if( azArg==0 ) goto no_mem; + z = (char*)&azArg[nField+1]; + for(pRec=&pTos[1-nField], i=0; i<nField; i++, pRec++){ + if( pRec->flags & MEM_Null ){ + azArg[i] = 0; + }else{ + azArg[i] = z; + memcpy(z, pRec->z, pRec->n); + z += pRec->n; + } + } + popStack(&pTos, nField); + pTos++; + pTos->n = nByte; + pTos->z = (char*)azArg; + pTos->flags = MEM_Str | MEM_Dyn; + break; +} + +/* Opcode: SortMakeKey * * P3 +** +** Convert the top few entries of the stack into a sort key. The +** number of stack entries consumed is the number of characters in +** the string P3. One character from P3 is prepended to each entry. +** The first character of P3 is prepended to the element lowest in +** the stack and the last character of P3 is prepended to the top of +** the stack. All stack entries are separated by a \000 character +** in the result. The whole key is terminated by two \000 characters +** in a row. +** +** "N" is substituted in place of the P3 character for NULL values. +** +** See also the MakeKey and MakeIdxKey opcodes. +*/ +case OP_SortMakeKey: { + char *zNewKey; + int nByte; + int nField; + int i, j, k; + Mem *pRec; + + nField = strlen(pOp->p3); + pRec = &pTos[1-nField]; + nByte = 1; + for(i=0; i<nField; i++, pRec++){ + if( pRec->flags & MEM_Null ){ + nByte += 2; + }else{ + Stringify(pRec); + nByte += pRec->n+2; + } + } + zNewKey = sqliteMallocRaw( nByte ); + if( zNewKey==0 ) goto no_mem; + j = 0; + k = 0; + for(pRec=&pTos[1-nField], i=0; i<nField; i++, pRec++){ + if( pRec->flags & MEM_Null ){ + zNewKey[j++] = 'N'; + zNewKey[j++] = 0; + k++; + }else{ + zNewKey[j++] = pOp->p3[k++]; + memcpy(&zNewKey[j], pRec->z, pRec->n-1); + j += pRec->n-1; + zNewKey[j++] = 0; + } + } + zNewKey[j] = 0; + assert( j<nByte ); + popStack(&pTos, nField); + pTos++; + pTos->n = nByte; + pTos->flags = MEM_Str|MEM_Dyn; + pTos->z = zNewKey; + break; +} + +/* Opcode: Sort * * * +** +** Sort all elements on the sorter. The algorithm is a +** mergesort. +*/ +case OP_Sort: { + int i; + Sorter *pElem; + Sorter *apSorter[NSORT]; + for(i=0; i<NSORT; i++){ + apSorter[i] = 0; + } + while( p->pSort ){ + pElem = p->pSort; + p->pSort = pElem->pNext; + pElem->pNext = 0; + for(i=0; i<NSORT-1; i++){ + if( apSorter[i]==0 ){ + apSorter[i] = pElem; + break; + }else{ + pElem = Merge(apSorter[i], pElem); + apSorter[i] = 0; + } + } + if( i>=NSORT-1 ){ + apSorter[NSORT-1] = Merge(apSorter[NSORT-1],pElem); + } + } + pElem = 0; + for(i=0; i<NSORT; i++){ + pElem = Merge(apSorter[i], pElem); + } + p->pSort = pElem; + break; +} + +/* Opcode: SortNext * P2 * +** +** Push the data for the topmost element in the sorter onto the +** stack, then remove the element from the sorter. If the sorter +** is empty, push nothing on the stack and instead jump immediately +** to instruction P2. +*/ +case OP_SortNext: { + Sorter *pSorter = p->pSort; + CHECK_FOR_INTERRUPT; + if( pSorter!=0 ){ + p->pSort = pSorter->pNext; + pTos++; + pTos->z = pSorter->pData; + pTos->n = pSorter->nData; + pTos->flags = MEM_Str|MEM_Dyn; + sqliteFree(pSorter->zKey); + sqliteFree(pSorter); + }else{ + pc = pOp->p2 - 1; + } + break; +} + +/* Opcode: SortCallback P1 * * +** +** The top of the stack contains a callback record built using +** the SortMakeRec operation with the same P1 value as this +** instruction. Pop this record from the stack and invoke the +** callback on it. +*/ +case OP_SortCallback: { + assert( pTos>=p->aStack ); + assert( pTos->flags & MEM_Str ); + p->nCallback++; + p->pc = pc+1; + p->azResColumn = (char**)pTos->z; + assert( p->nResColumn==pOp->p1 ); + p->popStack = 1; + p->pTos = pTos; + return SQLITE_ROW; +} + +/* Opcode: SortReset * * * +** +** Remove any elements that remain on the sorter. +*/ +case OP_SortReset: { + sqliteVdbeSorterReset(p); + break; +} + +/* Opcode: FileOpen * * P3 +** +** Open the file named by P3 for reading using the FileRead opcode. +** If P3 is "stdin" then open standard input for reading. +*/ +case OP_FileOpen: { + assert( pOp->p3!=0 ); + if( p->pFile ){ + if( p->pFile!=stdin ) fclose(p->pFile); + p->pFile = 0; + } + if( sqliteStrICmp(pOp->p3,"stdin")==0 ){ + p->pFile = stdin; + }else{ + p->pFile = fopen(pOp->p3, "r"); + } + if( p->pFile==0 ){ + sqliteSetString(&p->zErrMsg,"unable to open file: ", pOp->p3, (char*)0); + rc = SQLITE_ERROR; + } + break; +} + +/* Opcode: FileRead P1 P2 P3 +** +** Read a single line of input from the open file (the file opened using +** FileOpen). If we reach end-of-file, jump immediately to P2. If +** we are able to get another line, split the line apart using P3 as +** a delimiter. There should be P1 fields. If the input line contains +** more than P1 fields, ignore the excess. If the input line contains +** fewer than P1 fields, assume the remaining fields contain NULLs. +** +** Input ends if a line consists of just "\.". A field containing only +** "\N" is a null field. The backslash \ character can be used be used +** to escape newlines or the delimiter. +*/ +case OP_FileRead: { + int n, eol, nField, i, c, nDelim; + char *zDelim, *z; + CHECK_FOR_INTERRUPT; + if( p->pFile==0 ) goto fileread_jump; + nField = pOp->p1; + if( nField<=0 ) goto fileread_jump; + if( nField!=p->nField || p->azField==0 ){ + char **azField = sqliteRealloc(p->azField, sizeof(char*)*nField+1); + if( azField==0 ){ goto no_mem; } + p->azField = azField; + p->nField = nField; + } + n = 0; + eol = 0; + while( eol==0 ){ + if( p->zLine==0 || n+200>p->nLineAlloc ){ + char *zLine; + p->nLineAlloc = p->nLineAlloc*2 + 300; + zLine = sqliteRealloc(p->zLine, p->nLineAlloc); + if( zLine==0 ){ + p->nLineAlloc = 0; + sqliteFree(p->zLine); + p->zLine = 0; + goto no_mem; + } + p->zLine = zLine; + } + if( vdbe_fgets(&p->zLine[n], p->nLineAlloc-n, p->pFile)==0 ){ + eol = 1; + p->zLine[n] = 0; + }else{ + int c; + while( (c = p->zLine[n])!=0 ){ + if( c=='\\' ){ + if( p->zLine[n+1]==0 ) break; + n += 2; + }else if( c=='\n' ){ + p->zLine[n] = 0; + eol = 1; + break; + }else{ + n++; + } + } + } + } + if( n==0 ) goto fileread_jump; + z = p->zLine; + if( z[0]=='\\' && z[1]=='.' && z[2]==0 ){ + goto fileread_jump; + } + zDelim = pOp->p3; + if( zDelim==0 ) zDelim = "\t"; + c = zDelim[0]; + nDelim = strlen(zDelim); + p->azField[0] = z; + for(i=1; *z!=0 && i<=nField; i++){ + int from, to; + from = to = 0; + if( z[0]=='\\' && z[1]=='N' + && (z[2]==0 || strncmp(&z[2],zDelim,nDelim)==0) ){ + if( i<=nField ) p->azField[i-1] = 0; + z += 2 + nDelim; + if( i<nField ) p->azField[i] = z; + continue; + } + while( z[from] ){ + if( z[from]=='\\' && z[from+1]!=0 ){ + int tx = z[from+1]; + switch( tx ){ + case 'b': tx = '\b'; break; + case 'f': tx = '\f'; break; + case 'n': tx = '\n'; break; + case 'r': tx = '\r'; break; + case 't': tx = '\t'; break; + case 'v': tx = '\v'; break; + default: break; + } + z[to++] = tx; + from += 2; + continue; + } + if( z[from]==c && strncmp(&z[from],zDelim,nDelim)==0 ) break; + z[to++] = z[from++]; + } + if( z[from] ){ + z[to] = 0; + z += from + nDelim; + if( i<nField ) p->azField[i] = z; + }else{ + z[to] = 0; + z = ""; + } + } + while( i<nField ){ + p->azField[i++] = 0; + } + break; + + /* If we reach end-of-file, or if anything goes wrong, jump here. + ** This code will cause a jump to P2 */ +fileread_jump: + pc = pOp->p2 - 1; + break; +} + +/* Opcode: FileColumn P1 * * +** +** Push onto the stack the P1-th column of the most recently read line +** from the input file. +*/ +case OP_FileColumn: { + int i = pOp->p1; + char *z; + assert( i>=0 && i<p->nField ); + if( p->azField ){ + z = p->azField[i]; + }else{ + z = 0; + } + pTos++; + if( z ){ + pTos->n = strlen(z) + 1; + pTos->z = z; + pTos->flags = MEM_Str | MEM_Ephem; + }else{ + pTos->flags = MEM_Null; + } + break; +} + +/* Opcode: MemStore P1 P2 * +** +** Write the top of the stack into memory location P1. +** P1 should be a small integer since space is allocated +** for all memory locations between 0 and P1 inclusive. +** +** After the data is stored in the memory location, the +** stack is popped once if P2 is 1. If P2 is zero, then +** the original data remains on the stack. +*/ +case OP_MemStore: { + int i = pOp->p1; + Mem *pMem; + assert( pTos>=p->aStack ); + if( i>=p->nMem ){ + int nOld = p->nMem; + Mem *aMem; + p->nMem = i + 5; + aMem = sqliteRealloc(p->aMem, p->nMem*sizeof(p->aMem[0])); + if( aMem==0 ) goto no_mem; + if( aMem!=p->aMem ){ + int j; + for(j=0; j<nOld; j++){ + if( aMem[j].flags & MEM_Short ){ + aMem[j].z = aMem[j].zShort; + } + } + } + p->aMem = aMem; + if( nOld<p->nMem ){ + memset(&p->aMem[nOld], 0, sizeof(p->aMem[0])*(p->nMem-nOld)); + } + } + Deephemeralize(pTos); + pMem = &p->aMem[i]; + Release(pMem); + *pMem = *pTos; + if( pMem->flags & MEM_Dyn ){ + if( pOp->p2 ){ + pTos->flags = MEM_Null; + }else{ + pMem->z = sqliteMallocRaw( pMem->n ); + if( pMem->z==0 ) goto no_mem; + memcpy(pMem->z, pTos->z, pMem->n); + } + }else if( pMem->flags & MEM_Short ){ + pMem->z = pMem->zShort; + } + if( pOp->p2 ){ + Release(pTos); + pTos--; + } + break; +} + +/* Opcode: MemLoad P1 * * +** +** Push a copy of the value in memory location P1 onto the stack. +** +** If the value is a string, then the value pushed is a pointer to +** the string that is stored in the memory location. If the memory +** location is subsequently changed (using OP_MemStore) then the +** value pushed onto the stack will change too. +*/ +case OP_MemLoad: { + int i = pOp->p1; + assert( i>=0 && i<p->nMem ); + pTos++; + memcpy(pTos, &p->aMem[i], sizeof(pTos[0])-NBFS);; + if( pTos->flags & MEM_Str ){ + pTos->flags |= MEM_Ephem; + pTos->flags &= ~(MEM_Dyn|MEM_Static|MEM_Short); + } + break; +} + +/* Opcode: MemIncr P1 P2 * +** +** Increment the integer valued memory cell P1 by 1. If P2 is not zero +** and the result after the increment is greater than zero, then jump +** to P2. +** +** This instruction throws an error if the memory cell is not initially +** an integer. +*/ +case OP_MemIncr: { + int i = pOp->p1; + Mem *pMem; + assert( i>=0 && i<p->nMem ); + pMem = &p->aMem[i]; + assert( pMem->flags==MEM_Int ); + pMem->i++; + if( pOp->p2>0 && pMem->i>0 ){ + pc = pOp->p2 - 1; + } + break; +} + +/* Opcode: AggReset * P2 * +** +** Reset the aggregator so that it no longer contains any data. +** Future aggregator elements will contain P2 values each. +*/ +case OP_AggReset: { + sqliteVdbeAggReset(&p->agg); + p->agg.nMem = pOp->p2; + p->agg.apFunc = sqliteMalloc( p->agg.nMem*sizeof(p->agg.apFunc[0]) ); + if( p->agg.apFunc==0 ) goto no_mem; + break; +} + +/* Opcode: AggInit * P2 P3 +** +** Initialize the function parameters for an aggregate function. +** The aggregate will operate out of aggregate column P2. +** P3 is a pointer to the FuncDef structure for the function. +*/ +case OP_AggInit: { + int i = pOp->p2; + assert( i>=0 && i<p->agg.nMem ); + p->agg.apFunc[i] = (FuncDef*)pOp->p3; + break; +} + +/* Opcode: AggFunc * P2 P3 +** +** Execute the step function for an aggregate. The +** function has P2 arguments. P3 is a pointer to the FuncDef +** structure that specifies the function. +** +** The top of the stack must be an integer which is the index of +** the aggregate column that corresponds to this aggregate function. +** Ideally, this index would be another parameter, but there are +** no free parameters left. The integer is popped from the stack. +*/ +case OP_AggFunc: { + int n = pOp->p2; + int i; + Mem *pMem, *pRec; + char **azArgv = p->zArgv; + sqlite_func ctx; + + assert( n>=0 ); + assert( pTos->flags==MEM_Int ); + pRec = &pTos[-n]; + assert( pRec>=p->aStack ); + for(i=0; i<n; i++, pRec++){ + if( pRec->flags & MEM_Null ){ + azArgv[i] = 0; + }else{ + Stringify(pRec); + azArgv[i] = pRec->z; + } + } + i = pTos->i; + assert( i>=0 && i<p->agg.nMem ); + ctx.pFunc = (FuncDef*)pOp->p3; + pMem = &p->agg.pCurrent->aMem[i]; + ctx.s.z = pMem->zShort; /* Space used for small aggregate contexts */ + ctx.pAgg = pMem->z; + ctx.cnt = ++pMem->i; + ctx.isError = 0; + ctx.isStep = 1; + (ctx.pFunc->xStep)(&ctx, n, (const char**)azArgv); + pMem->z = ctx.pAgg; + pMem->flags = MEM_AggCtx; + popStack(&pTos, n+1); + if( ctx.isError ){ + rc = SQLITE_ERROR; + } + break; +} + +/* Opcode: AggFocus * P2 * +** +** Pop the top of the stack and use that as an aggregator key. If +** an aggregator with that same key already exists, then make the +** aggregator the current aggregator and jump to P2. If no aggregator +** with the given key exists, create one and make it current but +** do not jump. +** +** The order of aggregator opcodes is important. The order is: +** AggReset AggFocus AggNext. In other words, you must execute +** AggReset first, then zero or more AggFocus operations, then +** zero or more AggNext operations. You must not execute an AggFocus +** in between an AggNext and an AggReset. +*/ +case OP_AggFocus: { + AggElem *pElem; + char *zKey; + int nKey; + + assert( pTos>=p->aStack ); + Stringify(pTos); + zKey = pTos->z; + nKey = pTos->n; + pElem = sqliteHashFind(&p->agg.hash, zKey, nKey); + if( pElem ){ + p->agg.pCurrent = pElem; + pc = pOp->p2 - 1; + }else{ + AggInsert(&p->agg, zKey, nKey); + if( sqlite_malloc_failed ) goto no_mem; + } + Release(pTos); + pTos--; + break; +} + +/* Opcode: AggSet * P2 * +** +** Move the top of the stack into the P2-th field of the current +** aggregate. String values are duplicated into new memory. +*/ +case OP_AggSet: { + AggElem *pFocus = AggInFocus(p->agg); + Mem *pMem; + int i = pOp->p2; + assert( pTos>=p->aStack ); + if( pFocus==0 ) goto no_mem; + assert( i>=0 && i<p->agg.nMem ); + Deephemeralize(pTos); + pMem = &pFocus->aMem[i]; + Release(pMem); + *pMem = *pTos; + if( pMem->flags & MEM_Dyn ){ + pTos->flags = MEM_Null; + }else if( pMem->flags & MEM_Short ){ + pMem->z = pMem->zShort; + } + Release(pTos); + pTos--; + break; +} + +/* Opcode: AggGet * P2 * +** +** Push a new entry onto the stack which is a copy of the P2-th field +** of the current aggregate. Strings are not duplicated so +** string values will be ephemeral. +*/ +case OP_AggGet: { + AggElem *pFocus = AggInFocus(p->agg); + Mem *pMem; + int i = pOp->p2; + if( pFocus==0 ) goto no_mem; + assert( i>=0 && i<p->agg.nMem ); + pTos++; + pMem = &pFocus->aMem[i]; + *pTos = *pMem; + if( pTos->flags & MEM_Str ){ + pTos->flags &= ~(MEM_Dyn|MEM_Static|MEM_Short); + pTos->flags |= MEM_Ephem; + } + break; +} + +/* Opcode: AggNext * P2 * +** +** Make the next aggregate value the current aggregate. The prior +** aggregate is deleted. If all aggregate values have been consumed, +** jump to P2. +** +** The order of aggregator opcodes is important. The order is: +** AggReset AggFocus AggNext. In other words, you must execute +** AggReset first, then zero or more AggFocus operations, then +** zero or more AggNext operations. You must not execute an AggFocus +** in between an AggNext and an AggReset. +*/ +case OP_AggNext: { + CHECK_FOR_INTERRUPT; + if( p->agg.pSearch==0 ){ + p->agg.pSearch = sqliteHashFirst(&p->agg.hash); + }else{ + p->agg.pSearch = sqliteHashNext(p->agg.pSearch); + } + if( p->agg.pSearch==0 ){ + pc = pOp->p2 - 1; + } else { + int i; + sqlite_func ctx; + Mem *aMem; + p->agg.pCurrent = sqliteHashData(p->agg.pSearch); + aMem = p->agg.pCurrent->aMem; + for(i=0; i<p->agg.nMem; i++){ + int freeCtx; + if( p->agg.apFunc[i]==0 ) continue; + if( p->agg.apFunc[i]->xFinalize==0 ) continue; + ctx.s.flags = MEM_Null; + ctx.s.z = aMem[i].zShort; + ctx.pAgg = (void*)aMem[i].z; + freeCtx = aMem[i].z && aMem[i].z!=aMem[i].zShort; + ctx.cnt = aMem[i].i; + ctx.isStep = 0; + ctx.pFunc = p->agg.apFunc[i]; + (*p->agg.apFunc[i]->xFinalize)(&ctx); + if( freeCtx ){ + sqliteFree( aMem[i].z ); + } + aMem[i] = ctx.s; + if( aMem[i].flags & MEM_Short ){ + aMem[i].z = aMem[i].zShort; + } + } + } + break; +} + +/* Opcode: SetInsert P1 * P3 +** +** If Set P1 does not exist then create it. Then insert value +** P3 into that set. If P3 is NULL, then insert the top of the +** stack into the set. +*/ +case OP_SetInsert: { + int i = pOp->p1; + if( p->nSet<=i ){ + int k; + Set *aSet = sqliteRealloc(p->aSet, (i+1)*sizeof(p->aSet[0]) ); + if( aSet==0 ) goto no_mem; + p->aSet = aSet; + for(k=p->nSet; k<=i; k++){ + sqliteHashInit(&p->aSet[k].hash, SQLITE_HASH_BINARY, 1); + } + p->nSet = i+1; + } + if( pOp->p3 ){ + sqliteHashInsert(&p->aSet[i].hash, pOp->p3, strlen(pOp->p3)+1, p); + }else{ + assert( pTos>=p->aStack ); + Stringify(pTos); + sqliteHashInsert(&p->aSet[i].hash, pTos->z, pTos->n, p); + Release(pTos); + pTos--; + } + if( sqlite_malloc_failed ) goto no_mem; + break; +} + +/* Opcode: SetFound P1 P2 * +** +** Pop the stack once and compare the value popped off with the +** contents of set P1. If the element popped exists in set P1, +** then jump to P2. Otherwise fall through. +*/ +case OP_SetFound: { + int i = pOp->p1; + assert( pTos>=p->aStack ); + Stringify(pTos); + if( i>=0 && i<p->nSet && sqliteHashFind(&p->aSet[i].hash, pTos->z, pTos->n)){ + pc = pOp->p2 - 1; + } + Release(pTos); + pTos--; + break; +} + +/* Opcode: SetNotFound P1 P2 * +** +** Pop the stack once and compare the value popped off with the +** contents of set P1. If the element popped does not exists in +** set P1, then jump to P2. Otherwise fall through. +*/ +case OP_SetNotFound: { + int i = pOp->p1; + assert( pTos>=p->aStack ); + Stringify(pTos); + if( i<0 || i>=p->nSet || + sqliteHashFind(&p->aSet[i].hash, pTos->z, pTos->n)==0 ){ + pc = pOp->p2 - 1; + } + Release(pTos); + pTos--; + break; +} + +/* Opcode: SetFirst P1 P2 * +** +** Read the first element from set P1 and push it onto the stack. If the +** set is empty, push nothing and jump immediately to P2. This opcode is +** used in combination with OP_SetNext to loop over all elements of a set. +*/ +/* Opcode: SetNext P1 P2 * +** +** Read the next element from set P1 and push it onto the stack. If there +** are no more elements in the set, do not do the push and fall through. +** Otherwise, jump to P2 after pushing the next set element. +*/ +case OP_SetFirst: +case OP_SetNext: { + Set *pSet; + CHECK_FOR_INTERRUPT; + if( pOp->p1<0 || pOp->p1>=p->nSet ){ + if( pOp->opcode==OP_SetFirst ) pc = pOp->p2 - 1; + break; + } + pSet = &p->aSet[pOp->p1]; + if( pOp->opcode==OP_SetFirst ){ + pSet->prev = sqliteHashFirst(&pSet->hash); + if( pSet->prev==0 ){ + pc = pOp->p2 - 1; + break; + } + }else{ + if( pSet->prev ){ + pSet->prev = sqliteHashNext(pSet->prev); + } + if( pSet->prev==0 ){ + break; + }else{ + pc = pOp->p2 - 1; + } + } + pTos++; + pTos->z = sqliteHashKey(pSet->prev); + pTos->n = sqliteHashKeysize(pSet->prev); + pTos->flags = MEM_Str | MEM_Ephem; + break; +} + +/* Opcode: Vacuum * * * +** +** Vacuum the entire database. This opcode will cause other virtual +** machines to be created and run. It may not be called from within +** a transaction. +*/ +case OP_Vacuum: { + if( sqliteSafetyOff(db) ) goto abort_due_to_misuse; + rc = sqliteRunVacuum(&p->zErrMsg, db); + if( sqliteSafetyOn(db) ) goto abort_due_to_misuse; + break; +} + +/* Opcode: StackDepth * * * +** +** Push an integer onto the stack which is the depth of the stack prior +** to that integer being pushed. +*/ +case OP_StackDepth: { + int depth = (&pTos[1]) - p->aStack; + pTos++; + pTos->i = depth; + pTos->flags = MEM_Int; + break; +} + +/* Opcode: StackReset * * * +** +** Pop a single integer off of the stack. Then pop the stack +** as many times as necessary to get the depth of the stack down +** to the value of the integer that was popped. +*/ +case OP_StackReset: { + int depth, goal; + assert( pTos>=p->aStack ); + Integerify(pTos); + goal = pTos->i; + depth = (&pTos[1]) - p->aStack; + assert( goal<depth ); + popStack(&pTos, depth-goal); + break; +} + +/* An other opcode is illegal... +*/ +default: { + sqlite_snprintf(sizeof(zBuf),zBuf,"%d",pOp->opcode); + sqliteSetString(&p->zErrMsg, "unknown opcode ", zBuf, (char*)0); + rc = SQLITE_INTERNAL; + break; +} + +/***************************************************************************** +** The cases of the switch statement above this line should all be indented +** by 6 spaces. But the left-most 6 spaces have been removed to improve the +** readability. From this point on down, the normal indentation rules are +** restored. +*****************************************************************************/ + } + +#ifdef VDBE_PROFILE + { + long long elapse = hwtime() - start; + pOp->cycles += elapse; + pOp->cnt++; +#if 0 + fprintf(stdout, "%10lld ", elapse); + sqliteVdbePrintOp(stdout, origPc, &p->aOp[origPc]); +#endif + } +#endif + + /* The following code adds nothing to the actual functionality + ** of the program. It is only here for testing and debugging. + ** On the other hand, it does burn CPU cycles every time through + ** the evaluator loop. So we can leave it out when NDEBUG is defined. + */ +#ifndef NDEBUG + /* Sanity checking on the top element of the stack */ + if( pTos>=p->aStack ){ + assert( pTos->flags!=0 ); /* Must define some type */ + if( pTos->flags & MEM_Str ){ + int x = pTos->flags & (MEM_Static|MEM_Dyn|MEM_Ephem|MEM_Short); + assert( x!=0 ); /* Strings must define a string subtype */ + assert( (x & (x-1))==0 ); /* Only one string subtype can be defined */ + assert( pTos->z!=0 ); /* Strings must have a value */ + /* Mem.z points to Mem.zShort iff the subtype is MEM_Short */ + assert( (pTos->flags & MEM_Short)==0 || pTos->z==pTos->zShort ); + assert( (pTos->flags & MEM_Short)!=0 || pTos->z!=pTos->zShort ); + }else{ + /* Cannot define a string subtype for non-string objects */ + assert( (pTos->flags & (MEM_Static|MEM_Dyn|MEM_Ephem|MEM_Short))==0 ); + } + /* MEM_Null excludes all other types */ + assert( pTos->flags==MEM_Null || (pTos->flags&MEM_Null)==0 ); + } + if( pc<-1 || pc>=p->nOp ){ + sqliteSetString(&p->zErrMsg, "jump destination out of range", (char*)0); + rc = SQLITE_INTERNAL; + } + if( p->trace && pTos>=p->aStack ){ + int i; + fprintf(p->trace, "Stack:"); + for(i=0; i>-5 && &pTos[i]>=p->aStack; i--){ + if( pTos[i].flags & MEM_Null ){ + fprintf(p->trace, " NULL"); + }else if( (pTos[i].flags & (MEM_Int|MEM_Str))==(MEM_Int|MEM_Str) ){ + fprintf(p->trace, " si:%d", pTos[i].i); + }else if( pTos[i].flags & MEM_Int ){ + fprintf(p->trace, " i:%d", pTos[i].i); + }else if( pTos[i].flags & MEM_Real ){ + fprintf(p->trace, " r:%g", pTos[i].r); + }else if( pTos[i].flags & MEM_Str ){ + int j, k; + char zBuf[100]; + zBuf[0] = ' '; + if( pTos[i].flags & MEM_Dyn ){ + zBuf[1] = 'z'; + assert( (pTos[i].flags & (MEM_Static|MEM_Ephem))==0 ); + }else if( pTos[i].flags & MEM_Static ){ + zBuf[1] = 't'; + assert( (pTos[i].flags & (MEM_Dyn|MEM_Ephem))==0 ); + }else if( pTos[i].flags & MEM_Ephem ){ + zBuf[1] = 'e'; + assert( (pTos[i].flags & (MEM_Static|MEM_Dyn))==0 ); + }else{ + zBuf[1] = 's'; + } + zBuf[2] = '['; + k = 3; + for(j=0; j<20 && j<pTos[i].n; j++){ + int c = pTos[i].z[j]; + if( c==0 && j==pTos[i].n-1 ) break; + if( isprint(c) && !isspace(c) ){ + zBuf[k++] = c; + }else{ + zBuf[k++] = '.'; + } + } + zBuf[k++] = ']'; + zBuf[k++] = 0; + fprintf(p->trace, "%s", zBuf); + }else{ + fprintf(p->trace, " ???"); + } + } + if( rc!=0 ) fprintf(p->trace," rc=%d",rc); + fprintf(p->trace,"\n"); + } +#endif + } /* The end of the for(;;) loop the loops through opcodes */ + + /* If we reach this point, it means that execution is finished. + */ +vdbe_halt: + CHECK_FOR_INTERRUPT + if( rc ){ + p->rc = rc; + rc = SQLITE_ERROR; + }else{ + rc = SQLITE_DONE; + } + p->magic = VDBE_MAGIC_HALT; + p->pTos = pTos; + return rc; + + /* Jump to here if a malloc() fails. It's hard to get a malloc() + ** to fail on a modern VM computer, so this code is untested. + */ +no_mem: + sqliteSetString(&p->zErrMsg, "out of memory", (char*)0); + rc = SQLITE_NOMEM; + goto vdbe_halt; + + /* Jump to here for an SQLITE_MISUSE error. + */ +abort_due_to_misuse: + rc = SQLITE_MISUSE; + /* Fall thru into abort_due_to_error */ + + /* Jump to here for any other kind of fatal error. The "rc" variable + ** should hold the error number. + */ +abort_due_to_error: + if( p->zErrMsg==0 ){ + if( sqlite_malloc_failed ) rc = SQLITE_NOMEM; + sqliteSetString(&p->zErrMsg, sqlite_error_string(rc), (char*)0); + } + goto vdbe_halt; + + /* Jump to here if the sqlite_interrupt() API sets the interrupt + ** flag. + */ +abort_due_to_interrupt: + assert( db->flags & SQLITE_Interrupt ); + db->flags &= ~SQLITE_Interrupt; + if( db->magic!=SQLITE_MAGIC_BUSY ){ + rc = SQLITE_MISUSE; + }else{ + rc = SQLITE_INTERRUPT; + } + sqliteSetString(&p->zErrMsg, sqlite_error_string(rc), (char*)0); + goto vdbe_halt; +} diff --git a/kexi/3rdparty/kexisql/src/vdbe.h b/kexi/3rdparty/kexisql/src/vdbe.h new file mode 100644 index 00000000..fcb96949 --- /dev/null +++ b/kexi/3rdparty/kexisql/src/vdbe.h @@ -0,0 +1,112 @@ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** Header file for the Virtual DataBase Engine (VDBE) +** +** This header defines the interface to the virtual database engine +** or VDBE. The VDBE implements an abstract machine that runs a +** simple program to access and modify the underlying database. +** +** $Id: vdbe.h 410099 2005-05-06 17:52:07Z staniek $ +*/ +#ifndef _SQLITE_VDBE_H_ +#define _SQLITE_VDBE_H_ +#include <stdio.h> + +/* +** A single VDBE is an opaque structure named "Vdbe". Only routines +** in the source file sqliteVdbe.c are allowed to see the insides +** of this structure. +*/ +typedef struct Vdbe Vdbe; + +/* +** A single instruction of the virtual machine has an opcode +** and as many as three operands. The instruction is recorded +** as an instance of the following structure: +*/ +struct VdbeOp { + u8 opcode; /* What operation to perform */ + int p1; /* First operand */ + int p2; /* Second parameter (often the jump destination) */ + char *p3; /* Third parameter */ + int p3type; /* P3_STATIC, P3_DYNAMIC or P3_POINTER */ +#ifdef VDBE_PROFILE + int cnt; /* Number of times this instruction was executed */ + long long cycles; /* Total time spend executing this instruction */ +#endif +}; +typedef struct VdbeOp VdbeOp; + +/* +** A smaller version of VdbeOp used for the VdbeAddOpList() function because +** it takes up less space. +*/ +struct VdbeOpList { + u8 opcode; /* What operation to perform */ + signed char p1; /* First operand */ + short int p2; /* Second parameter (often the jump destination) */ + char *p3; /* Third parameter */ +}; +typedef struct VdbeOpList VdbeOpList; + +/* +** Allowed values of VdbeOp.p3type +*/ +#define P3_NOTUSED 0 /* The P3 parameter is not used */ +#define P3_DYNAMIC (-1) /* Pointer to a string obtained from sqliteMalloc() */ +#define P3_STATIC (-2) /* Pointer to a static string */ +#define P3_POINTER (-3) /* P3 is a pointer to some structure or object */ + +/* +** The following macro converts a relative address in the p2 field +** of a VdbeOp structure into a negative number so that +** sqliteVdbeAddOpList() knows that the address is relative. Calling +** the macro again restores the address. +*/ +#define ADDR(X) (-1-(X)) + +/* +** The makefile scans the vdbe.c source file and creates the "opcodes.h" +** header file that defines a number for each opcode used by the VDBE. +*/ +#include "opcodes.h" + +/* +** Prototypes for the VDBE interface. See comments on the implementation +** for a description of what each of these routines does. +*/ +Vdbe *sqliteVdbeCreate(sqlite*); +void sqliteVdbeCreateCallback(Vdbe*, int*); +int sqliteVdbeAddOp(Vdbe*,int,int,int); +int sqliteVdbeOp3(Vdbe*,int,int,int,const char *zP3,int); +int sqliteVdbeCode(Vdbe*,...); +int sqliteVdbeAddOpList(Vdbe*, int nOp, VdbeOpList const *aOp); +void sqliteVdbeChangeP1(Vdbe*, int addr, int P1); +void sqliteVdbeChangeP2(Vdbe*, int addr, int P2); +void sqliteVdbeChangeP3(Vdbe*, int addr, const char *zP1, int N); +void sqliteVdbeDequoteP3(Vdbe*, int addr); +int sqliteVdbeFindOp(Vdbe*, int, int); +VdbeOp *sqliteVdbeGetOp(Vdbe*, int); +int sqliteVdbeMakeLabel(Vdbe*); +void sqliteVdbeDelete(Vdbe*); +void sqliteVdbeMakeReady(Vdbe*,int,int); +int sqliteVdbeExec(Vdbe*); +int sqliteVdbeList(Vdbe*); +int sqliteVdbeFinalize(Vdbe*,char**); +void sqliteVdbeResolveLabel(Vdbe*, int); +int sqliteVdbeCurrentAddr(Vdbe*); +void sqliteVdbeTrace(Vdbe*,FILE*); +void sqliteVdbeCompressSpace(Vdbe*,int); +int sqliteVdbeReset(Vdbe*,char **); +int sqliteVdbeSetVariables(Vdbe*,int,const char**); + +#endif diff --git a/kexi/3rdparty/kexisql/src/vdbeInt.h b/kexi/3rdparty/kexisql/src/vdbeInt.h new file mode 100644 index 00000000..79b6b51a --- /dev/null +++ b/kexi/3rdparty/kexisql/src/vdbeInt.h @@ -0,0 +1,303 @@ +/* +** 2003 September 6 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This is the header file for information that is private to the +** VDBE. This information used to all be at the top of the single +** source code file "vdbe.c". When that file became too big (over +** 6000 lines long) it was split up into several smaller files and +** this header information was factored out. +*/ + +/* +** When converting from the native format to the key format and back +** again, in addition to changing the byte order we invert the high-order +** bit of the most significant byte. This causes negative numbers to +** sort before positive numbers in the memcmp() function. +*/ +#define keyToInt(X) (sqliteVdbeByteSwap(X) ^ 0x80000000) +#define intToKey(X) (sqliteVdbeByteSwap((X) ^ 0x80000000)) + +/* +** The makefile scans this source file and creates the following +** array of string constants which are the names of all VDBE opcodes. +** This array is defined in a separate source code file named opcode.c +** which is automatically generated by the makefile. +*/ +extern char *sqliteOpcodeNames[]; + +/* +** SQL is translated into a sequence of instructions to be +** executed by a virtual machine. Each instruction is an instance +** of the following structure. +*/ +typedef struct VdbeOp Op; + +/* +** Boolean values +*/ +typedef unsigned char Bool; + +/* +** A cursor is a pointer into a single BTree within a database file. +** The cursor can seek to a BTree entry with a particular key, or +** loop over all entries of the Btree. You can also insert new BTree +** entries or retrieve the key or data from the entry that the cursor +** is currently pointing to. +** +** Every cursor that the virtual machine has open is represented by an +** instance of the following structure. +** +** If the Cursor.isTriggerRow flag is set it means that this cursor is +** really a single row that represents the NEW or OLD pseudo-table of +** a row trigger. The data for the row is stored in Cursor.pData and +** the rowid is in Cursor.iKey. +*/ +struct Cursor { + BtCursor *pCursor; /* The cursor structure of the backend */ + int lastRecno; /* Last recno from a Next or NextIdx operation */ + int nextRowid; /* Next rowid returned by OP_NewRowid */ + Bool recnoIsValid; /* True if lastRecno is valid */ + Bool keyAsData; /* The OP_Column command works on key instead of data */ + Bool atFirst; /* True if pointing to first entry */ + Bool useRandomRowid; /* Generate new record numbers semi-randomly */ + Bool nullRow; /* True if pointing to a row with no data */ + Bool nextRowidValid; /* True if the nextRowid field is valid */ + Bool pseudoTable; /* This is a NEW or OLD pseudo-tables of a trigger */ + Bool deferredMoveto; /* A call to sqliteBtreeMoveto() is needed */ + int movetoTarget; /* Argument to the deferred sqliteBtreeMoveto() */ + Btree *pBt; /* Separate file holding temporary table */ + int nData; /* Number of bytes in pData */ + char *pData; /* Data for a NEW or OLD pseudo-table */ + int iKey; /* Key for the NEW or OLD pseudo-table row */ +}; +typedef struct Cursor Cursor; + +/* +** A sorter builds a list of elements to be sorted. Each element of +** the list is an instance of the following structure. +*/ +typedef struct Sorter Sorter; +struct Sorter { + int nKey; /* Number of bytes in the key */ + char *zKey; /* The key by which we will sort */ + int nData; /* Number of bytes in the data */ + char *pData; /* The data associated with this key */ + Sorter *pNext; /* Next in the list */ +}; + +/* +** Number of buckets used for merge-sort. +*/ +#define NSORT 30 + +/* +** Number of bytes of string storage space available to each stack +** layer without having to malloc. NBFS is short for Number of Bytes +** For Strings. +*/ +#define NBFS 32 + +/* +** A single level of the stack or a single memory cell +** is an instance of the following structure. +*/ +struct Mem { + int i; /* Integer value */ + int n; /* Number of characters in string value, including '\0' */ + int flags; /* Some combination of MEM_Null, MEM_Str, MEM_Dyn, etc. */ + double r; /* Real value */ + char *z; /* String value */ + char zShort[NBFS]; /* Space for short strings */ +}; +typedef struct Mem Mem; + +/* +** Allowed values for Mem.flags +*/ +#define MEM_Null 0x0001 /* Value is NULL */ +#define MEM_Str 0x0002 /* Value is a string */ +#define MEM_Int 0x0004 /* Value is an integer */ +#define MEM_Real 0x0008 /* Value is a real number */ +#define MEM_Dyn 0x0010 /* Need to call sqliteFree() on Mem.z */ +#define MEM_Static 0x0020 /* Mem.z points to a static string */ +#define MEM_Ephem 0x0040 /* Mem.z points to an ephemeral string */ +#define MEM_Short 0x0080 /* Mem.z points to Mem.zShort */ + +/* The following MEM_ value appears only in AggElem.aMem.s.flag fields. +** It indicates that the corresponding AggElem.aMem.z points to a +** aggregate function context that needs to be finalized. +*/ +#define MEM_AggCtx 0x0100 /* Mem.z points to an agg function context */ + +/* +** The "context" argument for a installable function. A pointer to an +** instance of this structure is the first argument to the routines used +** implement the SQL functions. +** +** There is a typedef for this structure in sqlite.h. So all routines, +** even the public interface to SQLite, can use a pointer to this structure. +** But this file is the only place where the internal details of this +** structure are known. +** +** This structure is defined inside of vdbe.c because it uses substructures +** (Mem) which are only defined there. +*/ +struct sqlite_func { + FuncDef *pFunc; /* Pointer to function information. MUST BE FIRST */ + Mem s; /* The return value is stored here */ + void *pAgg; /* Aggregate context */ + u8 isError; /* Set to true for an error */ + u8 isStep; /* Current in the step function */ + int cnt; /* Number of times that the step function has been called */ +}; + +/* +** An Agg structure describes an Aggregator. Each Agg consists of +** zero or more Aggregator elements (AggElem). Each AggElem contains +** a key and one or more values. The values are used in processing +** aggregate functions in a SELECT. The key is used to implement +** the GROUP BY clause of a select. +*/ +typedef struct Agg Agg; +typedef struct AggElem AggElem; +struct Agg { + int nMem; /* Number of values stored in each AggElem */ + AggElem *pCurrent; /* The AggElem currently in focus */ + HashElem *pSearch; /* The hash element for pCurrent */ + Hash hash; /* Hash table of all aggregate elements */ + FuncDef **apFunc; /* Information about aggregate functions */ +}; +struct AggElem { + char *zKey; /* The key to this AggElem */ + int nKey; /* Number of bytes in the key, including '\0' at end */ + Mem aMem[1]; /* The values for this AggElem */ +}; + +/* +** A Set structure is used for quick testing to see if a value +** is part of a small set. Sets are used to implement code like +** this: +** x.y IN ('hi','hoo','hum') +*/ +typedef struct Set Set; +struct Set { + Hash hash; /* A set is just a hash table */ + HashElem *prev; /* Previously accessed hash elemen */ +}; + +/* +** A Keylist is a bunch of keys into a table. The keylist can +** grow without bound. The keylist stores the ROWIDs of database +** records that need to be deleted or updated. +*/ +typedef struct Keylist Keylist; +struct Keylist { + int nKey; /* Number of slots in aKey[] */ + int nUsed; /* Next unwritten slot in aKey[] */ + int nRead; /* Next unread slot in aKey[] */ + Keylist *pNext; /* Next block of keys */ + int aKey[1]; /* One or more keys. Extra space allocated as needed */ +}; + +/* +** A Context stores the last insert rowid, the last statement change count, +** and the current statement change count (i.e. changes since last statement). +** Elements of Context structure type make up the ContextStack, which is +** updated by the ContextPush and ContextPop opcodes (used by triggers) +*/ +typedef struct Context Context; +struct Context { + int lastRowid; /* Last insert rowid (from db->lastRowid) */ + int lsChange; /* Last statement change count (from db->lsChange) */ + int csChange; /* Current statement change count (from db->csChange) */ +}; + +/* +** An instance of the virtual machine. This structure contains the complete +** state of the virtual machine. +** +** The "sqlite_vm" structure pointer that is returned by sqlite_compile() +** is really a pointer to an instance of this structure. +*/ +struct Vdbe { + sqlite *db; /* The whole database */ + Vdbe *pPrev,*pNext; /* Linked list of VDBEs with the same Vdbe.db */ + FILE *trace; /* Write an execution trace here, if not NULL */ + int nOp; /* Number of instructions in the program */ + int nOpAlloc; /* Number of slots allocated for aOp[] */ + Op *aOp; /* Space to hold the virtual machine's program */ + int nLabel; /* Number of labels used */ + int nLabelAlloc; /* Number of slots allocated in aLabel[] */ + int *aLabel; /* Space to hold the labels */ + Mem *aStack; /* The operand stack, except string values */ + Mem *pTos; /* Top entry in the operand stack */ + char **zArgv; /* Text values used by the callback */ + char **azColName; /* Becomes the 4th parameter to callbacks */ + int nCursor; /* Number of slots in aCsr[] */ + Cursor *aCsr; /* One element of this array for each open cursor */ + Sorter *pSort; /* A linked list of objects to be sorted */ + FILE *pFile; /* At most one open file handler */ + int nField; /* Number of file fields */ + char **azField; /* Data for each file field */ + int nVar; /* Number of entries in azVariable[] */ + char **azVar; /* Values for the OP_Variable opcode */ + int *anVar; /* Length of each value in azVariable[] */ + u8 *abVar; /* TRUE if azVariable[i] needs to be sqliteFree()ed */ + char *zLine; /* A single line from the input file */ + int nLineAlloc; /* Number of spaces allocated for zLine */ + int magic; /* Magic number for sanity checking */ + int nMem; /* Number of memory locations currently allocated */ + Mem *aMem; /* The memory locations */ + Agg agg; /* Aggregate information */ + int nSet; /* Number of sets allocated */ + Set *aSet; /* An array of sets */ + int nCallback; /* Number of callbacks invoked so far */ + Keylist *pList; /* A list of ROWIDs */ + int keylistStackDepth; /* The size of the "keylist" stack */ + Keylist **keylistStack; /* The stack used by opcodes ListPush & ListPop */ + int contextStackDepth; /* The size of the "context" stack */ + Context *contextStack; /* Stack used by opcodes ContextPush & ContextPop*/ + int pc; /* The program counter */ + int rc; /* Value to return */ + unsigned uniqueCnt; /* Used by OP_MakeRecord when P2!=0 */ + int errorAction; /* Recovery action to do in case of an error */ + int undoTransOnError; /* If error, either ROLLBACK or COMMIT */ + int inTempTrans; /* True if temp database is transactioned */ + int returnStack[100]; /* Return address stack for OP_Gosub & OP_Return */ + int returnDepth; /* Next unused element in returnStack[] */ + int nResColumn; /* Number of columns in one row of the result set */ + char **azResColumn; /* Values for one row of result */ + int popStack; /* Pop the stack this much on entry to VdbeExec() */ + char *zErrMsg; /* Error message written here */ + u8 explain; /* True if EXPLAIN present on SQL command */ +}; + +/* +** The following are allowed values for Vdbe.magic +*/ +#define VDBE_MAGIC_INIT 0x26bceaa5 /* Building a VDBE program */ +#define VDBE_MAGIC_RUN 0xbdf20da3 /* VDBE is ready to execute */ +#define VDBE_MAGIC_HALT 0x519c2973 /* VDBE has completed execution */ +#define VDBE_MAGIC_DEAD 0xb606c3c8 /* The VDBE has been deallocated */ + +/* +** Function prototypes +*/ +void sqliteVdbeCleanupCursor(Cursor*); +void sqliteVdbeSorterReset(Vdbe*); +void sqliteVdbeAggReset(Agg*); +void sqliteVdbeKeylistFree(Keylist*); +void sqliteVdbePopStack(Vdbe*,int); +int sqliteVdbeCursorMoveto(Cursor*); +int sqliteVdbeByteSwap(int); +#if !defined(NDEBUG) || defined(VDBE_PROFILE) +void sqliteVdbePrintOp(FILE*, int, Op*); +#endif diff --git a/kexi/3rdparty/kexisql/src/vdbeaux.c b/kexi/3rdparty/kexisql/src/vdbeaux.c new file mode 100644 index 00000000..c206bad4 --- /dev/null +++ b/kexi/3rdparty/kexisql/src/vdbeaux.c @@ -0,0 +1,1061 @@ +/* +** 2003 September 6 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains code used for creating, destroying, and populating +** a VDBE (or an "sqlite_vm" as it is known to the outside world.) Prior +** to version 2.8.7, all this code was combined into the vdbe.c source file. +** But that file was getting too big so this subroutines were split out. +*/ +#include "sqliteInt.h" +#include "os.h" +#include <ctype.h> +#include "vdbeInt.h" + + +/* +** When debugging the code generator in a symbolic debugger, one can +** set the sqlite_vdbe_addop_trace to 1 and all opcodes will be printed +** as they are added to the instruction stream. +*/ +#ifndef NDEBUG +int sqlite_vdbe_addop_trace = 0; +#endif + + +/* +** Create a new virtual database engine. +*/ +Vdbe *sqliteVdbeCreate(sqlite *db){ + Vdbe *p; + p = sqliteMalloc( sizeof(Vdbe) ); + if( p==0 ) return 0; + p->db = db; + if( db->pVdbe ){ + db->pVdbe->pPrev = p; + } + p->pNext = db->pVdbe; + p->pPrev = 0; + db->pVdbe = p; + p->magic = VDBE_MAGIC_INIT; + return p; +} + +/* +** Turn tracing on or off +*/ +void sqliteVdbeTrace(Vdbe *p, FILE *trace){ + p->trace = trace; +} + +/* +** Add a new instruction to the list of instructions current in the +** VDBE. Return the address of the new instruction. +** +** Parameters: +** +** p Pointer to the VDBE +** +** op The opcode for this instruction +** +** p1, p2 First two of the three possible operands. +** +** Use the sqliteVdbeResolveLabel() function to fix an address and +** the sqliteVdbeChangeP3() function to change the value of the P3 +** operand. +*/ +int sqliteVdbeAddOp(Vdbe *p, int op, int p1, int p2){ + int i; + VdbeOp *pOp; + + i = p->nOp; + p->nOp++; + assert( p->magic==VDBE_MAGIC_INIT ); + if( i>=p->nOpAlloc ){ + int oldSize = p->nOpAlloc; + Op *aNew; + p->nOpAlloc = p->nOpAlloc*2 + 100; + aNew = sqliteRealloc(p->aOp, p->nOpAlloc*sizeof(Op)); + if( aNew==0 ){ + p->nOpAlloc = oldSize; + return 0; + } + p->aOp = aNew; + memset(&p->aOp[oldSize], 0, (p->nOpAlloc-oldSize)*sizeof(Op)); + } + pOp = &p->aOp[i]; + pOp->opcode = op; + pOp->p1 = p1; + if( p2<0 && (-1-p2)<p->nLabel && p->aLabel[-1-p2]>=0 ){ + p2 = p->aLabel[-1-p2]; + } + pOp->p2 = p2; + pOp->p3 = 0; + pOp->p3type = P3_NOTUSED; +#ifndef NDEBUG + if( sqlite_vdbe_addop_trace ) sqliteVdbePrintOp(0, i, &p->aOp[i]); +#endif + return i; +} + +/* +** Add an opcode that includes the p3 value. +*/ +int sqliteVdbeOp3(Vdbe *p, int op, int p1, int p2, const char *zP3, int p3type){ + int addr = sqliteVdbeAddOp(p, op, p1, p2); + sqliteVdbeChangeP3(p, addr, zP3, p3type); + return addr; +} + +/* +** Add multiple opcodes. The list is terminated by an opcode of 0. +*/ +int sqliteVdbeCode(Vdbe *p, ...){ + int addr; + va_list ap; + int opcode, p1, p2; + va_start(ap, p); + addr = p->nOp; + while( (opcode = va_arg(ap,int))!=0 ){ + p1 = va_arg(ap,int); + p2 = va_arg(ap,int); + sqliteVdbeAddOp(p, opcode, p1, p2); + } + va_end(ap); + return addr; +} + + + +/* +** Create a new symbolic label for an instruction that has yet to be +** coded. The symbolic label is really just a negative number. The +** label can be used as the P2 value of an operation. Later, when +** the label is resolved to a specific address, the VDBE will scan +** through its operation list and change all values of P2 which match +** the label into the resolved address. +** +** The VDBE knows that a P2 value is a label because labels are +** always negative and P2 values are suppose to be non-negative. +** Hence, a negative P2 value is a label that has yet to be resolved. +*/ +int sqliteVdbeMakeLabel(Vdbe *p){ + int i; + i = p->nLabel++; + assert( p->magic==VDBE_MAGIC_INIT ); + if( i>=p->nLabelAlloc ){ + int *aNew; + p->nLabelAlloc = p->nLabelAlloc*2 + 10; + aNew = sqliteRealloc( p->aLabel, p->nLabelAlloc*sizeof(p->aLabel[0])); + if( aNew==0 ){ + sqliteFree(p->aLabel); + } + p->aLabel = aNew; + } + if( p->aLabel==0 ){ + p->nLabel = 0; + p->nLabelAlloc = 0; + return 0; + } + p->aLabel[i] = -1; + return -1-i; +} + +/* +** Resolve label "x" to be the address of the next instruction to +** be inserted. The parameter "x" must have been obtained from +** a prior call to sqliteVdbeMakeLabel(). +*/ +void sqliteVdbeResolveLabel(Vdbe *p, int x){ + int j; + assert( p->magic==VDBE_MAGIC_INIT ); + if( x<0 && (-x)<=p->nLabel && p->aOp ){ + if( p->aLabel[-1-x]==p->nOp ) return; + assert( p->aLabel[-1-x]<0 ); + p->aLabel[-1-x] = p->nOp; + for(j=0; j<p->nOp; j++){ + if( p->aOp[j].p2==x ) p->aOp[j].p2 = p->nOp; + } + } +} + +/* +** Return the address of the next instruction to be inserted. +*/ +int sqliteVdbeCurrentAddr(Vdbe *p){ + assert( p->magic==VDBE_MAGIC_INIT ); + return p->nOp; +} + +/* +** Add a whole list of operations to the operation stack. Return the +** address of the first operation added. +*/ +int sqliteVdbeAddOpList(Vdbe *p, int nOp, VdbeOpList const *aOp){ + int addr; + assert( p->magic==VDBE_MAGIC_INIT ); + if( p->nOp + nOp >= p->nOpAlloc ){ + int oldSize = p->nOpAlloc; + Op *aNew; + p->nOpAlloc = p->nOpAlloc*2 + nOp + 10; + aNew = sqliteRealloc(p->aOp, p->nOpAlloc*sizeof(Op)); + if( aNew==0 ){ + p->nOpAlloc = oldSize; + return 0; + } + p->aOp = aNew; + memset(&p->aOp[oldSize], 0, (p->nOpAlloc-oldSize)*sizeof(Op)); + } + addr = p->nOp; + if( nOp>0 ){ + int i; + VdbeOpList const *pIn = aOp; + for(i=0; i<nOp; i++, pIn++){ + int p2 = pIn->p2; + VdbeOp *pOut = &p->aOp[i+addr]; + pOut->opcode = pIn->opcode; + pOut->p1 = pIn->p1; + pOut->p2 = p2<0 ? addr + ADDR(p2) : p2; + pOut->p3 = pIn->p3; + pOut->p3type = pIn->p3 ? P3_STATIC : P3_NOTUSED; +#ifndef NDEBUG + if( sqlite_vdbe_addop_trace ){ + sqliteVdbePrintOp(0, i+addr, &p->aOp[i+addr]); + } +#endif + } + p->nOp += nOp; + } + return addr; +} + +/* +** Change the value of the P1 operand for a specific instruction. +** This routine is useful when a large program is loaded from a +** static array using sqliteVdbeAddOpList but we want to make a +** few minor changes to the program. +*/ +void sqliteVdbeChangeP1(Vdbe *p, int addr, int val){ + assert( p->magic==VDBE_MAGIC_INIT ); + if( p && addr>=0 && p->nOp>addr && p->aOp ){ + p->aOp[addr].p1 = val; + } +} + +/* +** Change the value of the P2 operand for a specific instruction. +** This routine is useful for setting a jump destination. +*/ +void sqliteVdbeChangeP2(Vdbe *p, int addr, int val){ + assert( val>=0 ); + assert( p->magic==VDBE_MAGIC_INIT ); + if( p && addr>=0 && p->nOp>addr && p->aOp ){ + p->aOp[addr].p2 = val; + } +} + +/* +** Change the value of the P3 operand for a specific instruction. +** This routine is useful when a large program is loaded from a +** static array using sqliteVdbeAddOpList but we want to make a +** few minor changes to the program. +** +** If n>=0 then the P3 operand is dynamic, meaning that a copy of +** the string is made into memory obtained from sqliteMalloc(). +** A value of n==0 means copy bytes of zP3 up to and including the +** first null byte. If n>0 then copy n+1 bytes of zP3. +** +** If n==P3_STATIC it means that zP3 is a pointer to a constant static +** string and we can just copy the pointer. n==P3_POINTER means zP3 is +** a pointer to some object other than a string. +** +** If addr<0 then change P3 on the most recently inserted instruction. +*/ +void sqliteVdbeChangeP3(Vdbe *p, int addr, const char *zP3, int n){ + Op *pOp; + assert( p->magic==VDBE_MAGIC_INIT ); + if( p==0 || p->aOp==0 ) return; + if( addr<0 || addr>=p->nOp ){ + addr = p->nOp - 1; + if( addr<0 ) return; + } + pOp = &p->aOp[addr]; + if( pOp->p3 && pOp->p3type==P3_DYNAMIC ){ + sqliteFree(pOp->p3); + pOp->p3 = 0; + } + if( zP3==0 ){ + pOp->p3 = 0; + pOp->p3type = P3_NOTUSED; + }else if( n<0 ){ + pOp->p3 = (char*)zP3; + pOp->p3type = n; + }else{ + sqliteSetNString(&pOp->p3, zP3, n, 0); + pOp->p3type = P3_DYNAMIC; + } +} + +/* +** If the P3 operand to the specified instruction appears +** to be a quoted string token, then this procedure removes +** the quotes. +** +** The quoting operator can be either a grave ascent (ASCII 0x27) +** or a double quote character (ASCII 0x22). Two quotes in a row +** resolve to be a single actual quote character within the string. +*/ +void sqliteVdbeDequoteP3(Vdbe *p, int addr){ + Op *pOp; + assert( p->magic==VDBE_MAGIC_INIT ); + if( p->aOp==0 ) return; + if( addr<0 || addr>=p->nOp ){ + addr = p->nOp - 1; + if( addr<0 ) return; + } + pOp = &p->aOp[addr]; + if( pOp->p3==0 || pOp->p3[0]==0 ) return; + if( pOp->p3type==P3_POINTER ) return; + if( pOp->p3type!=P3_DYNAMIC ){ + pOp->p3 = sqliteStrDup(pOp->p3); + pOp->p3type = P3_DYNAMIC; + } + sqliteDequote(pOp->p3); +} + +/* +** On the P3 argument of the given instruction, change all +** strings of whitespace characters into a single space and +** delete leading and trailing whitespace. +*/ +void sqliteVdbeCompressSpace(Vdbe *p, int addr){ + unsigned char *z; + int i, j; + Op *pOp; + assert( p->magic==VDBE_MAGIC_INIT ); + if( p->aOp==0 || addr<0 || addr>=p->nOp ) return; + pOp = &p->aOp[addr]; + if( pOp->p3type==P3_POINTER ){ + return; + } + if( pOp->p3type!=P3_DYNAMIC ){ + pOp->p3 = sqliteStrDup(pOp->p3); + pOp->p3type = P3_DYNAMIC; + } + z = (unsigned char*)pOp->p3; + if( z==0 ) return; + i = j = 0; + while( isspace(z[i]) ){ i++; } + while( z[i] ){ + if( isspace(z[i]) ){ + z[j++] = ' '; + while( isspace(z[++i]) ){} + }else{ + z[j++] = z[i++]; + } + } + while( j>0 && isspace(z[j-1]) ){ j--; } + z[j] = 0; +} + +/* +** Search for the current program for the given opcode and P2 +** value. Return the address plus 1 if found and 0 if not found. +*/ +int sqliteVdbeFindOp(Vdbe *p, int op, int p2){ + int i; + assert( p->magic==VDBE_MAGIC_INIT ); + for(i=0; i<p->nOp; i++){ + if( p->aOp[i].opcode==op && p->aOp[i].p2==p2 ) return i+1; + } + return 0; +} + +/* +** Return the opcode for a given address. +*/ +VdbeOp *sqliteVdbeGetOp(Vdbe *p, int addr){ + assert( p->magic==VDBE_MAGIC_INIT ); + assert( addr>=0 && addr<p->nOp ); + return &p->aOp[addr]; +} + +/* +** The following group or routines are employed by installable functions +** to return their results. +** +** The sqlite_set_result_string() routine can be used to return a string +** value or to return a NULL. To return a NULL, pass in NULL for zResult. +** A copy is made of the string before this routine returns so it is safe +** to pass in an ephemeral string. +** +** sqlite_set_result_error() works like sqlite_set_result_string() except +** that it signals a fatal error. The string argument, if any, is the +** error message. If the argument is NULL a generic substitute error message +** is used. +** +** The sqlite_set_result_int() and sqlite_set_result_double() set the return +** value of the user function to an integer or a double. +** +** These routines are defined here in vdbe.c because they depend on knowing +** the internals of the sqlite_func structure which is only defined in +** this source file. +*/ +char *sqlite_set_result_string(sqlite_func *p, const char *zResult, int n){ + assert( !p->isStep ); + if( p->s.flags & MEM_Dyn ){ + sqliteFree(p->s.z); + } + if( zResult==0 ){ + p->s.flags = MEM_Null; + n = 0; + p->s.z = 0; + p->s.n = 0; + }else{ + if( n<0 ) n = strlen(zResult); + if( n<NBFS-1 ){ + memcpy(p->s.zShort, zResult, n); + p->s.zShort[n] = 0; + p->s.flags = MEM_Str | MEM_Short; + p->s.z = p->s.zShort; + }else{ + p->s.z = sqliteMallocRaw( n+1 ); + if( p->s.z ){ + memcpy(p->s.z, zResult, n); + p->s.z[n] = 0; + } + p->s.flags = MEM_Str | MEM_Dyn; + } + p->s.n = n+1; + } + return p->s.z; +} +void sqlite_set_result_int(sqlite_func *p, int iResult){ + assert( !p->isStep ); + if( p->s.flags & MEM_Dyn ){ + sqliteFree(p->s.z); + } + p->s.i = iResult; + p->s.flags = MEM_Int; +} +void sqlite_set_result_double(sqlite_func *p, double rResult){ + assert( !p->isStep ); + if( p->s.flags & MEM_Dyn ){ + sqliteFree(p->s.z); + } + p->s.r = rResult; + p->s.flags = MEM_Real; +} +void sqlite_set_result_error(sqlite_func *p, const char *zMsg, int n){ + assert( !p->isStep ); + sqlite_set_result_string(p, zMsg, n); + p->isError = 1; +} + +/* +** Extract the user data from a sqlite_func structure and return a +** pointer to it. +*/ +void *sqlite_user_data(sqlite_func *p){ + assert( p && p->pFunc ); + return p->pFunc->pUserData; +} + +/* +** Allocate or return the aggregate context for a user function. A new +** context is allocated on the first call. Subsequent calls return the +** same context that was returned on prior calls. +** +** This routine is defined here in vdbe.c because it depends on knowing +** the internals of the sqlite_func structure which is only defined in +** this source file. +*/ +void *sqlite_aggregate_context(sqlite_func *p, int nByte){ + assert( p && p->pFunc && p->pFunc->xStep ); + if( p->pAgg==0 ){ + if( nByte<=NBFS ){ + p->pAgg = (void*)p->s.z; + memset(p->pAgg, 0, nByte); + }else{ + p->pAgg = sqliteMalloc( nByte ); + } + } + return p->pAgg; +} + +/* +** Return the number of times the Step function of a aggregate has been +** called. +** +** This routine is defined here in vdbe.c because it depends on knowing +** the internals of the sqlite_func structure which is only defined in +** this source file. +*/ +int sqlite_aggregate_count(sqlite_func *p){ + assert( p && p->pFunc && p->pFunc->xStep ); + return p->cnt; +} + +#if !defined(NDEBUG) || defined(VDBE_PROFILE) +/* +** Print a single opcode. This routine is used for debugging only. +*/ +void sqliteVdbePrintOp(FILE *pOut, int pc, Op *pOp){ + char *zP3; + char zPtr[40]; + if( pOp->p3type==P3_POINTER ){ + sprintf(zPtr, "ptr(%#lx)", (long)pOp->p3); + zP3 = zPtr; + }else{ + zP3 = pOp->p3; + } + if( pOut==0 ) pOut = stdout; + fprintf(pOut,"%4d %-12s %4d %4d %s\n", + pc, sqliteOpcodeNames[pOp->opcode], pOp->p1, pOp->p2, zP3 ? zP3 : ""); + fflush(pOut); +} +#endif + +/* +** Give a listing of the program in the virtual machine. +** +** The interface is the same as sqliteVdbeExec(). But instead of +** running the code, it invokes the callback once for each instruction. +** This feature is used to implement "EXPLAIN". +*/ +int sqliteVdbeList( + Vdbe *p /* The VDBE */ +){ + sqlite *db = p->db; + int i; + int rc = SQLITE_OK; + static char *azColumnNames[] = { + "addr", "opcode", "p1", "p2", "p3", + "int", "text", "int", "int", "text", + 0 + }; + + assert( p->popStack==0 ); + assert( p->explain ); + p->azColName = azColumnNames; + p->azResColumn = p->zArgv; + for(i=0; i<5; i++) p->zArgv[i] = p->aStack[i].zShort; + i = p->pc; + if( i>=p->nOp ){ + p->rc = SQLITE_OK; + rc = SQLITE_DONE; + }else if( db->flags & SQLITE_Interrupt ){ + db->flags &= ~SQLITE_Interrupt; + if( db->magic!=SQLITE_MAGIC_BUSY ){ + p->rc = SQLITE_MISUSE; + }else{ + p->rc = SQLITE_INTERRUPT; + } + rc = SQLITE_ERROR; + sqliteSetString(&p->zErrMsg, sqlite_error_string(p->rc), (char*)0); + }else{ + sprintf(p->zArgv[0],"%d",i); + sprintf(p->zArgv[2],"%d", p->aOp[i].p1); + sprintf(p->zArgv[3],"%d", p->aOp[i].p2); + if( p->aOp[i].p3type==P3_POINTER ){ + sprintf(p->aStack[4].zShort, "ptr(%#lx)", (long)p->aOp[i].p3); + p->zArgv[4] = p->aStack[4].zShort; + }else{ + p->zArgv[4] = p->aOp[i].p3; + } + p->zArgv[1] = sqliteOpcodeNames[p->aOp[i].opcode]; + p->pc = i+1; + p->azResColumn = p->zArgv; + p->nResColumn = 5; + p->rc = SQLITE_OK; + rc = SQLITE_ROW; + } + return rc; +} + +/* +** Prepare a virtual machine for execution. This involves things such +** as allocating stack space and initializing the program counter. +** After the VDBE has be prepped, it can be executed by one or more +** calls to sqliteVdbeExec(). +*/ +void sqliteVdbeMakeReady( + Vdbe *p, /* The VDBE */ + int nVar, /* Number of '?' see in the SQL statement */ + int isExplain /* True if the EXPLAIN keywords is present */ +){ + int n; + + assert( p!=0 ); + assert( p->magic==VDBE_MAGIC_INIT ); + + /* Add a HALT instruction to the very end of the program. + */ + if( p->nOp==0 || (p->aOp && p->aOp[p->nOp-1].opcode!=OP_Halt) ){ + sqliteVdbeAddOp(p, OP_Halt, 0, 0); + } + + /* No instruction ever pushes more than a single element onto the + ** stack. And the stack never grows on successive executions of the + ** same loop. So the total number of instructions is an upper bound + ** on the maximum stack depth required. + ** + ** Allocation all the stack space we will ever need. + */ + if( p->aStack==0 ){ + p->nVar = nVar; + assert( nVar>=0 ); + n = isExplain ? 10 : p->nOp; + p->aStack = sqliteMalloc( + n*(sizeof(p->aStack[0]) + 2*sizeof(char*)) /* aStack and zArgv */ + + p->nVar*(sizeof(char*)+sizeof(int)+1) /* azVar, anVar, abVar */ + ); + p->zArgv = (char**)&p->aStack[n]; + p->azColName = (char**)&p->zArgv[n]; + p->azVar = (char**)&p->azColName[n]; + p->anVar = (int*)&p->azVar[p->nVar]; + p->abVar = (u8*)&p->anVar[p->nVar]; + } + + sqliteHashInit(&p->agg.hash, SQLITE_HASH_BINARY, 0); + p->agg.pSearch = 0; +#ifdef MEMORY_DEBUG + if( sqliteOsFileExists("vdbe_trace") ){ + p->trace = stdout; + } +#endif + p->pTos = &p->aStack[-1]; + p->pc = 0; + p->rc = SQLITE_OK; + p->uniqueCnt = 0; + p->returnDepth = 0; + p->errorAction = OE_Abort; + p->undoTransOnError = 0; + p->popStack = 0; + p->explain |= isExplain; + p->magic = VDBE_MAGIC_RUN; +#ifdef VDBE_PROFILE + { + int i; + for(i=0; i<p->nOp; i++){ + p->aOp[i].cnt = 0; + p->aOp[i].cycles = 0; + } + } +#endif +} + + +/* +** Remove any elements that remain on the sorter for the VDBE given. +*/ +void sqliteVdbeSorterReset(Vdbe *p){ + while( p->pSort ){ + Sorter *pSorter = p->pSort; + p->pSort = pSorter->pNext; + sqliteFree(pSorter->zKey); + sqliteFree(pSorter->pData); + sqliteFree(pSorter); + } +} + +/* +** Reset an Agg structure. Delete all its contents. +** +** For installable aggregate functions, if the step function has been +** called, make sure the finalizer function has also been called. The +** finalizer might need to free memory that was allocated as part of its +** private context. If the finalizer has not been called yet, call it +** now. +*/ +void sqliteVdbeAggReset(Agg *pAgg){ + int i; + HashElem *p; + for(p = sqliteHashFirst(&pAgg->hash); p; p = sqliteHashNext(p)){ + AggElem *pElem = sqliteHashData(p); + assert( pAgg->apFunc!=0 ); + for(i=0; i<pAgg->nMem; i++){ + Mem *pMem = &pElem->aMem[i]; + if( pAgg->apFunc[i] && (pMem->flags & MEM_AggCtx)!=0 ){ + sqlite_func ctx; + ctx.pFunc = pAgg->apFunc[i]; + ctx.s.flags = MEM_Null; + ctx.pAgg = pMem->z; + ctx.cnt = pMem->i; + ctx.isStep = 0; + ctx.isError = 0; + (*pAgg->apFunc[i]->xFinalize)(&ctx); + if( pMem->z!=0 && pMem->z!=pMem->zShort ){ + sqliteFree(pMem->z); + } + if( ctx.s.flags & MEM_Dyn ){ + sqliteFree(ctx.s.z); + } + }else if( pMem->flags & MEM_Dyn ){ + sqliteFree(pMem->z); + } + } + sqliteFree(pElem); + } + sqliteHashClear(&pAgg->hash); + sqliteFree(pAgg->apFunc); + pAgg->apFunc = 0; + pAgg->pCurrent = 0; + pAgg->pSearch = 0; + pAgg->nMem = 0; +} + +/* +** Delete a keylist +*/ +void sqliteVdbeKeylistFree(Keylist *p){ + while( p ){ + Keylist *pNext = p->pNext; + sqliteFree(p); + p = pNext; + } +} + +/* +** Close a cursor and release all the resources that cursor happens +** to hold. +*/ +void sqliteVdbeCleanupCursor(Cursor *pCx){ + if( pCx->pCursor ){ + sqliteBtreeCloseCursor(pCx->pCursor); + } + if( pCx->pBt ){ + sqliteBtreeClose(pCx->pBt); + } + sqliteFree(pCx->pData); + memset(pCx, 0, sizeof(Cursor)); +} + +/* +** Close all cursors +*/ +static void closeAllCursors(Vdbe *p){ + int i; + for(i=0; i<p->nCursor; i++){ + sqliteVdbeCleanupCursor(&p->aCsr[i]); + } + sqliteFree(p->aCsr); + p->aCsr = 0; + p->nCursor = 0; +} + +/* +** Clean up the VM after execution. +** +** This routine will automatically close any cursors, lists, and/or +** sorters that were left open. It also deletes the values of +** variables in the azVariable[] array. +*/ +static void Cleanup(Vdbe *p){ + int i; + if( p->aStack ){ + Mem *pTos = p->pTos; + while( pTos>=p->aStack ){ + if( pTos->flags & MEM_Dyn ){ + sqliteFree(pTos->z); + } + pTos--; + } + p->pTos = pTos; + } + closeAllCursors(p); + if( p->aMem ){ + for(i=0; i<p->nMem; i++){ + if( p->aMem[i].flags & MEM_Dyn ){ + sqliteFree(p->aMem[i].z); + } + } + } + sqliteFree(p->aMem); + p->aMem = 0; + p->nMem = 0; + if( p->pList ){ + sqliteVdbeKeylistFree(p->pList); + p->pList = 0; + } + sqliteVdbeSorterReset(p); + if( p->pFile ){ + if( p->pFile!=stdin ) fclose(p->pFile); + p->pFile = 0; + } + if( p->azField ){ + sqliteFree(p->azField); + p->azField = 0; + } + p->nField = 0; + if( p->zLine ){ + sqliteFree(p->zLine); + p->zLine = 0; + } + p->nLineAlloc = 0; + sqliteVdbeAggReset(&p->agg); + if( p->aSet ){ + for(i=0; i<p->nSet; i++){ + sqliteHashClear(&p->aSet[i].hash); + } + } + sqliteFree(p->aSet); + p->aSet = 0; + p->nSet = 0; + if( p->keylistStack ){ + int ii; + for(ii = 0; ii < p->keylistStackDepth; ii++){ + sqliteVdbeKeylistFree(p->keylistStack[ii]); + } + sqliteFree(p->keylistStack); + p->keylistStackDepth = 0; + p->keylistStack = 0; + } + sqliteFree(p->contextStack); + p->contextStack = 0; + sqliteFree(p->zErrMsg); + p->zErrMsg = 0; +} + +/* +** Clean up a VDBE after execution but do not delete the VDBE just yet. +** Write any error messages into *pzErrMsg. Return the result code. +** +** After this routine is run, the VDBE should be ready to be executed +** again. +*/ +int sqliteVdbeReset(Vdbe *p, char **pzErrMsg){ + sqlite *db = p->db; + int i; + + if( p->magic!=VDBE_MAGIC_RUN && p->magic!=VDBE_MAGIC_HALT ){ + sqliteSetString(pzErrMsg, sqlite_error_string(SQLITE_MISUSE), (char*)0); + return SQLITE_MISUSE; + } + if( p->zErrMsg ){ + if( pzErrMsg && *pzErrMsg==0 ){ + *pzErrMsg = p->zErrMsg; + }else{ + sqliteFree(p->zErrMsg); + } + p->zErrMsg = 0; + }else if( p->rc ){ + sqliteSetString(pzErrMsg, sqlite_error_string(p->rc), (char*)0); + } + Cleanup(p); + if( p->rc!=SQLITE_OK ){ + switch( p->errorAction ){ + case OE_Abort: { + if( !p->undoTransOnError ){ + for(i=0; i<db->nDb; i++){ + if( db->aDb[i].pBt ){ + sqliteBtreeRollbackCkpt(db->aDb[i].pBt); + } + } + break; + } + /* Fall through to ROLLBACK */ + } + case OE_Rollback: { + sqliteRollbackAll(db); + db->flags &= ~SQLITE_InTrans; + db->onError = OE_Default; + break; + } + default: { + if( p->undoTransOnError ){ + sqliteRollbackAll(db); + db->flags &= ~SQLITE_InTrans; + db->onError = OE_Default; + } + break; + } + } + sqliteRollbackInternalChanges(db); + } + for(i=0; i<db->nDb; i++){ + if( db->aDb[i].pBt && db->aDb[i].inTrans==2 ){ + sqliteBtreeCommitCkpt(db->aDb[i].pBt); + db->aDb[i].inTrans = 1; + } + } + assert( p->pTos<&p->aStack[p->pc] || sqlite_malloc_failed==1 ); +#ifdef VDBE_PROFILE + { + FILE *out = fopen("vdbe_profile.out", "a"); + if( out ){ + int i; + fprintf(out, "---- "); + for(i=0; i<p->nOp; i++){ + fprintf(out, "%02x", p->aOp[i].opcode); + } + fprintf(out, "\n"); + for(i=0; i<p->nOp; i++){ + fprintf(out, "%6d %10lld %8lld ", + p->aOp[i].cnt, + p->aOp[i].cycles, + p->aOp[i].cnt>0 ? p->aOp[i].cycles/p->aOp[i].cnt : 0 + ); + sqliteVdbePrintOp(out, i, &p->aOp[i]); + } + fclose(out); + } + } +#endif + p->magic = VDBE_MAGIC_INIT; + return p->rc; +} + +/* +** Clean up and delete a VDBE after execution. Return an integer which is +** the result code. Write any error message text into *pzErrMsg. +*/ +int sqliteVdbeFinalize(Vdbe *p, char **pzErrMsg){ + int rc; + sqlite *db; + + if( p->magic!=VDBE_MAGIC_RUN && p->magic!=VDBE_MAGIC_HALT ){ + sqliteSetString(pzErrMsg, sqlite_error_string(SQLITE_MISUSE), (char*)0); + return SQLITE_MISUSE; + } + db = p->db; + rc = sqliteVdbeReset(p, pzErrMsg); + sqliteVdbeDelete(p); + if( db->want_to_close && db->pVdbe==0 ){ + sqlite_close(db); + } + if( rc==SQLITE_SCHEMA ){ + sqliteResetInternalSchema(db, 0); + } + return rc; +} + +/* +** Set the values of all variables. Variable $1 in the original SQL will +** be the string azValue[0]. $2 will have the value azValue[1]. And +** so forth. If a value is out of range (for example $3 when nValue==2) +** then its value will be NULL. +** +** This routine overrides any prior call. +*/ +int sqlite_bind(sqlite_vm *pVm, int i, const char *zVal, int len, int copy){ + Vdbe *p = (Vdbe*)pVm; + if( p->magic!=VDBE_MAGIC_RUN || p->pc!=0 ){ + return SQLITE_MISUSE; + } + if( i<1 || i>p->nVar ){ + return SQLITE_RANGE; + } + i--; + if( p->abVar[i] ){ + sqliteFree(p->azVar[i]); + } + if( zVal==0 ){ + copy = 0; + len = 0; + } + if( len<0 ){ + len = strlen(zVal)+1; + } + if( copy ){ + p->azVar[i] = sqliteMalloc( len ); + if( p->azVar[i] ) memcpy(p->azVar[i], zVal, len); + }else{ + p->azVar[i] = (char*)zVal; + } + p->abVar[i] = copy; + p->anVar[i] = len; + return SQLITE_OK; +} + + +/* +** Delete an entire VDBE. +*/ +void sqliteVdbeDelete(Vdbe *p){ + int i; + if( p==0 ) return; + Cleanup(p); + if( p->pPrev ){ + p->pPrev->pNext = p->pNext; + }else{ + assert( p->db->pVdbe==p ); + p->db->pVdbe = p->pNext; + } + if( p->pNext ){ + p->pNext->pPrev = p->pPrev; + } + p->pPrev = p->pNext = 0; + if( p->nOpAlloc==0 ){ + p->aOp = 0; + p->nOp = 0; + } + for(i=0; i<p->nOp; i++){ + if( p->aOp[i].p3type==P3_DYNAMIC ){ + sqliteFree(p->aOp[i].p3); + } + } + for(i=0; i<p->nVar; i++){ + if( p->abVar[i] ) sqliteFree(p->azVar[i]); + } + sqliteFree(p->aOp); + sqliteFree(p->aLabel); + sqliteFree(p->aStack); + p->magic = VDBE_MAGIC_DEAD; + sqliteFree(p); +} + +/* +** Convert an integer in between the native integer format and +** the bigEndian format used as the record number for tables. +** +** The bigEndian format (most significant byte first) is used for +** record numbers so that records will sort into the correct order +** even though memcmp() is used to compare the keys. On machines +** whose native integer format is little endian (ex: i486) the +** order of bytes is reversed. On native big-endian machines +** (ex: Alpha, Sparc, Motorola) the byte order is the same. +** +** This function is its own inverse. In other words +** +** X == byteSwap(byteSwap(X)) +*/ +int sqliteVdbeByteSwap(int x){ + union { + char zBuf[sizeof(int)]; + int i; + } ux; + ux.zBuf[3] = x&0xff; + ux.zBuf[2] = (x>>8)&0xff; + ux.zBuf[1] = (x>>16)&0xff; + ux.zBuf[0] = (x>>24)&0xff; + return ux.i; +} + +/* +** If a MoveTo operation is pending on the given cursor, then do that +** MoveTo now. Return an error code. If no MoveTo is pending, this +** routine does nothing and returns SQLITE_OK. +*/ +int sqliteVdbeCursorMoveto(Cursor *p){ + if( p->deferredMoveto ){ + int res; + extern int sqlite_search_count; + sqliteBtreeMoveto(p->pCursor, (char*)&p->movetoTarget, sizeof(int), &res); + p->lastRecno = keyToInt(p->movetoTarget); + p->recnoIsValid = res==0; + if( res<0 ){ + sqliteBtreeNext(p->pCursor, &res); + } + sqlite_search_count++; + p->deferredMoveto = 0; + } + return SQLITE_OK; +} diff --git a/kexi/3rdparty/kexisql/src/where.c b/kexi/3rdparty/kexisql/src/where.c new file mode 100644 index 00000000..714972f8 --- /dev/null +++ b/kexi/3rdparty/kexisql/src/where.c @@ -0,0 +1,1235 @@ +/* +** 2001 September 15 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This module contains C code that generates VDBE code used to process +** the WHERE clause of SQL statements. +** +** $Id: where.c 410099 2005-05-06 17:52:07Z staniek $ +*/ +#include "sqliteInt.h" + +/* +** The query generator uses an array of instances of this structure to +** help it analyze the subexpressions of the WHERE clause. Each WHERE +** clause subexpression is separated from the others by an AND operator. +*/ +typedef struct ExprInfo ExprInfo; +struct ExprInfo { + Expr *p; /* Pointer to the subexpression */ + u8 indexable; /* True if this subexprssion is usable by an index */ + short int idxLeft; /* p->pLeft is a column in this table number. -1 if + ** p->pLeft is not the column of any table */ + short int idxRight; /* p->pRight is a column in this table number. -1 if + ** p->pRight is not the column of any table */ + unsigned prereqLeft; /* Bitmask of tables referenced by p->pLeft */ + unsigned prereqRight; /* Bitmask of tables referenced by p->pRight */ + unsigned prereqAll; /* Bitmask of tables referenced by p */ +}; + +/* +** An instance of the following structure keeps track of a mapping +** between VDBE cursor numbers and bitmasks. The VDBE cursor numbers +** are small integers contained in SrcList_item.iCursor and Expr.iTable +** fields. For any given WHERE clause, we want to track which cursors +** are being used, so we assign a single bit in a 32-bit word to track +** that cursor. Then a 32-bit integer is able to show the set of all +** cursors being used. +*/ +typedef struct ExprMaskSet ExprMaskSet; +struct ExprMaskSet { + int n; /* Number of assigned cursor values */ + int ix[31]; /* Cursor assigned to each bit */ +}; + +/* +** Determine the number of elements in an array. +*/ +#define ARRAYSIZE(X) (sizeof(X)/sizeof(X[0])) + +/* +** This routine is used to divide the WHERE expression into subexpressions +** separated by the AND operator. +** +** aSlot[] is an array of subexpressions structures. +** There are nSlot spaces left in this array. This routine attempts to +** split pExpr into subexpressions and fills aSlot[] with those subexpressions. +** The return value is the number of slots filled. +*/ +static int exprSplit(int nSlot, ExprInfo *aSlot, Expr *pExpr){ + int cnt = 0; + if( pExpr==0 || nSlot<1 ) return 0; + if( nSlot==1 || pExpr->op!=TK_AND ){ + aSlot[0].p = pExpr; + return 1; + } + if( pExpr->pLeft->op!=TK_AND ){ + aSlot[0].p = pExpr->pLeft; + cnt = 1 + exprSplit(nSlot-1, &aSlot[1], pExpr->pRight); + }else{ + cnt = exprSplit(nSlot, aSlot, pExpr->pLeft); + cnt += exprSplit(nSlot-cnt, &aSlot[cnt], pExpr->pRight); + } + return cnt; +} + +/* +** Initialize an expression mask set +*/ +#define initMaskSet(P) memset(P, 0, sizeof(*P)) + +/* +** Return the bitmask for the given cursor. Assign a new bitmask +** if this is the first time the cursor has been seen. +*/ +static int getMask(ExprMaskSet *pMaskSet, int iCursor){ + int i; + for(i=0; i<pMaskSet->n; i++){ + if( pMaskSet->ix[i]==iCursor ) return 1<<i; + } + if( i==pMaskSet->n && i<ARRAYSIZE(pMaskSet->ix) ){ + pMaskSet->n++; + pMaskSet->ix[i] = iCursor; + return 1<<i; + } + return 0; +} + +/* +** Destroy an expression mask set +*/ +#define freeMaskSet(P) /* NO-OP */ + +/* +** This routine walks (recursively) an expression tree and generates +** a bitmask indicating which tables are used in that expression +** tree. +** +** In order for this routine to work, the calling function must have +** previously invoked sqliteExprResolveIds() on the expression. See +** the header comment on that routine for additional information. +** The sqliteExprResolveIds() routines looks for column names and +** sets their opcodes to TK_COLUMN and their Expr.iTable fields to +** the VDBE cursor number of the table. +*/ +static int exprTableUsage(ExprMaskSet *pMaskSet, Expr *p){ + unsigned int mask = 0; + if( p==0 ) return 0; + if( p->op==TK_COLUMN ){ + mask = getMask(pMaskSet, p->iTable); + if( mask==0 ) mask = -1; + return mask; + } + if( p->pRight ){ + mask = exprTableUsage(pMaskSet, p->pRight); + } + if( p->pLeft ){ + mask |= exprTableUsage(pMaskSet, p->pLeft); + } + if( p->pList ){ + int i; + for(i=0; i<p->pList->nExpr; i++){ + mask |= exprTableUsage(pMaskSet, p->pList->a[i].pExpr); + } + } + return mask; +} + +/* +** Return TRUE if the given operator is one of the operators that is +** allowed for an indexable WHERE clause. The allowed operators are +** "=", "<", ">", "<=", ">=", and "IN". +*/ +static int allowedOp(int op){ + switch( op ){ + case TK_LT: + case TK_LE: + case TK_GT: + case TK_GE: + case TK_EQ: + case TK_IN: + return 1; + default: + return 0; + } +} + +/* +** The input to this routine is an ExprInfo structure with only the +** "p" field filled in. The job of this routine is to analyze the +** subexpression and populate all the other fields of the ExprInfo +** structure. +*/ +static void exprAnalyze(ExprMaskSet *pMaskSet, ExprInfo *pInfo){ + Expr *pExpr = pInfo->p; + pInfo->prereqLeft = exprTableUsage(pMaskSet, pExpr->pLeft); + pInfo->prereqRight = exprTableUsage(pMaskSet, pExpr->pRight); + pInfo->prereqAll = exprTableUsage(pMaskSet, pExpr); + pInfo->indexable = 0; + pInfo->idxLeft = -1; + pInfo->idxRight = -1; + if( allowedOp(pExpr->op) && (pInfo->prereqRight & pInfo->prereqLeft)==0 ){ + if( pExpr->pRight && pExpr->pRight->op==TK_COLUMN ){ + pInfo->idxRight = pExpr->pRight->iTable; + pInfo->indexable = 1; + } + if( pExpr->pLeft->op==TK_COLUMN ){ + pInfo->idxLeft = pExpr->pLeft->iTable; + pInfo->indexable = 1; + } + } +} + +/* +** pOrderBy is an ORDER BY clause from a SELECT statement. pTab is the +** left-most table in the FROM clause of that same SELECT statement and +** the table has a cursor number of "base". +** +** This routine attempts to find an index for pTab that generates the +** correct record sequence for the given ORDER BY clause. The return value +** is a pointer to an index that does the job. NULL is returned if the +** table has no index that will generate the correct sort order. +** +** If there are two or more indices that generate the correct sort order +** and pPreferredIdx is one of those indices, then return pPreferredIdx. +** +** nEqCol is the number of columns of pPreferredIdx that are used as +** equality constraints. Any index returned must have exactly this same +** set of columns. The ORDER BY clause only matches index columns beyond the +** the first nEqCol columns. +** +** All terms of the ORDER BY clause must be either ASC or DESC. The +** *pbRev value is set to 1 if the ORDER BY clause is all DESC and it is +** set to 0 if the ORDER BY clause is all ASC. +*/ +static Index *findSortingIndex( + Table *pTab, /* The table to be sorted */ + int base, /* Cursor number for pTab */ + ExprList *pOrderBy, /* The ORDER BY clause */ + Index *pPreferredIdx, /* Use this index, if possible and not NULL */ + int nEqCol, /* Number of index columns used with == constraints */ + int *pbRev /* Set to 1 if ORDER BY is DESC */ +){ + int i, j; + Index *pMatch; + Index *pIdx; + int sortOrder; + + assert( pOrderBy!=0 ); + assert( pOrderBy->nExpr>0 ); + sortOrder = pOrderBy->a[0].sortOrder & SQLITE_SO_DIRMASK; + for(i=0; i<pOrderBy->nExpr; i++){ + Expr *p; + if( (pOrderBy->a[i].sortOrder & SQLITE_SO_DIRMASK)!=sortOrder ){ + /* Indices can only be used if all ORDER BY terms are either + ** DESC or ASC. Indices cannot be used on a mixture. */ + return 0; + } + if( (pOrderBy->a[i].sortOrder & SQLITE_SO_TYPEMASK)!=SQLITE_SO_UNK ){ + /* Do not sort by index if there is a COLLATE clause */ + return 0; + } + p = pOrderBy->a[i].pExpr; + if( p->op!=TK_COLUMN || p->iTable!=base ){ + /* Can not use an index sort on anything that is not a column in the + ** left-most table of the FROM clause */ + return 0; + } + } + + /* If we get this far, it means the ORDER BY clause consists only of + ** ascending columns in the left-most table of the FROM clause. Now + ** check for a matching index. + */ + pMatch = 0; + for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){ + int nExpr = pOrderBy->nExpr; + if( pIdx->nColumn < nEqCol || pIdx->nColumn < nExpr ) continue; + for(i=j=0; i<nEqCol; i++){ + if( pPreferredIdx->aiColumn[i]!=pIdx->aiColumn[i] ) break; + if( j<nExpr && pOrderBy->a[j].pExpr->iColumn==pIdx->aiColumn[i] ){ j++; } + } + if( i<nEqCol ) continue; + for(i=0; i+j<nExpr; i++){ + if( pOrderBy->a[i+j].pExpr->iColumn!=pIdx->aiColumn[i+nEqCol] ) break; + } + if( i+j>=nExpr ){ + pMatch = pIdx; + if( pIdx==pPreferredIdx ) break; + } + } + if( pMatch && pbRev ){ + *pbRev = sortOrder==SQLITE_SO_DESC; + } + return pMatch; +} + +/* +** Disable a term in the WHERE clause. Except, do not disable the term +** if it controls a LEFT OUTER JOIN and it did not originate in the ON +** or USING clause of that join. +** +** Consider the term t2.z='ok' in the following queries: +** +** (1) SELECT * FROM t1 LEFT JOIN t2 ON t1.a=t2.x WHERE t2.z='ok' +** (2) SELECT * FROM t1 LEFT JOIN t2 ON t1.a=t2.x AND t2.z='ok' +** (3) SELECT * FROM t1, t2 WHERE t1.a=t2.x AND t2.z='ok' +** +** The t2.z='ok' is disabled in the in (2) because it did not originate +** in the ON clause. The term is disabled in (3) because it is not part +** of a LEFT OUTER JOIN. In (1), the term is not disabled. +** +** Disabling a term causes that term to not be tested in the inner loop +** of the join. Disabling is an optimization. We would get the correct +** results if nothing were ever disabled, but joins might run a little +** slower. The trick is to disable as much as we can without disabling +** too much. If we disabled in (1), we'd get the wrong answer. +** See ticket #813. +*/ +static void disableTerm(WhereLevel *pLevel, Expr **ppExpr){ + Expr *pExpr = *ppExpr; + if( pLevel->iLeftJoin==0 || ExprHasProperty(pExpr, EP_FromJoin) ){ + *ppExpr = 0; + } +} + +/* +** Generate the beginning of the loop used for WHERE clause processing. +** The return value is a pointer to an (opaque) structure that contains +** information needed to terminate the loop. Later, the calling routine +** should invoke sqliteWhereEnd() with the return value of this function +** in order to complete the WHERE clause processing. +** +** If an error occurs, this routine returns NULL. +** +** The basic idea is to do a nested loop, one loop for each table in +** the FROM clause of a select. (INSERT and UPDATE statements are the +** same as a SELECT with only a single table in the FROM clause.) For +** example, if the SQL is this: +** +** SELECT * FROM t1, t2, t3 WHERE ...; +** +** Then the code generated is conceptually like the following: +** +** foreach row1 in t1 do \ Code generated +** foreach row2 in t2 do |-- by sqliteWhereBegin() +** foreach row3 in t3 do / +** ... +** end \ Code generated +** end |-- by sqliteWhereEnd() +** end / +** +** There are Btree cursors associated with each table. t1 uses cursor +** number pTabList->a[0].iCursor. t2 uses the cursor pTabList->a[1].iCursor. +** And so forth. This routine generates code to open those VDBE cursors +** and sqliteWhereEnd() generates the code to close them. +** +** If the WHERE clause is empty, the foreach loops must each scan their +** entire tables. Thus a three-way join is an O(N^3) operation. But if +** the tables have indices and there are terms in the WHERE clause that +** refer to those indices, a complete table scan can be avoided and the +** code will run much faster. Most of the work of this routine is checking +** to see if there are indices that can be used to speed up the loop. +** +** Terms of the WHERE clause are also used to limit which rows actually +** make it to the "..." in the middle of the loop. After each "foreach", +** terms of the WHERE clause that use only terms in that loop and outer +** loops are evaluated and if false a jump is made around all subsequent +** inner loops (or around the "..." if the test occurs within the inner- +** most loop) +** +** OUTER JOINS +** +** An outer join of tables t1 and t2 is conceptally coded as follows: +** +** foreach row1 in t1 do +** flag = 0 +** foreach row2 in t2 do +** start: +** ... +** flag = 1 +** end +** if flag==0 then +** move the row2 cursor to a null row +** goto start +** fi +** end +** +** ORDER BY CLAUSE PROCESSING +** +** *ppOrderBy is a pointer to the ORDER BY clause of a SELECT statement, +** if there is one. If there is no ORDER BY clause or if this routine +** is called from an UPDATE or DELETE statement, then ppOrderBy is NULL. +** +** If an index can be used so that the natural output order of the table +** scan is correct for the ORDER BY clause, then that index is used and +** *ppOrderBy is set to NULL. This is an optimization that prevents an +** unnecessary sort of the result set if an index appropriate for the +** ORDER BY clause already exists. +** +** If the where clause loops cannot be arranged to provide the correct +** output order, then the *ppOrderBy is unchanged. +*/ +WhereInfo *sqliteWhereBegin( + Parse *pParse, /* The parser context */ + SrcList *pTabList, /* A list of all tables to be scanned */ + Expr *pWhere, /* The WHERE clause */ + int pushKey, /* If TRUE, leave the table key on the stack */ + ExprList **ppOrderBy /* An ORDER BY clause, or NULL */ +){ + int i; /* Loop counter */ + WhereInfo *pWInfo; /* Will become the return value of this function */ + Vdbe *v = pParse->pVdbe; /* The virtual database engine */ + int brk, cont = 0; /* Addresses used during code generation */ + int nExpr; /* Number of subexpressions in the WHERE clause */ + int loopMask; /* One bit set for each outer loop */ + int haveKey; /* True if KEY is on the stack */ + ExprMaskSet maskSet; /* The expression mask set */ + int iDirectEq[32]; /* Term of the form ROWID==X for the N-th table */ + int iDirectLt[32]; /* Term of the form ROWID<X or ROWID<=X */ + int iDirectGt[32]; /* Term of the form ROWID>X or ROWID>=X */ + ExprInfo aExpr[101]; /* The WHERE clause is divided into these expressions */ + + /* pushKey is only allowed if there is a single table (as in an INSERT or + ** UPDATE statement) + */ + assert( pushKey==0 || pTabList->nSrc==1 ); + + /* Split the WHERE clause into separate subexpressions where each + ** subexpression is separated by an AND operator. If the aExpr[] + ** array fills up, the last entry might point to an expression which + ** contains additional unfactored AND operators. + */ + initMaskSet(&maskSet); + memset(aExpr, 0, sizeof(aExpr)); + nExpr = exprSplit(ARRAYSIZE(aExpr), aExpr, pWhere); + if( nExpr==ARRAYSIZE(aExpr) ){ + sqliteErrorMsg(pParse, "WHERE clause too complex - no more " + "than %d terms allowed", (int)ARRAYSIZE(aExpr)-1); + return 0; + } + + /* Allocate and initialize the WhereInfo structure that will become the + ** return value. + */ + pWInfo = sqliteMalloc( sizeof(WhereInfo) + pTabList->nSrc*sizeof(WhereLevel)); + if( sqlite_malloc_failed ){ + sqliteFree(pWInfo); + return 0; + } + pWInfo->pParse = pParse; + pWInfo->pTabList = pTabList; + pWInfo->peakNTab = pWInfo->savedNTab = pParse->nTab; + pWInfo->iBreak = sqliteVdbeMakeLabel(v); + + /* Special case: a WHERE clause that is constant. Evaluate the + ** expression and either jump over all of the code or fall thru. + */ + if( pWhere && (pTabList->nSrc==0 || sqliteExprIsConstant(pWhere)) ){ + sqliteExprIfFalse(pParse, pWhere, pWInfo->iBreak, 1); + pWhere = 0; + } + + /* Analyze all of the subexpressions. + */ + for(i=0; i<nExpr; i++){ + exprAnalyze(&maskSet, &aExpr[i]); + + /* If we are executing a trigger body, remove all references to + ** new.* and old.* tables from the prerequisite masks. + */ + if( pParse->trigStack ){ + int x; + if( (x = pParse->trigStack->newIdx) >= 0 ){ + int mask = ~getMask(&maskSet, x); + aExpr[i].prereqRight &= mask; + aExpr[i].prereqLeft &= mask; + aExpr[i].prereqAll &= mask; + } + if( (x = pParse->trigStack->oldIdx) >= 0 ){ + int mask = ~getMask(&maskSet, x); + aExpr[i].prereqRight &= mask; + aExpr[i].prereqLeft &= mask; + aExpr[i].prereqAll &= mask; + } + } + } + + /* Figure out what index to use (if any) for each nested loop. + ** Make pWInfo->a[i].pIdx point to the index to use for the i-th nested + ** loop where i==0 is the outer loop and i==pTabList->nSrc-1 is the inner + ** loop. + ** + ** If terms exist that use the ROWID of any table, then set the + ** iDirectEq[], iDirectLt[], or iDirectGt[] elements for that table + ** to the index of the term containing the ROWID. We always prefer + ** to use a ROWID which can directly access a table rather than an + ** index which requires reading an index first to get the rowid then + ** doing a second read of the actual database table. + ** + ** Actually, if there are more than 32 tables in the join, only the + ** first 32 tables are candidates for indices. This is (again) due + ** to the limit of 32 bits in an integer bitmask. + */ + loopMask = 0; + for(i=0; i<pTabList->nSrc && i<ARRAYSIZE(iDirectEq); i++){ + int j; + int iCur = pTabList->a[i].iCursor; /* The cursor for this table */ + int mask = getMask(&maskSet, iCur); /* Cursor mask for this table */ + Table *pTab = pTabList->a[i].pTab; + Index *pIdx; + Index *pBestIdx = 0; + int bestScore = 0; + + /* Check to see if there is an expression that uses only the + ** ROWID field of this table. For terms of the form ROWID==expr + ** set iDirectEq[i] to the index of the term. For terms of the + ** form ROWID<expr or ROWID<=expr set iDirectLt[i] to the term index. + ** For terms like ROWID>expr or ROWID>=expr set iDirectGt[i]. + ** + ** (Added:) Treat ROWID IN expr like ROWID=expr. + */ + pWInfo->a[i].iCur = -1; + iDirectEq[i] = -1; + iDirectLt[i] = -1; + iDirectGt[i] = -1; + for(j=0; j<nExpr; j++){ + if( aExpr[j].idxLeft==iCur && aExpr[j].p->pLeft->iColumn<0 + && (aExpr[j].prereqRight & loopMask)==aExpr[j].prereqRight ){ + switch( aExpr[j].p->op ){ + case TK_IN: + case TK_EQ: iDirectEq[i] = j; break; + case TK_LE: + case TK_LT: iDirectLt[i] = j; break; + case TK_GE: + case TK_GT: iDirectGt[i] = j; break; + } + } + if( aExpr[j].idxRight==iCur && aExpr[j].p->pRight->iColumn<0 + && (aExpr[j].prereqLeft & loopMask)==aExpr[j].prereqLeft ){ + switch( aExpr[j].p->op ){ + case TK_EQ: iDirectEq[i] = j; break; + case TK_LE: + case TK_LT: iDirectGt[i] = j; break; + case TK_GE: + case TK_GT: iDirectLt[i] = j; break; + } + } + } + if( iDirectEq[i]>=0 ){ + loopMask |= mask; + pWInfo->a[i].pIdx = 0; + continue; + } + + /* Do a search for usable indices. Leave pBestIdx pointing to + ** the "best" index. pBestIdx is left set to NULL if no indices + ** are usable. + ** + ** The best index is determined as follows. For each of the + ** left-most terms that is fixed by an equality operator, add + ** 8 to the score. The right-most term of the index may be + ** constrained by an inequality. Add 1 if for an "x<..." constraint + ** and add 2 for an "x>..." constraint. Chose the index that + ** gives the best score. + ** + ** This scoring system is designed so that the score can later be + ** used to determine how the index is used. If the score&7 is 0 + ** then all constraints are equalities. If score&1 is not 0 then + ** there is an inequality used as a termination key. (ex: "x<...") + ** If score&2 is not 0 then there is an inequality used as the + ** start key. (ex: "x>..."). A score or 4 is the special case + ** of an IN operator constraint. (ex: "x IN ..."). + ** + ** The IN operator (as in "<expr> IN (...)") is treated the same as + ** an equality comparison except that it can only be used on the + ** left-most column of an index and other terms of the WHERE clause + ** cannot be used in conjunction with the IN operator to help satisfy + ** other columns of the index. + */ + for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){ + int eqMask = 0; /* Index columns covered by an x=... term */ + int ltMask = 0; /* Index columns covered by an x<... term */ + int gtMask = 0; /* Index columns covered by an x>... term */ + int inMask = 0; /* Index columns covered by an x IN .. term */ + int nEq, m, score; + + if( pIdx->nColumn>32 ) continue; /* Ignore indices too many columns */ + for(j=0; j<nExpr; j++){ + if( aExpr[j].idxLeft==iCur + && (aExpr[j].prereqRight & loopMask)==aExpr[j].prereqRight ){ + int iColumn = aExpr[j].p->pLeft->iColumn; + int k; + for(k=0; k<pIdx->nColumn; k++){ + if( pIdx->aiColumn[k]==iColumn ){ + switch( aExpr[j].p->op ){ + case TK_IN: { + if( k==0 ) inMask |= 1; + break; + } + case TK_EQ: { + eqMask |= 1<<k; + break; + } + case TK_LE: + case TK_LT: { + ltMask |= 1<<k; + break; + } + case TK_GE: + case TK_GT: { + gtMask |= 1<<k; + break; + } + default: { + /* CANT_HAPPEN */ + assert( 0 ); + break; + } + } + break; + } + } + } + if( aExpr[j].idxRight==iCur + && (aExpr[j].prereqLeft & loopMask)==aExpr[j].prereqLeft ){ + int iColumn = aExpr[j].p->pRight->iColumn; + int k; + for(k=0; k<pIdx->nColumn; k++){ + if( pIdx->aiColumn[k]==iColumn ){ + switch( aExpr[j].p->op ){ + case TK_EQ: { + eqMask |= 1<<k; + break; + } + case TK_LE: + case TK_LT: { + gtMask |= 1<<k; + break; + } + case TK_GE: + case TK_GT: { + ltMask |= 1<<k; + break; + } + default: { + /* CANT_HAPPEN */ + assert( 0 ); + break; + } + } + break; + } + } + } + } + + /* The following loop ends with nEq set to the number of columns + ** on the left of the index with == constraints. + */ + for(nEq=0; nEq<pIdx->nColumn; nEq++){ + m = (1<<(nEq+1))-1; + if( (m & eqMask)!=m ) break; + } + score = nEq*8; /* Base score is 8 times number of == constraints */ + m = 1<<nEq; + if( m & ltMask ) score++; /* Increase score for a < constraint */ + if( m & gtMask ) score+=2; /* Increase score for a > constraint */ + if( score==0 && inMask ) score = 4; /* Default score for IN constraint */ + if( score>bestScore ){ + pBestIdx = pIdx; + bestScore = score; + } + } + pWInfo->a[i].pIdx = pBestIdx; + pWInfo->a[i].score = bestScore; + pWInfo->a[i].bRev = 0; + loopMask |= mask; + if( pBestIdx ){ + pWInfo->a[i].iCur = pParse->nTab++; + pWInfo->peakNTab = pParse->nTab; + } + } + + /* Check to see if the ORDER BY clause is or can be satisfied by the + ** use of an index on the first table. + */ + if( ppOrderBy && *ppOrderBy && pTabList->nSrc>0 ){ + Index *pSortIdx; + Index *pIdx; + Table *pTab; + int bRev = 0; + + pTab = pTabList->a[0].pTab; + pIdx = pWInfo->a[0].pIdx; + if( pIdx && pWInfo->a[0].score==4 ){ + /* If there is already an IN index on the left-most table, + ** it will not give the correct sort order. + ** So, pretend that no suitable index is found. + */ + pSortIdx = 0; + }else if( iDirectEq[0]>=0 || iDirectLt[0]>=0 || iDirectGt[0]>=0 ){ + /* If the left-most column is accessed using its ROWID, then do + ** not try to sort by index. + */ + pSortIdx = 0; + }else{ + int nEqCol = (pWInfo->a[0].score+4)/8; + pSortIdx = findSortingIndex(pTab, pTabList->a[0].iCursor, + *ppOrderBy, pIdx, nEqCol, &bRev); + } + if( pSortIdx && (pIdx==0 || pIdx==pSortIdx) ){ + if( pIdx==0 ){ + pWInfo->a[0].pIdx = pSortIdx; + pWInfo->a[0].iCur = pParse->nTab++; + pWInfo->peakNTab = pParse->nTab; + } + pWInfo->a[0].bRev = bRev; + *ppOrderBy = 0; + } + } + + /* Open all tables in the pTabList and all indices used by those tables. + */ + for(i=0; i<pTabList->nSrc; i++){ + Table *pTab; + Index *pIx; + + pTab = pTabList->a[i].pTab; + if( pTab->isTransient || pTab->pSelect ) continue; + sqliteVdbeAddOp(v, OP_Integer, pTab->iDb, 0); + sqliteVdbeOp3(v, OP_OpenRead, pTabList->a[i].iCursor, pTab->tnum, + pTab->zName, P3_STATIC); + sqliteCodeVerifySchema(pParse, pTab->iDb); + if( (pIx = pWInfo->a[i].pIdx)!=0 ){ + sqliteVdbeAddOp(v, OP_Integer, pIx->iDb, 0); + sqliteVdbeOp3(v, OP_OpenRead, pWInfo->a[i].iCur, pIx->tnum, pIx->zName,0); + } + } + + /* Generate the code to do the search + */ + loopMask = 0; + for(i=0; i<pTabList->nSrc; i++){ + int j, k; + int iCur = pTabList->a[i].iCursor; + Index *pIdx; + WhereLevel *pLevel = &pWInfo->a[i]; + + /* If this is the right table of a LEFT OUTER JOIN, allocate and + ** initialize a memory cell that records if this table matches any + ** row of the left table of the join. + */ + if( i>0 && (pTabList->a[i-1].jointype & JT_LEFT)!=0 ){ + if( !pParse->nMem ) pParse->nMem++; + pLevel->iLeftJoin = pParse->nMem++; + sqliteVdbeAddOp(v, OP_String, 0, 0); + sqliteVdbeAddOp(v, OP_MemStore, pLevel->iLeftJoin, 1); + } + + pIdx = pLevel->pIdx; + pLevel->inOp = OP_Noop; + if( i<ARRAYSIZE(iDirectEq) && iDirectEq[i]>=0 ){ + /* Case 1: We can directly reference a single row using an + ** equality comparison against the ROWID field. Or + ** we reference multiple rows using a "rowid IN (...)" + ** construct. + */ + k = iDirectEq[i]; + assert( k<nExpr ); + assert( aExpr[k].p!=0 ); + assert( aExpr[k].idxLeft==iCur || aExpr[k].idxRight==iCur ); + brk = pLevel->brk = sqliteVdbeMakeLabel(v); + if( aExpr[k].idxLeft==iCur ){ + Expr *pX = aExpr[k].p; + if( pX->op!=TK_IN ){ + sqliteExprCode(pParse, aExpr[k].p->pRight); + }else if( pX->pList ){ + sqliteVdbeAddOp(v, OP_SetFirst, pX->iTable, brk); + pLevel->inOp = OP_SetNext; + pLevel->inP1 = pX->iTable; + pLevel->inP2 = sqliteVdbeCurrentAddr(v); + }else{ + assert( pX->pSelect ); + sqliteVdbeAddOp(v, OP_Rewind, pX->iTable, brk); + sqliteVdbeAddOp(v, OP_KeyAsData, pX->iTable, 1); + pLevel->inP2 = sqliteVdbeAddOp(v, OP_FullKey, pX->iTable, 0); + pLevel->inOp = OP_Next; + pLevel->inP1 = pX->iTable; + } + }else{ + sqliteExprCode(pParse, aExpr[k].p->pLeft); + } + disableTerm(pLevel, &aExpr[k].p); + cont = pLevel->cont = sqliteVdbeMakeLabel(v); + sqliteVdbeAddOp(v, OP_MustBeInt, 1, brk); + haveKey = 0; + sqliteVdbeAddOp(v, OP_NotExists, iCur, brk); + pLevel->op = OP_Noop; + }else if( pIdx!=0 && pLevel->score>0 && pLevel->score%4==0 ){ + /* Case 2: There is an index and all terms of the WHERE clause that + ** refer to the index use the "==" or "IN" operators. + */ + int start; + int testOp; + int nColumn = (pLevel->score+4)/8; + brk = pLevel->brk = sqliteVdbeMakeLabel(v); + for(j=0; j<nColumn; j++){ + for(k=0; k<nExpr; k++){ + Expr *pX = aExpr[k].p; + if( pX==0 ) continue; + if( aExpr[k].idxLeft==iCur + && (aExpr[k].prereqRight & loopMask)==aExpr[k].prereqRight + && pX->pLeft->iColumn==pIdx->aiColumn[j] + ){ + if( pX->op==TK_EQ ){ + sqliteExprCode(pParse, pX->pRight); + disableTerm(pLevel, &aExpr[k].p); + break; + } + if( pX->op==TK_IN && nColumn==1 ){ + if( pX->pList ){ + sqliteVdbeAddOp(v, OP_SetFirst, pX->iTable, brk); + pLevel->inOp = OP_SetNext; + pLevel->inP1 = pX->iTable; + pLevel->inP2 = sqliteVdbeCurrentAddr(v); + }else{ + assert( pX->pSelect ); + sqliteVdbeAddOp(v, OP_Rewind, pX->iTable, brk); + sqliteVdbeAddOp(v, OP_KeyAsData, pX->iTable, 1); + pLevel->inP2 = sqliteVdbeAddOp(v, OP_FullKey, pX->iTable, 0); + pLevel->inOp = OP_Next; + pLevel->inP1 = pX->iTable; + } + disableTerm(pLevel, &aExpr[k].p); + break; + } + } + if( aExpr[k].idxRight==iCur + && aExpr[k].p->op==TK_EQ + && (aExpr[k].prereqLeft & loopMask)==aExpr[k].prereqLeft + && aExpr[k].p->pRight->iColumn==pIdx->aiColumn[j] + ){ + sqliteExprCode(pParse, aExpr[k].p->pLeft); + disableTerm(pLevel, &aExpr[k].p); + break; + } + } + } + pLevel->iMem = pParse->nMem++; + cont = pLevel->cont = sqliteVdbeMakeLabel(v); + sqliteVdbeAddOp(v, OP_NotNull, -nColumn, sqliteVdbeCurrentAddr(v)+3); + sqliteVdbeAddOp(v, OP_Pop, nColumn, 0); + sqliteVdbeAddOp(v, OP_Goto, 0, brk); + sqliteVdbeAddOp(v, OP_MakeKey, nColumn, 0); + sqliteAddIdxKeyType(v, pIdx); + if( nColumn==pIdx->nColumn || pLevel->bRev ){ + sqliteVdbeAddOp(v, OP_MemStore, pLevel->iMem, 0); + testOp = OP_IdxGT; + }else{ + sqliteVdbeAddOp(v, OP_Dup, 0, 0); + sqliteVdbeAddOp(v, OP_IncrKey, 0, 0); + sqliteVdbeAddOp(v, OP_MemStore, pLevel->iMem, 1); + testOp = OP_IdxGE; + } + if( pLevel->bRev ){ + /* Scan in reverse order */ + sqliteVdbeAddOp(v, OP_IncrKey, 0, 0); + sqliteVdbeAddOp(v, OP_MoveLt, pLevel->iCur, brk); + start = sqliteVdbeAddOp(v, OP_MemLoad, pLevel->iMem, 0); + sqliteVdbeAddOp(v, OP_IdxLT, pLevel->iCur, brk); + pLevel->op = OP_Prev; + }else{ + /* Scan in the forward order */ + sqliteVdbeAddOp(v, OP_MoveTo, pLevel->iCur, brk); + start = sqliteVdbeAddOp(v, OP_MemLoad, pLevel->iMem, 0); + sqliteVdbeAddOp(v, testOp, pLevel->iCur, brk); + pLevel->op = OP_Next; + } + sqliteVdbeAddOp(v, OP_RowKey, pLevel->iCur, 0); + sqliteVdbeAddOp(v, OP_IdxIsNull, nColumn, cont); + sqliteVdbeAddOp(v, OP_IdxRecno, pLevel->iCur, 0); + if( i==pTabList->nSrc-1 && pushKey ){ + haveKey = 1; + }else{ + sqliteVdbeAddOp(v, OP_MoveTo, iCur, 0); + haveKey = 0; + } + pLevel->p1 = pLevel->iCur; + pLevel->p2 = start; + }else if( i<ARRAYSIZE(iDirectLt) && (iDirectLt[i]>=0 || iDirectGt[i]>=0) ){ + /* Case 3: We have an inequality comparison against the ROWID field. + */ + int testOp = OP_Noop; + int start; + + brk = pLevel->brk = sqliteVdbeMakeLabel(v); + cont = pLevel->cont = sqliteVdbeMakeLabel(v); + if( iDirectGt[i]>=0 ){ + k = iDirectGt[i]; + assert( k<nExpr ); + assert( aExpr[k].p!=0 ); + assert( aExpr[k].idxLeft==iCur || aExpr[k].idxRight==iCur ); + if( aExpr[k].idxLeft==iCur ){ + sqliteExprCode(pParse, aExpr[k].p->pRight); + }else{ + sqliteExprCode(pParse, aExpr[k].p->pLeft); + } + sqliteVdbeAddOp(v, OP_ForceInt, + aExpr[k].p->op==TK_LT || aExpr[k].p->op==TK_GT, brk); + sqliteVdbeAddOp(v, OP_MoveTo, iCur, brk); + disableTerm(pLevel, &aExpr[k].p); + }else{ + sqliteVdbeAddOp(v, OP_Rewind, iCur, brk); + } + if( iDirectLt[i]>=0 ){ + k = iDirectLt[i]; + assert( k<nExpr ); + assert( aExpr[k].p!=0 ); + assert( aExpr[k].idxLeft==iCur || aExpr[k].idxRight==iCur ); + if( aExpr[k].idxLeft==iCur ){ + sqliteExprCode(pParse, aExpr[k].p->pRight); + }else{ + sqliteExprCode(pParse, aExpr[k].p->pLeft); + } + /* sqliteVdbeAddOp(v, OP_MustBeInt, 0, sqliteVdbeCurrentAddr(v)+1); */ + pLevel->iMem = pParse->nMem++; + sqliteVdbeAddOp(v, OP_MemStore, pLevel->iMem, 1); + if( aExpr[k].p->op==TK_LT || aExpr[k].p->op==TK_GT ){ + testOp = OP_Ge; + }else{ + testOp = OP_Gt; + } + disableTerm(pLevel, &aExpr[k].p); + } + start = sqliteVdbeCurrentAddr(v); + pLevel->op = OP_Next; + pLevel->p1 = iCur; + pLevel->p2 = start; + if( testOp!=OP_Noop ){ + sqliteVdbeAddOp(v, OP_Recno, iCur, 0); + sqliteVdbeAddOp(v, OP_MemLoad, pLevel->iMem, 0); + sqliteVdbeAddOp(v, testOp, 0, brk); + } + haveKey = 0; + }else if( pIdx==0 ){ + /* Case 4: There is no usable index. We must do a complete + ** scan of the entire database table. + */ + int start; + + brk = pLevel->brk = sqliteVdbeMakeLabel(v); + cont = pLevel->cont = sqliteVdbeMakeLabel(v); + sqliteVdbeAddOp(v, OP_Rewind, iCur, brk); + start = sqliteVdbeCurrentAddr(v); + pLevel->op = OP_Next; + pLevel->p1 = iCur; + pLevel->p2 = start; + haveKey = 0; + }else{ + /* Case 5: The WHERE clause term that refers to the right-most + ** column of the index is an inequality. For example, if + ** the index is on (x,y,z) and the WHERE clause is of the + ** form "x=5 AND y<10" then this case is used. Only the + ** right-most column can be an inequality - the rest must + ** use the "==" operator. + ** + ** This case is also used when there are no WHERE clause + ** constraints but an index is selected anyway, in order + ** to force the output order to conform to an ORDER BY. + */ + int score = pLevel->score; + int nEqColumn = score/8; + int start; + int leFlag, geFlag; + int testOp; + + /* Evaluate the equality constraints + */ + for(j=0; j<nEqColumn; j++){ + for(k=0; k<nExpr; k++){ + if( aExpr[k].p==0 ) continue; + if( aExpr[k].idxLeft==iCur + && aExpr[k].p->op==TK_EQ + && (aExpr[k].prereqRight & loopMask)==aExpr[k].prereqRight + && aExpr[k].p->pLeft->iColumn==pIdx->aiColumn[j] + ){ + sqliteExprCode(pParse, aExpr[k].p->pRight); + disableTerm(pLevel, &aExpr[k].p); + break; + } + if( aExpr[k].idxRight==iCur + && aExpr[k].p->op==TK_EQ + && (aExpr[k].prereqLeft & loopMask)==aExpr[k].prereqLeft + && aExpr[k].p->pRight->iColumn==pIdx->aiColumn[j] + ){ + sqliteExprCode(pParse, aExpr[k].p->pLeft); + disableTerm(pLevel, &aExpr[k].p); + break; + } + } + } + + /* Duplicate the equality term values because they will all be + ** used twice: once to make the termination key and once to make the + ** start key. + */ + for(j=0; j<nEqColumn; j++){ + sqliteVdbeAddOp(v, OP_Dup, nEqColumn-1, 0); + } + + /* Labels for the beginning and end of the loop + */ + cont = pLevel->cont = sqliteVdbeMakeLabel(v); + brk = pLevel->brk = sqliteVdbeMakeLabel(v); + + /* Generate the termination key. This is the key value that + ** will end the search. There is no termination key if there + ** are no equality terms and no "X<..." term. + ** + ** 2002-Dec-04: On a reverse-order scan, the so-called "termination" + ** key computed here really ends up being the start key. + */ + if( (score & 1)!=0 ){ + for(k=0; k<nExpr; k++){ + Expr *pExpr = aExpr[k].p; + if( pExpr==0 ) continue; + if( aExpr[k].idxLeft==iCur + && (pExpr->op==TK_LT || pExpr->op==TK_LE) + && (aExpr[k].prereqRight & loopMask)==aExpr[k].prereqRight + && pExpr->pLeft->iColumn==pIdx->aiColumn[j] + ){ + sqliteExprCode(pParse, pExpr->pRight); + leFlag = pExpr->op==TK_LE; + disableTerm(pLevel, &aExpr[k].p); + break; + } + if( aExpr[k].idxRight==iCur + && (pExpr->op==TK_GT || pExpr->op==TK_GE) + && (aExpr[k].prereqLeft & loopMask)==aExpr[k].prereqLeft + && pExpr->pRight->iColumn==pIdx->aiColumn[j] + ){ + sqliteExprCode(pParse, pExpr->pLeft); + leFlag = pExpr->op==TK_GE; + disableTerm(pLevel, &aExpr[k].p); + break; + } + } + testOp = OP_IdxGE; + }else{ + testOp = nEqColumn>0 ? OP_IdxGE : OP_Noop; + leFlag = 1; + } + if( testOp!=OP_Noop ){ + int nCol = nEqColumn + (score & 1); + pLevel->iMem = pParse->nMem++; + sqliteVdbeAddOp(v, OP_NotNull, -nCol, sqliteVdbeCurrentAddr(v)+3); + sqliteVdbeAddOp(v, OP_Pop, nCol, 0); + sqliteVdbeAddOp(v, OP_Goto, 0, brk); + sqliteVdbeAddOp(v, OP_MakeKey, nCol, 0); + sqliteAddIdxKeyType(v, pIdx); + if( leFlag ){ + sqliteVdbeAddOp(v, OP_IncrKey, 0, 0); + } + if( pLevel->bRev ){ + sqliteVdbeAddOp(v, OP_MoveLt, pLevel->iCur, brk); + }else{ + sqliteVdbeAddOp(v, OP_MemStore, pLevel->iMem, 1); + } + }else if( pLevel->bRev ){ + sqliteVdbeAddOp(v, OP_Last, pLevel->iCur, brk); + } + + /* Generate the start key. This is the key that defines the lower + ** bound on the search. There is no start key if there are no + ** equality terms and if there is no "X>..." term. In + ** that case, generate a "Rewind" instruction in place of the + ** start key search. + ** + ** 2002-Dec-04: In the case of a reverse-order search, the so-called + ** "start" key really ends up being used as the termination key. + */ + if( (score & 2)!=0 ){ + for(k=0; k<nExpr; k++){ + Expr *pExpr = aExpr[k].p; + if( pExpr==0 ) continue; + if( aExpr[k].idxLeft==iCur + && (pExpr->op==TK_GT || pExpr->op==TK_GE) + && (aExpr[k].prereqRight & loopMask)==aExpr[k].prereqRight + && pExpr->pLeft->iColumn==pIdx->aiColumn[j] + ){ + sqliteExprCode(pParse, pExpr->pRight); + geFlag = pExpr->op==TK_GE; + disableTerm(pLevel, &aExpr[k].p); + break; + } + if( aExpr[k].idxRight==iCur + && (pExpr->op==TK_LT || pExpr->op==TK_LE) + && (aExpr[k].prereqLeft & loopMask)==aExpr[k].prereqLeft + && pExpr->pRight->iColumn==pIdx->aiColumn[j] + ){ + sqliteExprCode(pParse, pExpr->pLeft); + geFlag = pExpr->op==TK_LE; + disableTerm(pLevel, &aExpr[k].p); + break; + } + } + }else{ + geFlag = 1; + } + if( nEqColumn>0 || (score&2)!=0 ){ + int nCol = nEqColumn + ((score&2)!=0); + sqliteVdbeAddOp(v, OP_NotNull, -nCol, sqliteVdbeCurrentAddr(v)+3); + sqliteVdbeAddOp(v, OP_Pop, nCol, 0); + sqliteVdbeAddOp(v, OP_Goto, 0, brk); + sqliteVdbeAddOp(v, OP_MakeKey, nCol, 0); + sqliteAddIdxKeyType(v, pIdx); + if( !geFlag ){ + sqliteVdbeAddOp(v, OP_IncrKey, 0, 0); + } + if( pLevel->bRev ){ + pLevel->iMem = pParse->nMem++; + sqliteVdbeAddOp(v, OP_MemStore, pLevel->iMem, 1); + testOp = OP_IdxLT; + }else{ + sqliteVdbeAddOp(v, OP_MoveTo, pLevel->iCur, brk); + } + }else if( pLevel->bRev ){ + testOp = OP_Noop; + }else{ + sqliteVdbeAddOp(v, OP_Rewind, pLevel->iCur, brk); + } + + /* Generate the the top of the loop. If there is a termination + ** key we have to test for that key and abort at the top of the + ** loop. + */ + start = sqliteVdbeCurrentAddr(v); + if( testOp!=OP_Noop ){ + sqliteVdbeAddOp(v, OP_MemLoad, pLevel->iMem, 0); + sqliteVdbeAddOp(v, testOp, pLevel->iCur, brk); + } + sqliteVdbeAddOp(v, OP_RowKey, pLevel->iCur, 0); + sqliteVdbeAddOp(v, OP_IdxIsNull, nEqColumn + (score & 1), cont); + sqliteVdbeAddOp(v, OP_IdxRecno, pLevel->iCur, 0); + if( i==pTabList->nSrc-1 && pushKey ){ + haveKey = 1; + }else{ + sqliteVdbeAddOp(v, OP_MoveTo, iCur, 0); + haveKey = 0; + } + + /* Record the instruction used to terminate the loop. + */ + pLevel->op = pLevel->bRev ? OP_Prev : OP_Next; + pLevel->p1 = pLevel->iCur; + pLevel->p2 = start; + } + loopMask |= getMask(&maskSet, iCur); + + /* Insert code to test every subexpression that can be completely + ** computed using the current set of tables. + */ + for(j=0; j<nExpr; j++){ + if( aExpr[j].p==0 ) continue; + if( (aExpr[j].prereqAll & loopMask)!=aExpr[j].prereqAll ) continue; + if( pLevel->iLeftJoin && !ExprHasProperty(aExpr[j].p,EP_FromJoin) ){ + continue; + } + if( haveKey ){ + haveKey = 0; + sqliteVdbeAddOp(v, OP_MoveTo, iCur, 0); + } + sqliteExprIfFalse(pParse, aExpr[j].p, cont, 1); + aExpr[j].p = 0; + } + brk = cont; + + /* For a LEFT OUTER JOIN, generate code that will record the fact that + ** at least one row of the right table has matched the left table. + */ + if( pLevel->iLeftJoin ){ + pLevel->top = sqliteVdbeCurrentAddr(v); + sqliteVdbeAddOp(v, OP_Integer, 1, 0); + sqliteVdbeAddOp(v, OP_MemStore, pLevel->iLeftJoin, 1); + for(j=0; j<nExpr; j++){ + if( aExpr[j].p==0 ) continue; + if( (aExpr[j].prereqAll & loopMask)!=aExpr[j].prereqAll ) continue; + if( haveKey ){ + /* Cannot happen. "haveKey" can only be true if pushKey is true + ** an pushKey can only be true for DELETE and UPDATE and there are + ** no outer joins with DELETE and UPDATE. + */ + haveKey = 0; + sqliteVdbeAddOp(v, OP_MoveTo, iCur, 0); + } + sqliteExprIfFalse(pParse, aExpr[j].p, cont, 1); + aExpr[j].p = 0; + } + } + } + pWInfo->iContinue = cont; + if( pushKey && !haveKey ){ + sqliteVdbeAddOp(v, OP_Recno, pTabList->a[0].iCursor, 0); + } + freeMaskSet(&maskSet); + return pWInfo; +} + +/* +** Generate the end of the WHERE loop. See comments on +** sqliteWhereBegin() for additional information. +*/ +void sqliteWhereEnd(WhereInfo *pWInfo){ + Vdbe *v = pWInfo->pParse->pVdbe; + int i; + WhereLevel *pLevel; + SrcList *pTabList = pWInfo->pTabList; + + for(i=pTabList->nSrc-1; i>=0; i--){ + pLevel = &pWInfo->a[i]; + sqliteVdbeResolveLabel(v, pLevel->cont); + if( pLevel->op!=OP_Noop ){ + sqliteVdbeAddOp(v, pLevel->op, pLevel->p1, pLevel->p2); + } + sqliteVdbeResolveLabel(v, pLevel->brk); + if( pLevel->inOp!=OP_Noop ){ + sqliteVdbeAddOp(v, pLevel->inOp, pLevel->inP1, pLevel->inP2); + } + if( pLevel->iLeftJoin ){ + int addr; + addr = sqliteVdbeAddOp(v, OP_MemLoad, pLevel->iLeftJoin, 0); + sqliteVdbeAddOp(v, OP_NotNull, 1, addr+4 + (pLevel->iCur>=0)); + sqliteVdbeAddOp(v, OP_NullRow, pTabList->a[i].iCursor, 0); + if( pLevel->iCur>=0 ){ + sqliteVdbeAddOp(v, OP_NullRow, pLevel->iCur, 0); + } + sqliteVdbeAddOp(v, OP_Goto, 0, pLevel->top); + } + } + sqliteVdbeResolveLabel(v, pWInfo->iBreak); + for(i=0; i<pTabList->nSrc; i++){ + Table *pTab = pTabList->a[i].pTab; + assert( pTab!=0 ); + if( pTab->isTransient || pTab->pSelect ) continue; + pLevel = &pWInfo->a[i]; + sqliteVdbeAddOp(v, OP_Close, pTabList->a[i].iCursor, 0); + if( pLevel->pIdx!=0 ){ + sqliteVdbeAddOp(v, OP_Close, pLevel->iCur, 0); + } + } +#if 0 /* Never reuse a cursor */ + if( pWInfo->pParse->nTab==pWInfo->peakNTab ){ + pWInfo->pParse->nTab = pWInfo->savedNTab; + } +#endif + sqliteFree(pWInfo); + return; +} diff --git a/kexi/3rdparty/kexisql/tool/Makefile.am b/kexi/3rdparty/kexisql/tool/Makefile.am new file mode 100644 index 00000000..1e5bd027 --- /dev/null +++ b/kexi/3rdparty/kexisql/tool/Makefile.am @@ -0,0 +1 @@ +#add something here ;) diff --git a/kexi/3rdparty/kexisql/tool/diffdb.c b/kexi/3rdparty/kexisql/tool/diffdb.c new file mode 100644 index 00000000..0537d387 --- /dev/null +++ b/kexi/3rdparty/kexisql/tool/diffdb.c @@ -0,0 +1,44 @@ +/* +** A utility for printing the differences between two SQLite database files. +*/ +#include <stdio.h> +#include <ctype.h> +#include <sys/types.h> +#include <sys/stat.h> +#include <fcntl.h> +#include <unistd.h> +#include <stdlib.h> + + +#define PAGESIZE 1024 +static int db1 = -1; +static int db2 = -1; + +int main(int argc, char **argv){ + int iPg; + unsigned char a1[PAGESIZE], a2[PAGESIZE]; + if( argc!=3 ){ + fprintf(stderr,"Usage: %s FILENAME FILENAME\n", argv[0]); + exit(1); + } + db1 = open(argv[1], O_RDONLY); + if( db1<0 ){ + fprintf(stderr,"%s: can't open %s\n", argv[0], argv[1]); + exit(1); + } + db2 = open(argv[2], O_RDONLY); + if( db2<0 ){ + fprintf(stderr,"%s: can't open %s\n", argv[0], argv[2]); + exit(1); + } + iPg = 1; + while( read(db1, a1, PAGESIZE)==PAGESIZE && read(db2,a2,PAGESIZE)==PAGESIZE ){ + if( memcmp(a1,a2,PAGESIZE) ){ + printf("Page %d\n", iPg); + } + iPg++; + } + printf("%d pages checked\n", iPg-1); + close(db1); + close(db2); +} diff --git a/kexi/3rdparty/kexisql/tool/lemon.c b/kexi/3rdparty/kexisql/tool/lemon.c new file mode 100644 index 00000000..b801e6b3 --- /dev/null +++ b/kexi/3rdparty/kexisql/tool/lemon.c @@ -0,0 +1,4117 @@ +/* +** This file contains all sources (including headers) to the LEMON +** LALR(1) parser generator. The sources have been combined into a +** single file to make it easy to include LEMON in the source tree +** and Makefile of another program. +** +** The author of this program disclaims copyright. +*/ +#include <stdio.h> +#include <stdarg.h> +#include <string.h> +#include <ctype.h> + +extern void qsort(); +extern double strtod(); +extern long strtol(); +extern void free(); +extern int access(); +extern int atoi(); + +#ifndef __WIN32__ +# if defined(_WIN32) || defined(WIN32) +# define __WIN32__ +# endif +#endif + +/* #define PRIVATE static */ +#define PRIVATE + +#ifdef TEST +#define MAXRHS 5 /* Set low to exercise exception code */ +#else +#define MAXRHS 1000 +#endif + +char *msort(); +extern void *malloc(); + +/******** From the file "action.h" *************************************/ +struct action *Action_new(); +struct action *Action_sort(); +void Action_add(); + +/********* From the file "assert.h" ************************************/ +void myassert(); +#ifndef NDEBUG +# define assert(X) if(!(X))myassert(__FILE__,__LINE__) +#else +# define assert(X) +#endif + +/********** From the file "build.h" ************************************/ +void FindRulePrecedences(); +void FindFirstSets(); +void FindStates(); +void FindLinks(); +void FindFollowSets(); +void FindActions(); + +/********* From the file "configlist.h" *********************************/ +void Configlist_init(/* void */); +struct config *Configlist_add(/* struct rule *, int */); +struct config *Configlist_addbasis(/* struct rule *, int */); +void Configlist_closure(/* void */); +void Configlist_sort(/* void */); +void Configlist_sortbasis(/* void */); +struct config *Configlist_return(/* void */); +struct config *Configlist_basis(/* void */); +void Configlist_eat(/* struct config * */); +void Configlist_reset(/* void */); + +/********* From the file "error.h" ***************************************/ +void ErrorMsg(const char *, int,const char *, ...); + +/****** From the file "option.h" ******************************************/ +struct s_options { + enum { OPT_FLAG=1, OPT_INT, OPT_DBL, OPT_STR, + OPT_FFLAG, OPT_FINT, OPT_FDBL, OPT_FSTR} type; + char *label; + char *arg; + char *message; +}; +int OptInit(/* char**,struct s_options*,FILE* */); +int OptNArgs(/* void */); +char *OptArg(/* int */); +void OptErr(/* int */); +void OptPrint(/* void */); + +/******** From the file "parse.h" *****************************************/ +void Parse(/* struct lemon *lemp */); + +/********* From the file "plink.h" ***************************************/ +struct plink *Plink_new(/* void */); +void Plink_add(/* struct plink **, struct config * */); +void Plink_copy(/* struct plink **, struct plink * */); +void Plink_delete(/* struct plink * */); + +/********** From the file "report.h" *************************************/ +void Reprint(/* struct lemon * */); +void ReportOutput(/* struct lemon * */); +void ReportTable(/* struct lemon * */); +void ReportHeader(/* struct lemon * */); +void CompressTables(/* struct lemon * */); + +/********** From the file "set.h" ****************************************/ +void SetSize(/* int N */); /* All sets will be of size N */ +char *SetNew(/* void */); /* A new set for element 0..N */ +void SetFree(/* char* */); /* Deallocate a set */ + +int SetAdd(/* char*,int */); /* Add element to a set */ +int SetUnion(/* char *A,char *B */); /* A <- A U B, thru element N */ + +#define SetFind(X,Y) (X[Y]) /* True if Y is in set X */ + +/********** From the file "struct.h" *************************************/ +/* +** Principal data structures for the LEMON parser generator. +*/ + +typedef enum {B_FALSE=0, B_TRUE} Boolean; + +/* Symbols (terminals and nonterminals) of the grammar are stored +** in the following: */ +struct symbol { + char *name; /* Name of the symbol */ + int index; /* Index number for this symbol */ + enum { + TERMINAL, + NONTERMINAL + } type; /* Symbols are all either TERMINALS or NTs */ + struct rule *rule; /* Linked list of rules of this (if an NT) */ + struct symbol *fallback; /* fallback token in case this token doesn't parse */ + int prec; /* Precedence if defined (-1 otherwise) */ + enum e_assoc { + LEFT, + RIGHT, + NONE, + UNK + } assoc; /* Associativity if predecence is defined */ + char *firstset; /* First-set for all rules of this symbol */ + Boolean lambda; /* True if NT and can generate an empty string */ + char *destructor; /* Code which executes whenever this symbol is + ** popped from the stack during error processing */ + int destructorln; /* Line number of destructor code */ + char *datatype; /* The data type of information held by this + ** object. Only used if type==NONTERMINAL */ + int dtnum; /* The data type number. In the parser, the value + ** stack is a union. The .yy%d element of this + ** union is the correct data type for this object */ +}; + +/* Each production rule in the grammar is stored in the following +** structure. */ +struct rule { + struct symbol *lhs; /* Left-hand side of the rule */ + char *lhsalias; /* Alias for the LHS (NULL if none) */ + int ruleline; /* Line number for the rule */ + int nrhs; /* Number of RHS symbols */ + struct symbol **rhs; /* The RHS symbols */ + char **rhsalias; /* An alias for each RHS symbol (NULL if none) */ + int line; /* Line number at which code begins */ + char *code; /* The code executed when this rule is reduced */ + struct symbol *precsym; /* Precedence symbol for this rule */ + int index; /* An index number for this rule */ + Boolean canReduce; /* True if this rule is ever reduced */ + struct rule *nextlhs; /* Next rule with the same LHS */ + struct rule *next; /* Next rule in the global list */ +}; + +/* A configuration is a production rule of the grammar together with +** a mark (dot) showing how much of that rule has been processed so far. +** Configurations also contain a follow-set which is a list of terminal +** symbols which are allowed to immediately follow the end of the rule. +** Every configuration is recorded as an instance of the following: */ +struct config { + struct rule *rp; /* The rule upon which the configuration is based */ + int dot; /* The parse point */ + char *fws; /* Follow-set for this configuration only */ + struct plink *fplp; /* Follow-set forward propagation links */ + struct plink *bplp; /* Follow-set backwards propagation links */ + struct state *stp; /* Pointer to state which contains this */ + enum { + COMPLETE, /* The status is used during followset and */ + INCOMPLETE /* shift computations */ + } status; + struct config *next; /* Next configuration in the state */ + struct config *bp; /* The next basis configuration */ +}; + +/* Every shift or reduce operation is stored as one of the following */ +struct action { + struct symbol *sp; /* The look-ahead symbol */ + enum e_action { + SHIFT, + ACCEPT, + REDUCE, + ERROR, + CONFLICT, /* Was a reduce, but part of a conflict */ + SH_RESOLVED, /* Was a shift. Precedence resolved conflict */ + RD_RESOLVED, /* Was reduce. Precedence resolved conflict */ + NOT_USED /* Deleted by compression */ + } type; + union { + struct state *stp; /* The new state, if a shift */ + struct rule *rp; /* The rule, if a reduce */ + } x; + struct action *next; /* Next action for this state */ + struct action *collide; /* Next action with the same hash */ +}; + +/* Each state of the generated parser's finite state machine +** is encoded as an instance of the following structure. */ +struct state { + struct config *bp; /* The basis configurations for this state */ + struct config *cfp; /* All configurations in this set */ + int index; /* Sequencial number for this state */ + struct action *ap; /* Array of actions for this state */ + int naction; /* Number of actions for this state */ + int tabstart; /* First index of the action table */ + int tabdfltact; /* Default action */ +}; + +/* A followset propagation link indicates that the contents of one +** configuration followset should be propagated to another whenever +** the first changes. */ +struct plink { + struct config *cfp; /* The configuration to which linked */ + struct plink *next; /* The next propagate link */ +}; + +/* The state vector for the entire parser generator is recorded as +** follows. (LEMON uses no global variables and makes little use of +** static variables. Fields in the following structure can be thought +** of as begin global variables in the program.) */ +struct lemon { + struct state **sorted; /* Table of states sorted by state number */ + struct rule *rule; /* List of all rules */ + int nstate; /* Number of states */ + int nrule; /* Number of rules */ + int nsymbol; /* Number of terminal and nonterminal symbols */ + int nterminal; /* Number of terminal symbols */ + struct symbol **symbols; /* Sorted array of pointers to symbols */ + int errorcnt; /* Number of errors */ + struct symbol *errsym; /* The error symbol */ + char *name; /* Name of the generated parser */ + char *arg; /* Declaration of the 3th argument to parser */ + char *tokentype; /* Type of terminal symbols in the parser stack */ + char *vartype; /* The default type of non-terminal symbols */ + char *start; /* Name of the start symbol for the grammar */ + char *stacksize; /* Size of the parser stack */ + char *include; /* Code to put at the start of the C file */ + int includeln; /* Line number for start of include code */ + char *error; /* Code to execute when an error is seen */ + int errorln; /* Line number for start of error code */ + char *overflow; /* Code to execute on a stack overflow */ + int overflowln; /* Line number for start of overflow code */ + char *failure; /* Code to execute on parser failure */ + int failureln; /* Line number for start of failure code */ + char *accept; /* Code to execute when the parser excepts */ + int acceptln; /* Line number for the start of accept code */ + char *extracode; /* Code appended to the generated file */ + int extracodeln; /* Line number for the start of the extra code */ + char *tokendest; /* Code to execute to destroy token data */ + int tokendestln; /* Line number for token destroyer code */ + char *vardest; /* Code for the default non-terminal destructor */ + int vardestln; /* Line number for default non-term destructor code*/ + char *filename; /* Name of the input file */ + char *outname; /* Name of the current output file */ + char *tokenprefix; /* A prefix added to token names in the .h file */ + int nconflict; /* Number of parsing conflicts */ + int tablesize; /* Size of the parse tables */ + int basisflag; /* Print only basis configurations */ + int has_fallback; /* True if any %fallback is seen in the grammer */ + char *argv0; /* Name of the program */ +}; + +#define MemoryCheck(X) if((X)==0){ \ + extern void memory_error(); \ + memory_error(); \ +} + +/**************** From the file "table.h" *********************************/ +/* +** All code in this file has been automatically generated +** from a specification in the file +** "table.q" +** by the associative array code building program "aagen". +** Do not edit this file! Instead, edit the specification +** file, then rerun aagen. +*/ +/* +** Code for processing tables in the LEMON parser generator. +*/ + +/* Routines for handling a strings */ + +char *Strsafe(); + +void Strsafe_init(/* void */); +int Strsafe_insert(/* char * */); +char *Strsafe_find(/* char * */); + +/* Routines for handling symbols of the grammar */ + +struct symbol *Symbol_new(); +int Symbolcmpp(/* struct symbol **, struct symbol ** */); +void Symbol_init(/* void */); +int Symbol_insert(/* struct symbol *, char * */); +struct symbol *Symbol_find(/* char * */); +struct symbol *Symbol_Nth(/* int */); +int Symbol_count(/* */); +struct symbol **Symbol_arrayof(/* */); + +/* Routines to manage the state table */ + +int Configcmp(/* struct config *, struct config * */); +struct state *State_new(); +void State_init(/* void */); +int State_insert(/* struct state *, struct config * */); +struct state *State_find(/* struct config * */); +struct state **State_arrayof(/* */); + +/* Routines used for efficiency in Configlist_add */ + +void Configtable_init(/* void */); +int Configtable_insert(/* struct config * */); +struct config *Configtable_find(/* struct config * */); +void Configtable_clear(/* int(*)(struct config *) */); +/****************** From the file "action.c" *******************************/ +/* +** Routines processing parser actions in the LEMON parser generator. +*/ + +/* Allocate a new parser action */ +struct action *Action_new(){ + static struct action *freelist = 0; + struct action *new; + + if( freelist==0 ){ + int i; + int amt = 100; + freelist = (struct action *)malloc( sizeof(struct action)*amt ); + if( freelist==0 ){ + fprintf(stderr,"Unable to allocate memory for a new parser action."); + exit(1); + } + for(i=0; i<amt-1; i++) freelist[i].next = &freelist[i+1]; + freelist[amt-1].next = 0; + } + new = freelist; + freelist = freelist->next; + return new; +} + +/* Compare two actions */ +static int actioncmp(ap1,ap2) +struct action *ap1; +struct action *ap2; +{ + int rc; + rc = ap1->sp->index - ap2->sp->index; + if( rc==0 ) rc = (int)ap1->type - (int)ap2->type; + if( rc==0 ){ + assert( ap1->type==REDUCE || ap1->type==RD_RESOLVED || ap1->type==CONFLICT); + assert( ap2->type==REDUCE || ap2->type==RD_RESOLVED || ap2->type==CONFLICT); + rc = ap1->x.rp->index - ap2->x.rp->index; + } + return rc; +} + +/* Sort parser actions */ +struct action *Action_sort(ap) +struct action *ap; +{ + ap = (struct action *)msort(ap,&ap->next,actioncmp); + return ap; +} + +void Action_add(app,type,sp,arg) +struct action **app; +enum e_action type; +struct symbol *sp; +char *arg; +{ + struct action *new; + new = Action_new(); + new->next = *app; + *app = new; + new->type = type; + new->sp = sp; + if( type==SHIFT ){ + new->x.stp = (struct state *)arg; + }else{ + new->x.rp = (struct rule *)arg; + } +} +/********************** From the file "assert.c" ****************************/ +/* +** A more efficient way of handling assertions. +*/ +void myassert(file,line) +char *file; +int line; +{ + fprintf(stderr,"Assertion failed on line %d of file \"%s\"\n",line,file); + exit(1); +} +/********************** From the file "build.c" *****************************/ +/* +** Routines to construction the finite state machine for the LEMON +** parser generator. +*/ + +/* Find a precedence symbol of every rule in the grammar. +** +** Those rules which have a precedence symbol coded in the input +** grammar using the "[symbol]" construct will already have the +** rp->precsym field filled. Other rules take as their precedence +** symbol the first RHS symbol with a defined precedence. If there +** are not RHS symbols with a defined precedence, the precedence +** symbol field is left blank. +*/ +void FindRulePrecedences(xp) +struct lemon *xp; +{ + struct rule *rp; + for(rp=xp->rule; rp; rp=rp->next){ + if( rp->precsym==0 ){ + int i; + for(i=0; i<rp->nrhs; i++){ + if( rp->rhs[i]->prec>=0 ){ + rp->precsym = rp->rhs[i]; + break; + } + } + } + } + return; +} + +/* Find all nonterminals which will generate the empty string. +** Then go back and compute the first sets of every nonterminal. +** The first set is the set of all terminal symbols which can begin +** a string generated by that nonterminal. +*/ +void FindFirstSets(lemp) +struct lemon *lemp; +{ + int i; + struct rule *rp; + int progress; + + for(i=0; i<lemp->nsymbol; i++){ + lemp->symbols[i]->lambda = B_FALSE; + } + for(i=lemp->nterminal; i<lemp->nsymbol; i++){ + lemp->symbols[i]->firstset = SetNew(); + } + + /* First compute all lambdas */ + do{ + progress = 0; + for(rp=lemp->rule; rp; rp=rp->next){ + if( rp->lhs->lambda ) continue; + for(i=0; i<rp->nrhs; i++){ + if( rp->rhs[i]->lambda==B_FALSE ) break; + } + if( i==rp->nrhs ){ + rp->lhs->lambda = B_TRUE; + progress = 1; + } + } + }while( progress ); + + /* Now compute all first sets */ + do{ + struct symbol *s1, *s2; + progress = 0; + for(rp=lemp->rule; rp; rp=rp->next){ + s1 = rp->lhs; + for(i=0; i<rp->nrhs; i++){ + s2 = rp->rhs[i]; + if( s2->type==TERMINAL ){ + progress += SetAdd(s1->firstset,s2->index); + break; + }else if( s1==s2 ){ + if( s1->lambda==B_FALSE ) break; + }else{ + progress += SetUnion(s1->firstset,s2->firstset); + if( s2->lambda==B_FALSE ) break; + } + } + } + }while( progress ); + return; +} + +/* Compute all LR(0) states for the grammar. Links +** are added to between some states so that the LR(1) follow sets +** can be computed later. +*/ +PRIVATE struct state *getstate(/* struct lemon * */); /* forward reference */ +void FindStates(lemp) +struct lemon *lemp; +{ + struct symbol *sp; + struct rule *rp; + + Configlist_init(); + + /* Find the start symbol */ + if( lemp->start ){ + sp = Symbol_find(lemp->start); + if( sp==0 ){ + ErrorMsg(lemp->filename,0, +"The specified start symbol \"%s\" is not \ +in a nonterminal of the grammar. \"%s\" will be used as the start \ +symbol instead.",lemp->start,lemp->rule->lhs->name); + lemp->errorcnt++; + sp = lemp->rule->lhs; + } + }else{ + sp = lemp->rule->lhs; + } + + /* Make sure the start symbol doesn't occur on the right-hand side of + ** any rule. Report an error if it does. (YACC would generate a new + ** start symbol in this case.) */ + for(rp=lemp->rule; rp; rp=rp->next){ + int i; + for(i=0; i<rp->nrhs; i++){ + if( rp->rhs[i]==sp ){ + ErrorMsg(lemp->filename,0, +"The start symbol \"%s\" occurs on the \ +right-hand side of a rule. This will result in a parser which \ +does not work properly.",sp->name); + lemp->errorcnt++; + } + } + } + + /* The basis configuration set for the first state + ** is all rules which have the start symbol as their + ** left-hand side */ + for(rp=sp->rule; rp; rp=rp->nextlhs){ + struct config *newcfp; + newcfp = Configlist_addbasis(rp,0); + SetAdd(newcfp->fws,0); + } + + /* Compute the first state. All other states will be + ** computed automatically during the computation of the first one. + ** The returned pointer to the first state is not used. */ + (void)getstate(lemp); + return; +} + +/* Return a pointer to a state which is described by the configuration +** list which has been built from calls to Configlist_add. +*/ +PRIVATE void buildshifts(/* struct lemon *, struct state * */); /* Forwd ref */ +PRIVATE struct state *getstate(lemp) +struct lemon *lemp; +{ + struct config *cfp, *bp; + struct state *stp; + + /* Extract the sorted basis of the new state. The basis was constructed + ** by prior calls to "Configlist_addbasis()". */ + Configlist_sortbasis(); + bp = Configlist_basis(); + + /* Get a state with the same basis */ + stp = State_find(bp); + if( stp ){ + /* A state with the same basis already exists! Copy all the follow-set + ** propagation links from the state under construction into the + ** preexisting state, then return a pointer to the preexisting state */ + struct config *x, *y; + for(x=bp, y=stp->bp; x && y; x=x->bp, y=y->bp){ + Plink_copy(&y->bplp,x->bplp); + Plink_delete(x->fplp); + x->fplp = x->bplp = 0; + } + cfp = Configlist_return(); + Configlist_eat(cfp); + }else{ + /* This really is a new state. Construct all the details */ + Configlist_closure(lemp); /* Compute the configuration closure */ + Configlist_sort(); /* Sort the configuration closure */ + cfp = Configlist_return(); /* Get a pointer to the config list */ + stp = State_new(); /* A new state structure */ + MemoryCheck(stp); + stp->bp = bp; /* Remember the configuration basis */ + stp->cfp = cfp; /* Remember the configuration closure */ + stp->index = lemp->nstate++; /* Every state gets a sequence number */ + stp->ap = 0; /* No actions, yet. */ + State_insert(stp,stp->bp); /* Add to the state table */ + buildshifts(lemp,stp); /* Recursively compute successor states */ + } + return stp; +} + +/* Construct all successor states to the given state. A "successor" +** state is any state which can be reached by a shift action. +*/ +PRIVATE void buildshifts(lemp,stp) +struct lemon *lemp; +struct state *stp; /* The state from which successors are computed */ +{ + struct config *cfp; /* For looping thru the config closure of "stp" */ + struct config *bcfp; /* For the inner loop on config closure of "stp" */ + struct config *new; /* */ + struct symbol *sp; /* Symbol following the dot in configuration "cfp" */ + struct symbol *bsp; /* Symbol following the dot in configuration "bcfp" */ + struct state *newstp; /* A pointer to a successor state */ + + /* Each configuration becomes complete after it contibutes to a successor + ** state. Initially, all configurations are incomplete */ + for(cfp=stp->cfp; cfp; cfp=cfp->next) cfp->status = INCOMPLETE; + + /* Loop through all configurations of the state "stp" */ + for(cfp=stp->cfp; cfp; cfp=cfp->next){ + if( cfp->status==COMPLETE ) continue; /* Already used by inner loop */ + if( cfp->dot>=cfp->rp->nrhs ) continue; /* Can't shift this config */ + Configlist_reset(); /* Reset the new config set */ + sp = cfp->rp->rhs[cfp->dot]; /* Symbol after the dot */ + + /* For every configuration in the state "stp" which has the symbol "sp" + ** following its dot, add the same configuration to the basis set under + ** construction but with the dot shifted one symbol to the right. */ + for(bcfp=cfp; bcfp; bcfp=bcfp->next){ + if( bcfp->status==COMPLETE ) continue; /* Already used */ + if( bcfp->dot>=bcfp->rp->nrhs ) continue; /* Can't shift this one */ + bsp = bcfp->rp->rhs[bcfp->dot]; /* Get symbol after dot */ + if( bsp!=sp ) continue; /* Must be same as for "cfp" */ + bcfp->status = COMPLETE; /* Mark this config as used */ + new = Configlist_addbasis(bcfp->rp,bcfp->dot+1); + Plink_add(&new->bplp,bcfp); + } + + /* Get a pointer to the state described by the basis configuration set + ** constructed in the preceding loop */ + newstp = getstate(lemp); + + /* The state "newstp" is reached from the state "stp" by a shift action + ** on the symbol "sp" */ + Action_add(&stp->ap,SHIFT,sp,newstp); + } +} + +/* +** Construct the propagation links +*/ +void FindLinks(lemp) +struct lemon *lemp; +{ + int i; + struct config *cfp, *other; + struct state *stp; + struct plink *plp; + + /* Housekeeping detail: + ** Add to every propagate link a pointer back to the state to + ** which the link is attached. */ + for(i=0; i<lemp->nstate; i++){ + stp = lemp->sorted[i]; + for(cfp=stp->cfp; cfp; cfp=cfp->next){ + cfp->stp = stp; + } + } + + /* Convert all backlinks into forward links. Only the forward + ** links are used in the follow-set computation. */ + for(i=0; i<lemp->nstate; i++){ + stp = lemp->sorted[i]; + for(cfp=stp->cfp; cfp; cfp=cfp->next){ + for(plp=cfp->bplp; plp; plp=plp->next){ + other = plp->cfp; + Plink_add(&other->fplp,cfp); + } + } + } +} + +/* Compute all followsets. +** +** A followset is the set of all symbols which can come immediately +** after a configuration. +*/ +void FindFollowSets(lemp) +struct lemon *lemp; +{ + int i; + struct config *cfp; + struct plink *plp; + int progress; + int change; + + for(i=0; i<lemp->nstate; i++){ + for(cfp=lemp->sorted[i]->cfp; cfp; cfp=cfp->next){ + cfp->status = INCOMPLETE; + } + } + + do{ + progress = 0; + for(i=0; i<lemp->nstate; i++){ + for(cfp=lemp->sorted[i]->cfp; cfp; cfp=cfp->next){ + if( cfp->status==COMPLETE ) continue; + for(plp=cfp->fplp; plp; plp=plp->next){ + change = SetUnion(plp->cfp->fws,cfp->fws); + if( change ){ + plp->cfp->status = INCOMPLETE; + progress = 1; + } + } + cfp->status = COMPLETE; + } + } + }while( progress ); +} + +static int resolve_conflict(); + +/* Compute the reduce actions, and resolve conflicts. +*/ +void FindActions(lemp) +struct lemon *lemp; +{ + int i,j; + struct config *cfp; + struct state *stp; + struct symbol *sp; + struct rule *rp; + + /* Add all of the reduce actions + ** A reduce action is added for each element of the followset of + ** a configuration which has its dot at the extreme right. + */ + for(i=0; i<lemp->nstate; i++){ /* Loop over all states */ + stp = lemp->sorted[i]; + for(cfp=stp->cfp; cfp; cfp=cfp->next){ /* Loop over all configurations */ + if( cfp->rp->nrhs==cfp->dot ){ /* Is dot at extreme right? */ + for(j=0; j<lemp->nterminal; j++){ + if( SetFind(cfp->fws,j) ){ + /* Add a reduce action to the state "stp" which will reduce by the + ** rule "cfp->rp" if the lookahead symbol is "lemp->symbols[j]" */ + Action_add(&stp->ap,REDUCE,lemp->symbols[j],cfp->rp); + } + } + } + } + } + + /* Add the accepting token */ + if( lemp->start ){ + sp = Symbol_find(lemp->start); + if( sp==0 ) sp = lemp->rule->lhs; + }else{ + sp = lemp->rule->lhs; + } + /* Add to the first state (which is always the starting state of the + ** finite state machine) an action to ACCEPT if the lookahead is the + ** start nonterminal. */ + Action_add(&lemp->sorted[0]->ap,ACCEPT,sp,0); + + /* Resolve conflicts */ + for(i=0; i<lemp->nstate; i++){ + struct action *ap, *nap; + struct state *stp; + stp = lemp->sorted[i]; + assert( stp->ap ); + stp->ap = Action_sort(stp->ap); + for(ap=stp->ap; ap && ap->next; ap=ap->next){ + for(nap=ap->next; nap && nap->sp==ap->sp; nap=nap->next){ + /* The two actions "ap" and "nap" have the same lookahead. + ** Figure out which one should be used */ + lemp->nconflict += resolve_conflict(ap,nap,lemp->errsym); + } + } + } + + /* Report an error for each rule that can never be reduced. */ + for(rp=lemp->rule; rp; rp=rp->next) rp->canReduce = B_FALSE; + for(i=0; i<lemp->nstate; i++){ + struct action *ap; + for(ap=lemp->sorted[i]->ap; ap; ap=ap->next){ + if( ap->type==REDUCE ) ap->x.rp->canReduce = B_TRUE; + } + } + for(rp=lemp->rule; rp; rp=rp->next){ + if( rp->canReduce ) continue; + ErrorMsg(lemp->filename,rp->ruleline,"This rule can not be reduced.\n"); + lemp->errorcnt++; + } +} + +/* Resolve a conflict between the two given actions. If the +** conflict can't be resolve, return non-zero. +** +** NO LONGER TRUE: +** To resolve a conflict, first look to see if either action +** is on an error rule. In that case, take the action which +** is not associated with the error rule. If neither or both +** actions are associated with an error rule, then try to +** use precedence to resolve the conflict. +** +** If either action is a SHIFT, then it must be apx. This +** function won't work if apx->type==REDUCE and apy->type==SHIFT. +*/ +static int resolve_conflict(apx,apy,errsym) +struct action *apx; +struct action *apy; +struct symbol *errsym; /* The error symbol (if defined. NULL otherwise) */ +{ + struct symbol *spx, *spy; + int errcnt = 0; + assert( apx->sp==apy->sp ); /* Otherwise there would be no conflict */ + if( apx->type==SHIFT && apy->type==REDUCE ){ + spx = apx->sp; + spy = apy->x.rp->precsym; + if( spy==0 || spx->prec<0 || spy->prec<0 ){ + /* Not enough precedence information. */ + apy->type = CONFLICT; + errcnt++; + }else if( spx->prec>spy->prec ){ /* Lower precedence wins */ + apy->type = RD_RESOLVED; + }else if( spx->prec<spy->prec ){ + apx->type = SH_RESOLVED; + }else if( spx->prec==spy->prec && spx->assoc==RIGHT ){ /* Use operator */ + apy->type = RD_RESOLVED; /* associativity */ + }else if( spx->prec==spy->prec && spx->assoc==LEFT ){ /* to break tie */ + apx->type = SH_RESOLVED; + }else{ + assert( spx->prec==spy->prec && spx->assoc==NONE ); + apy->type = CONFLICT; + errcnt++; + } + }else if( apx->type==REDUCE && apy->type==REDUCE ){ + spx = apx->x.rp->precsym; + spy = apy->x.rp->precsym; + if( spx==0 || spy==0 || spx->prec<0 || + spy->prec<0 || spx->prec==spy->prec ){ + apy->type = CONFLICT; + errcnt++; + }else if( spx->prec>spy->prec ){ + apy->type = RD_RESOLVED; + }else if( spx->prec<spy->prec ){ + apx->type = RD_RESOLVED; + } + }else{ + assert( + apx->type==SH_RESOLVED || + apx->type==RD_RESOLVED || + apx->type==CONFLICT || + apy->type==SH_RESOLVED || + apy->type==RD_RESOLVED || + apy->type==CONFLICT + ); + /* The REDUCE/SHIFT case cannot happen because SHIFTs come before + ** REDUCEs on the list. If we reach this point it must be because + ** the parser conflict had already been resolved. */ + } + return errcnt; +} +/********************* From the file "configlist.c" *************************/ +/* +** Routines to processing a configuration list and building a state +** in the LEMON parser generator. +*/ + +static struct config *freelist = 0; /* List of free configurations */ +static struct config *current = 0; /* Top of list of configurations */ +static struct config **currentend = 0; /* Last on list of configs */ +static struct config *basis = 0; /* Top of list of basis configs */ +static struct config **basisend = 0; /* End of list of basis configs */ + +/* Return a pointer to a new configuration */ +PRIVATE struct config *newconfig(){ + struct config *new; + if( freelist==0 ){ + int i; + int amt = 3; + freelist = (struct config *)malloc( sizeof(struct config)*amt ); + if( freelist==0 ){ + fprintf(stderr,"Unable to allocate memory for a new configuration."); + exit(1); + } + for(i=0; i<amt-1; i++) freelist[i].next = &freelist[i+1]; + freelist[amt-1].next = 0; + } + new = freelist; + freelist = freelist->next; + return new; +} + +/* The configuration "old" is no longer used */ +PRIVATE void deleteconfig(old) +struct config *old; +{ + old->next = freelist; + freelist = old; +} + +/* Initialized the configuration list builder */ +void Configlist_init(){ + current = 0; + currentend = ¤t; + basis = 0; + basisend = &basis; + Configtable_init(); + return; +} + +/* Initialized the configuration list builder */ +void Configlist_reset(){ + current = 0; + currentend = ¤t; + basis = 0; + basisend = &basis; + Configtable_clear(0); + return; +} + +/* Add another configuration to the configuration list */ +struct config *Configlist_add(rp,dot) +struct rule *rp; /* The rule */ +int dot; /* Index into the RHS of the rule where the dot goes */ +{ + struct config *cfp, model; + + assert( currentend!=0 ); + model.rp = rp; + model.dot = dot; + cfp = Configtable_find(&model); + if( cfp==0 ){ + cfp = newconfig(); + cfp->rp = rp; + cfp->dot = dot; + cfp->fws = SetNew(); + cfp->stp = 0; + cfp->fplp = cfp->bplp = 0; + cfp->next = 0; + cfp->bp = 0; + *currentend = cfp; + currentend = &cfp->next; + Configtable_insert(cfp); + } + return cfp; +} + +/* Add a basis configuration to the configuration list */ +struct config *Configlist_addbasis(rp,dot) +struct rule *rp; +int dot; +{ + struct config *cfp, model; + + assert( basisend!=0 ); + assert( currentend!=0 ); + model.rp = rp; + model.dot = dot; + cfp = Configtable_find(&model); + if( cfp==0 ){ + cfp = newconfig(); + cfp->rp = rp; + cfp->dot = dot; + cfp->fws = SetNew(); + cfp->stp = 0; + cfp->fplp = cfp->bplp = 0; + cfp->next = 0; + cfp->bp = 0; + *currentend = cfp; + currentend = &cfp->next; + *basisend = cfp; + basisend = &cfp->bp; + Configtable_insert(cfp); + } + return cfp; +} + +/* Compute the closure of the configuration list */ +void Configlist_closure(lemp) +struct lemon *lemp; +{ + struct config *cfp, *newcfp; + struct rule *rp, *newrp; + struct symbol *sp, *xsp; + int i, dot; + + assert( currentend!=0 ); + for(cfp=current; cfp; cfp=cfp->next){ + rp = cfp->rp; + dot = cfp->dot; + if( dot>=rp->nrhs ) continue; + sp = rp->rhs[dot]; + if( sp->type==NONTERMINAL ){ + if( sp->rule==0 && sp!=lemp->errsym ){ + ErrorMsg(lemp->filename,rp->line,"Nonterminal \"%s\" has no rules.", + sp->name); + lemp->errorcnt++; + } + for(newrp=sp->rule; newrp; newrp=newrp->nextlhs){ + newcfp = Configlist_add(newrp,0); + for(i=dot+1; i<rp->nrhs; i++){ + xsp = rp->rhs[i]; + if( xsp->type==TERMINAL ){ + SetAdd(newcfp->fws,xsp->index); + break; + }else{ + SetUnion(newcfp->fws,xsp->firstset); + if( xsp->lambda==B_FALSE ) break; + } + } + if( i==rp->nrhs ) Plink_add(&cfp->fplp,newcfp); + } + } + } + return; +} + +/* Sort the configuration list */ +void Configlist_sort(){ + current = (struct config *)msort(current,&(current->next),Configcmp); + currentend = 0; + return; +} + +/* Sort the basis configuration list */ +void Configlist_sortbasis(){ + basis = (struct config *)msort(current,&(current->bp),Configcmp); + basisend = 0; + return; +} + +/* Return a pointer to the head of the configuration list and +** reset the list */ +struct config *Configlist_return(){ + struct config *old; + old = current; + current = 0; + currentend = 0; + return old; +} + +/* Return a pointer to the head of the configuration list and +** reset the list */ +struct config *Configlist_basis(){ + struct config *old; + old = basis; + basis = 0; + basisend = 0; + return old; +} + +/* Free all elements of the given configuration list */ +void Configlist_eat(cfp) +struct config *cfp; +{ + struct config *nextcfp; + for(; cfp; cfp=nextcfp){ + nextcfp = cfp->next; + assert( cfp->fplp==0 ); + assert( cfp->bplp==0 ); + if( cfp->fws ) SetFree(cfp->fws); + deleteconfig(cfp); + } + return; +} +/***************** From the file "error.c" *********************************/ +/* +** Code for printing error message. +*/ + +/* Find a good place to break "msg" so that its length is at least "min" +** but no more than "max". Make the point as close to max as possible. +*/ +static int findbreak(msg,min,max) +char *msg; +int min; +int max; +{ + int i,spot; + char c; + for(i=spot=min; i<=max; i++){ + c = msg[i]; + if( c=='\t' ) msg[i] = ' '; + if( c=='\n' ){ msg[i] = ' '; spot = i; break; } + if( c==0 ){ spot = i; break; } + if( c=='-' && i<max-1 ) spot = i+1; + if( c==' ' ) spot = i; + } + return spot; +} + +/* +** The error message is split across multiple lines if necessary. The +** splits occur at a space, if there is a space available near the end +** of the line. +*/ +#define ERRMSGSIZE 10000 /* Hope this is big enough. No way to error check */ +#define LINEWIDTH 79 /* Max width of any output line */ +#define PREFIXLIMIT 30 /* Max width of the prefix on each line */ +void ErrorMsg(const char *filename, int lineno, const char *format, ...){ + char errmsg[ERRMSGSIZE]; + char prefix[PREFIXLIMIT+10]; + int errmsgsize; + int prefixsize; + int availablewidth; + va_list ap; + int end, restart, base; + + va_start(ap, format); + /* Prepare a prefix to be prepended to every output line */ + if( lineno>0 ){ + sprintf(prefix,"%.*s:%d: ",PREFIXLIMIT-10,filename,lineno); + }else{ + sprintf(prefix,"%.*s: ",PREFIXLIMIT-10,filename); + } + prefixsize = strlen(prefix); + availablewidth = LINEWIDTH - prefixsize; + + /* Generate the error message */ + vsprintf(errmsg,format,ap); + va_end(ap); + errmsgsize = strlen(errmsg); + /* Remove trailing '\n's from the error message. */ + while( errmsgsize>0 && errmsg[errmsgsize-1]=='\n' ){ + errmsg[--errmsgsize] = 0; + } + + /* Print the error message */ + base = 0; + while( errmsg[base]!=0 ){ + end = restart = findbreak(&errmsg[base],0,availablewidth); + restart += base; + while( errmsg[restart]==' ' ) restart++; + fprintf(stdout,"%s%.*s\n",prefix,end,&errmsg[base]); + base = restart; + } +} +/**************** From the file "main.c" ************************************/ +/* +** Main program file for the LEMON parser generator. +*/ + +/* Report an out-of-memory condition and abort. This function +** is used mostly by the "MemoryCheck" macro in struct.h +*/ +void memory_error(){ + fprintf(stderr,"Out of memory. Aborting...\n"); + exit(1); +} + + +/* The main program. Parse the command line and do it... */ +int main(argc,argv) +int argc; +char **argv; +{ + static int version = 0; + static int rpflag = 0; + static int basisflag = 0; + static int compress = 0; + static int quiet = 0; + static int statistics = 0; + static int mhflag = 0; + static struct s_options options[] = { + {OPT_FLAG, "b", (char*)&basisflag, "Print only the basis in report."}, + {OPT_FLAG, "c", (char*)&compress, "Don't compress the action table."}, + {OPT_FLAG, "g", (char*)&rpflag, "Print grammar without actions."}, + {OPT_FLAG, "m", (char*)&mhflag, "Output a makeheaders compatible file"}, + {OPT_FLAG, "q", (char*)&quiet, "(Quiet) Don't print the report file."}, + {OPT_FLAG, "s", (char*)&statistics, "Print parser stats to standard output."}, + {OPT_FLAG, "x", (char*)&version, "Print the version number."}, + {OPT_FLAG,0,0,0} + }; + int i; + struct lemon lem; + + OptInit(argv,options,stderr); + if( version ){ + printf("Lemon version 1.0\n"); + exit(0); + } + if( OptNArgs()!=1 ){ + fprintf(stderr,"Exactly one filename argument is required.\n"); + exit(1); + } + lem.errorcnt = 0; + + /* Initialize the machine */ + Strsafe_init(); + Symbol_init(); + State_init(); + lem.argv0 = argv[0]; + lem.filename = OptArg(0); + lem.basisflag = basisflag; + lem.has_fallback = 0; + lem.nconflict = 0; + lem.name = lem.include = lem.arg = lem.tokentype = lem.start = 0; + lem.vartype = 0; + lem.stacksize = 0; + lem.error = lem.overflow = lem.failure = lem.accept = lem.tokendest = + lem.tokenprefix = lem.outname = lem.extracode = 0; + lem.vardest = 0; + lem.tablesize = 0; + Symbol_new("$"); + lem.errsym = Symbol_new("error"); + + /* Parse the input file */ + Parse(&lem); + if( lem.errorcnt ) exit(lem.errorcnt); + if( lem.rule==0 ){ + fprintf(stderr,"Empty grammar.\n"); + exit(1); + } + + /* Count and index the symbols of the grammar */ + lem.nsymbol = Symbol_count(); + Symbol_new("{default}"); + lem.symbols = Symbol_arrayof(); + qsort(lem.symbols,lem.nsymbol+1,sizeof(struct symbol*), + (int(*)())Symbolcmpp); + for(i=0; i<=lem.nsymbol; i++) lem.symbols[i]->index = i; + for(i=1; isupper(lem.symbols[i]->name[0]); i++); + lem.nterminal = i; + + /* Generate a reprint of the grammar, if requested on the command line */ + if( rpflag ){ + Reprint(&lem); + }else{ + /* Initialize the size for all follow and first sets */ + SetSize(lem.nterminal); + + /* Find the precedence for every production rule (that has one) */ + FindRulePrecedences(&lem); + + /* Compute the lambda-nonterminals and the first-sets for every + ** nonterminal */ + FindFirstSets(&lem); + + /* Compute all LR(0) states. Also record follow-set propagation + ** links so that the follow-set can be computed later */ + lem.nstate = 0; + FindStates(&lem); + lem.sorted = State_arrayof(); + + /* Tie up loose ends on the propagation links */ + FindLinks(&lem); + + /* Compute the follow set of every reducible configuration */ + FindFollowSets(&lem); + + /* Compute the action tables */ + FindActions(&lem); + + /* Compress the action tables */ + if( compress==0 ) CompressTables(&lem); + + /* Generate a report of the parser generated. (the "y.output" file) */ + if( !quiet ) ReportOutput(&lem); + + /* Generate the source code for the parser */ + ReportTable(&lem, mhflag); + + /* Produce a header file for use by the scanner. (This step is + ** omitted if the "-m" option is used because makeheaders will + ** generate the file for us.) */ + if( !mhflag ) ReportHeader(&lem); + } + if( statistics ){ + printf("Parser statistics: %d terminals, %d nonterminals, %d rules\n", + lem.nterminal, lem.nsymbol - lem.nterminal, lem.nrule); + printf(" %d states, %d parser table entries, %d conflicts\n", + lem.nstate, lem.tablesize, lem.nconflict); + } + if( lem.nconflict ){ + fprintf(stderr,"%d parsing conflicts.\n",lem.nconflict); + } + exit(lem.errorcnt + lem.nconflict); +} +/******************** From the file "msort.c" *******************************/ +/* +** A generic merge-sort program. +** +** USAGE: +** Let "ptr" be a pointer to some structure which is at the head of +** a null-terminated list. Then to sort the list call: +** +** ptr = msort(ptr,&(ptr->next),cmpfnc); +** +** In the above, "cmpfnc" is a pointer to a function which compares +** two instances of the structure and returns an integer, as in +** strcmp. The second argument is a pointer to the pointer to the +** second element of the linked list. This address is used to compute +** the offset to the "next" field within the structure. The offset to +** the "next" field must be constant for all structures in the list. +** +** The function returns a new pointer which is the head of the list +** after sorting. +** +** ALGORITHM: +** Merge-sort. +*/ + +/* +** Return a pointer to the next structure in the linked list. +*/ +#define NEXT(A) (*(char**)(((unsigned long)A)+offset)) + +/* +** Inputs: +** a: A sorted, null-terminated linked list. (May be null). +** b: A sorted, null-terminated linked list. (May be null). +** cmp: A pointer to the comparison function. +** offset: Offset in the structure to the "next" field. +** +** Return Value: +** A pointer to the head of a sorted list containing the elements +** of both a and b. +** +** Side effects: +** The "next" pointers for elements in the lists a and b are +** changed. +*/ +static char *merge(a,b,cmp,offset) +char *a; +char *b; +int (*cmp)(); +int offset; +{ + char *ptr, *head; + + if( a==0 ){ + head = b; + }else if( b==0 ){ + head = a; + }else{ + if( (*cmp)(a,b)<0 ){ + ptr = a; + a = NEXT(a); + }else{ + ptr = b; + b = NEXT(b); + } + head = ptr; + while( a && b ){ + if( (*cmp)(a,b)<0 ){ + NEXT(ptr) = a; + ptr = a; + a = NEXT(a); + }else{ + NEXT(ptr) = b; + ptr = b; + b = NEXT(b); + } + } + if( a ) NEXT(ptr) = a; + else NEXT(ptr) = b; + } + return head; +} + +/* +** Inputs: +** list: Pointer to a singly-linked list of structures. +** next: Pointer to pointer to the second element of the list. +** cmp: A comparison function. +** +** Return Value: +** A pointer to the head of a sorted list containing the elements +** orginally in list. +** +** Side effects: +** The "next" pointers for elements in list are changed. +*/ +#define LISTSIZE 30 +char *msort(list,next,cmp) +char *list; +char **next; +int (*cmp)(); +{ + unsigned long offset; + char *ep; + char *set[LISTSIZE]; + int i; + offset = (unsigned long)next - (unsigned long)list; + for(i=0; i<LISTSIZE; i++) set[i] = 0; + while( list ){ + ep = list; + list = NEXT(list); + NEXT(ep) = 0; + for(i=0; i<LISTSIZE-1 && set[i]!=0; i++){ + ep = merge(ep,set[i],cmp,offset); + set[i] = 0; + } + set[i] = ep; + } + ep = 0; + for(i=0; i<LISTSIZE; i++) if( set[i] ) ep = merge(ep,set[i],cmp,offset); + return ep; +} +/************************ From the file "option.c" **************************/ +static char **argv; +static struct s_options *op; +static FILE *errstream; + +#define ISOPT(X) ((X)[0]=='-'||(X)[0]=='+'||strchr((X),'=')!=0) + +/* +** Print the command line with a carrot pointing to the k-th character +** of the n-th field. +*/ +static void errline(n,k,err) +int n; +int k; +FILE *err; +{ + int spcnt, i; + spcnt = 0; + if( argv[0] ) fprintf(err,"%s",argv[0]); + spcnt = strlen(argv[0]) + 1; + for(i=1; i<n && argv[i]; i++){ + fprintf(err," %s",argv[i]); + spcnt += strlen(argv[i]+1); + } + spcnt += k; + for(; argv[i]; i++) fprintf(err," %s",argv[i]); + if( spcnt<20 ){ + fprintf(err,"\n%*s^-- here\n",spcnt,""); + }else{ + fprintf(err,"\n%*shere --^\n",spcnt-7,""); + } +} + +/* +** Return the index of the N-th non-switch argument. Return -1 +** if N is out of range. +*/ +static int argindex(n) +int n; +{ + int i; + int dashdash = 0; + if( argv!=0 && *argv!=0 ){ + for(i=1; argv[i]; i++){ + if( dashdash || !ISOPT(argv[i]) ){ + if( n==0 ) return i; + n--; + } + if( strcmp(argv[i],"--")==0 ) dashdash = 1; + } + } + return -1; +} + +static char emsg[] = "Command line syntax error: "; + +/* +** Process a flag command line argument. +*/ +static int handleflags(i,err) +int i; +FILE *err; +{ + int v; + int errcnt = 0; + int j; + for(j=0; op[j].label; j++){ + if( strcmp(&argv[i][1],op[j].label)==0 ) break; + } + v = argv[i][0]=='-' ? 1 : 0; + if( op[j].label==0 ){ + if( err ){ + fprintf(err,"%sundefined option.\n",emsg); + errline(i,1,err); + } + errcnt++; + }else if( op[j].type==OPT_FLAG ){ + *((int*)op[j].arg) = v; + }else if( op[j].type==OPT_FFLAG ){ + (*(void(*)())(op[j].arg))(v); + }else{ + if( err ){ + fprintf(err,"%smissing argument on switch.\n",emsg); + errline(i,1,err); + } + errcnt++; + } + return errcnt; +} + +/* +** Process a command line switch which has an argument. +*/ +static int handleswitch(i,err) +int i; +FILE *err; +{ + int lv = 0; + double dv = 0.0; + char *sv = 0, *end; + char *cp; + int j; + int errcnt = 0; + cp = strchr(argv[i],'='); + *cp = 0; + for(j=0; op[j].label; j++){ + if( strcmp(argv[i],op[j].label)==0 ) break; + } + *cp = '='; + if( op[j].label==0 ){ + if( err ){ + fprintf(err,"%sundefined option.\n",emsg); + errline(i,0,err); + } + errcnt++; + }else{ + cp++; + switch( op[j].type ){ + case OPT_FLAG: + case OPT_FFLAG: + if( err ){ + fprintf(err,"%soption requires an argument.\n",emsg); + errline(i,0,err); + } + errcnt++; + break; + case OPT_DBL: + case OPT_FDBL: + dv = strtod(cp,&end); + if( *end ){ + if( err ){ + fprintf(err,"%sillegal character in floating-point argument.\n",emsg); + errline(i,((unsigned long)end)-(unsigned long)argv[i],err); + } + errcnt++; + } + break; + case OPT_INT: + case OPT_FINT: + lv = strtol(cp,&end,0); + if( *end ){ + if( err ){ + fprintf(err,"%sillegal character in integer argument.\n",emsg); + errline(i,((unsigned long)end)-(unsigned long)argv[i],err); + } + errcnt++; + } + break; + case OPT_STR: + case OPT_FSTR: + sv = cp; + break; + } + switch( op[j].type ){ + case OPT_FLAG: + case OPT_FFLAG: + break; + case OPT_DBL: + *(double*)(op[j].arg) = dv; + break; + case OPT_FDBL: + (*(void(*)())(op[j].arg))(dv); + break; + case OPT_INT: + *(int*)(op[j].arg) = lv; + break; + case OPT_FINT: + (*(void(*)())(op[j].arg))((int)lv); + break; + case OPT_STR: + *(char**)(op[j].arg) = sv; + break; + case OPT_FSTR: + (*(void(*)())(op[j].arg))(sv); + break; + } + } + return errcnt; +} + +int OptInit(a,o,err) +char **a; +struct s_options *o; +FILE *err; +{ + int errcnt = 0; + argv = a; + op = o; + errstream = err; + if( argv && *argv && op ){ + int i; + for(i=1; argv[i]; i++){ + if( argv[i][0]=='+' || argv[i][0]=='-' ){ + errcnt += handleflags(i,err); + }else if( strchr(argv[i],'=') ){ + errcnt += handleswitch(i,err); + } + } + } + if( errcnt>0 ){ + fprintf(err,"Valid command line options for \"%s\" are:\n",*a); + OptPrint(); + exit(1); + } + return 0; +} + +int OptNArgs(){ + int cnt = 0; + int dashdash = 0; + int i; + if( argv!=0 && argv[0]!=0 ){ + for(i=1; argv[i]; i++){ + if( dashdash || !ISOPT(argv[i]) ) cnt++; + if( strcmp(argv[i],"--")==0 ) dashdash = 1; + } + } + return cnt; +} + +char *OptArg(n) +int n; +{ + int i; + i = argindex(n); + return i>=0 ? argv[i] : 0; +} + +void OptErr(n) +int n; +{ + int i; + i = argindex(n); + if( i>=0 ) errline(i,0,errstream); +} + +void OptPrint(){ + int i; + int max, len; + max = 0; + for(i=0; op[i].label; i++){ + len = strlen(op[i].label) + 1; + switch( op[i].type ){ + case OPT_FLAG: + case OPT_FFLAG: + break; + case OPT_INT: + case OPT_FINT: + len += 9; /* length of "<integer>" */ + break; + case OPT_DBL: + case OPT_FDBL: + len += 6; /* length of "<real>" */ + break; + case OPT_STR: + case OPT_FSTR: + len += 8; /* length of "<string>" */ + break; + } + if( len>max ) max = len; + } + for(i=0; op[i].label; i++){ + switch( op[i].type ){ + case OPT_FLAG: + case OPT_FFLAG: + fprintf(errstream," -%-*s %s\n",max,op[i].label,op[i].message); + break; + case OPT_INT: + case OPT_FINT: + fprintf(errstream," %s=<integer>%*s %s\n",op[i].label, + max-strlen(op[i].label)-9,"",op[i].message); + break; + case OPT_DBL: + case OPT_FDBL: + fprintf(errstream," %s=<real>%*s %s\n",op[i].label, + max-strlen(op[i].label)-6,"",op[i].message); + break; + case OPT_STR: + case OPT_FSTR: + fprintf(errstream," %s=<string>%*s %s\n",op[i].label, + max-strlen(op[i].label)-8,"",op[i].message); + break; + } + } +} +/*********************** From the file "parse.c" ****************************/ +/* +** Input file parser for the LEMON parser generator. +*/ + +/* The state of the parser */ +struct pstate { + char *filename; /* Name of the input file */ + int tokenlineno; /* Linenumber at which current token starts */ + int errorcnt; /* Number of errors so far */ + char *tokenstart; /* Text of current token */ + struct lemon *gp; /* Global state vector */ + enum e_state { + INITIALIZE, + WAITING_FOR_DECL_OR_RULE, + WAITING_FOR_DECL_KEYWORD, + WAITING_FOR_DECL_ARG, + WAITING_FOR_PRECEDENCE_SYMBOL, + WAITING_FOR_ARROW, + IN_RHS, + LHS_ALIAS_1, + LHS_ALIAS_2, + LHS_ALIAS_3, + RHS_ALIAS_1, + RHS_ALIAS_2, + PRECEDENCE_MARK_1, + PRECEDENCE_MARK_2, + RESYNC_AFTER_RULE_ERROR, + RESYNC_AFTER_DECL_ERROR, + WAITING_FOR_DESTRUCTOR_SYMBOL, + WAITING_FOR_DATATYPE_SYMBOL, + WAITING_FOR_FALLBACK_ID + } state; /* The state of the parser */ + struct symbol *fallback; /* The fallback token */ + struct symbol *lhs; /* Left-hand side of current rule */ + char *lhsalias; /* Alias for the LHS */ + int nrhs; /* Number of right-hand side symbols seen */ + struct symbol *rhs[MAXRHS]; /* RHS symbols */ + char *alias[MAXRHS]; /* Aliases for each RHS symbol (or NULL) */ + struct rule *prevrule; /* Previous rule parsed */ + char *declkeyword; /* Keyword of a declaration */ + char **declargslot; /* Where the declaration argument should be put */ + int *decllnslot; /* Where the declaration linenumber is put */ + enum e_assoc declassoc; /* Assign this association to decl arguments */ + int preccounter; /* Assign this precedence to decl arguments */ + struct rule *firstrule; /* Pointer to first rule in the grammar */ + struct rule *lastrule; /* Pointer to the most recently parsed rule */ +}; + +/* Parse a single token */ +static void parseonetoken(psp) +struct pstate *psp; +{ + char *x; + x = Strsafe(psp->tokenstart); /* Save the token permanently */ +#if 0 + printf("%s:%d: Token=[%s] state=%d\n",psp->filename,psp->tokenlineno, + x,psp->state); +#endif + switch( psp->state ){ + case INITIALIZE: + psp->prevrule = 0; + psp->preccounter = 0; + psp->firstrule = psp->lastrule = 0; + psp->gp->nrule = 0; + /* Fall thru to next case */ + case WAITING_FOR_DECL_OR_RULE: + if( x[0]=='%' ){ + psp->state = WAITING_FOR_DECL_KEYWORD; + }else if( islower(x[0]) ){ + psp->lhs = Symbol_new(x); + psp->nrhs = 0; + psp->lhsalias = 0; + psp->state = WAITING_FOR_ARROW; + }else if( x[0]=='{' ){ + if( psp->prevrule==0 ){ + ErrorMsg(psp->filename,psp->tokenlineno, +"There is not prior rule opon which to attach the code \ +fragment which begins on this line."); + psp->errorcnt++; + }else if( psp->prevrule->code!=0 ){ + ErrorMsg(psp->filename,psp->tokenlineno, +"Code fragment beginning on this line is not the first \ +to follow the previous rule."); + psp->errorcnt++; + }else{ + psp->prevrule->line = psp->tokenlineno; + psp->prevrule->code = &x[1]; + } + }else if( x[0]=='[' ){ + psp->state = PRECEDENCE_MARK_1; + }else{ + ErrorMsg(psp->filename,psp->tokenlineno, + "Token \"%s\" should be either \"%%\" or a nonterminal name.", + x); + psp->errorcnt++; + } + break; + case PRECEDENCE_MARK_1: + if( !isupper(x[0]) ){ + ErrorMsg(psp->filename,psp->tokenlineno, + "The precedence symbol must be a terminal."); + psp->errorcnt++; + }else if( psp->prevrule==0 ){ + ErrorMsg(psp->filename,psp->tokenlineno, + "There is no prior rule to assign precedence \"[%s]\".",x); + psp->errorcnt++; + }else if( psp->prevrule->precsym!=0 ){ + ErrorMsg(psp->filename,psp->tokenlineno, +"Precedence mark on this line is not the first \ +to follow the previous rule."); + psp->errorcnt++; + }else{ + psp->prevrule->precsym = Symbol_new(x); + } + psp->state = PRECEDENCE_MARK_2; + break; + case PRECEDENCE_MARK_2: + if( x[0]!=']' ){ + ErrorMsg(psp->filename,psp->tokenlineno, + "Missing \"]\" on precedence mark."); + psp->errorcnt++; + } + psp->state = WAITING_FOR_DECL_OR_RULE; + break; + case WAITING_FOR_ARROW: + if( x[0]==':' && x[1]==':' && x[2]=='=' ){ + psp->state = IN_RHS; + }else if( x[0]=='(' ){ + psp->state = LHS_ALIAS_1; + }else{ + ErrorMsg(psp->filename,psp->tokenlineno, + "Expected to see a \":\" following the LHS symbol \"%s\".", + psp->lhs->name); + psp->errorcnt++; + psp->state = RESYNC_AFTER_RULE_ERROR; + } + break; + case LHS_ALIAS_1: + if( isalpha(x[0]) ){ + psp->lhsalias = x; + psp->state = LHS_ALIAS_2; + }else{ + ErrorMsg(psp->filename,psp->tokenlineno, + "\"%s\" is not a valid alias for the LHS \"%s\"\n", + x,psp->lhs->name); + psp->errorcnt++; + psp->state = RESYNC_AFTER_RULE_ERROR; + } + break; + case LHS_ALIAS_2: + if( x[0]==')' ){ + psp->state = LHS_ALIAS_3; + }else{ + ErrorMsg(psp->filename,psp->tokenlineno, + "Missing \")\" following LHS alias name \"%s\".",psp->lhsalias); + psp->errorcnt++; + psp->state = RESYNC_AFTER_RULE_ERROR; + } + break; + case LHS_ALIAS_3: + if( x[0]==':' && x[1]==':' && x[2]=='=' ){ + psp->state = IN_RHS; + }else{ + ErrorMsg(psp->filename,psp->tokenlineno, + "Missing \"->\" following: \"%s(%s)\".", + psp->lhs->name,psp->lhsalias); + psp->errorcnt++; + psp->state = RESYNC_AFTER_RULE_ERROR; + } + break; + case IN_RHS: + if( x[0]=='.' ){ + struct rule *rp; + rp = (struct rule *)malloc( sizeof(struct rule) + + sizeof(struct symbol*)*psp->nrhs + sizeof(char*)*psp->nrhs ); + if( rp==0 ){ + ErrorMsg(psp->filename,psp->tokenlineno, + "Can't allocate enough memory for this rule."); + psp->errorcnt++; + psp->prevrule = 0; + }else{ + int i; + rp->ruleline = psp->tokenlineno; + rp->rhs = (struct symbol**)&rp[1]; + rp->rhsalias = (char**)&(rp->rhs[psp->nrhs]); + for(i=0; i<psp->nrhs; i++){ + rp->rhs[i] = psp->rhs[i]; + rp->rhsalias[i] = psp->alias[i]; + } + rp->lhs = psp->lhs; + rp->lhsalias = psp->lhsalias; + rp->nrhs = psp->nrhs; + rp->code = 0; + rp->precsym = 0; + rp->index = psp->gp->nrule++; + rp->nextlhs = rp->lhs->rule; + rp->lhs->rule = rp; + rp->next = 0; + if( psp->firstrule==0 ){ + psp->firstrule = psp->lastrule = rp; + }else{ + psp->lastrule->next = rp; + psp->lastrule = rp; + } + psp->prevrule = rp; + } + psp->state = WAITING_FOR_DECL_OR_RULE; + }else if( isalpha(x[0]) ){ + if( psp->nrhs>=MAXRHS ){ + ErrorMsg(psp->filename,psp->tokenlineno, + "Too many symbol on RHS or rule beginning at \"%s\".", + x); + psp->errorcnt++; + psp->state = RESYNC_AFTER_RULE_ERROR; + }else{ + psp->rhs[psp->nrhs] = Symbol_new(x); + psp->alias[psp->nrhs] = 0; + psp->nrhs++; + } + }else if( x[0]=='(' && psp->nrhs>0 ){ + psp->state = RHS_ALIAS_1; + }else{ + ErrorMsg(psp->filename,psp->tokenlineno, + "Illegal character on RHS of rule: \"%s\".",x); + psp->errorcnt++; + psp->state = RESYNC_AFTER_RULE_ERROR; + } + break; + case RHS_ALIAS_1: + if( isalpha(x[0]) ){ + psp->alias[psp->nrhs-1] = x; + psp->state = RHS_ALIAS_2; + }else{ + ErrorMsg(psp->filename,psp->tokenlineno, + "\"%s\" is not a valid alias for the RHS symbol \"%s\"\n", + x,psp->rhs[psp->nrhs-1]->name); + psp->errorcnt++; + psp->state = RESYNC_AFTER_RULE_ERROR; + } + break; + case RHS_ALIAS_2: + if( x[0]==')' ){ + psp->state = IN_RHS; + }else{ + ErrorMsg(psp->filename,psp->tokenlineno, + "Missing \")\" following LHS alias name \"%s\".",psp->lhsalias); + psp->errorcnt++; + psp->state = RESYNC_AFTER_RULE_ERROR; + } + break; + case WAITING_FOR_DECL_KEYWORD: + if( isalpha(x[0]) ){ + psp->declkeyword = x; + psp->declargslot = 0; + psp->decllnslot = 0; + psp->state = WAITING_FOR_DECL_ARG; + if( strcmp(x,"name")==0 ){ + psp->declargslot = &(psp->gp->name); + }else if( strcmp(x,"include")==0 ){ + psp->declargslot = &(psp->gp->include); + psp->decllnslot = &psp->gp->includeln; + }else if( strcmp(x,"code")==0 ){ + psp->declargslot = &(psp->gp->extracode); + psp->decllnslot = &psp->gp->extracodeln; + }else if( strcmp(x,"token_destructor")==0 ){ + psp->declargslot = &psp->gp->tokendest; + psp->decllnslot = &psp->gp->tokendestln; + }else if( strcmp(x,"default_destructor")==0 ){ + psp->declargslot = &psp->gp->vardest; + psp->decllnslot = &psp->gp->vardestln; + }else if( strcmp(x,"token_prefix")==0 ){ + psp->declargslot = &psp->gp->tokenprefix; + }else if( strcmp(x,"syntax_error")==0 ){ + psp->declargslot = &(psp->gp->error); + psp->decllnslot = &psp->gp->errorln; + }else if( strcmp(x,"parse_accept")==0 ){ + psp->declargslot = &(psp->gp->accept); + psp->decllnslot = &psp->gp->acceptln; + }else if( strcmp(x,"parse_failure")==0 ){ + psp->declargslot = &(psp->gp->failure); + psp->decllnslot = &psp->gp->failureln; + }else if( strcmp(x,"stack_overflow")==0 ){ + psp->declargslot = &(psp->gp->overflow); + psp->decllnslot = &psp->gp->overflowln; + }else if( strcmp(x,"extra_argument")==0 ){ + psp->declargslot = &(psp->gp->arg); + }else if( strcmp(x,"token_type")==0 ){ + psp->declargslot = &(psp->gp->tokentype); + }else if( strcmp(x,"default_type")==0 ){ + psp->declargslot = &(psp->gp->vartype); + }else if( strcmp(x,"stack_size")==0 ){ + psp->declargslot = &(psp->gp->stacksize); + }else if( strcmp(x,"start_symbol")==0 ){ + psp->declargslot = &(psp->gp->start); + }else if( strcmp(x,"left")==0 ){ + psp->preccounter++; + psp->declassoc = LEFT; + psp->state = WAITING_FOR_PRECEDENCE_SYMBOL; + }else if( strcmp(x,"right")==0 ){ + psp->preccounter++; + psp->declassoc = RIGHT; + psp->state = WAITING_FOR_PRECEDENCE_SYMBOL; + }else if( strcmp(x,"nonassoc")==0 ){ + psp->preccounter++; + psp->declassoc = NONE; + psp->state = WAITING_FOR_PRECEDENCE_SYMBOL; + }else if( strcmp(x,"destructor")==0 ){ + psp->state = WAITING_FOR_DESTRUCTOR_SYMBOL; + }else if( strcmp(x,"type")==0 ){ + psp->state = WAITING_FOR_DATATYPE_SYMBOL; + }else if( strcmp(x,"fallback")==0 ){ + psp->fallback = 0; + psp->state = WAITING_FOR_FALLBACK_ID; + }else{ + ErrorMsg(psp->filename,psp->tokenlineno, + "Unknown declaration keyword: \"%%%s\".",x); + psp->errorcnt++; + psp->state = RESYNC_AFTER_DECL_ERROR; + } + }else{ + ErrorMsg(psp->filename,psp->tokenlineno, + "Illegal declaration keyword: \"%s\".",x); + psp->errorcnt++; + psp->state = RESYNC_AFTER_DECL_ERROR; + } + break; + case WAITING_FOR_DESTRUCTOR_SYMBOL: + if( !isalpha(x[0]) ){ + ErrorMsg(psp->filename,psp->tokenlineno, + "Symbol name missing after %destructor keyword"); + psp->errorcnt++; + psp->state = RESYNC_AFTER_DECL_ERROR; + }else{ + struct symbol *sp = Symbol_new(x); + psp->declargslot = &sp->destructor; + psp->decllnslot = &sp->destructorln; + psp->state = WAITING_FOR_DECL_ARG; + } + break; + case WAITING_FOR_DATATYPE_SYMBOL: + if( !isalpha(x[0]) ){ + ErrorMsg(psp->filename,psp->tokenlineno, + "Symbol name missing after %destructor keyword"); + psp->errorcnt++; + psp->state = RESYNC_AFTER_DECL_ERROR; + }else{ + struct symbol *sp = Symbol_new(x); + psp->declargslot = &sp->datatype; + psp->decllnslot = 0; + psp->state = WAITING_FOR_DECL_ARG; + } + break; + case WAITING_FOR_PRECEDENCE_SYMBOL: + if( x[0]=='.' ){ + psp->state = WAITING_FOR_DECL_OR_RULE; + }else if( isupper(x[0]) ){ + struct symbol *sp; + sp = Symbol_new(x); + if( sp->prec>=0 ){ + ErrorMsg(psp->filename,psp->tokenlineno, + "Symbol \"%s\" has already be given a precedence.",x); + psp->errorcnt++; + }else{ + sp->prec = psp->preccounter; + sp->assoc = psp->declassoc; + } + }else{ + ErrorMsg(psp->filename,psp->tokenlineno, + "Can't assign a precedence to \"%s\".",x); + psp->errorcnt++; + } + break; + case WAITING_FOR_DECL_ARG: + if( (x[0]=='{' || x[0]=='\"' || isalnum(x[0])) ){ + if( *(psp->declargslot)!=0 ){ + ErrorMsg(psp->filename,psp->tokenlineno, + "The argument \"%s\" to declaration \"%%%s\" is not the first.", + x[0]=='\"' ? &x[1] : x,psp->declkeyword); + psp->errorcnt++; + psp->state = RESYNC_AFTER_DECL_ERROR; + }else{ + *(psp->declargslot) = (x[0]=='\"' || x[0]=='{') ? &x[1] : x; + if( psp->decllnslot ) *psp->decllnslot = psp->tokenlineno; + psp->state = WAITING_FOR_DECL_OR_RULE; + } + }else{ + ErrorMsg(psp->filename,psp->tokenlineno, + "Illegal argument to %%%s: %s",psp->declkeyword,x); + psp->errorcnt++; + psp->state = RESYNC_AFTER_DECL_ERROR; + } + break; + case WAITING_FOR_FALLBACK_ID: + if( x[0]=='.' ){ + psp->state = WAITING_FOR_DECL_OR_RULE; + }else if( !isupper(x[0]) ){ + ErrorMsg(psp->filename, psp->tokenlineno, + "%%fallback argument \"%s\" should be a token", x); + psp->errorcnt++; + }else{ + struct symbol *sp = Symbol_new(x); + if( psp->fallback==0 ){ + psp->fallback = sp; + }else if( sp->fallback ){ + ErrorMsg(psp->filename, psp->tokenlineno, + "More than one fallback assigned to token %s", x); + psp->errorcnt++; + }else{ + sp->fallback = psp->fallback; + psp->gp->has_fallback = 1; + } + } + break; + case RESYNC_AFTER_RULE_ERROR: +/* if( x[0]=='.' ) psp->state = WAITING_FOR_DECL_OR_RULE; +** break; */ + case RESYNC_AFTER_DECL_ERROR: + if( x[0]=='.' ) psp->state = WAITING_FOR_DECL_OR_RULE; + if( x[0]=='%' ) psp->state = WAITING_FOR_DECL_KEYWORD; + break; + } +} + +/* In spite of its name, this function is really a scanner. It read +** in the entire input file (all at once) then tokenizes it. Each +** token is passed to the function "parseonetoken" which builds all +** the appropriate data structures in the global state vector "gp". +*/ +void Parse(gp) +struct lemon *gp; +{ + struct pstate ps; + FILE *fp; + char *filebuf; + int filesize; + int lineno; + int c; + char *cp, *nextcp; + int startline = 0; + + ps.gp = gp; + ps.filename = gp->filename; + ps.errorcnt = 0; + ps.state = INITIALIZE; + + /* Begin by reading the input file */ + fp = fopen(ps.filename,"rb"); + if( fp==0 ){ + ErrorMsg(ps.filename,0,"Can't open this file for reading."); + gp->errorcnt++; + return; + } + fseek(fp,0,2); + filesize = ftell(fp); + rewind(fp); + filebuf = (char *)malloc( filesize+1 ); + if( filebuf==0 ){ + ErrorMsg(ps.filename,0,"Can't allocate %d of memory to hold this file.", + filesize+1); + gp->errorcnt++; + return; + } + if( fread(filebuf,1,filesize,fp)!=filesize ){ + ErrorMsg(ps.filename,0,"Can't read in all %d bytes of this file.", + filesize); + free(filebuf); + gp->errorcnt++; + return; + } + fclose(fp); + filebuf[filesize] = 0; + + /* Now scan the text of the input file */ + lineno = 1; + for(cp=filebuf; (c= *cp)!=0; ){ + if( c=='\n' ) lineno++; /* Keep track of the line number */ + if( isspace(c) ){ cp++; continue; } /* Skip all white space */ + if( c=='/' && cp[1]=='/' ){ /* Skip C++ style comments */ + cp+=2; + while( (c= *cp)!=0 && c!='\n' ) cp++; + continue; + } + if( c=='/' && cp[1]=='*' ){ /* Skip C style comments */ + cp+=2; + while( (c= *cp)!=0 && (c!='/' || cp[-1]!='*') ){ + if( c=='\n' ) lineno++; + cp++; + } + if( c ) cp++; + continue; + } + ps.tokenstart = cp; /* Mark the beginning of the token */ + ps.tokenlineno = lineno; /* Linenumber on which token begins */ + if( c=='\"' ){ /* String literals */ + cp++; + while( (c= *cp)!=0 && c!='\"' ){ + if( c=='\n' ) lineno++; + cp++; + } + if( c==0 ){ + ErrorMsg(ps.filename,startline, +"String starting on this line is not terminated before the end of the file."); + ps.errorcnt++; + nextcp = cp; + }else{ + nextcp = cp+1; + } + }else if( c=='{' ){ /* A block of C code */ + int level; + cp++; + for(level=1; (c= *cp)!=0 && (level>1 || c!='}'); cp++){ + if( c=='\n' ) lineno++; + else if( c=='{' ) level++; + else if( c=='}' ) level--; + else if( c=='/' && cp[1]=='*' ){ /* Skip comments */ + int prevc; + cp = &cp[2]; + prevc = 0; + while( (c= *cp)!=0 && (c!='/' || prevc!='*') ){ + if( c=='\n' ) lineno++; + prevc = c; + cp++; + } + }else if( c=='/' && cp[1]=='/' ){ /* Skip C++ style comments too */ + cp = &cp[2]; + while( (c= *cp)!=0 && c!='\n' ) cp++; + if( c ) lineno++; + }else if( c=='\'' || c=='\"' ){ /* String a character literals */ + int startchar, prevc; + startchar = c; + prevc = 0; + for(cp++; (c= *cp)!=0 && (c!=startchar || prevc=='\\'); cp++){ + if( c=='\n' ) lineno++; + if( prevc=='\\' ) prevc = 0; + else prevc = c; + } + } + } + if( c==0 ){ + ErrorMsg(ps.filename,ps.tokenlineno, +"C code starting on this line is not terminated before the end of the file."); + ps.errorcnt++; + nextcp = cp; + }else{ + nextcp = cp+1; + } + }else if( isalnum(c) ){ /* Identifiers */ + while( (c= *cp)!=0 && (isalnum(c) || c=='_') ) cp++; + nextcp = cp; + }else if( c==':' && cp[1]==':' && cp[2]=='=' ){ /* The operator "::=" */ + cp += 3; + nextcp = cp; + }else{ /* All other (one character) operators */ + cp++; + nextcp = cp; + } + c = *cp; + *cp = 0; /* Null terminate the token */ + parseonetoken(&ps); /* Parse the token */ + *cp = c; /* Restore the buffer */ + cp = nextcp; + } + free(filebuf); /* Release the buffer after parsing */ + gp->rule = ps.firstrule; + gp->errorcnt = ps.errorcnt; +} +/*************************** From the file "plink.c" *********************/ +/* +** Routines processing configuration follow-set propagation links +** in the LEMON parser generator. +*/ +static struct plink *plink_freelist = 0; + +/* Allocate a new plink */ +struct plink *Plink_new(){ + struct plink *new; + + if( plink_freelist==0 ){ + int i; + int amt = 100; + plink_freelist = (struct plink *)malloc( sizeof(struct plink)*amt ); + if( plink_freelist==0 ){ + fprintf(stderr, + "Unable to allocate memory for a new follow-set propagation link.\n"); + exit(1); + } + for(i=0; i<amt-1; i++) plink_freelist[i].next = &plink_freelist[i+1]; + plink_freelist[amt-1].next = 0; + } + new = plink_freelist; + plink_freelist = plink_freelist->next; + return new; +} + +/* Add a plink to a plink list */ +void Plink_add(plpp,cfp) +struct plink **plpp; +struct config *cfp; +{ + struct plink *new; + new = Plink_new(); + new->next = *plpp; + *plpp = new; + new->cfp = cfp; +} + +/* Transfer every plink on the list "from" to the list "to" */ +void Plink_copy(to,from) +struct plink **to; +struct plink *from; +{ + struct plink *nextpl; + while( from ){ + nextpl = from->next; + from->next = *to; + *to = from; + from = nextpl; + } +} + +/* Delete every plink on the list */ +void Plink_delete(plp) +struct plink *plp; +{ + struct plink *nextpl; + + while( plp ){ + nextpl = plp->next; + plp->next = plink_freelist; + plink_freelist = plp; + plp = nextpl; + } +} +/*********************** From the file "report.c" **************************/ +/* +** Procedures for generating reports and tables in the LEMON parser generator. +*/ + +/* Generate a filename with the given suffix. Space to hold the +** name comes from malloc() and must be freed by the calling +** function. +*/ +PRIVATE char *file_makename(lemp,suffix) +struct lemon *lemp; +char *suffix; +{ + char *name; + char *cp; + + name = malloc( strlen(lemp->filename) + strlen(suffix) + 5 ); + if( name==0 ){ + fprintf(stderr,"Can't allocate space for a filename.\n"); + exit(1); + } + strcpy(name,lemp->filename); + cp = strrchr(name,'.'); + if( cp ) *cp = 0; + strcat(name,suffix); + return name; +} + +/* Open a file with a name based on the name of the input file, +** but with a different (specified) suffix, and return a pointer +** to the stream */ +PRIVATE FILE *file_open(lemp,suffix,mode) +struct lemon *lemp; +char *suffix; +char *mode; +{ + FILE *fp; + + if( lemp->outname ) free(lemp->outname); + lemp->outname = file_makename(lemp, suffix); + fp = fopen(lemp->outname,mode); + if( fp==0 && *mode=='w' ){ + fprintf(stderr,"Can't open file \"%s\".\n",lemp->outname); + lemp->errorcnt++; + return 0; + } + return fp; +} + +/* Duplicate the input file without comments and without actions +** on rules */ +void Reprint(lemp) +struct lemon *lemp; +{ + struct rule *rp; + struct symbol *sp; + int i, j, maxlen, len, ncolumns, skip; + printf("// Reprint of input file \"%s\".\n// Symbols:\n",lemp->filename); + maxlen = 10; + for(i=0; i<lemp->nsymbol; i++){ + sp = lemp->symbols[i]; + len = strlen(sp->name); + if( len>maxlen ) maxlen = len; + } + ncolumns = 76/(maxlen+5); + if( ncolumns<1 ) ncolumns = 1; + skip = (lemp->nsymbol + ncolumns - 1)/ncolumns; + for(i=0; i<skip; i++){ + printf("//"); + for(j=i; j<lemp->nsymbol; j+=skip){ + sp = lemp->symbols[j]; + assert( sp->index==j ); + printf(" %3d %-*.*s",j,maxlen,maxlen,sp->name); + } + printf("\n"); + } + for(rp=lemp->rule; rp; rp=rp->next){ + printf("%s",rp->lhs->name); +/* if( rp->lhsalias ) printf("(%s)",rp->lhsalias); */ + printf(" ::="); + for(i=0; i<rp->nrhs; i++){ + printf(" %s",rp->rhs[i]->name); +/* if( rp->rhsalias[i] ) printf("(%s)",rp->rhsalias[i]); */ + } + printf("."); + if( rp->precsym ) printf(" [%s]",rp->precsym->name); +/* if( rp->code ) printf("\n %s",rp->code); */ + printf("\n"); + } +} + +void ConfigPrint(fp,cfp) +FILE *fp; +struct config *cfp; +{ + struct rule *rp; + int i; + rp = cfp->rp; + fprintf(fp,"%s ::=",rp->lhs->name); + for(i=0; i<=rp->nrhs; i++){ + if( i==cfp->dot ) fprintf(fp," *"); + if( i==rp->nrhs ) break; + fprintf(fp," %s",rp->rhs[i]->name); + } +} + +/* #define TEST */ +#ifdef TEST +/* Print a set */ +PRIVATE void SetPrint(out,set,lemp) +FILE *out; +char *set; +struct lemon *lemp; +{ + int i; + char *spacer; + spacer = ""; + fprintf(out,"%12s[",""); + for(i=0; i<lemp->nterminal; i++){ + if( SetFind(set,i) ){ + fprintf(out,"%s%s",spacer,lemp->symbols[i]->name); + spacer = " "; + } + } + fprintf(out,"]\n"); +} + +/* Print a plink chain */ +PRIVATE void PlinkPrint(out,plp,tag) +FILE *out; +struct plink *plp; +char *tag; +{ + while( plp ){ + fprintf(out,"%12s%s (state %2d) ","",tag,plp->cfp->stp->index); + ConfigPrint(out,plp->cfp); + fprintf(out,"\n"); + plp = plp->next; + } +} +#endif + +/* Print an action to the given file descriptor. Return FALSE if +** nothing was actually printed. +*/ +int PrintAction(struct action *ap, FILE *fp, int indent){ + int result = 1; + switch( ap->type ){ + case SHIFT: + fprintf(fp,"%*s shift %d",indent,ap->sp->name,ap->x.stp->index); + break; + case REDUCE: + fprintf(fp,"%*s reduce %d",indent,ap->sp->name,ap->x.rp->index); + break; + case ACCEPT: + fprintf(fp,"%*s accept",indent,ap->sp->name); + break; + case ERROR: + fprintf(fp,"%*s error",indent,ap->sp->name); + break; + case CONFLICT: + fprintf(fp,"%*s reduce %-3d ** Parsing conflict **", + indent,ap->sp->name,ap->x.rp->index); + break; + case SH_RESOLVED: + case RD_RESOLVED: + case NOT_USED: + result = 0; + break; + } + return result; +} + +/* Generate the "y.output" log file */ +void ReportOutput(lemp) +struct lemon *lemp; +{ + int i; + struct state *stp; + struct config *cfp; + struct action *ap; + FILE *fp; + + fp = file_open(lemp,".out","w"); + if( fp==0 ) return; + fprintf(fp," \b"); + for(i=0; i<lemp->nstate; i++){ + stp = lemp->sorted[i]; + fprintf(fp,"State %d:\n",stp->index); + if( lemp->basisflag ) cfp=stp->bp; + else cfp=stp->cfp; + while( cfp ){ + char buf[20]; + if( cfp->dot==cfp->rp->nrhs ){ + sprintf(buf,"(%d)",cfp->rp->index); + fprintf(fp," %5s ",buf); + }else{ + fprintf(fp," "); + } + ConfigPrint(fp,cfp); + fprintf(fp,"\n"); +#ifdef TEST + SetPrint(fp,cfp->fws,lemp); + PlinkPrint(fp,cfp->fplp,"To "); + PlinkPrint(fp,cfp->bplp,"From"); +#endif + if( lemp->basisflag ) cfp=cfp->bp; + else cfp=cfp->next; + } + fprintf(fp,"\n"); + for(ap=stp->ap; ap; ap=ap->next){ + if( PrintAction(ap,fp,30) ) fprintf(fp,"\n"); + } + fprintf(fp,"\n"); + } + fclose(fp); + return; +} + +/* Search for the file "name" which is in the same directory as +** the exacutable */ +PRIVATE char *pathsearch(argv0,name,modemask) +char *argv0; +char *name; +int modemask; +{ + char *pathlist; + char *path,*cp; + char c; + extern int access(); + +#ifdef __WIN32__ + cp = strrchr(argv0,'\\'); +#else + cp = strrchr(argv0,'/'); +#endif + if( cp ){ + c = *cp; + *cp = 0; + path = (char *)malloc( strlen(argv0) + strlen(name) + 2 ); + if( path ) sprintf(path,"%s/%s",argv0,name); + *cp = c; + }else{ + extern char *getenv(); + pathlist = getenv("PATH"); + if( pathlist==0 ) pathlist = ".:/bin:/usr/bin"; + path = (char *)malloc( strlen(pathlist)+strlen(name)+2 ); + if( path!=0 ){ + while( *pathlist ){ + cp = strchr(pathlist,':'); + if( cp==0 ) cp = &pathlist[strlen(pathlist)]; + c = *cp; + *cp = 0; + sprintf(path,"%s/%s",pathlist,name); + *cp = c; + if( c==0 ) pathlist = ""; + else pathlist = &cp[1]; + if( access(path,modemask)==0 ) break; + } + } + } + return path; +} + +/* Given an action, compute the integer value for that action +** which is to be put in the action table of the generated machine. +** Return negative if no action should be generated. +*/ +PRIVATE int compute_action(lemp,ap) +struct lemon *lemp; +struct action *ap; +{ + int act; + switch( ap->type ){ + case SHIFT: act = ap->x.stp->index; break; + case REDUCE: act = ap->x.rp->index + lemp->nstate; break; + case ERROR: act = lemp->nstate + lemp->nrule; break; + case ACCEPT: act = lemp->nstate + lemp->nrule + 1; break; + default: act = -1; break; + } + return act; +} + +#define LINESIZE 1000 +/* The next cluster of routines are for reading the template file +** and writing the results to the generated parser */ +/* The first function transfers data from "in" to "out" until +** a line is seen which begins with "%%". The line number is +** tracked. +** +** if name!=0, then any word that begin with "Parse" is changed to +** begin with *name instead. +*/ +PRIVATE void tplt_xfer(name,in,out,lineno) +char *name; +FILE *in; +FILE *out; +int *lineno; +{ + int i, iStart; + char line[LINESIZE]; + while( fgets(line,LINESIZE,in) && (line[0]!='%' || line[1]!='%') ){ + (*lineno)++; + iStart = 0; + if( name ){ + for(i=0; line[i]; i++){ + if( line[i]=='P' && strncmp(&line[i],"Parse",5)==0 + && (i==0 || !isalpha(line[i-1])) + ){ + if( i>iStart ) fprintf(out,"%.*s",i-iStart,&line[iStart]); + fprintf(out,"%s",name); + i += 4; + iStart = i+1; + } + } + } + fprintf(out,"%s",&line[iStart]); + } +} + +/* The next function finds the template file and opens it, returning +** a pointer to the opened file. */ +PRIVATE FILE *tplt_open(lemp) +struct lemon *lemp; +{ + static char templatename[] = "lempar.c"; + char buf[1000]; + FILE *in; + char *tpltname; + char *cp; + + cp = strrchr(lemp->filename,'.'); + if( cp ){ + sprintf(buf,"%.*s.lt",(unsigned long)cp-(unsigned long)lemp->filename,lemp->filename); + }else{ + sprintf(buf,"%s.lt",lemp->filename); + } + if( access(buf,004)==0 ){ + tpltname = buf; + }else if( access(templatename,004)==0 ){ + tpltname = templatename; + }else{ + tpltname = pathsearch(lemp->argv0,templatename,0); + } + if( tpltname==0 ){ + fprintf(stderr,"Can't find the parser driver template file \"%s\".\n", + templatename); + lemp->errorcnt++; + return 0; + } + in = fopen(tpltname,"r"); + if( in==0 ){ + fprintf(stderr,"Can't open the template file \"%s\".\n",templatename); + lemp->errorcnt++; + return 0; + } + return in; +} + +/* Print a string to the file and keep the linenumber up to date */ +PRIVATE void tplt_print(out,lemp,str,strln,lineno) +FILE *out; +struct lemon *lemp; +char *str; +int strln; +int *lineno; +{ + if( str==0 ) return; + fprintf(out,"#line %d \"%s\"\n",strln,lemp->filename); (*lineno)++; + while( *str ){ + if( *str=='\n' ) (*lineno)++; + putc(*str,out); + str++; + } + fprintf(out,"\n#line %d \"%s\"\n",*lineno+2,lemp->outname); (*lineno)+=2; + return; +} + +/* +** The following routine emits code for the destructor for the +** symbol sp +*/ +void emit_destructor_code(out,sp,lemp,lineno) +FILE *out; +struct symbol *sp; +struct lemon *lemp; +int *lineno; +{ + char *cp; + + int linecnt = 0; + if( sp->type==TERMINAL ){ + cp = lemp->tokendest; + if( cp==0 ) return; + fprintf(out,"#line %d \"%s\"\n{",lemp->tokendestln,lemp->filename); + }else if( sp->destructor ){ + cp = sp->destructor; + fprintf(out,"#line %d \"%s\"\n{",sp->destructorln,lemp->filename); + }else if( lemp->vardest ){ + cp = lemp->vardest; + if( cp==0 ) return; + fprintf(out,"#line %d \"%s\"\n{",lemp->vardestln,lemp->filename); + } + for(; *cp; cp++){ + if( *cp=='$' && cp[1]=='$' ){ + fprintf(out,"(yypminor->yy%d)",sp->dtnum); + cp++; + continue; + } + if( *cp=='\n' ) linecnt++; + fputc(*cp,out); + } + (*lineno) += 3 + linecnt; + fprintf(out,"}\n#line %d \"%s\"\n",*lineno,lemp->outname); + return; +} + +/* +** Return TRUE (non-zero) if the given symbol has a destructor. +*/ +int has_destructor(sp, lemp) +struct symbol *sp; +struct lemon *lemp; +{ + int ret; + if( sp->type==TERMINAL ){ + ret = lemp->tokendest!=0; + }else{ + ret = lemp->vardest!=0 || sp->destructor!=0; + } + return ret; +} + +/* +** Generate code which executes when the rule "rp" is reduced. Write +** the code to "out". Make sure lineno stays up-to-date. +*/ +PRIVATE void emit_code(out,rp,lemp,lineno) +FILE *out; +struct rule *rp; +struct lemon *lemp; +int *lineno; +{ + char *cp, *xp; + int linecnt = 0; + int i; + char lhsused = 0; /* True if the LHS element has been used */ + char used[MAXRHS]; /* True for each RHS element which is used */ + + for(i=0; i<rp->nrhs; i++) used[i] = 0; + lhsused = 0; + + /* Generate code to do the reduce action */ + if( rp->code ){ + fprintf(out,"#line %d \"%s\"\n{",rp->line,lemp->filename); + for(cp=rp->code; *cp; cp++){ + if( isalpha(*cp) && (cp==rp->code || (!isalnum(cp[-1]) && cp[-1]!='_')) ){ + char saved; + for(xp= &cp[1]; isalnum(*xp) || *xp=='_'; xp++); + saved = *xp; + *xp = 0; + if( rp->lhsalias && strcmp(cp,rp->lhsalias)==0 ){ + fprintf(out,"yygotominor.yy%d",rp->lhs->dtnum); + cp = xp; + lhsused = 1; + }else{ + for(i=0; i<rp->nrhs; i++){ + if( rp->rhsalias[i] && strcmp(cp,rp->rhsalias[i])==0 ){ + fprintf(out,"yymsp[%d].minor.yy%d",i-rp->nrhs+1,rp->rhs[i]->dtnum); + cp = xp; + used[i] = 1; + break; + } + } + } + *xp = saved; + } + if( *cp=='\n' ) linecnt++; + fputc(*cp,out); + } /* End loop */ + (*lineno) += 3 + linecnt; + fprintf(out,"}\n#line %d \"%s\"\n",*lineno,lemp->outname); + } /* End if( rp->code ) */ + + /* Check to make sure the LHS has been used */ + if( rp->lhsalias && !lhsused ){ + ErrorMsg(lemp->filename,rp->ruleline, + "Label \"%s\" for \"%s(%s)\" is never used.", + rp->lhsalias,rp->lhs->name,rp->lhsalias); + lemp->errorcnt++; + } + + /* Generate destructor code for RHS symbols which are not used in the + ** reduce code */ + for(i=0; i<rp->nrhs; i++){ + if( rp->rhsalias[i] && !used[i] ){ + ErrorMsg(lemp->filename,rp->ruleline, + "Label %s for \"%s(%s)\" is never used.", + rp->rhsalias[i],rp->rhs[i]->name,rp->rhsalias[i]); + lemp->errorcnt++; + }else if( rp->rhsalias[i]==0 ){ + if( has_destructor(rp->rhs[i],lemp) ){ + fprintf(out," yy_destructor(%d,&yymsp[%d].minor);\n", + rp->rhs[i]->index,i-rp->nrhs+1); (*lineno)++; + }else{ + fprintf(out," /* No destructor defined for %s */\n", + rp->rhs[i]->name); + (*lineno)++; + } + } + } + return; +} + +/* +** Print the definition of the union used for the parser's data stack. +** This union contains fields for every possible data type for tokens +** and nonterminals. In the process of computing and printing this +** union, also set the ".dtnum" field of every terminal and nonterminal +** symbol. +*/ +void print_stack_union(out,lemp,plineno,mhflag) +FILE *out; /* The output stream */ +struct lemon *lemp; /* The main info structure for this parser */ +int *plineno; /* Pointer to the line number */ +int mhflag; /* True if generating makeheaders output */ +{ + int lineno = *plineno; /* The line number of the output */ + char **types; /* A hash table of datatypes */ + int arraysize; /* Size of the "types" array */ + int maxdtlength; /* Maximum length of any ".datatype" field. */ + char *stddt; /* Standardized name for a datatype */ + int i,j; /* Loop counters */ + int hash; /* For hashing the name of a type */ + char *name; /* Name of the parser */ + + /* Allocate and initialize types[] and allocate stddt[] */ + arraysize = lemp->nsymbol * 2; + types = (char**)malloc( arraysize * sizeof(char*) ); + for(i=0; i<arraysize; i++) types[i] = 0; + maxdtlength = 0; + if( lemp->vartype ){ + maxdtlength = strlen(lemp->vartype); + } + for(i=0; i<lemp->nsymbol; i++){ + int len; + struct symbol *sp = lemp->symbols[i]; + if( sp->datatype==0 ) continue; + len = strlen(sp->datatype); + if( len>maxdtlength ) maxdtlength = len; + } + stddt = (char*)malloc( maxdtlength*2 + 1 ); + if( types==0 || stddt==0 ){ + fprintf(stderr,"Out of memory.\n"); + exit(1); + } + + /* Build a hash table of datatypes. The ".dtnum" field of each symbol + ** is filled in with the hash index plus 1. A ".dtnum" value of 0 is + ** used for terminal symbols. If there is no %default_type defined then + ** 0 is also used as the .dtnum value for nonterminals which do not specify + ** a datatype using the %type directive. + */ + for(i=0; i<lemp->nsymbol; i++){ + struct symbol *sp = lemp->symbols[i]; + char *cp; + if( sp==lemp->errsym ){ + sp->dtnum = arraysize+1; + continue; + } + if( sp->type!=NONTERMINAL || (sp->datatype==0 && lemp->vartype==0) ){ + sp->dtnum = 0; + continue; + } + cp = sp->datatype; + if( cp==0 ) cp = lemp->vartype; + j = 0; + while( isspace(*cp) ) cp++; + while( *cp ) stddt[j++] = *cp++; + while( j>0 && isspace(stddt[j-1]) ) j--; + stddt[j] = 0; + hash = 0; + for(j=0; stddt[j]; j++){ + hash = hash*53 + stddt[j]; + } + hash = (hash & 0x7fffffff)%arraysize; + while( types[hash] ){ + if( strcmp(types[hash],stddt)==0 ){ + sp->dtnum = hash + 1; + break; + } + hash++; + if( hash>=arraysize ) hash = 0; + } + if( types[hash]==0 ){ + sp->dtnum = hash + 1; + types[hash] = (char*)malloc( strlen(stddt)+1 ); + if( types[hash]==0 ){ + fprintf(stderr,"Out of memory.\n"); + exit(1); + } + strcpy(types[hash],stddt); + } + } + + /* Print out the definition of YYTOKENTYPE and YYMINORTYPE */ + name = lemp->name ? lemp->name : "Parse"; + lineno = *plineno; + if( mhflag ){ fprintf(out,"#if INTERFACE\n"); lineno++; } + fprintf(out,"#define %sTOKENTYPE %s\n",name, + lemp->tokentype?lemp->tokentype:"void*"); lineno++; + if( mhflag ){ fprintf(out,"#endif\n"); lineno++; } + fprintf(out,"typedef union {\n"); lineno++; + fprintf(out," %sTOKENTYPE yy0;\n",name); lineno++; + for(i=0; i<arraysize; i++){ + if( types[i]==0 ) continue; + fprintf(out," %s yy%d;\n",types[i],i+1); lineno++; + free(types[i]); + } + fprintf(out," int yy%d;\n",lemp->errsym->dtnum); lineno++; + free(stddt); + free(types); + fprintf(out,"} YYMINORTYPE;\n"); lineno++; + *plineno = lineno; +} + +/* +** Return the name of a C datatype able to represent values between +** 0 and N, inclusive. +*/ +static const char *minimum_size_type(int N){ + if( N<=255 ){ + return "unsigned char"; + }else if( N<65535 ){ + return "unsigned short int"; + }else{ + return "unsigned int"; + } +} + +/* Generate C source code for the parser */ +void ReportTable(lemp, mhflag) +struct lemon *lemp; +int mhflag; /* Output in makeheaders format if true */ +{ + FILE *out, *in; + char line[LINESIZE]; + int lineno; + struct state *stp; + struct action *ap; + struct rule *rp; + int i, j; + int tablecnt; + char *name; + + in = tplt_open(lemp); + if( in==0 ) return; + out = file_open(lemp,".c","w"); + if( out==0 ){ + fclose(in); + return; + } + lineno = 1; + tplt_xfer(lemp->name,in,out,&lineno); + + /* Generate the include code, if any */ + tplt_print(out,lemp,lemp->include,lemp->includeln,&lineno); + if( mhflag ){ + char *name = file_makename(lemp, ".h"); + fprintf(out,"#include \"%s\"\n", name); lineno++; + free(name); + } + tplt_xfer(lemp->name,in,out,&lineno); + + /* Generate #defines for all tokens */ + if( mhflag ){ + char *prefix; + fprintf(out,"#if INTERFACE\n"); lineno++; + if( lemp->tokenprefix ) prefix = lemp->tokenprefix; + else prefix = ""; + for(i=1; i<lemp->nterminal; i++){ + fprintf(out,"#define %s%-30s %2d\n",prefix,lemp->symbols[i]->name,i); + lineno++; + } + fprintf(out,"#endif\n"); lineno++; + } + tplt_xfer(lemp->name,in,out,&lineno); + + /* Generate the defines */ + fprintf(out,"/* \001 */\n"); + fprintf(out,"#define YYCODETYPE %s\n", + minimum_size_type(lemp->nsymbol+5)); lineno++; + fprintf(out,"#define YYNOCODE %d\n",lemp->nsymbol+1); lineno++; + fprintf(out,"#define YYACTIONTYPE %s\n", + minimum_size_type(lemp->nstate+lemp->nrule+5)); lineno++; + print_stack_union(out,lemp,&lineno,mhflag); + if( lemp->stacksize ){ + if( atoi(lemp->stacksize)<=0 ){ + ErrorMsg(lemp->filename,0, +"Illegal stack size: [%s]. The stack size should be an integer constant.", + lemp->stacksize); + lemp->errorcnt++; + lemp->stacksize = "100"; + } + fprintf(out,"#define YYSTACKDEPTH %s\n",lemp->stacksize); lineno++; + }else{ + fprintf(out,"#define YYSTACKDEPTH 100\n"); lineno++; + } + if( mhflag ){ + fprintf(out,"#if INTERFACE\n"); lineno++; + } + name = lemp->name ? lemp->name : "Parse"; + if( lemp->arg && lemp->arg[0] ){ + int i; + i = strlen(lemp->arg); + while( i>=1 && isspace(lemp->arg[i-1]) ) i--; + while( i>=1 && (isalnum(lemp->arg[i-1]) || lemp->arg[i-1]=='_') ) i--; + fprintf(out,"#define %sARG_SDECL %s;\n",name,lemp->arg); lineno++; + fprintf(out,"#define %sARG_PDECL ,%s\n",name,lemp->arg); lineno++; + fprintf(out,"#define %sARG_FETCH %s = yypParser->%s\n", + name,lemp->arg,&lemp->arg[i]); lineno++; + fprintf(out,"#define %sARG_STORE yypParser->%s = %s\n", + name,&lemp->arg[i],&lemp->arg[i]); lineno++; + }else{ + fprintf(out,"#define %sARG_SDECL\n",name); lineno++; + fprintf(out,"#define %sARG_PDECL\n",name); lineno++; + fprintf(out,"#define %sARG_FETCH\n",name); lineno++; + fprintf(out,"#define %sARG_STORE\n",name); lineno++; + } + if( mhflag ){ + fprintf(out,"#endif\n"); lineno++; + } + fprintf(out,"#define YYNSTATE %d\n",lemp->nstate); lineno++; + fprintf(out,"#define YYNRULE %d\n",lemp->nrule); lineno++; + fprintf(out,"#define YYERRORSYMBOL %d\n",lemp->errsym->index); lineno++; + fprintf(out,"#define YYERRSYMDT yy%d\n",lemp->errsym->dtnum); lineno++; + if( lemp->has_fallback ){ + fprintf(out,"#define YYFALLBACK 1\n"); lineno++; + } + tplt_xfer(lemp->name,in,out,&lineno); + + /* Generate the action table. + ** + ** Each entry in the action table is an element of the following + ** structure: + ** struct yyActionEntry { + ** YYCODETYPE lookahead; + ** YYCODETYPE next; + ** YYACTIONTYPE action; + ** } + ** + ** The entries are grouped into hash tables, one hash table for each + ** parser state. The hash table has a size which is the number of + ** entries in that table. In case of a collision, the "next" value + ** contains one more than the index into the hash table of the next + ** entry in the collision chain. A "next" value of 0 means the end + ** of the chain has been reached. + */ + tablecnt = 0; + + /* Loop over parser states */ + for(i=0; i<lemp->nstate; i++){ + int tablesize; /* size of the hash table */ + int j,k; /* Loop counter */ + int collide[2048]; /* The collision chain for the table */ + struct action *table[2048]; /* Build the hash table here */ + + /* Find the number of actions and initialize the hash table */ + stp = lemp->sorted[i]; + stp->tabstart = tablecnt; + stp->naction = 0; + for(ap=stp->ap; ap; ap=ap->next){ + if( ap->sp->index!=lemp->nsymbol && compute_action(lemp,ap)>=0 ){ + stp->naction++; + } + } + tablesize = stp->naction; + assert( tablesize<= sizeof(table)/sizeof(table[0]) ); + for(j=0; j<tablesize; j++){ + table[j] = 0; + collide[j] = -1; + } + + /* Hash the actions into the hash table */ + stp->tabdfltact = lemp->nstate + lemp->nrule; + for(ap=stp->ap; ap; ap=ap->next){ + int action = compute_action(lemp,ap); + int h; + if( ap->sp->index==lemp->nsymbol ){ + stp->tabdfltact = action; + }else if( action>=0 ){ + h = ap->sp->index % tablesize; + ap->collide = table[h]; + table[h] = ap; + } + } + + /* Resolve collisions */ + for(j=k=0; j<tablesize; j++){ + if( table[j] && table[j]->collide ){ + while( table[k] ) k++; + table[k] = table[j]->collide; + collide[j] = k; + table[j]->collide = 0; + if( k<j ) j = k-1; + } + } + + /* Print the hash table */ + if( tablesize>0 ){ + fprintf(out,"/* State %d */\n",stp->index); lineno++; + } + for(j=0; j<tablesize; j++){ + assert( table[j]!=0 ); + fprintf(out," {%4d,%4d,%4d}, /* %2d: ", + table[j]->sp->index, + collide[j]+1, + compute_action(lemp,table[j]), + j+1); + PrintAction(table[j],out,22); + fprintf(out," */\n"); + lineno++; + } + + /* Update the table count */ + tablecnt += tablesize; + } + tplt_xfer(lemp->name,in,out,&lineno); + lemp->tablesize = tablecnt; + + /* Generate the state table + ** + ** Each entry is an element of the following structure: + ** struct yyStateEntry { + ** struct yyActionEntry *hashtbl; + ** YYCODETYPE nEntry; + ** YYACTIONTYPE actionDefault; + ** } + */ + for(i=0; i<lemp->nstate; i++){ + stp = lemp->sorted[i]; + fprintf(out," { &yyActionTable[%d],%4d,%4d },\n", + stp->tabstart, + stp->naction, + stp->tabdfltact); lineno++; + } + tplt_xfer(lemp->name,in,out,&lineno); + + /* Generate the table of fallback tokens. + */ + if( lemp->has_fallback ){ + for(i=0; i<lemp->nterminal; i++){ + struct symbol *p = lemp->symbols[i]; + if( p->fallback==0 ){ + fprintf(out, " 0, /* %10s => nothing */\n", p->name); + }else{ + fprintf(out, " %3d, /* %10s => %s */\n", p->fallback->index, + p->name, p->fallback->name); + } + lineno++; + } + } + tplt_xfer(lemp->name, in, out, &lineno); + + /* Generate a table containing the symbolic name of every symbol + */ + for(i=0; i<lemp->nsymbol; i++){ + sprintf(line,"\"%s\",",lemp->symbols[i]->name); + fprintf(out," %-15s",line); + if( (i&3)==3 ){ fprintf(out,"\n"); lineno++; } + } + if( (i&3)!=0 ){ fprintf(out,"\n"); lineno++; } + tplt_xfer(lemp->name,in,out,&lineno); + + /* Generate a table containing a text string that describes every + ** rule in the rule set of the grammer. This information is used + ** when tracing REDUCE actions. + */ + for(i=0, rp=lemp->rule; rp; rp=rp->next, i++){ + assert( rp->index==i ); + fprintf(out," /* %3d */ \"%s ::=", i, rp->lhs->name); + for(j=0; j<rp->nrhs; j++) fprintf(out," %s",rp->rhs[j]->name); + fprintf(out,"\",\n"); lineno++; + } + tplt_xfer(lemp->name,in,out,&lineno); + + /* Generate code which executes every time a symbol is popped from + ** the stack while processing errors or while destroying the parser. + ** (In other words, generate the %destructor actions) + */ + if( lemp->tokendest ){ + for(i=0; i<lemp->nsymbol; i++){ + struct symbol *sp = lemp->symbols[i]; + if( sp==0 || sp->type!=TERMINAL ) continue; + fprintf(out," case %d:\n",sp->index); lineno++; + } + for(i=0; i<lemp->nsymbol && lemp->symbols[i]->type!=TERMINAL; i++); + if( i<lemp->nsymbol ){ + emit_destructor_code(out,lemp->symbols[i],lemp,&lineno); + fprintf(out," break;\n"); lineno++; + } + } + for(i=0; i<lemp->nsymbol; i++){ + struct symbol *sp = lemp->symbols[i]; + if( sp==0 || sp->type==TERMINAL || sp->destructor==0 ) continue; + fprintf(out," case %d:\n",sp->index); lineno++; + emit_destructor_code(out,lemp->symbols[i],lemp,&lineno); + fprintf(out," break;\n"); lineno++; + } + if( lemp->vardest ){ + struct symbol *dflt_sp = 0; + for(i=0; i<lemp->nsymbol; i++){ + struct symbol *sp = lemp->symbols[i]; + if( sp==0 || sp->type==TERMINAL || + sp->index<=0 || sp->destructor!=0 ) continue; + fprintf(out," case %d:\n",sp->index); lineno++; + dflt_sp = sp; + } + if( dflt_sp!=0 ){ + emit_destructor_code(out,dflt_sp,lemp,&lineno); + fprintf(out," break;\n"); lineno++; + } + } + tplt_xfer(lemp->name,in,out,&lineno); + + /* Generate code which executes whenever the parser stack overflows */ + tplt_print(out,lemp,lemp->overflow,lemp->overflowln,&lineno); + tplt_xfer(lemp->name,in,out,&lineno); + + /* Generate the table of rule information + ** + ** Note: This code depends on the fact that rules are number + ** sequentually beginning with 0. + */ + for(rp=lemp->rule; rp; rp=rp->next){ + fprintf(out," { %d, %d },\n",rp->lhs->index,rp->nrhs); lineno++; + } + tplt_xfer(lemp->name,in,out,&lineno); + + /* Generate code which execution during each REDUCE action */ + for(rp=lemp->rule; rp; rp=rp->next){ + fprintf(out," case %d:\n",rp->index); lineno++; + emit_code(out,rp,lemp,&lineno); + fprintf(out," break;\n"); lineno++; + } + tplt_xfer(lemp->name,in,out,&lineno); + + /* Generate code which executes if a parse fails */ + tplt_print(out,lemp,lemp->failure,lemp->failureln,&lineno); + tplt_xfer(lemp->name,in,out,&lineno); + + /* Generate code which executes when a syntax error occurs */ + tplt_print(out,lemp,lemp->error,lemp->errorln,&lineno); + tplt_xfer(lemp->name,in,out,&lineno); + + /* Generate code which executes when the parser accepts its input */ + tplt_print(out,lemp,lemp->accept,lemp->acceptln,&lineno); + tplt_xfer(lemp->name,in,out,&lineno); + + /* Append any addition code the user desires */ + tplt_print(out,lemp,lemp->extracode,lemp->extracodeln,&lineno); + + fclose(in); + fclose(out); + return; +} + +/* Generate a header file for the parser */ +void ReportHeader(lemp) +struct lemon *lemp; +{ + FILE *out, *in; + char *prefix; + char line[LINESIZE]; + char pattern[LINESIZE]; + int i; + + if( lemp->tokenprefix ) prefix = lemp->tokenprefix; + else prefix = ""; + in = file_open(lemp,".h","r"); + if( in ){ + for(i=1; i<lemp->nterminal && fgets(line,LINESIZE,in); i++){ + sprintf(pattern,"#define %s%-30s %2d\n",prefix,lemp->symbols[i]->name,i); + if( strcmp(line,pattern) ) break; + } + fclose(in); + if( i==lemp->nterminal ){ + /* No change in the file. Don't rewrite it. */ + return; + } + } + out = file_open(lemp,".h","w"); + if( out ){ + for(i=1; i<lemp->nterminal; i++){ + fprintf(out,"#define %s%-30s %2d\n",prefix,lemp->symbols[i]->name,i); + } + fclose(out); + } + return; +} + +/* Reduce the size of the action tables, if possible, by making use +** of defaults. +** +** In this version, we take the most frequent REDUCE action and make +** it the default. Only default a reduce if there are more than one. +*/ +void CompressTables(lemp) +struct lemon *lemp; +{ + struct state *stp; + struct action *ap, *ap2; + struct rule *rp, *rp2, *rbest; + int nbest, n; + int i; + int cnt; + + for(i=0; i<lemp->nstate; i++){ + stp = lemp->sorted[i]; + nbest = 0; + rbest = 0; + + for(ap=stp->ap; ap; ap=ap->next){ + if( ap->type!=REDUCE ) continue; + rp = ap->x.rp; + if( rp==rbest ) continue; + n = 1; + for(ap2=ap->next; ap2; ap2=ap2->next){ + if( ap2->type!=REDUCE ) continue; + rp2 = ap2->x.rp; + if( rp2==rbest ) continue; + if( rp2==rp ) n++; + } + if( n>nbest ){ + nbest = n; + rbest = rp; + } + } + + /* Do not make a default if the number of rules to default + ** is not at least 2 */ + if( nbest<2 ) continue; + + + /* Combine matching REDUCE actions into a single default */ + for(ap=stp->ap; ap; ap=ap->next){ + if( ap->type==REDUCE && ap->x.rp==rbest ) break; + } + assert( ap ); + ap->sp = Symbol_new("{default}"); + for(ap=ap->next; ap; ap=ap->next){ + if( ap->type==REDUCE && ap->x.rp==rbest ) ap->type = NOT_USED; + } + stp->ap = Action_sort(stp->ap); + } +} + +/***************** From the file "set.c" ************************************/ +/* +** Set manipulation routines for the LEMON parser generator. +*/ + +static int size = 0; + +/* Set the set size */ +void SetSize(n) +int n; +{ + size = n+1; +} + +/* Allocate a new set */ +char *SetNew(){ + char *s; + int i; + s = (char*)malloc( size ); + if( s==0 ){ + extern void memory_error(); + memory_error(); + } + for(i=0; i<size; i++) s[i] = 0; + return s; +} + +/* Deallocate a set */ +void SetFree(s) +char *s; +{ + free(s); +} + +/* Add a new element to the set. Return TRUE if the element was added +** and FALSE if it was already there. */ +int SetAdd(s,e) +char *s; +int e; +{ + int rv; + rv = s[e]; + s[e] = 1; + return !rv; +} + +/* Add every element of s2 to s1. Return TRUE if s1 changes. */ +int SetUnion(s1,s2) +char *s1; +char *s2; +{ + int i, progress; + progress = 0; + for(i=0; i<size; i++){ + if( s2[i]==0 ) continue; + if( s1[i]==0 ){ + progress = 1; + s1[i] = 1; + } + } + return progress; +} +/********************** From the file "table.c" ****************************/ +/* +** All code in this file has been automatically generated +** from a specification in the file +** "table.q" +** by the associative array code building program "aagen". +** Do not edit this file! Instead, edit the specification +** file, then rerun aagen. +*/ +/* +** Code for processing tables in the LEMON parser generator. +*/ + +PRIVATE int strhash(x) +char *x; +{ + int h = 0; + while( *x) h = h*13 + *(x++); + return h; +} + +/* Works like strdup, sort of. Save a string in malloced memory, but +** keep strings in a table so that the same string is not in more +** than one place. +*/ +char *Strsafe(y) +char *y; +{ + char *z; + + z = Strsafe_find(y); + if( z==0 && (z=malloc( strlen(y)+1 ))!=0 ){ + strcpy(z,y); + Strsafe_insert(z); + } + MemoryCheck(z); + return z; +} + +/* There is one instance of the following structure for each +** associative array of type "x1". +*/ +struct s_x1 { + int size; /* The number of available slots. */ + /* Must be a power of 2 greater than or */ + /* equal to 1 */ + int count; /* Number of currently slots filled */ + struct s_x1node *tbl; /* The data stored here */ + struct s_x1node **ht; /* Hash table for lookups */ +}; + +/* There is one instance of this structure for every data element +** in an associative array of type "x1". +*/ +typedef struct s_x1node { + char *data; /* The data */ + struct s_x1node *next; /* Next entry with the same hash */ + struct s_x1node **from; /* Previous link */ +} x1node; + +/* There is only one instance of the array, which is the following */ +static struct s_x1 *x1a; + +/* Allocate a new associative array */ +void Strsafe_init(){ + if( x1a ) return; + x1a = (struct s_x1*)malloc( sizeof(struct s_x1) ); + if( x1a ){ + x1a->size = 1024; + x1a->count = 0; + x1a->tbl = (x1node*)malloc( + (sizeof(x1node) + sizeof(x1node*))*1024 ); + if( x1a->tbl==0 ){ + free(x1a); + x1a = 0; + }else{ + int i; + x1a->ht = (x1node**)&(x1a->tbl[1024]); + for(i=0; i<1024; i++) x1a->ht[i] = 0; + } + } +} +/* Insert a new record into the array. Return TRUE if successful. +** Prior data with the same key is NOT overwritten */ +int Strsafe_insert(data) +char *data; +{ + x1node *np; + int h; + int ph; + + if( x1a==0 ) return 0; + ph = strhash(data); + h = ph & (x1a->size-1); + np = x1a->ht[h]; + while( np ){ + if( strcmp(np->data,data)==0 ){ + /* An existing entry with the same key is found. */ + /* Fail because overwrite is not allows. */ + return 0; + } + np = np->next; + } + if( x1a->count>=x1a->size ){ + /* Need to make the hash table bigger */ + int i,size; + struct s_x1 array; + array.size = size = x1a->size*2; + array.count = x1a->count; + array.tbl = (x1node*)malloc( + (sizeof(x1node) + sizeof(x1node*))*size ); + if( array.tbl==0 ) return 0; /* Fail due to malloc failure */ + array.ht = (x1node**)&(array.tbl[size]); + for(i=0; i<size; i++) array.ht[i] = 0; + for(i=0; i<x1a->count; i++){ + x1node *oldnp, *newnp; + oldnp = &(x1a->tbl[i]); + h = strhash(oldnp->data) & (size-1); + newnp = &(array.tbl[i]); + if( array.ht[h] ) array.ht[h]->from = &(newnp->next); + newnp->next = array.ht[h]; + newnp->data = oldnp->data; + newnp->from = &(array.ht[h]); + array.ht[h] = newnp; + } + free(x1a->tbl); + *x1a = array; + } + /* Insert the new data */ + h = ph & (x1a->size-1); + np = &(x1a->tbl[x1a->count++]); + np->data = data; + if( x1a->ht[h] ) x1a->ht[h]->from = &(np->next); + np->next = x1a->ht[h]; + x1a->ht[h] = np; + np->from = &(x1a->ht[h]); + return 1; +} + +/* Return a pointer to data assigned to the given key. Return NULL +** if no such key. */ +char *Strsafe_find(key) +char *key; +{ + int h; + x1node *np; + + if( x1a==0 ) return 0; + h = strhash(key) & (x1a->size-1); + np = x1a->ht[h]; + while( np ){ + if( strcmp(np->data,key)==0 ) break; + np = np->next; + } + return np ? np->data : 0; +} + +/* Return a pointer to the (terminal or nonterminal) symbol "x". +** Create a new symbol if this is the first time "x" has been seen. +*/ +struct symbol *Symbol_new(x) +char *x; +{ + struct symbol *sp; + + sp = Symbol_find(x); + if( sp==0 ){ + sp = (struct symbol *)malloc( sizeof(struct symbol) ); + MemoryCheck(sp); + sp->name = Strsafe(x); + sp->type = isupper(*x) ? TERMINAL : NONTERMINAL; + sp->rule = 0; + sp->fallback = 0; + sp->prec = -1; + sp->assoc = UNK; + sp->firstset = 0; + sp->lambda = B_FALSE; + sp->destructor = 0; + sp->datatype = 0; + Symbol_insert(sp,sp->name); + } + return sp; +} + +/* Compare two symbols */ +int Symbolcmpp(a,b) +struct symbol **a; +struct symbol **b; +{ + return strcmp((**a).name,(**b).name); +} + +/* There is one instance of the following structure for each +** associative array of type "x2". +*/ +struct s_x2 { + int size; /* The number of available slots. */ + /* Must be a power of 2 greater than or */ + /* equal to 1 */ + int count; /* Number of currently slots filled */ + struct s_x2node *tbl; /* The data stored here */ + struct s_x2node **ht; /* Hash table for lookups */ +}; + +/* There is one instance of this structure for every data element +** in an associative array of type "x2". +*/ +typedef struct s_x2node { + struct symbol *data; /* The data */ + char *key; /* The key */ + struct s_x2node *next; /* Next entry with the same hash */ + struct s_x2node **from; /* Previous link */ +} x2node; + +/* There is only one instance of the array, which is the following */ +static struct s_x2 *x2a; + +/* Allocate a new associative array */ +void Symbol_init(){ + if( x2a ) return; + x2a = (struct s_x2*)malloc( sizeof(struct s_x2) ); + if( x2a ){ + x2a->size = 128; + x2a->count = 0; + x2a->tbl = (x2node*)malloc( + (sizeof(x2node) + sizeof(x2node*))*128 ); + if( x2a->tbl==0 ){ + free(x2a); + x2a = 0; + }else{ + int i; + x2a->ht = (x2node**)&(x2a->tbl[128]); + for(i=0; i<128; i++) x2a->ht[i] = 0; + } + } +} +/* Insert a new record into the array. Return TRUE if successful. +** Prior data with the same key is NOT overwritten */ +int Symbol_insert(data,key) +struct symbol *data; +char *key; +{ + x2node *np; + int h; + int ph; + + if( x2a==0 ) return 0; + ph = strhash(key); + h = ph & (x2a->size-1); + np = x2a->ht[h]; + while( np ){ + if( strcmp(np->key,key)==0 ){ + /* An existing entry with the same key is found. */ + /* Fail because overwrite is not allows. */ + return 0; + } + np = np->next; + } + if( x2a->count>=x2a->size ){ + /* Need to make the hash table bigger */ + int i,size; + struct s_x2 array; + array.size = size = x2a->size*2; + array.count = x2a->count; + array.tbl = (x2node*)malloc( + (sizeof(x2node) + sizeof(x2node*))*size ); + if( array.tbl==0 ) return 0; /* Fail due to malloc failure */ + array.ht = (x2node**)&(array.tbl[size]); + for(i=0; i<size; i++) array.ht[i] = 0; + for(i=0; i<x2a->count; i++){ + x2node *oldnp, *newnp; + oldnp = &(x2a->tbl[i]); + h = strhash(oldnp->key) & (size-1); + newnp = &(array.tbl[i]); + if( array.ht[h] ) array.ht[h]->from = &(newnp->next); + newnp->next = array.ht[h]; + newnp->key = oldnp->key; + newnp->data = oldnp->data; + newnp->from = &(array.ht[h]); + array.ht[h] = newnp; + } + free(x2a->tbl); + *x2a = array; + } + /* Insert the new data */ + h = ph & (x2a->size-1); + np = &(x2a->tbl[x2a->count++]); + np->key = key; + np->data = data; + if( x2a->ht[h] ) x2a->ht[h]->from = &(np->next); + np->next = x2a->ht[h]; + x2a->ht[h] = np; + np->from = &(x2a->ht[h]); + return 1; +} + +/* Return a pointer to data assigned to the given key. Return NULL +** if no such key. */ +struct symbol *Symbol_find(key) +char *key; +{ + int h; + x2node *np; + + if( x2a==0 ) return 0; + h = strhash(key) & (x2a->size-1); + np = x2a->ht[h]; + while( np ){ + if( strcmp(np->key,key)==0 ) break; + np = np->next; + } + return np ? np->data : 0; +} + +/* Return the n-th data. Return NULL if n is out of range. */ +struct symbol *Symbol_Nth(n) +int n; +{ + struct symbol *data; + if( x2a && n>0 && n<=x2a->count ){ + data = x2a->tbl[n-1].data; + }else{ + data = 0; + } + return data; +} + +/* Return the size of the array */ +int Symbol_count() +{ + return x2a ? x2a->count : 0; +} + +/* Return an array of pointers to all data in the table. +** The array is obtained from malloc. Return NULL if memory allocation +** problems, or if the array is empty. */ +struct symbol **Symbol_arrayof() +{ + struct symbol **array; + int i,size; + if( x2a==0 ) return 0; + size = x2a->count; + array = (struct symbol **)malloc( sizeof(struct symbol *)*size ); + if( array ){ + for(i=0; i<size; i++) array[i] = x2a->tbl[i].data; + } + return array; +} + +/* Compare two configurations */ +int Configcmp(a,b) +struct config *a; +struct config *b; +{ + int x; + x = a->rp->index - b->rp->index; + if( x==0 ) x = a->dot - b->dot; + return x; +} + +/* Compare two states */ +PRIVATE int statecmp(a,b) +struct config *a; +struct config *b; +{ + int rc; + for(rc=0; rc==0 && a && b; a=a->bp, b=b->bp){ + rc = a->rp->index - b->rp->index; + if( rc==0 ) rc = a->dot - b->dot; + } + if( rc==0 ){ + if( a ) rc = 1; + if( b ) rc = -1; + } + return rc; +} + +/* Hash a state */ +PRIVATE int statehash(a) +struct config *a; +{ + int h=0; + while( a ){ + h = h*571 + a->rp->index*37 + a->dot; + a = a->bp; + } + return h; +} + +/* Allocate a new state structure */ +struct state *State_new() +{ + struct state *new; + new = (struct state *)malloc( sizeof(struct state) ); + MemoryCheck(new); + return new; +} + +/* There is one instance of the following structure for each +** associative array of type "x3". +*/ +struct s_x3 { + int size; /* The number of available slots. */ + /* Must be a power of 2 greater than or */ + /* equal to 1 */ + int count; /* Number of currently slots filled */ + struct s_x3node *tbl; /* The data stored here */ + struct s_x3node **ht; /* Hash table for lookups */ +}; + +/* There is one instance of this structure for every data element +** in an associative array of type "x3". +*/ +typedef struct s_x3node { + struct state *data; /* The data */ + struct config *key; /* The key */ + struct s_x3node *next; /* Next entry with the same hash */ + struct s_x3node **from; /* Previous link */ +} x3node; + +/* There is only one instance of the array, which is the following */ +static struct s_x3 *x3a; + +/* Allocate a new associative array */ +void State_init(){ + if( x3a ) return; + x3a = (struct s_x3*)malloc( sizeof(struct s_x3) ); + if( x3a ){ + x3a->size = 128; + x3a->count = 0; + x3a->tbl = (x3node*)malloc( + (sizeof(x3node) + sizeof(x3node*))*128 ); + if( x3a->tbl==0 ){ + free(x3a); + x3a = 0; + }else{ + int i; + x3a->ht = (x3node**)&(x3a->tbl[128]); + for(i=0; i<128; i++) x3a->ht[i] = 0; + } + } +} +/* Insert a new record into the array. Return TRUE if successful. +** Prior data with the same key is NOT overwritten */ +int State_insert(data,key) +struct state *data; +struct config *key; +{ + x3node *np; + int h; + int ph; + + if( x3a==0 ) return 0; + ph = statehash(key); + h = ph & (x3a->size-1); + np = x3a->ht[h]; + while( np ){ + if( statecmp(np->key,key)==0 ){ + /* An existing entry with the same key is found. */ + /* Fail because overwrite is not allows. */ + return 0; + } + np = np->next; + } + if( x3a->count>=x3a->size ){ + /* Need to make the hash table bigger */ + int i,size; + struct s_x3 array; + array.size = size = x3a->size*2; + array.count = x3a->count; + array.tbl = (x3node*)malloc( + (sizeof(x3node) + sizeof(x3node*))*size ); + if( array.tbl==0 ) return 0; /* Fail due to malloc failure */ + array.ht = (x3node**)&(array.tbl[size]); + for(i=0; i<size; i++) array.ht[i] = 0; + for(i=0; i<x3a->count; i++){ + x3node *oldnp, *newnp; + oldnp = &(x3a->tbl[i]); + h = statehash(oldnp->key) & (size-1); + newnp = &(array.tbl[i]); + if( array.ht[h] ) array.ht[h]->from = &(newnp->next); + newnp->next = array.ht[h]; + newnp->key = oldnp->key; + newnp->data = oldnp->data; + newnp->from = &(array.ht[h]); + array.ht[h] = newnp; + } + free(x3a->tbl); + *x3a = array; + } + /* Insert the new data */ + h = ph & (x3a->size-1); + np = &(x3a->tbl[x3a->count++]); + np->key = key; + np->data = data; + if( x3a->ht[h] ) x3a->ht[h]->from = &(np->next); + np->next = x3a->ht[h]; + x3a->ht[h] = np; + np->from = &(x3a->ht[h]); + return 1; +} + +/* Return a pointer to data assigned to the given key. Return NULL +** if no such key. */ +struct state *State_find(key) +struct config *key; +{ + int h; + x3node *np; + + if( x3a==0 ) return 0; + h = statehash(key) & (x3a->size-1); + np = x3a->ht[h]; + while( np ){ + if( statecmp(np->key,key)==0 ) break; + np = np->next; + } + return np ? np->data : 0; +} + +/* Return an array of pointers to all data in the table. +** The array is obtained from malloc. Return NULL if memory allocation +** problems, or if the array is empty. */ +struct state **State_arrayof() +{ + struct state **array; + int i,size; + if( x3a==0 ) return 0; + size = x3a->count; + array = (struct state **)malloc( sizeof(struct state *)*size ); + if( array ){ + for(i=0; i<size; i++) array[i] = x3a->tbl[i].data; + } + return array; +} + +/* Hash a configuration */ +PRIVATE int confighash(a) +struct config *a; +{ + int h=0; + h = h*571 + a->rp->index*37 + a->dot; + return h; +} + +/* There is one instance of the following structure for each +** associative array of type "x4". +*/ +struct s_x4 { + int size; /* The number of available slots. */ + /* Must be a power of 2 greater than or */ + /* equal to 1 */ + int count; /* Number of currently slots filled */ + struct s_x4node *tbl; /* The data stored here */ + struct s_x4node **ht; /* Hash table for lookups */ +}; + +/* There is one instance of this structure for every data element +** in an associative array of type "x4". +*/ +typedef struct s_x4node { + struct config *data; /* The data */ + struct s_x4node *next; /* Next entry with the same hash */ + struct s_x4node **from; /* Previous link */ +} x4node; + +/* There is only one instance of the array, which is the following */ +static struct s_x4 *x4a; + +/* Allocate a new associative array */ +void Configtable_init(){ + if( x4a ) return; + x4a = (struct s_x4*)malloc( sizeof(struct s_x4) ); + if( x4a ){ + x4a->size = 64; + x4a->count = 0; + x4a->tbl = (x4node*)malloc( + (sizeof(x4node) + sizeof(x4node*))*64 ); + if( x4a->tbl==0 ){ + free(x4a); + x4a = 0; + }else{ + int i; + x4a->ht = (x4node**)&(x4a->tbl[64]); + for(i=0; i<64; i++) x4a->ht[i] = 0; + } + } +} +/* Insert a new record into the array. Return TRUE if successful. +** Prior data with the same key is NOT overwritten */ +int Configtable_insert(data) +struct config *data; +{ + x4node *np; + int h; + int ph; + + if( x4a==0 ) return 0; + ph = confighash(data); + h = ph & (x4a->size-1); + np = x4a->ht[h]; + while( np ){ + if( Configcmp(np->data,data)==0 ){ + /* An existing entry with the same key is found. */ + /* Fail because overwrite is not allows. */ + return 0; + } + np = np->next; + } + if( x4a->count>=x4a->size ){ + /* Need to make the hash table bigger */ + int i,size; + struct s_x4 array; + array.size = size = x4a->size*2; + array.count = x4a->count; + array.tbl = (x4node*)malloc( + (sizeof(x4node) + sizeof(x4node*))*size ); + if( array.tbl==0 ) return 0; /* Fail due to malloc failure */ + array.ht = (x4node**)&(array.tbl[size]); + for(i=0; i<size; i++) array.ht[i] = 0; + for(i=0; i<x4a->count; i++){ + x4node *oldnp, *newnp; + oldnp = &(x4a->tbl[i]); + h = confighash(oldnp->data) & (size-1); + newnp = &(array.tbl[i]); + if( array.ht[h] ) array.ht[h]->from = &(newnp->next); + newnp->next = array.ht[h]; + newnp->data = oldnp->data; + newnp->from = &(array.ht[h]); + array.ht[h] = newnp; + } + free(x4a->tbl); + *x4a = array; + } + /* Insert the new data */ + h = ph & (x4a->size-1); + np = &(x4a->tbl[x4a->count++]); + np->data = data; + if( x4a->ht[h] ) x4a->ht[h]->from = &(np->next); + np->next = x4a->ht[h]; + x4a->ht[h] = np; + np->from = &(x4a->ht[h]); + return 1; +} + +/* Return a pointer to data assigned to the given key. Return NULL +** if no such key. */ +struct config *Configtable_find(key) +struct config *key; +{ + int h; + x4node *np; + + if( x4a==0 ) return 0; + h = confighash(key) & (x4a->size-1); + np = x4a->ht[h]; + while( np ){ + if( Configcmp(np->data,key)==0 ) break; + np = np->next; + } + return np ? np->data : 0; +} + +/* Remove all data from the table. Pass each data to the function "f" +** as it is removed. ("f" may be null to avoid this step.) */ +void Configtable_clear(f) +int(*f)(/* struct config * */); +{ + int i; + if( x4a==0 || x4a->count==0 ) return; + if( f ) for(i=0; i<x4a->count; i++) (*f)(x4a->tbl[i].data); + for(i=0; i<x4a->size; i++) x4a->ht[i] = 0; + x4a->count = 0; + return; +} diff --git a/kexi/3rdparty/kexisql/tool/lempar.c b/kexi/3rdparty/kexisql/tool/lempar.c new file mode 100644 index 00000000..5604fe10 --- /dev/null +++ b/kexi/3rdparty/kexisql/tool/lempar.c @@ -0,0 +1,657 @@ +/* Driver template for the LEMON parser generator. +** The author disclaims copyright to this source code. +*/ +/* First off, code is include which follows the "include" declaration +** in the input file. */ +#include <stdio.h> +%% +/* Next is all token values, in a form suitable for use by makeheaders. +** This section will be null unless lemon is run with the -m switch. +*/ +/* +** These constants (all generated automatically by the parser generator) +** specify the various kinds of tokens (terminals) that the parser +** understands. +** +** Each symbol here is a terminal symbol in the grammar. +*/ +%% +/* Make sure the INTERFACE macro is defined. +*/ +#ifndef INTERFACE +# define INTERFACE 1 +#endif +/* The next thing included is series of defines which control +** various aspects of the generated parser. +** YYCODETYPE is the data type used for storing terminal +** and nonterminal numbers. "unsigned char" is +** used if there are fewer than 250 terminals +** and nonterminals. "int" is used otherwise. +** YYNOCODE is a number of type YYCODETYPE which corresponds +** to no legal terminal or nonterminal number. This +** number is used to fill in empty slots of the hash +** table. +** YYFALLBACK If defined, this indicates that one or more tokens +** have fall-back values which should be used if the +** original value of the token will not parse. +** YYACTIONTYPE is the data type used for storing terminal +** and nonterminal numbers. "unsigned char" is +** used if there are fewer than 250 rules and +** states combined. "int" is used otherwise. +** ParseTOKENTYPE 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 ParseTOKENTYPE. The entry in the union +** for base tokens is called "yy0". +** YYSTACKDEPTH is the maximum depth of the parser's stack. +** ParseARG_SDECL A static variable declaration for the %extra_argument +** ParseARG_PDECL A parameter declaration for the %extra_argument +** ParseARG_STORE Code to store %extra_argument into yypParser +** ParseARG_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 YY_NO_ACTION (YYNSTATE+YYNRULE+2) +#define YY_ACCEPT_ACTION (YYNSTATE+YYNRULE+1) +#define YY_ERROR_ACTION (YYNSTATE+YYNRULE) +/* Next is the action table. Each entry in this table contains +** +** + An integer which is the number representing the look-ahead +** token +** +** + An integer indicating what action to take. Number (N) between +** 0 and YYNSTATE-1 mean shift the look-ahead and go to state N. +** Numbers between YYNSTATE and YYNSTATE+YYNRULE-1 mean reduce by +** rule N-YYNSTATE. Number YYNSTATE+YYNRULE means that a syntax +** error has occurred. Number YYNSTATE+YYNRULE+1 means the parser +** accepts its input. +** +** + A pointer to the next entry with the same hash value. +** +** The action table is really a series of hash tables. Each hash +** table contains a number of entries which is a power of two. The +** "state" table (which follows) contains information about the starting +** point and size of each hash table. +*/ +struct yyActionEntry { + YYCODETYPE lookahead; /* The value of the look-ahead token */ + YYCODETYPE next; /* Next entry + 1. Zero at end of collision chain */ + YYACTIONTYPE action; /* Action to take for this look-ahead */ +}; +typedef struct yyActionEntry yyActionEntry; +static const yyActionEntry yyActionTable[] = { +%% +}; + +/* The state table contains information needed to look up the correct +** action in the action table, given the current state of the parser. +** Information needed includes: +** +** + A pointer to the start of the action hash table in yyActionTable. +** +** + The number of entries in the action hash table. +** +** + The default action. This is the action to take if no entry for +** the given look-ahead is found in the action hash table. +*/ +struct yyStateEntry { + const yyActionEntry *hashtbl; /* Start of the hash table in yyActionTable */ + YYCODETYPE nEntry; /* Number of entries in action hash table */ + YYACTIONTYPE actionDefault; /* Default action if look-ahead not found */ +}; +typedef struct yyStateEntry yyStateEntry; +static const yyStateEntry yyStateTable[] = { +%% +}; + +/* The next table maps tokens into fallback tokens. If a construct +** like the following: +** +** %fallback ID X Y Z. +** +** appears in the grammer, then ID becomes a fallback token for X, Y, +** and Z. Whenever one of the tokens X, Y, or Z is input to the parser +** but it does not parse, the type of the token is changed to ID and +** the parse is retried before an error is thrown. +*/ +#ifdef YYFALLBACK +static const YYCODETYPE yyFallback[] = { +%% +}; +#endif /* YYFALLBACK */ + +/* The following structure represents a single element of the +** parser's stack. Information stored includes: +** +** + The state number for the parser at this level of the stack. +** +** + The value of the token stored at this level of the stack. +** (In other words, the "major" token.) +** +** + The semantic value stored at this level of the stack. This is +** the information used by the action routines in the grammar. +** It is sometimes called the "minor" token. +*/ +struct yyStackEntry { + int stateno; /* The state-number */ + int major; /* The major token value. This is the code + ** number for the token at this stack level */ + YYMINORTYPE minor; /* The user-supplied minor token value. This + ** is the value of the token */ +}; +typedef struct yyStackEntry yyStackEntry; + +/* The state of the parser is completely contained in an instance of +** the following structure */ +struct yyParser { + int yyidx; /* Index of top element in stack */ + int yyerrcnt; /* Shifts left before out of the error */ + yyStackEntry *yytop; /* Pointer to the top stack element */ + ParseARG_SDECL /* A place to hold %extra_argument */ + yyStackEntry yystack[YYSTACKDEPTH]; /* The parser's stack */ +}; +typedef struct yyParser yyParser; + +#ifndef NDEBUG +#include <stdio.h> +static FILE *yyTraceFILE = 0; +static char *yyTracePrompt = 0; +#endif /* NDEBUG */ + +#ifndef NDEBUG +/* +** Turn parser tracing on by giving a stream to which to write the trace +** and a prompt to preface each trace message. Tracing is turned off +** by making either argument NULL +** +** Inputs: +** <ul> +** <li> A FILE* to which trace output should be written. +** If NULL, then tracing is turned off. +** <li> A prefix string written at the beginning of every +** line of trace output. If NULL, then tracing is +** turned off. +** </ul> +** +** Outputs: +** None. +*/ +void ParseTrace(FILE *TraceFILE, char *zTracePrompt){ + yyTraceFILE = TraceFILE; + yyTracePrompt = zTracePrompt; + if( yyTraceFILE==0 ) yyTracePrompt = 0; + else if( yyTracePrompt==0 ) yyTraceFILE = 0; +} +#endif /* NDEBUG */ + +#ifndef NDEBUG +/* For tracing shifts, the names of all terminals and nonterminals +** are required. The following table supplies these names */ +static const char *yyTokenName[] = { +%% +}; +#endif /* NDEBUG */ + +#ifndef NDEBUG +/* For tracing reduce actions, the names of all rules are required. +*/ +static const char *yyRuleName[] = { +%% +}; +#endif /* NDEBUG */ + +/* +** This function returns the symbolic name associated with a token +** value. +*/ +const char *ParseTokenName(int tokenType){ +#ifndef NDEBUG + if( tokenType>0 && tokenType<(sizeof(yyTokenName)/sizeof(yyTokenName[0])) ){ + return yyTokenName[tokenType]; + }else{ + return "Unknown"; + } +#else + return ""; +#endif +} + +/* +** This function allocates a new parser. +** The only argument is a pointer to a function which works like +** malloc. +** +** Inputs: +** A pointer to the function used to allocate memory. +** +** Outputs: +** A pointer to a parser. This pointer is used in subsequent calls +** to Parse and ParseFree. +*/ +void *ParseAlloc(void *(*mallocProc)(size_t)){ + yyParser *pParser; + pParser = (yyParser*)(*mallocProc)( (size_t)sizeof(yyParser) ); + if( pParser ){ + pParser->yyidx = -1; + } + return pParser; +} + +/* The following function deletes the value associated with a +** symbol. The symbol can be either a terminal or nonterminal. +** "yymajor" is the symbol code, and "yypminor" is a pointer to +** the value. +*/ +static void yy_destructor(YYCODETYPE yymajor, YYMINORTYPE *yypminor){ + switch( yymajor ){ + /* Here is inserted the actions which take place when a + ** terminal or non-terminal is destroyed. This can happen + ** when the symbol is popped from the stack during a + ** reduce or during error processing or when a parser is + ** being destroyed before it is finished parsing. + ** + ** Note: during a reduce, the only symbols destroyed are those + ** which appear on the RHS of the rule, but which are not used + ** inside the C code. + */ +%% + default: break; /* If no destructor action specified: do nothing */ + } +} + +/* +** Pop the parser's stack once. +** +** If there is a destructor routine associated with the token which +** is popped from the stack, then call it. +** +** Return the major token number for the symbol popped. +*/ +static int yy_pop_parser_stack(yyParser *pParser){ + YYCODETYPE yymajor; + + if( pParser->yyidx<0 ) return 0; +#ifndef NDEBUG + if( yyTraceFILE && pParser->yyidx>=0 ){ + fprintf(yyTraceFILE,"%sPopping %s\n", + yyTracePrompt, + yyTokenName[pParser->yytop->major]); + } +#endif + yymajor = pParser->yytop->major; + yy_destructor( yymajor, &pParser->yytop->minor); + pParser->yyidx--; + pParser->yytop--; + return yymajor; +} + +/* +** Deallocate and destroy a parser. Destructors are all called for +** all stack elements before shutting the parser down. +** +** Inputs: +** <ul> +** <li> A pointer to the parser. This should be a pointer +** obtained from ParseAlloc. +** <li> A pointer to a function used to reclaim memory obtained +** from malloc. +** </ul> +*/ +void ParseFree( + void *p, /* The parser to be deleted */ + void (*freeProc)(void*) /* Function used to reclaim memory */ +){ + yyParser *pParser = (yyParser*)p; + if( pParser==0 ) return; + while( pParser->yyidx>=0 ) yy_pop_parser_stack(pParser); + (*freeProc)((void*)pParser); +} + +/* +** Find the appropriate action for a parser given the look-ahead token. +** +** If the look-ahead token is YYNOCODE, then check to see if the action is +** independent of the look-ahead. If it is, return the action, otherwise +** return YY_NO_ACTION. +*/ +static int yy_find_parser_action( + yyParser *pParser, /* The parser */ + int iLookAhead /* The look-ahead token */ +){ + const yyStateEntry *pState; /* Appropriate entry in the state table */ + const yyActionEntry *pAction; /* Action appropriate for the look-ahead */ + int iFallback; /* Fallback token */ + + /* if( pParser->yyidx<0 ) return YY_NO_ACTION; */ + pState = &yyStateTable[pParser->yytop->stateno]; + if( pState->nEntry==0 ){ + return pState->actionDefault; + }else if( iLookAhead!=YYNOCODE ){ + pAction = &pState->hashtbl[iLookAhead % pState->nEntry]; + while( 1 ){ + if( pAction->lookahead==iLookAhead ) return pAction->action; + if( pAction->next==0 ) break; + pAction = &pState->hashtbl[pAction->next-1]; + } +#ifdef YYFALLBACK + if( iLookAhead<sizeof(yyFallback)/sizeof(yyFallback[0]) + && (iFallback = yyFallback[iLookAhead])!=0 ){ +#ifndef NDEBUG + if( yyTraceFILE ){ + fprintf(yyTraceFILE, "%sFALLBACK %s => %s\n", + yyTracePrompt, yyTokenName[iLookAhead], yyTokenName[iFallback]); + } +#endif + return yy_find_parser_action(pParser, iFallback); + } +#endif + }else if( pState->hashtbl->lookahead!=YYNOCODE ){ + return YY_NO_ACTION; + } + return pState->actionDefault; +} + +/* +** Perform a shift action. +*/ +static void yy_shift( + yyParser *yypParser, /* The parser to be shifted */ + int yyNewState, /* The new state to shift in */ + int yyMajor, /* The major token to shift in */ + YYMINORTYPE *yypMinor /* Pointer ot the minor token to shift in */ +){ + yypParser->yyidx++; + yypParser->yytop++; + if( yypParser->yyidx>=YYSTACKDEPTH ){ + ParseARG_FETCH; + yypParser->yyidx--; + yypParser->yytop--; +#ifndef NDEBUG + if( yyTraceFILE ){ + fprintf(yyTraceFILE,"%sStack Overflow!\n",yyTracePrompt); + } +#endif + while( yypParser->yyidx>=0 ) yy_pop_parser_stack(yypParser); + /* Here code is inserted which will execute if the parser + ** stack every overflows */ +%% + ParseARG_STORE; /* Suppress warning about unused %extra_argument var */ + return; + } + yypParser->yytop->stateno = yyNewState; + yypParser->yytop->major = yyMajor; + yypParser->yytop->minor = *yypMinor; +#ifndef NDEBUG + if( yyTraceFILE && yypParser->yyidx>0 ){ + int i; + fprintf(yyTraceFILE,"%sShift %d\n",yyTracePrompt,yyNewState); + fprintf(yyTraceFILE,"%sStack:",yyTracePrompt); + for(i=1; i<=yypParser->yyidx; i++) + fprintf(yyTraceFILE," %s",yyTokenName[yypParser->yystack[i].major]); + fprintf(yyTraceFILE,"\n"); + } +#endif +} + +/* The following table contains information about every rule that +** is used during the reduce. +*/ +static 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[] = { +%% +}; + +static void yy_accept(yyParser*); /* Forward Declaration */ + +/* +** Perform a reduce action and the shift that must immediately +** follow the reduce. +*/ +static void yy_reduce( + yyParser *yypParser, /* The parser */ + int yyruleno /* Number of the rule by which to reduce */ +){ + int yygoto; /* The next state */ + int yyact; /* The next action */ + YYMINORTYPE yygotominor; /* The LHS of the rule reduced */ + yyStackEntry *yymsp; /* The top of the parser's stack */ + int yysize; /* Amount to pop the stack */ + ParseARG_FETCH; + yymsp = yypParser->yytop; +#ifndef NDEBUG + if( yyTraceFILE && yyruleno>=0 + && yyruleno<sizeof(yyRuleName)/sizeof(yyRuleName[0]) ){ + fprintf(yyTraceFILE, "%sReduce [%s].\n", yyTracePrompt, + yyRuleName[yyruleno]); + } +#endif /* NDEBUG */ + + switch( yyruleno ){ + /* Beginning here are the reduction cases. A typical example + ** follows: + ** case 0: + ** #line <lineno> <grammarfile> + ** { ... } // User supplied code + ** #line <lineno> <thisfile> + ** break; + */ +%% + }; + yygoto = yyRuleInfo[yyruleno].lhs; + yysize = yyRuleInfo[yyruleno].nrhs; + yypParser->yyidx -= yysize; + yypParser->yytop -= yysize; + yyact = yy_find_parser_action(yypParser,yygoto); + if( yyact < YYNSTATE ){ + yy_shift(yypParser,yyact,yygoto,&yygotominor); + }else if( yyact == YYNSTATE + YYNRULE + 1 ){ + yy_accept(yypParser); + } +} + +/* +** The following code executes when the parse fails +*/ +static void yy_parse_failed( + yyParser *yypParser /* The parser */ +){ + ParseARG_FETCH; +#ifndef NDEBUG + if( yyTraceFILE ){ + fprintf(yyTraceFILE,"%sFail!\n",yyTracePrompt); + } +#endif + while( yypParser->yyidx>=0 ) yy_pop_parser_stack(yypParser); + /* Here code is inserted which will be executed whenever the + ** parser fails */ +%% + ParseARG_STORE; /* Suppress warning about unused %extra_argument variable */ +} + +/* +** The following code executes when a syntax error first occurs. +*/ +static void yy_syntax_error( + yyParser *yypParser, /* The parser */ + int yymajor, /* The major type of the error token */ + YYMINORTYPE yyminor /* The minor type of the error token */ +){ + ParseARG_FETCH; +#define TOKEN (yyminor.yy0) +%% + ParseARG_STORE; /* Suppress warning about unused %extra_argument variable */ +} + +/* +** The following is executed when the parser accepts +*/ +static void yy_accept( + yyParser *yypParser /* The parser */ +){ + ParseARG_FETCH; +#ifndef NDEBUG + if( yyTraceFILE ){ + fprintf(yyTraceFILE,"%sAccept!\n",yyTracePrompt); + } +#endif + while( yypParser->yyidx>=0 ) yy_pop_parser_stack(yypParser); + /* Here code is inserted which will be executed whenever the + ** parser accepts */ +%% + ParseARG_STORE; /* Suppress warning about unused %extra_argument variable */ +} + +/* The main parser program. +** The first argument is a pointer to a structure obtained from +** "ParseAlloc" which describes the current state of the parser. +** The second argument is the major token number. The third is +** the minor token. The fourth optional argument is whatever the +** user wants (and specified in the grammar) and is available for +** use by the action routines. +** +** Inputs: +** <ul> +** <li> A pointer to the parser (an opaque structure.) +** <li> The major token number. +** <li> The minor token number. +** <li> An option argument of a grammar-specified type. +** </ul> +** +** Outputs: +** None. +*/ +void Parse( + void *yyp, /* The parser */ + int yymajor, /* The major token code number */ + ParseTOKENTYPE yyminor /* The value for the token */ + ParseARG_PDECL /* Optional %extra_argument parameter */ +){ + YYMINORTYPE yyminorunion; + int yyact; /* The parser action. */ + int yyendofinput; /* True if we are at the end of input */ + int yyerrorhit = 0; /* True if yymajor has invoked an error */ + yyParser *yypParser; /* The parser */ + + /* (re)initialize the parser, if necessary */ + yypParser = (yyParser*)yyp; + if( yypParser->yyidx<0 ){ + if( yymajor==0 ) return; + yypParser->yyidx = 0; + yypParser->yyerrcnt = -1; + yypParser->yytop = &yypParser->yystack[0]; + yypParser->yytop->stateno = 0; + yypParser->yytop->major = 0; + } + yyminorunion.yy0 = yyminor; + yyendofinput = (yymajor==0); + ParseARG_STORE; + +#ifndef NDEBUG + if( yyTraceFILE ){ + fprintf(yyTraceFILE,"%sInput %s\n",yyTracePrompt,yyTokenName[yymajor]); + } +#endif + + do{ + yyact = yy_find_parser_action(yypParser,yymajor); + if( yyact<YYNSTATE ){ + yy_shift(yypParser,yyact,yymajor,&yyminorunion); + yypParser->yyerrcnt--; + if( yyendofinput && yypParser->yyidx>=0 ){ + yymajor = 0; + }else{ + yymajor = YYNOCODE; + } + }else if( yyact < YYNSTATE + YYNRULE ){ + yy_reduce(yypParser,yyact-YYNSTATE); + }else if( yyact == YY_ERROR_ACTION ){ +#ifndef NDEBUG + if( yyTraceFILE ){ + fprintf(yyTraceFILE,"%sSyntax Error!\n",yyTracePrompt); + } +#endif +#ifdef YYERRORSYMBOL + /* A syntax error has occurred. + ** The response to an error depends upon whether or not the + ** grammar defines an error token "ERROR". + ** + ** This is what we do if the grammar does define ERROR: + ** + ** * Call the %syntax_error function. + ** + ** * Begin popping the stack until we enter a state where + ** it is legal to shift the error symbol, then shift + ** the error symbol. + ** + ** * Set the error count to three. + ** + ** * Begin accepting and shifting new tokens. No new error + ** processing will occur until three tokens have been + ** shifted successfully. + ** + */ + if( yypParser->yyerrcnt<0 ){ + yy_syntax_error(yypParser,yymajor,yyminorunion); + } + if( yypParser->yytop->major==YYERRORSYMBOL || yyerrorhit ){ +#ifndef NDEBUG + if( yyTraceFILE ){ + fprintf(yyTraceFILE,"%sDiscard input token %s\n", + yyTracePrompt,yyTokenName[yymajor]); + } +#endif + yy_destructor(yymajor,&yyminorunion); + yymajor = YYNOCODE; + }else{ + while( + yypParser->yyidx >= 0 && + yypParser->yytop->major != YYERRORSYMBOL && + (yyact = yy_find_parser_action(yypParser,YYERRORSYMBOL)) >= YYNSTATE + ){ + yy_pop_parser_stack(yypParser); + } + if( yypParser->yyidx < 0 || yymajor==0 ){ + yy_destructor(yymajor,&yyminorunion); + yy_parse_failed(yypParser); + yymajor = YYNOCODE; + }else if( yypParser->yytop->major!=YYERRORSYMBOL ){ + YYMINORTYPE u2; + u2.YYERRSYMDT = 0; + yy_shift(yypParser,yyact,YYERRORSYMBOL,&u2); + } + } + yypParser->yyerrcnt = 3; + yyerrorhit = 1; +#else /* YYERRORSYMBOL is not defined */ + /* This is what we do if the grammar does not define ERROR: + ** + ** * Report an error message, and throw away the input token. + ** + ** * If the input token is $, then fail the parse. + ** + ** As before, subsequent error messages are suppressed until + ** three input tokens have been successfully shifted. + */ + if( yypParser->yyerrcnt<=0 ){ + yy_syntax_error(yypParser,yymajor,yyminorunion); + } + yypParser->yyerrcnt = 3; + yy_destructor(yymajor,&yyminorunion); + if( yyendofinput ){ + yy_parse_failed(yypParser); + } + yymajor = YYNOCODE; +#endif + }else{ + yy_accept(yypParser); + yymajor = YYNOCODE; + } + }while( yymajor!=YYNOCODE && yypParser->yyidx>=0 ); + return; +} diff --git a/kexi/3rdparty/kexisql/tool/opcodes.sh b/kexi/3rdparty/kexisql/tool/opcodes.sh new file mode 100755 index 00000000..7e7024ed --- /dev/null +++ b/kexi/3rdparty/kexisql/tool/opcodes.sh @@ -0,0 +1,14 @@ +#!/bin/sh + +# this script has to be run after the version +# changed + +#generate c file: +echo '/* Automatically generated file. Do not edit */' >../src/opcodes.c +echo 'char *sqliteOpcodeNames[] = { "???", ' >>../src/opcodes.c +grep '^case OP_' ../src/vdbe.c | sed -e 's/^.*OP_/ "/' -e 's/:.*/", /' >>../src/opcodes.c +echo '};' >>../src/opcodes.c + +#generate header file: +echo '/* Automatically generated file. Do not edit */' >../src/opcodes.h +grep '^case OP_' ../src/vdbe.c | sed -e 's/case //' -e 's/:[ {]*//' | awk '{printf "#define %-30s %3d\n", $$2, ++cnt}' >>../src/opcodes.h |