[Freeswitch-svn] [commit] r3741 - in freeswitch/trunk: . libs/win32/sqlite

Author: mikej Date: Tue Dec 19 18:09:46 2006 New Revision: 3741 Added: freeswitch/trunk/libs/win32/sqlite/keywordhash.h freeswitch/trunk/libs/win32/sqlite/opcodes.c freeswitch/trunk/libs/win32/sqlite/opcodes.h freeswitch/trunk/libs/win32/sqlite/parse.c freeswitch/trunk/libs/win32/sqlite/parse.h freeswitch/trunk/libs/win32/sqlite/sqlite3.def freeswitch/trunk/libs/win32/sqlite/sqlite3.h Modified: freeswitch/trunk/Freeswitch.sln freeswitch/trunk/libs/win32/sqlite/sqlite.vcproj Log: move windows build to use the in tree sqlite Modified: freeswitch/trunk/Freeswitch.sln ============================================================================== --- freeswitch/trunk/Freeswitch.sln (original) +++ freeswitch/trunk/Freeswitch.sln Tue Dec 19 18:09:46 2006 @@ -340,9 +340,6 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libsrtp", "libs\srtp\libsrtp.vcproj", "{EEF031CB-FED8-451E-A471-91EC8D4F6750}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libsqlite", "libs\win32\sqlite\sqlite.vcproj", "{6EDFEFD5-3596-4FA9-8EBA-B331547B35A3}" - ProjectSection(ProjectDependencies) = postProject - {6B9217D6-8259-4817-B8A5-2FEAD349EDEB} = {6B9217D6-8259-4817-B8A5-2FEAD349EDEB} - EndProjectSection EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libpcre", "libs\win32\pcre\libpcre.vcproj", "{8D04B550-D240-4A44-8A18-35DA3F7038D9}" ProjectSection(ProjectDependencies) = postProject @@ -368,8 +365,6 @@ EndProject Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "_Downloads", "_Downloads", "{C120A020-773F-4EA3-923F-B67AF28B750D}" EndProject -Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Download SQLITE", "libs\win32\Download SQLITE.vcproj", "{6B9217D6-8259-4817-B8A5-2FEAD349EDEB}" -EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Download SPEEX", "libs\win32\Download SPEEX.vcproj", "{5C9C69D2-8B98-42DA-8D82-6E0B48446FAC}" EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libspeex", "libs\win32\speex\libspeex.vcproj", "{1C469CDD-A3AF-4A94-A592-B2CF12F2D918}" @@ -782,10 +777,6 @@ {F057DA7F-79E5-4B00-845C-EF446EF055E3}.Debug|Win32.Build.0 = Debug|Win32 {F057DA7F-79E5-4B00-845C-EF446EF055E3}.Release|Win32.ActiveCfg = Release|Win32 {F057DA7F-79E5-4B00-845C-EF446EF055E3}.Release|Win32.Build.0 = Release|Win32 - {6B9217D6-8259-4817-B8A5-2FEAD349EDEB}.Debug|Win32.ActiveCfg = Debug|Win32 - {6B9217D6-8259-4817-B8A5-2FEAD349EDEB}.Debug|Win32.Build.0 = Debug|Win32 - {6B9217D6-8259-4817-B8A5-2FEAD349EDEB}.Release|Win32.ActiveCfg = Release|Win32 - {6B9217D6-8259-4817-B8A5-2FEAD349EDEB}.Release|Win32.Build.0 = Release|Win32 {5C9C69D2-8B98-42DA-8D82-6E0B48446FAC}.Debug|Win32.ActiveCfg = Debug|Win32 {5C9C69D2-8B98-42DA-8D82-6E0B48446FAC}.Debug|Win32.Build.0 = Debug|Win32 {5C9C69D2-8B98-42DA-8D82-6E0B48446FAC}.Release|Win32.ActiveCfg = Release|Win32 @@ -1027,7 +1018,6 @@ {1C453396-D912-4213-89FD-9B489162B7B5} = {A7AB4405-FDB7-4853-9FBB-1516B1C3D80A} {CBEC7225-0C21-4DA8-978E-1F158F8AD950} = {F69A4A6B-9360-4EBB-A280-22AA3C455AC5} {AB91A099-7690-4ECF-8994-E458F4EA1ED4} = {F69A4A6B-9360-4EBB-A280-22AA3C455AC5} - {6B9217D6-8259-4817-B8A5-2FEAD349EDEB} = {C120A020-773F-4EA3-923F-B67AF28B750D} {5C9C69D2-8B98-42DA-8D82-6E0B48446FAC} = {C120A020-773F-4EA3-923F-B67AF28B750D} {F8C28DF9-D76A-449E-A621-D97D869974DA} = {C120A020-773F-4EA3-923F-B67AF28B750D} {985135DA-BBE1-42D2-8A85-1F7DF0609B3D} = {C120A020-773F-4EA3-923F-B67AF28B750D} Added: freeswitch/trunk/libs/win32/sqlite/keywordhash.h ============================================================================== --- (empty file) +++ freeswitch/trunk/libs/win32/sqlite/keywordhash.h Tue Dec 19 18:09:46 2006 @@ -0,0 +1,98 @@ +/* Hash score: 167 */ +static int keywordCode(const char *z, int n){ + static const char zText[544] = + "ABORTABLEFTEMPORARYADDATABASELECTHENDEFAULTRANSACTIONATURALTER" + "AISEACHECKEYAFTEREFERENCESCAPELSEXCEPTRIGGEREGEXPLAINITIALLYANALYZE" + "XCLUSIVEXISTSTATEMENTANDEFERRABLEATTACHAVINGLOBEFOREIGNOREINDEX" + "AUTOINCREMENTBEGINNERENAMEBETWEENOTNULLIKEBYCASCADEFERREDELETE" + "CASECASTCOLLATECOLUMNCOMMITCONFLICTCONSTRAINTERSECTCREATECROSS" + "CURRENT_DATECURRENT_TIMESTAMPLANDESCDETACHDISTINCTDROPRAGMATCH" + "FAILIMITFROMFULLGROUPDATEIFIMMEDIATEINSERTINSTEADINTOFFSETISNULL" + "JOINORDEREPLACEOUTERESTRICTPRIMARYQUERYRIGHTROLLBACKROWHENUNION" + "UNIQUEUSINGVACUUMVALUESVIEWHEREVIRTUAL"; + static const unsigned char aHash[127] = { + 92, 80, 107, 91, 0, 4, 0, 0, 114, 0, 83, 0, 0, + 96, 44, 76, 93, 0, 106, 109, 97, 90, 0, 10, 0, 0, + 113, 0, 117, 103, 0, 28, 48, 0, 41, 0, 0, 65, 71, + 0, 63, 19, 0, 105, 36, 104, 0, 108, 75, 0, 0, 33, + 0, 61, 37, 0, 8, 0, 115, 38, 12, 0, 77, 40, 25, + 66, 0, 0, 31, 81, 53, 30, 50, 20, 88, 0, 34, 0, + 74, 26, 0, 72, 0, 0, 0, 64, 47, 67, 22, 87, 29, + 69, 86, 0, 1, 0, 9, 101, 58, 18, 0, 112, 82, 99, + 55, 6, 85, 0, 0, 49, 94, 0, 102, 0, 70, 0, 0, + 15, 0, 116, 51, 56, 0, 2, 54, 0, 111, + }; + static const unsigned char aNext[117] = { + 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 17, 0, 0, 0, 0, + 0, 11, 0, 0, 0, 0, 5, 13, 0, 7, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 42, 0, 0, 0, 0, 0, + 0, 16, 0, 0, 23, 52, 0, 0, 0, 0, 45, 0, 59, + 0, 0, 0, 0, 0, 0, 0, 0, 43, 73, 0, 24, 60, + 21, 0, 79, 0, 0, 68, 0, 0, 84, 46, 0, 0, 0, + 0, 0, 0, 0, 0, 39, 95, 98, 0, 0, 100, 0, 32, + 0, 14, 27, 78, 0, 57, 89, 0, 35, 0, 62, 0, 110, + }; + static const unsigned char aLen[117] = { + 5, 5, 4, 4, 9, 2, 3, 8, 2, 6, 4, 3, 7, + 11, 2, 7, 5, 5, 4, 5, 3, 5, 10, 6, 4, 6, + 7, 6, 7, 9, 3, 7, 9, 6, 9, 3, 10, 6, 6, + 4, 6, 7, 3, 6, 7, 5, 13, 2, 2, 5, 5, 6, + 7, 7, 3, 4, 4, 2, 7, 3, 8, 6, 4, 4, 7, + 6, 6, 8, 10, 9, 6, 5, 12, 17, 12, 4, 4, 6, + 8, 2, 4, 6, 5, 4, 5, 4, 4, 5, 6, 2, 9, + 6, 7, 4, 6, 2, 3, 6, 4, 5, 7, 5, 8, 7, + 5, 5, 8, 3, 4, 5, 6, 5, 6, 6, 4, 5, 7, + }; + static const unsigned short int aOffset[117] = { + 0, 4, 7, 10, 10, 14, 19, 21, 26, 27, 32, 34, 36, + 42, 51, 52, 57, 61, 65, 67, 71, 74, 78, 86, 91, 94, + 99, 105, 108, 113, 118, 122, 128, 136, 141, 150, 152, 162, 167, + 172, 175, 177, 177, 181, 185, 187, 192, 194, 196, 205, 208, 212, + 218, 224, 224, 227, 230, 234, 236, 237, 241, 248, 254, 258, 262, + 269, 275, 281, 289, 296, 305, 311, 316, 328, 328, 344, 348, 352, + 358, 359, 366, 369, 373, 378, 381, 386, 390, 394, 397, 403, 405, + 414, 420, 427, 430, 430, 433, 436, 442, 446, 450, 457, 461, 469, + 476, 481, 486, 494, 496, 500, 505, 511, 516, 522, 528, 531, 536, + }; + static const unsigned char aCode[117] = { + TK_ABORT, TK_TABLE, TK_JOIN_KW, TK_TEMP, TK_TEMP, + TK_OR, TK_ADD, TK_DATABASE, TK_AS, TK_SELECT, + TK_THEN, TK_END, TK_DEFAULT, TK_TRANSACTION,TK_ON, + TK_JOIN_KW, TK_ALTER, TK_RAISE, TK_EACH, TK_CHECK, + TK_KEY, TK_AFTER, TK_REFERENCES, TK_ESCAPE, TK_ELSE, + TK_EXCEPT, TK_TRIGGER, TK_LIKE_KW, TK_EXPLAIN, TK_INITIALLY, + TK_ALL, TK_ANALYZE, TK_EXCLUSIVE, TK_EXISTS, TK_STATEMENT, + TK_AND, TK_DEFERRABLE, TK_ATTACH, TK_HAVING, TK_LIKE_KW, + TK_BEFORE, TK_FOREIGN, TK_FOR, TK_IGNORE, TK_REINDEX, + TK_INDEX, TK_AUTOINCR, TK_TO, TK_IN, TK_BEGIN, + TK_JOIN_KW, TK_RENAME, TK_BETWEEN, TK_NOTNULL, TK_NOT, + TK_NULL, TK_LIKE_KW, TK_BY, TK_CASCADE, TK_ASC, + TK_DEFERRED, TK_DELETE, TK_CASE, TK_CAST, TK_COLLATE, + TK_COLUMNKW, TK_COMMIT, TK_CONFLICT, TK_CONSTRAINT, TK_INTERSECT, + TK_CREATE, TK_JOIN_KW, TK_CTIME_KW, TK_CTIME_KW, TK_CTIME_KW, + TK_PLAN, TK_DESC, TK_DETACH, TK_DISTINCT, TK_IS, + TK_DROP, TK_PRAGMA, TK_MATCH, TK_FAIL, TK_LIMIT, + TK_FROM, TK_JOIN_KW, TK_GROUP, TK_UPDATE, TK_IF, + TK_IMMEDIATE, TK_INSERT, TK_INSTEAD, TK_INTO, TK_OFFSET, + TK_OF, TK_SET, TK_ISNULL, TK_JOIN, TK_ORDER, + TK_REPLACE, TK_JOIN_KW, TK_RESTRICT, TK_PRIMARY, TK_QUERY, + TK_JOIN_KW, TK_ROLLBACK, TK_ROW, TK_WHEN, TK_UNION, + TK_UNIQUE, TK_USING, TK_VACUUM, TK_VALUES, TK_VIEW, + TK_WHERE, TK_VIRTUAL, + }; + int h, i; + if( n<2 ) return TK_ID; + h = ((charMap(z[0])*4) ^ + (charMap(z[n-1])*3) ^ + n) % 127; + for(i=((int)aHash[h])-1; i>=0; i=((int)aNext[i])-1){ + if( aLen[i]==n && sqlite3StrNICmp(&zText[aOffset[i]],z,n)==0 ){ + return aCode[i]; + } + } + return TK_ID; +} +int sqlite3KeywordCode(const unsigned char *z, int n){ + return keywordCode((char*)z, n); +} Added: freeswitch/trunk/libs/win32/sqlite/opcodes.c ============================================================================== --- (empty file) +++ freeswitch/trunk/libs/win32/sqlite/opcodes.c Tue Dec 19 18:09:46 2006 @@ -0,0 +1,149 @@ +/* Automatically generated. Do not edit */ +/* See the mkopcodec.awk script for details. */ +#if !defined(SQLITE_OMIT_EXPLAIN) || !defined(NDEBUG) || defined(VDBE_PROFILE) || defined(SQLITE_DEBUG) +const char *const sqlite3OpcodeNames[] = { "?", + /* 1 */ "VRowid", + /* 2 */ "VFilter", + /* 3 */ "ContextPop", + /* 4 */ "IntegrityCk", + /* 5 */ "DropTrigger", + /* 6 */ "DropIndex", + /* 7 */ "IdxInsert", + /* 8 */ "Delete", + /* 9 */ "MoveGt", + /* 10 */ "OpenEphemeral", + /* 11 */ "VerifyCookie", + /* 12 */ "Push", + /* 13 */ "Dup", + /* 14 */ "Blob", + /* 15 */ "FifoWrite", + /* 16 */ "Not", + /* 17 */ "IdxGT", + /* 18 */ "RowKey", + /* 19 */ "IsUnique", + /* 20 */ "SetNumColumns", + /* 21 */ "VUpdate", + /* 22 */ "Expire", + /* 23 */ "IdxIsNull", + /* 24 */ "NullRow", + /* 25 */ "OpenPseudo", + /* 26 */ "OpenWrite", + /* 27 */ "OpenRead", + /* 28 */ "Transaction", + /* 29 */ "AutoCommit", + /* 30 */ "Pop", + /* 31 */ "Halt", + /* 32 */ "Vacuum", + /* 33 */ "IfMemNeg", + /* 34 */ "RowData", + /* 35 */ "NotExists", + /* 36 */ "MoveLe", + /* 37 */ "SetCookie", + /* 38 */ "Variable", + /* 39 */ "VNext", + /* 40 */ "VDestroy", + /* 41 */ "TableLock", + /* 42 */ "MemMove", + /* 43 */ "LoadAnalysis", + /* 44 */ "IdxDelete", + /* 45 */ "Sort", + /* 46 */ "ResetCount", + /* 47 */ "Integer", + /* 48 */ "AggStep", + /* 49 */ "CreateIndex", + /* 50 */ "NewRowid", + /* 51 */ "MoveLt", + /* 52 */ "Explain", + /* 53 */ "Return", + /* 54 */ "MemLoad", + /* 55 */ "IdxLT", + /* 56 */ "Rewind", + /* 57 */ "MakeIdxRec", + /* 58 */ "AddImm", + /* 59 */ "Null", + /* 60 */ "VColumn", + /* 61 */ "Or", + /* 62 */ "And", + /* 63 */ "MemNull", + /* 64 */ "MemIncr", + /* 65 */ "Clear", + /* 66 */ "IsNull", + /* 67 */ "NotNull", + /* 68 */ "Ne", + /* 69 */ "Eq", + /* 70 */ "Gt", + /* 71 */ "Le", + /* 72 */ "Lt", + /* 73 */ "Ge", + /* 74 */ "If", + /* 75 */ "BitAnd", + /* 76 */ "BitOr", + /* 77 */ "ShiftLeft", + /* 78 */ "ShiftRight", + /* 79 */ "Add", + /* 80 */ "Subtract", + /* 81 */ "Multiply", + /* 82 */ "Divide", + /* 83 */ "Remainder", + /* 84 */ "Concat", + /* 85 */ "Negative", + /* 86 */ "RealAffinity", + /* 87 */ "BitNot", + /* 88 */ "String8", + /* 89 */ "Callback", + /* 90 */ "AggFinal", + /* 91 */ "IfMemZero", + /* 92 */ "Last", + /* 93 */ "Rowid", + /* 94 */ "Sequence", + /* 95 */ "NotFound", + /* 96 */ "MakeRecord", + /* 97 */ "String", + /* 98 */ "Goto", + /* 99 */ "VCreate", + /* 100 */ "MemInt", + /* 101 */ "IfMemPos", + /* 102 */ "DropTable", + /* 103 */ "IdxRowid", + /* 104 */ "Insert", + /* 105 */ "Column", + /* 106 */ "Noop", + /* 107 */ "VOpen", + /* 108 */ "CreateTable", + /* 109 */ "Found", + /* 110 */ "Distinct", + /* 111 */ "Close", + /* 112 */ "Statement", + /* 113 */ "IfNot", + /* 114 */ "Pull", + /* 115 */ "VBegin", + /* 116 */ "MemMax", + /* 117 */ "MemStore", + /* 118 */ "Next", + /* 119 */ "Prev", + /* 120 */ "MoveGe", + /* 121 */ "MustBeInt", + /* 122 */ "ForceInt", + /* 123 */ "CollSeq", + /* 124 */ "Gosub", + /* 125 */ "ContextPush", + /* 126 */ "Real", + /* 127 */ "HexBlob", + /* 128 */ "FifoRead", + /* 129 */ "ParseSchema", + /* 130 */ "Destroy", + /* 131 */ "IdxGE", + /* 132 */ "ReadCookie", + /* 133 */ "AbsValue", + /* 134 */ "Function", + /* 135 */ "Int64", + /* 136 */ "NotUsed_136", + /* 137 */ "NotUsed_137", + /* 138 */ "NotUsed_138", + /* 139 */ "ToText", + /* 140 */ "ToBlob", + /* 141 */ "ToNumeric", + /* 142 */ "ToInt", + /* 143 */ "ToReal", +}; +#endif Added: freeswitch/trunk/libs/win32/sqlite/opcodes.h ============================================================================== --- (empty file) +++ freeswitch/trunk/libs/win32/sqlite/opcodes.h Tue Dec 19 18:09:46 2006 @@ -0,0 +1,161 @@ +/* Automatically generated. Do not edit */ +/* See the mkopcodeh.awk script for details */ +#define OP_VRowid 1 +#define OP_VFilter 2 +#define OP_ContextPop 3 +#define OP_IntegrityCk 4 +#define OP_DropTrigger 5 +#define OP_DropIndex 6 +#define OP_IdxInsert 7 +#define OP_Delete 8 +#define OP_MoveGt 9 +#define OP_OpenEphemeral 10 +#define OP_VerifyCookie 11 +#define OP_Push 12 +#define OP_Dup 13 +#define OP_Blob 14 +#define OP_FifoWrite 15 +#define OP_IdxGT 17 +#define OP_RowKey 18 +#define OP_IsUnique 19 +#define OP_SetNumColumns 20 +#define OP_Eq 69 /* same as TK_EQ */ +#define OP_VUpdate 21 +#define OP_Expire 22 +#define OP_IdxIsNull 23 +#define OP_NullRow 24 +#define OP_OpenPseudo 25 +#define OP_OpenWrite 26 +#define OP_OpenRead 27 +#define OP_Transaction 28 +#define OP_AutoCommit 29 +#define OP_Negative 85 /* same as TK_UMINUS */ +#define OP_Pop 30 +#define OP_Halt 31 +#define OP_Vacuum 32 +#define OP_IfMemNeg 33 +#define OP_RowData 34 +#define OP_NotExists 35 +#define OP_MoveLe 36 +#define OP_SetCookie 37 +#define OP_Variable 38 +#define OP_VNext 39 +#define OP_VDestroy 40 +#define OP_TableLock 41 +#define OP_MemMove 42 +#define OP_LoadAnalysis 43 +#define OP_IdxDelete 44 +#define OP_Sort 45 +#define OP_ResetCount 46 +#define OP_NotNull 67 /* same as TK_NOTNULL */ +#define OP_Ge 73 /* same as TK_GE */ +#define OP_Remainder 83 /* same as TK_REM */ +#define OP_Divide 82 /* same as TK_SLASH */ +#define OP_Integer 47 +#define OP_AggStep 48 +#define OP_CreateIndex 49 +#define OP_NewRowid 50 +#define OP_MoveLt 51 +#define OP_Explain 52 +#define OP_And 62 /* same as TK_AND */ +#define OP_ShiftLeft 77 /* same as TK_LSHIFT */ +#define OP_Real 126 /* same as TK_FLOAT */ +#define OP_Return 53 +#define OP_MemLoad 54 +#define OP_IdxLT 55 +#define OP_Rewind 56 +#define OP_MakeIdxRec 57 +#define OP_Gt 70 /* same as TK_GT */ +#define OP_AddImm 58 +#define OP_Subtract 80 /* same as TK_MINUS */ +#define OP_Null 59 +#define OP_VColumn 60 +#define OP_MemNull 63 +#define OP_MemIncr 64 +#define OP_Clear 65 +#define OP_IsNull 66 /* same as TK_ISNULL */ +#define OP_If 74 +#define OP_ToBlob 140 /* same as TK_TO_BLOB */ +#define OP_RealAffinity 86 +#define OP_Callback 89 +#define OP_AggFinal 90 +#define OP_IfMemZero 91 +#define OP_Last 92 +#define OP_Rowid 93 +#define OP_Sequence 94 +#define OP_NotFound 95 +#define OP_MakeRecord 96 +#define OP_ToText 139 /* same as TK_TO_TEXT */ +#define OP_BitAnd 75 /* same as TK_BITAND */ +#define OP_Add 79 /* same as TK_PLUS */ +#define OP_HexBlob 127 /* same as TK_BLOB */ +#define OP_String 97 +#define OP_Goto 98 +#define OP_VCreate 99 +#define OP_MemInt 100 +#define OP_IfMemPos 101 +#define OP_DropTable 102 +#define OP_IdxRowid 103 +#define OP_Insert 104 +#define OP_Column 105 +#define OP_Noop 106 +#define OP_Not 16 /* same as TK_NOT */ +#define OP_Le 71 /* same as TK_LE */ +#define OP_BitOr 76 /* same as TK_BITOR */ +#define OP_Multiply 81 /* same as TK_STAR */ +#define OP_String8 88 /* same as TK_STRING */ +#define OP_VOpen 107 +#define OP_CreateTable 108 +#define OP_Found 109 +#define OP_Distinct 110 +#define OP_Close 111 +#define OP_Statement 112 +#define OP_IfNot 113 +#define OP_ToInt 142 /* same as TK_TO_INT */ +#define OP_Pull 114 +#define OP_VBegin 115 +#define OP_MemMax 116 +#define OP_MemStore 117 +#define OP_Next 118 +#define OP_Prev 119 +#define OP_MoveGe 120 +#define OP_Lt 72 /* same as TK_LT */ +#define OP_Ne 68 /* same as TK_NE */ +#define OP_MustBeInt 121 +#define OP_ForceInt 122 +#define OP_ShiftRight 78 /* same as TK_RSHIFT */ +#define OP_CollSeq 123 +#define OP_Gosub 124 +#define OP_ContextPush 125 +#define OP_FifoRead 128 +#define OP_ParseSchema 129 +#define OP_Destroy 130 +#define OP_IdxGE 131 +#define OP_ReadCookie 132 +#define OP_BitNot 87 /* same as TK_BITNOT */ +#define OP_AbsValue 133 +#define OP_Or 61 /* same as TK_OR */ +#define OP_ToReal 143 /* same as TK_TO_REAL */ +#define OP_ToNumeric 141 /* same as TK_TO_NUMERIC*/ +#define OP_Function 134 +#define OP_Concat 84 /* same as TK_CONCAT */ +#define OP_Int64 135 + +/* The following opcode values are never used */ +#define OP_NotUsed_136 136 +#define OP_NotUsed_137 137 +#define OP_NotUsed_138 138 + +/* Opcodes that are guaranteed to never push a value onto the stack +** contain a 1 their corresponding position of the following mask +** set. See the opcodeNoPush() function in vdbeaux.c */ +#define NOPUSH_MASK_0 0x9fec +#define NOPUSH_MASK_1 0xfffb +#define NOPUSH_MASK_2 0x7bbb +#define NOPUSH_MASK_3 0x65a9 +#define NOPUSH_MASK_4 0xffff +#define NOPUSH_MASK_5 0x9eef +#define NOPUSH_MASK_6 0xed6c +#define NOPUSH_MASK_7 0x3fff +#define NOPUSH_MASK_8 0xf80a +#define NOPUSH_MASK_9 0x0000 Added: freeswitch/trunk/libs/win32/sqlite/parse.c ============================================================================== --- (empty file) +++ freeswitch/trunk/libs/win32/sqlite/parse.c Tue Dec 19 18:09:46 2006 @@ -0,0 +1,3426 @@ +/* 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 56 "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 { + Expr *pLimit; /* The LIMIT expression. NULL if there is no limit */ + Expr *pOffset; /* The OFFSET expression. NULL if there is none */ +}; + +/* +** An instance of this structure is used to store the LIKE, +** GLOB, NOT LIKE, and NOT GLOB operators. +*/ +struct LikeOp { + Token eOperator; /* "like" or "glob" or "regexp" */ + int not; /* True if the NOT keyword is present */ +}; + +/* +** An instance of the following structure describes the event of a +** TRIGGER. "a" is the event type, one of TK_UPDATE, TK_INSERT, +** TK_DELETE, or TK_INSTEAD. If the event is of the form +** +** UPDATE ON (a,b,c) +** +** Then the "b" IdList records the list "a,b,c". +*/ +struct TrigEvent { int a; IdList * b; }; + +/* +** An instance of this structure holds the ATTACH key and the key type. +*/ +struct AttachKey { int type; Token key; }; + +#line 48 "parse.c" +/* Next is all token values, in a form suitable for use by makeheaders. +** This section will be null unless lemon is run with the -m switch. +*/ +/* +** These constants (all generated automatically by the parser generator) +** specify the various kinds of tokens (terminals) that the parser +** understands. +** +** Each symbol here is a terminal symbol in the grammar. +*/ +/* Make sure the INTERFACE macro is defined. +*/ +#ifndef INTERFACE +# define INTERFACE 1 +#endif +/* The next thing included is series of defines which control +** various aspects of the generated parser. +** YYCODETYPE is the data type used for storing terminal +** and nonterminal numbers. "unsigned char" is +** used if there are fewer than 250 terminals +** and nonterminals. "int" is used otherwise. +** YYNOCODE is a number of type YYCODETYPE which corresponds +** to no legal terminal or nonterminal number. This +** number is used to fill in empty slots of the hash +** table. +** YYFALLBACK If defined, this indicates that one or more tokens +** have fall-back values which should be used if the +** original value of the token will not parse. +** YYACTIONTYPE is the data type used for storing terminal +** and nonterminal numbers. "unsigned char" is +** used if there are fewer than 250 rules and +** states combined. "int" is used otherwise. +** sqlite3ParserTOKENTYPE is the data type used for minor tokens given +** directly to the parser from the tokenizer. +** YYMINORTYPE is the data type used for all minor tokens. +** This is typically a union of many types, one of +** which is sqlite3ParserTOKENTYPE. The entry in the union +** for base tokens is called "yy0". +** YYSTACKDEPTH is the maximum depth of the parser's stack. +** sqlite3ParserARG_SDECL A static variable declaration for the %extra_argument +** sqlite3ParserARG_PDECL A parameter declaration for the %extra_argument +** sqlite3ParserARG_STORE Code to store %extra_argument into yypParser +** sqlite3ParserARG_FETCH Code to extract %extra_argument from yypParser +** YYNSTATE the combined number of states. +** YYNRULE the number of rules in the grammar +** YYERRORSYMBOL is the code number of the error symbol. If not +** defined, then do no error processing. +*/ +#define YYCODETYPE unsigned char +#define YYNOCODE 248 +#define YYACTIONTYPE unsigned short int +#define YYWILDCARD 60 +#define sqlite3ParserTOKENTYPE Token +typedef union { + sqlite3ParserTOKENTYPE yy0; + int yy46; + struct LikeOp yy72; + Expr* yy172; + ExprList* yy174; + Select* yy219; + struct LimitVal yy234; + TriggerStep* yy243; + struct TrigEvent yy370; + SrcList* yy373; + Expr * yy386; + struct {int value; int mask;} yy405; + Token yy410; + IdList* yy432; + int yy495; +} YYMINORTYPE; +#define YYSTACKDEPTH 100 +#define sqlite3ParserARG_SDECL Parse *pParse; +#define sqlite3ParserARG_PDECL ,Parse *pParse +#define sqlite3ParserARG_FETCH Parse *pParse = yypParser->pParse +#define sqlite3ParserARG_STORE yypParser->pParse = pParse +#define YYNSTATE 586 +#define YYNRULE 310 +#define YYERRORSYMBOL 139 +#define YYERRSYMDT yy495 +#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 const YYACTIONTYPE yy_action[] = { + /* 0 */ 290, 897, 128, 585, 237, 172, 2, 478, 89, 89, + /* 10 */ 89, 89, 302, 75, 75, 75, 75, 71, 71, 85, + /* 20 */ 85, 85, 60, 417, 418, 302, 456, 443, 67, 75, + /* 30 */ 75, 75, 75, 71, 71, 85, 85, 85, 60, 286, + /* 40 */ 324, 458, 463, 464, 171, 80, 83, 313, 435, 433, + /* 50 */ 442, 442, 91, 91, 89, 89, 89, 89, 422, 75, + /* 60 */ 75, 75, 75, 71, 71, 85, 85, 85, 60, 290, + /* 70 */ 479, 477, 478, 57, 491, 78, 75, 75, 75, 75, + /* 80 */ 71, 71, 85, 85, 85, 60, 181, 114, 243, 327, + /* 90 */ 244, 330, 182, 248, 424, 456, 443, 279, 423, 90, + /* 100 */ 253, 243, 327, 244, 330, 182, 248, 485, 485, 485, + /* 110 */ 363, 283, 290, 253, 80, 83, 313, 435, 433, 442, + /* 120 */ 442, 91, 91, 89, 89, 89, 89, 336, 75, 75, + /* 130 */ 75, 75, 71, 71, 85, 85, 85, 60, 456, 443, + /* 140 */ 71, 71, 85, 85, 85, 60, 172, 448, 478, 499, + /* 150 */ 49, 580, 887, 427, 887, 290, 573, 80, 83, 313, + /* 160 */ 435, 433, 442, 442, 91, 91, 89, 89, 89, 89, + /* 170 */ 177, 75, 75, 75, 75, 71, 71, 85, 85, 85, + /* 180 */ 60, 456, 443, 159, 565, 447, 352, 359, 364, 386, + /* 190 */ 235, 339, 575, 1, 72, 79, 64, 565, 369, 388, + /* 200 */ 80, 83, 313, 435, 433, 442, 442, 91, 91, 89, + /* 210 */ 89, 89, 89, 478, 75, 75, 75, 75, 71, 71, + /* 220 */ 85, 85, 85, 60, 462, 527, 568, 290, 92, 438, + /* 230 */ 242, 486, 565, 545, 22, 458, 341, 275, 276, 565, + /* 240 */ 466, 217, 462, 577, 315, 148, 582, 210, 258, 564, + /* 250 */ 561, 392, 22, 456, 443, 147, 145, 146, 393, 431, + /* 260 */ 533, 195, 564, 561, 479, 463, 346, 171, 491, 822, + /* 270 */ 55, 59, 80, 83, 313, 435, 433, 442, 442, 91, + /* 280 */ 91, 89, 89, 89, 89, 557, 75, 75, 75, 75, + /* 290 */ 71, 71, 85, 85, 85, 60, 290, 564, 561, 308, + /* 300 */ 490, 485, 485, 485, 564, 561, 159, 223, 565, 352, + /* 310 */ 359, 364, 336, 159, 336, 548, 352, 359, 364, 221, + /* 320 */ 151, 369, 456, 443, 413, 316, 576, 422, 369, 580, + /* 330 */ 888, 206, 888, 197, 499, 47, 499, 23, 191, 583, + /* 340 */ 232, 80, 83, 313, 435, 433, 442, 442, 91, 91, + /* 350 */ 89, 89, 89, 89, 498, 75, 75, 75, 75, 71, + /* 360 */ 71, 85, 85, 85, 60, 290, 457, 498, 529, 255, + /* 370 */ 575, 207, 498, 564, 561, 512, 529, 312, 54, 229, + /* 380 */ 528, 224, 510, 65, 336, 76, 153, 581, 528, 400, + /* 390 */ 2, 456, 443, 526, 571, 531, 287, 328, 274, 6, + /* 400 */ 410, 526, 437, 375, 133, 530, 499, 49, 290, 236, + /* 410 */ 80, 83, 313, 435, 433, 442, 442, 91, 91, 89, + /* 420 */ 89, 89, 89, 317, 75, 75, 75, 75, 71, 71, + /* 430 */ 85, 85, 85, 60, 456, 443, 58, 234, 133, 269, + /* 440 */ 85, 85, 85, 60, 164, 238, 65, 228, 76, 153, + /* 450 */ 320, 178, 149, 80, 83, 313, 435, 433, 442, 442, + /* 460 */ 91, 91, 89, 89, 89, 89, 544, 75, 75, 75, + /* 470 */ 75, 71, 71, 85, 85, 85, 60, 290, 498, 414, + /* 480 */ 543, 502, 56, 336, 9, 336, 210, 336, 565, 515, + /* 490 */ 162, 149, 565, 336, 378, 354, 265, 455, 454, 344, + /* 500 */ 318, 155, 219, 456, 443, 499, 47, 499, 24, 499, + /* 510 */ 47, 343, 473, 471, 513, 499, 26, 115, 239, 451, + /* 520 */ 444, 184, 80, 83, 313, 435, 433, 442, 442, 91, + /* 530 */ 91, 89, 89, 89, 89, 498, 75, 75, 75, 75, + /* 540 */ 71, 71, 85, 85, 85, 60, 290, 452, 296, 421, + /* 550 */ 483, 109, 384, 564, 561, 565, 336, 564, 561, 351, + /* 560 */ 400, 336, 489, 336, 400, 336, 360, 336, 429, 429, + /* 570 */ 158, 20, 456, 443, 211, 478, 184, 292, 499, 47, + /* 580 */ 293, 236, 253, 499, 48, 499, 41, 499, 48, 499, + /* 590 */ 100, 80, 83, 313, 435, 433, 442, 442, 91, 91, + /* 600 */ 89, 89, 89, 89, 498, 75, 75, 75, 75, 71, + /* 610 */ 71, 85, 85, 85, 60, 290, 558, 555, 554, 520, + /* 620 */ 564, 561, 500, 300, 473, 471, 586, 577, 315, 345, + /* 630 */ 295, 336, 292, 401, 304, 441, 360, 230, 429, 429, + /* 640 */ 478, 456, 443, 65, 396, 76, 153, 462, 434, 360, + /* 650 */ 314, 429, 429, 499, 30, 362, 566, 22, 290, 355, + /* 660 */ 80, 83, 313, 435, 433, 442, 442, 91, 91, 89, + /* 670 */ 89, 89, 89, 336, 75, 75, 75, 75, 71, 71, + /* 680 */ 85, 85, 85, 60, 456, 443, 211, 476, 65, 21, + /* 690 */ 76, 153, 405, 398, 524, 499, 27, 537, 537, 537, + /* 700 */ 404, 290, 399, 80, 83, 313, 435, 433, 442, 442, + /* 710 */ 91, 91, 89, 89, 89, 89, 336, 75, 75, 75, + /* 720 */ 75, 71, 71, 85, 85, 85, 60, 456, 443, 419, + /* 730 */ 366, 419, 204, 299, 310, 298, 119, 537, 499, 97, + /* 740 */ 537, 185, 192, 186, 290, 406, 80, 82, 313, 435, + /* 750 */ 433, 442, 442, 91, 91, 89, 89, 89, 89, 336, + /* 760 */ 75, 75, 75, 75, 71, 71, 85, 85, 85, 60, + /* 770 */ 456, 443, 305, 468, 468, 301, 225, 225, 225, 519, + /* 780 */ 518, 499, 39, 360, 142, 429, 429, 290, 157, 376, + /* 790 */ 83, 313, 435, 433, 442, 442, 91, 91, 89, 89, + /* 800 */ 89, 89, 336, 75, 75, 75, 75, 71, 71, 85, + /* 810 */ 85, 85, 60, 456, 443, 373, 225, 133, 469, 225, + /* 820 */ 195, 240, 498, 408, 499, 44, 348, 523, 264, 57, + /* 830 */ 133, 183, 193, 201, 313, 435, 433, 442, 442, 91, + /* 840 */ 91, 89, 89, 89, 89, 336, 75, 75, 75, 75, + /* 850 */ 71, 71, 85, 85, 85, 60, 88, 367, 532, 4, + /* 860 */ 336, 325, 336, 306, 180, 498, 504, 499, 25, 336, + /* 870 */ 506, 340, 88, 367, 336, 4, 534, 535, 331, 306, + /* 880 */ 439, 210, 499, 98, 499, 16, 271, 340, 374, 347, + /* 890 */ 152, 499, 35, 249, 326, 336, 499, 32, 498, 458, + /* 900 */ 336, 19, 336, 139, 374, 504, 563, 559, 336, 506, + /* 910 */ 187, 336, 537, 574, 289, 458, 408, 499, 50, 84, + /* 920 */ 86, 347, 499, 42, 499, 31, 620, 88, 333, 334, + /* 930 */ 499, 29, 491, 499, 51, 84, 86, 461, 211, 569, + /* 940 */ 336, 365, 349, 88, 333, 334, 88, 367, 491, 4, + /* 950 */ 336, 210, 336, 306, 336, 218, 542, 336, 236, 236, + /* 960 */ 18, 340, 499, 43, 515, 485, 485, 485, 484, 481, + /* 970 */ 14, 236, 499, 36, 499, 28, 499, 94, 374, 499, + /* 980 */ 53, 485, 485, 485, 484, 481, 14, 205, 356, 458, + /* 990 */ 179, 233, 336, 472, 236, 273, 268, 261, 99, 503, + /* 1000 */ 245, 336, 493, 336, 200, 336, 236, 336, 236, 84, + /* 1010 */ 86, 166, 497, 241, 499, 111, 439, 88, 333, 334, + /* 1020 */ 254, 336, 491, 499, 113, 499, 110, 499, 112, 499, + /* 1030 */ 34, 336, 188, 379, 447, 267, 439, 236, 498, 190, + /* 1040 */ 336, 422, 170, 499, 45, 336, 478, 227, 336, 329, + /* 1050 */ 560, 336, 133, 499, 52, 485, 485, 485, 484, 481, + /* 1060 */ 14, 259, 499, 33, 445, 536, 336, 499, 96, 578, + /* 1070 */ 499, 46, 336, 499, 38, 420, 336, 303, 492, 336, + /* 1080 */ 262, 342, 539, 536, 465, 332, 220, 276, 499, 93, + /* 1090 */ 402, 291, 12, 514, 499, 40, 210, 294, 499, 10, + /* 1100 */ 272, 499, 37, 499, 3, 466, 217, 549, 501, 579, + /* 1110 */ 12, 478, 278, 247, 357, 246, 281, 517, 277, 337, + /* 1120 */ 321, 144, 470, 390, 487, 524, 389, 562, 372, 488, + /* 1130 */ 440, 540, 460, 196, 467, 117, 380, 307, 323, 126, + /* 1140 */ 521, 397, 383, 194, 522, 231, 209, 74, 368, 412, + /* 1150 */ 226, 214, 199, 61, 388, 215, 387, 189, 216, 335, + /* 1160 */ 212, 134, 409, 309, 106, 285, 135, 125, 547, 210, + /* 1170 */ 496, 138, 68, 541, 509, 121, 260, 55, 507, 250, + /* 1180 */ 385, 288, 251, 87, 252, 381, 62, 266, 505, 173, + /* 1190 */ 415, 120, 8, 513, 358, 322, 175, 550, 516, 73, + /* 1200 */ 361, 263, 69, 428, 425, 432, 570, 508, 482, 551, + /* 1210 */ 495, 567, 280, 131, 552, 123, 174, 203, 553, 446, + /* 1220 */ 449, 5, 556, 12, 338, 391, 382, 213, 394, 17, + /* 1230 */ 7, 377, 102, 101, 141, 95, 118, 403, 221, 127, + /* 1240 */ 311, 202, 222, 407, 150, 156, 176, 371, 411, 257, + /* 1250 */ 108, 416, 480, 370, 297, 475, 195, 140, 453, 395, + /* 1260 */ 137, 66, 256, 122, 430, 426, 107, 168, 105, 284, + /* 1270 */ 270, 129, 104, 353, 436, 60, 584, 450, 136, 572, + /* 1280 */ 350, 81, 143, 77, 282, 459, 198, 161, 13, 103, + /* 1290 */ 319, 474, 154, 546, 169, 525, 167, 160, 116, 63, + /* 1300 */ 163, 538, 15, 208, 494, 165, 132, 124, 622, 70, + /* 1310 */ 621, 511, 130, 559, 11, +}; +static const YYCODETYPE yy_lookahead[] = { + /* 0 */ 16, 140, 141, 142, 148, 21, 145, 23, 70, 71, + /* 10 */ 72, 73, 16, 75, 76, 77, 78, 79, 80, 81, + /* 20 */ 82, 83, 84, 51, 52, 16, 42, 43, 74, 75, + /* 30 */ 76, 77, 78, 79, 80, 81, 82, 83, 84, 159, + /* 40 */ 148, 59, 162, 163, 164, 61, 62, 63, 64, 65, + /* 50 */ 66, 67, 68, 69, 70, 71, 72, 73, 162, 75, + /* 60 */ 76, 77, 78, 79, 80, 81, 82, 83, 84, 16, + /* 70 */ 88, 20, 88, 22, 92, 22, 75, 76, 77, 78, + /* 80 */ 79, 80, 81, 82, 83, 84, 90, 91, 92, 93, + /* 90 */ 94, 95, 96, 97, 25, 42, 43, 201, 29, 46, + /* 100 */ 104, 92, 93, 94, 95, 96, 97, 125, 126, 127, + /* 110 */ 41, 148, 16, 104, 61, 62, 63, 64, 65, 66, + /* 120 */ 67, 68, 69, 70, 71, 72, 73, 148, 75, 76, + /* 130 */ 77, 78, 79, 80, 81, 82, 83, 84, 42, 43, + /* 140 */ 79, 80, 81, 82, 83, 84, 21, 11, 23, 170, + /* 150 */ 171, 19, 20, 18, 22, 16, 179, 61, 62, 63, + /* 160 */ 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, + /* 170 */ 22, 75, 76, 77, 78, 79, 80, 81, 82, 83, + /* 180 */ 84, 42, 43, 90, 23, 49, 93, 94, 95, 210, + /* 190 */ 211, 56, 60, 19, 131, 19, 133, 23, 105, 23, + /* 200 */ 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, + /* 210 */ 71, 72, 73, 88, 75, 76, 77, 78, 79, 80, + /* 220 */ 81, 82, 83, 84, 148, 148, 30, 16, 132, 94, + /* 230 */ 191, 20, 23, 157, 158, 59, 100, 101, 102, 23, + /* 240 */ 79, 80, 148, 1, 2, 22, 50, 111, 154, 88, + /* 250 */ 89, 157, 158, 42, 43, 79, 80, 181, 182, 20, + /* 260 */ 99, 22, 88, 89, 88, 162, 163, 164, 92, 134, + /* 270 */ 122, 132, 61, 62, 63, 64, 65, 66, 67, 68, + /* 280 */ 69, 70, 71, 72, 73, 179, 75, 76, 77, 78, + /* 290 */ 79, 80, 81, 82, 83, 84, 16, 88, 89, 103, + /* 300 */ 20, 125, 126, 127, 88, 89, 90, 92, 23, 93, + /* 310 */ 94, 95, 148, 90, 148, 148, 93, 94, 95, 104, + /* 320 */ 156, 105, 42, 43, 115, 143, 144, 162, 105, 19, + /* 330 */ 20, 149, 22, 156, 170, 171, 170, 171, 156, 179, + /* 340 */ 14, 61, 62, 63, 64, 65, 66, 67, 68, 69, + /* 350 */ 70, 71, 72, 73, 190, 75, 76, 77, 78, 79, + /* 360 */ 80, 81, 82, 83, 84, 16, 201, 190, 12, 20, + /* 370 */ 60, 193, 190, 88, 89, 27, 12, 213, 200, 53, + /* 380 */ 24, 55, 34, 218, 148, 220, 221, 142, 24, 225, + /* 390 */ 145, 42, 43, 37, 20, 39, 22, 215, 14, 192, + /* 400 */ 115, 37, 20, 39, 22, 49, 170, 171, 16, 148, + /* 410 */ 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, + /* 420 */ 71, 72, 73, 241, 75, 76, 77, 78, 79, 80, + /* 430 */ 81, 82, 83, 84, 42, 43, 44, 53, 22, 55, + /* 440 */ 81, 82, 83, 84, 156, 148, 218, 211, 220, 221, + /* 450 */ 189, 202, 203, 61, 62, 63, 64, 65, 66, 67, + /* 460 */ 68, 69, 70, 71, 72, 73, 238, 75, 76, 77, + /* 470 */ 78, 79, 80, 81, 82, 83, 84, 16, 190, 20, + /* 480 */ 168, 169, 21, 148, 19, 148, 111, 148, 23, 177, + /* 490 */ 202, 203, 23, 148, 16, 207, 146, 42, 43, 124, + /* 500 */ 239, 156, 148, 42, 43, 170, 171, 170, 171, 170, + /* 510 */ 171, 165, 166, 167, 98, 170, 171, 148, 134, 64, + /* 520 */ 65, 43, 61, 62, 63, 64, 65, 66, 67, 68, + /* 530 */ 69, 70, 71, 72, 73, 190, 75, 76, 77, 78, + /* 540 */ 79, 80, 81, 82, 83, 84, 16, 92, 213, 20, + /* 550 */ 81, 21, 213, 88, 89, 23, 148, 88, 89, 16, + /* 560 */ 225, 148, 20, 148, 225, 148, 107, 148, 109, 110, + /* 570 */ 156, 19, 42, 43, 228, 23, 43, 99, 170, 171, + /* 580 */ 151, 148, 104, 170, 171, 170, 171, 170, 171, 170, + /* 590 */ 171, 61, 62, 63, 64, 65, 66, 67, 68, 69, + /* 600 */ 70, 71, 72, 73, 190, 75, 76, 77, 78, 79, + /* 610 */ 80, 81, 82, 83, 84, 16, 7, 8, 9, 20, + /* 620 */ 88, 89, 189, 165, 166, 167, 0, 1, 2, 215, + /* 630 */ 217, 148, 99, 225, 217, 92, 107, 222, 109, 110, + /* 640 */ 88, 42, 43, 218, 219, 220, 221, 148, 148, 107, + /* 650 */ 236, 109, 110, 170, 171, 226, 157, 158, 16, 230, + /* 660 */ 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, + /* 670 */ 71, 72, 73, 148, 75, 76, 77, 78, 79, 80, + /* 680 */ 81, 82, 83, 84, 42, 43, 228, 20, 218, 22, + /* 690 */ 220, 221, 22, 177, 178, 170, 171, 148, 148, 148, + /* 700 */ 184, 16, 148, 61, 62, 63, 64, 65, 66, 67, + /* 710 */ 68, 69, 70, 71, 72, 73, 148, 75, 76, 77, + /* 720 */ 78, 79, 80, 81, 82, 83, 84, 42, 43, 100, + /* 730 */ 101, 102, 183, 183, 183, 242, 243, 148, 170, 171, + /* 740 */ 148, 100, 101, 102, 16, 204, 61, 62, 63, 64, + /* 750 */ 65, 66, 67, 68, 69, 70, 71, 72, 73, 148, + /* 760 */ 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, + /* 770 */ 42, 43, 183, 125, 126, 183, 227, 227, 227, 7, + /* 780 */ 8, 170, 171, 107, 114, 109, 110, 16, 156, 233, + /* 790 */ 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, + /* 800 */ 72, 73, 148, 75, 76, 77, 78, 79, 80, 81, + /* 810 */ 82, 83, 84, 42, 43, 20, 227, 22, 20, 227, + /* 820 */ 22, 148, 190, 22, 170, 171, 148, 20, 20, 22, + /* 830 */ 22, 156, 19, 232, 63, 64, 65, 66, 67, 68, + /* 840 */ 69, 70, 71, 72, 73, 148, 75, 76, 77, 78, + /* 850 */ 79, 80, 81, 82, 83, 84, 16, 17, 148, 19, + /* 860 */ 148, 91, 148, 23, 156, 190, 108, 170, 171, 148, + /* 870 */ 112, 31, 16, 17, 148, 19, 166, 167, 81, 23, + /* 880 */ 148, 111, 170, 171, 170, 171, 148, 31, 48, 148, + /* 890 */ 89, 170, 171, 148, 124, 148, 170, 171, 190, 59, + /* 900 */ 148, 19, 148, 21, 48, 108, 91, 92, 148, 112, + /* 910 */ 19, 148, 148, 244, 245, 59, 115, 170, 171, 79, + /* 920 */ 80, 148, 170, 171, 170, 171, 113, 87, 88, 89, + /* 930 */ 170, 171, 92, 170, 171, 79, 80, 81, 228, 148, + /* 940 */ 148, 209, 148, 87, 88, 89, 16, 17, 92, 19, + /* 950 */ 148, 111, 148, 23, 148, 214, 169, 148, 148, 148, + /* 960 */ 69, 31, 170, 171, 177, 125, 126, 127, 128, 129, + /* 970 */ 130, 148, 170, 171, 170, 171, 170, 171, 48, 170, + /* 980 */ 171, 125, 126, 127, 128, 129, 130, 214, 174, 59, + /* 990 */ 5, 227, 148, 161, 148, 10, 11, 12, 13, 189, + /* 1000 */ 189, 148, 170, 148, 156, 148, 148, 148, 148, 79, + /* 1010 */ 80, 26, 189, 28, 170, 171, 148, 87, 88, 89, + /* 1020 */ 35, 148, 92, 170, 171, 170, 171, 170, 171, 170, + /* 1030 */ 171, 148, 47, 148, 49, 189, 148, 148, 190, 54, + /* 1040 */ 148, 162, 57, 170, 171, 148, 23, 189, 148, 189, + /* 1050 */ 20, 148, 22, 170, 171, 125, 126, 127, 128, 129, + /* 1060 */ 130, 148, 170, 171, 186, 187, 148, 170, 171, 20, + /* 1070 */ 170, 171, 148, 170, 171, 148, 148, 209, 189, 148, + /* 1080 */ 201, 148, 186, 187, 162, 100, 101, 102, 170, 171, + /* 1090 */ 20, 106, 22, 195, 170, 171, 111, 209, 170, 171, + /* 1100 */ 148, 170, 171, 170, 171, 79, 80, 150, 20, 60, + /* 1110 */ 22, 88, 148, 194, 148, 173, 148, 173, 148, 148, + /* 1120 */ 135, 192, 229, 173, 148, 178, 173, 148, 224, 148, + /* 1130 */ 148, 173, 195, 113, 229, 61, 153, 40, 99, 185, + /* 1140 */ 180, 153, 15, 152, 172, 97, 212, 131, 38, 235, + /* 1150 */ 234, 212, 152, 131, 23, 223, 161, 152, 212, 15, + /* 1160 */ 212, 188, 153, 153, 19, 175, 188, 19, 33, 111, + /* 1170 */ 190, 216, 237, 172, 172, 216, 172, 122, 161, 195, + /* 1180 */ 119, 175, 196, 120, 197, 117, 237, 198, 180, 152, + /* 1190 */ 172, 153, 22, 98, 153, 155, 6, 147, 174, 99, + /* 1200 */ 116, 205, 121, 206, 172, 172, 147, 195, 195, 147, + /* 1210 */ 199, 138, 205, 188, 147, 188, 185, 153, 153, 185, + /* 1220 */ 206, 118, 153, 22, 153, 153, 16, 176, 17, 231, + /* 1230 */ 118, 187, 240, 176, 21, 160, 243, 20, 104, 99, + /* 1240 */ 246, 22, 148, 20, 148, 19, 96, 148, 11, 148, + /* 1250 */ 19, 115, 170, 44, 36, 170, 22, 19, 182, 182, + /* 1260 */ 45, 19, 134, 19, 108, 45, 19, 99, 19, 5, + /* 1270 */ 20, 20, 19, 44, 92, 84, 4, 1, 103, 1, + /* 1280 */ 3, 69, 19, 69, 137, 20, 123, 136, 19, 14, + /* 1290 */ 58, 20, 113, 20, 114, 124, 14, 116, 32, 19, + /* 1300 */ 113, 20, 19, 44, 17, 113, 123, 103, 113, 19, + /* 1310 */ 113, 20, 114, 247, 22, +}; +#define YY_SHIFT_USE_DFLT (-63) +#define YY_SHIFT_MAX 386 +static const short yy_shift_ofst[] = { + /* 0 */ 242, 840, 985, -16, 840, 930, 930, 930, 216, 1058, + /* 10 */ 392, 930, 930, 930, 930, 930, -46, 136, 161, 532, + /* 20 */ 1026, 1026, 1023, 53, 599, 349, 280, 96, 139, 211, + /* 30 */ 461, 530, 642, 642, 642, 685, 642, 642, 642, 642, + /* 40 */ 642, 642, 642, 642, 642, 642, 642, 642, 642, 642, + /* 50 */ 642, 728, 771, 771, 856, 930, 930, 930, 930, 930, + /* 60 */ 930, 930, 930, 930, 930, 930, 930, 930, 930, 930, + /* 70 */ 930, 930, 930, 930, 930, 930, 930, 930, 930, 930, + /* 80 */ 930, 930, 930, 930, 930, 930, 930, 930, 930, 930, + /* 90 */ 930, 930, 930, -62, -62, -4, 1, 1, 61, 135, + /* 100 */ 359, 478, 532, 532, 532, 532, 532, 532, 532, 1023, + /* 110 */ 1191, -63, -63, -63, 176, 9, 356, 356, 310, 132, + /* 120 */ 125, 770, 532, 532, 532, 532, 532, 532, 626, 125, + /* 130 */ 532, 532, 532, 532, 532, 532, 532, 532, 375, 1058, + /* 140 */ 1058, 1058, -63, -63, -63, -18, 223, -18, 93, 465, + /* 150 */ 209, 529, 285, 174, 469, 542, 364, 459, 676, 532, + /* 160 */ 532, 532, 801, 532, 676, 532, 532, 532, 532, 532, + /* 170 */ 532, 552, 532, 532, 532, 532, 532, 532, 801, 609, + /* 180 */ 676, 532, 532, 676, 532, 196, 196, 532, 532, 532, + /* 190 */ 532, 676, 196, 797, 532, 532, 532, 676, 532, 532, + /* 200 */ 676, 629, 532, 69, 416, 148, 882, 670, 348, 348, + /* 210 */ 758, 648, 348, 533, 348, 63, 348, 648, 148, 1020, + /* 220 */ 1074, 1097, 1020, 1039, 1127, 1048, 1016, 1110, 1048, 1127, + /* 230 */ 1022, 1131, 1127, 1048, 1144, 1048, 1020, 1020, 1145, 1144, + /* 240 */ 1148, 1135, 1058, 1039, 1039, 1148, 1039, 1055, 1131, 1145, + /* 250 */ 1061, 1063, 1068, 1097, 1135, 1039, 1127, 1020, 1170, 1020, + /* 260 */ 1095, 1190, 1100, 1084, 1039, 1190, 1081, 1055, 1190, 1144, + /* 270 */ 1039, 1020, 1020, 1190, 1144, 1074, 1074, 1020, 1055, 1100, + /* 280 */ 1084, 1020, 1073, 1020, -63, -63, -63, -63, -63, -63, + /* 290 */ 455, 384, 641, 326, 239, 51, 1088, -28, 374, 382, + /* 300 */ 667, 795, 215, 798, 807, 808, 813, 772, 815, 891, + /* 310 */ 1030, 1049, 1070, 543, 1276, 1277, 1278, 1263, 1147, 1151, + /* 320 */ 1232, 1275, 1273, 1266, 1281, 1171, 1283, 1259, 1183, 1204, + /* 330 */ 1290, 1291, 1198, 1197, 1195, 1287, 1192, 1187, 1181, 1282, + /* 340 */ 1280, 1180, 1179, 1271, 1269, 1163, 1265, 1214, 1212, 1175, + /* 350 */ 1272, 1182, 1229, 1253, 1251, 1264, 1250, 1249, 1168, 1247, + /* 360 */ 1156, 1244, 1128, 1220, 1242, 1234, 1215, 1238, 1218, 1209, + /* 370 */ 1231, 1136, 1237, 1150, 1226, 1223, 1140, 1219, 1134, 1217, + /* 380 */ 1213, 1112, 1211, 1210, 1201, 1103, 1292, +}; +#define YY_REDUCE_USE_DFLT (-145) +#define YY_REDUCE_MAX 289 +static const short yy_reduce_ofst[] = { + /* 0 */ -139, 164, 182, 165, 345, 339, 335, -21, 76, 288, + /* 10 */ 228, 236, 408, 413, 415, 417, 425, 414, 710, 94, + /* 20 */ 458, 346, -120, 470, 470, 470, 470, 470, 470, 470, + /* 30 */ 470, 470, 470, 470, 470, 470, 470, 470, 470, 470, + /* 40 */ 470, 470, 470, 470, 470, 470, 470, 470, 470, 470, + /* 50 */ 470, 470, 470, 470, 933, 931, 928, 903, 892, 859, + /* 60 */ 853, 804, 792, 754, 747, 714, 697, 568, 483, 166, + /* 70 */ 337, 419, 525, 611, 654, 712, 721, 726, 752, 760, + /* 80 */ 763, 802, 806, 809, 844, 855, 857, 873, 883, 897, + /* 90 */ 900, 918, 924, 470, 470, 312, 470, 470, 470, 429, + /* 100 */ 470, 516, 499, 261, 549, 550, 551, 589, 592, 103, + /* 110 */ 470, 470, 470, 470, 832, 787, 896, 878, 669, 669, + /* 120 */ 879, 848, 888, 889, 773, 868, 860, 858, 245, -104, + /* 130 */ 846, 823, 811, 764, 810, 433, 741, 732, 708, 675, + /* 140 */ 632, 177, 249, 493, 178, 1085, 1077, 1082, 1076, 1101, + /* 150 */ 1099, 39, 1096, 1094, 971, 39, 1044, 39, 39, 982, + /* 160 */ 981, 979, 541, 976, 39, 971, 970, 968, 966, 964, + /* 170 */ 952, 922, 927, 913, 794, 791, 745, 678, 541, 350, + /* 180 */ 39, 369, 297, 39, 167, 106, -23, -108, -144, -37, + /* 190 */ 77, 39, 160, 207, 354, 500, 554, 39, 673, 738, + /* 200 */ 39, 556, 885, 601, 814, 898, 957, 919, 942, 944, + /* 210 */ 929, 893, 950, 947, 953, 904, 958, 905, 937, 983, + /* 220 */ 954, 960, 988, 972, 991, 934, 914, 916, 939, 1000, + /* 230 */ 932, 995, 1005, 946, 973, 948, 1009, 1010, 990, 978, + /* 240 */ 955, 935, 980, 1001, 1002, 959, 1004, 984, 1017, 1006, + /* 250 */ 986, 987, 989, 1008, 949, 1018, 1037, 1038, 1040, 1041, + /* 260 */ 1024, 1050, 996, 997, 1032, 1059, 1011, 1012, 1062, 1025, + /* 270 */ 1033, 1064, 1065, 1067, 1027, 1031, 1034, 1069, 1013, 1007, + /* 280 */ 1014, 1071, 992, 1072, 998, 1051, 1075, 993, 1057, 994, +}; +static const YYACTIONTYPE yy_default[] = { + /* 0 */ 592, 819, 896, 707, 896, 819, 819, 896, 896, 711, + /* 10 */ 870, 896, 819, 896, 815, 896, 790, 896, 841, 896, + /* 20 */ 841, 841, 623, 742, 896, 896, 896, 896, 896, 896, + /* 30 */ 896, 896, 750, 871, 811, 896, 749, 747, 756, 723, + /* 40 */ 810, 814, 744, 874, 855, 740, 743, 818, 757, 731, + /* 50 */ 812, 778, 796, 777, 896, 896, 896, 896, 896, 896, + /* 60 */ 896, 896, 896, 896, 896, 896, 896, 896, 896, 896, + /* 70 */ 896, 896, 896, 896, 896, 896, 896, 896, 896, 896, + /* 80 */ 896, 896, 896, 896, 896, 896, 896, 896, 896, 896, + /* 90 */ 896, 896, 896, 780, 801, 616, 779, 789, 781, 611, + /* 100 */ 782, 676, 896, 896, 896, 896, 896, 896, 896, 896, + /* 110 */ 783, 798, 797, 784, 896, 896, 896, 896, 896, 896, + /* 120 */ 707, 896, 896, 896, 896, 896, 896, 896, 592, 707, + /* 130 */ 896, 896, 896, 896, 896, 896, 896, 896, 896, 896, + /* 140 */ 896, 896, 711, 889, 701, 896, 667, 896, 896, 896, + /* 150 */ 896, 896, 896, 896, 896, 896, 896, 896, 862, 896, + /* 160 */ 896, 896, 715, 896, 714, 896, 877, 896, 896, 896, + /* 170 */ 875, 625, 896, 896, 896, 597, 896, 896, 709, 599, + /* 180 */ 860, 896, 896, 613, 896, 896, 896, 896, 896, 896, + /* 190 */ 829, 690, 896, 699, 896, 896, 896, 688, 896, 896, + /* 200 */ 752, 896, 896, 847, 649, 746, 896, 708, 734, 734, + /* 210 */ 699, 896, 734, 646, 734, 813, 734, 896, 746, 716, + /* 220 */ 680, 663, 716, 678, 608, 735, 854, 851, 735, 608, + /* 230 */ 896, 896, 608, 735, 687, 735, 716, 716, 823, 687, + /* 240 */ 758, 873, 896, 678, 678, 758, 678, 746, 896, 823, + /* 250 */ 737, 739, 727, 663, 873, 678, 608, 716, 666, 716, + /* 260 */ 649, 596, 724, 726, 678, 596, 741, 746, 596, 687, + /* 270 */ 678, 716, 716, 596, 687, 680, 680, 716, 746, 724, + /* 280 */ 726, 716, 882, 716, 857, 651, 633, 889, 651, 894, + /* 290 */ 896, 896, 896, 896, 896, 896, 896, 896, 896, 896, + /* 300 */ 896, 896, 896, 896, 896, 896, 765, 896, 896, 836, + /* 310 */ 896, 896, 896, 896, 896, 593, 896, 884, 896, 896, + /* 320 */ 881, 896, 896, 896, 896, 896, 896, 896, 896, 896, + /* 330 */ 896, 896, 896, 770, 766, 896, 896, 767, 896, 896, + /* 340 */ 896, 896, 896, 896, 896, 896, 896, 896, 896, 896, + /* 350 */ 896, 896, 896, 896, 896, 896, 896, 896, 896, 896, + /* 360 */ 693, 896, 896, 896, 896, 850, 849, 896, 896, 896, + /* 370 */ 896, 896, 896, 896, 896, 896, 896, 896, 896, 896, + /* 380 */ 896, 896, 896, 896, 738, 896, 728, 736, 618, 729, + /* 390 */ 730, 607, 615, 670, 609, 669, 791, 807, 677, 717, + /* 400 */ 817, 816, 804, 864, 675, 700, 710, 863, 719, 718, + /* 410 */ 720, 809, 843, 721, 808, 674, 722, 852, 853, 848, + /* 420 */ 705, 806, 706, 844, 845, 673, 846, 610, 712, 695, + /* 430 */ 694, 725, 672, 802, 760, 799, 795, 820, 821, 761, + /* 440 */ 671, 793, 792, 787, 803, 681, 754, 755, 842, 713, + /* 450 */ 856, 800, 794, 668, 788, 786, 785, 702, 776, 773, + /* 460 */ 858, 703, 617, 628, 624, 629, 840, 838, 839, 759, + /* 470 */ 837, 631, 640, 630, 627, 639, 626, 859, 619, 770, + /* 480 */ 638, 772, 861, 704, 771, 769, 637, 768, 886, 805, + /* 490 */ 763, 764, 685, 636, 686, 696, 692, 689, 691, 762, + /* 500 */ 828, 774, 635, 868, 698, 662, 697, 648, 745, 644, + /* 510 */ 733, 775, 732, 650, 748, 647, 643, 826, 665, 664, + /* 520 */ 645, 661, 642, 751, 652, 753, 867, 830, 866, 865, + /* 530 */ 684, 683, 831, 832, 833, 834, 682, 827, 835, 679, + /* 540 */ 825, 641, 634, 632, 869, 614, 612, 872, 653, 606, + /* 550 */ 605, 604, 603, 876, 602, 601, 878, 654, 600, 657, + /* 560 */ 824, 622, 879, 658, 621, 620, 880, 883, 659, 598, + /* 570 */ 595, 885, 591, 656, 890, 891, 589, 590, 892, 895, + /* 580 */ 893, 587, 660, 655, 594, 588, +}; +#define YY_SZ_ACTTAB (int)(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, /* SEMI => nothing */ + 23, /* EXPLAIN => ID */ + 23, /* QUERY => ID */ + 23, /* PLAN => ID */ + 23, /* BEGIN => ID */ + 0, /* TRANSACTION => nothing */ + 23, /* DEFERRED => ID */ + 23, /* IMMEDIATE => ID */ + 23, /* EXCLUSIVE => ID */ + 0, /* COMMIT => nothing */ + 23, /* END => ID */ + 0, /* ROLLBACK => nothing */ + 0, /* CREATE => nothing */ + 0, /* TABLE => nothing */ + 23, /* IF => ID */ + 0, /* NOT => nothing */ + 0, /* EXISTS => nothing */ + 23, /* TEMP => ID */ + 0, /* LP => nothing */ + 0, /* RP => nothing */ + 0, /* AS => nothing */ + 0, /* COMMA => nothing */ + 0, /* ID => nothing */ + 23, /* ABORT => ID */ + 23, /* AFTER => ID */ + 23, /* ANALYZE => ID */ + 23, /* ASC => ID */ + 23, /* ATTACH => ID */ + 23, /* BEFORE => ID */ + 23, /* CASCADE => ID */ + 23, /* CAST => ID */ + 23, /* CONFLICT => ID */ + 23, /* DATABASE => ID */ + 23, /* DESC => ID */ + 23, /* DETACH => ID */ + 23, /* EACH => ID */ + 23, /* FAIL => ID */ + 23, /* FOR => ID */ + 23, /* IGNORE => ID */ + 23, /* INITIALLY => ID */ + 23, /* INSTEAD => ID */ + 23, /* LIKE_KW => 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 */ + 23, /* VIRTUAL => ID */ + 23, /* REINDEX => ID */ + 23, /* RENAME => ID */ + 23, /* CTIME_KW => ID */ + 0, /* ANY => nothing */ + 0, /* OR => nothing */ + 0, /* AND => nothing */ + 0, /* IS => nothing */ + 0, /* BETWEEN => nothing */ + 0, /* IN => nothing */ + 0, /* ISNULL => nothing */ + 0, /* NOTNULL => nothing */ + 0, /* NE => nothing */ + 0, /* EQ => nothing */ + 0, /* GT => nothing */ + 0, /* LE => nothing */ + 0, /* LT => nothing */ + 0, /* GE => nothing */ + 0, /* ESCAPE => 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, /* CONSTRAINT => nothing */ + 0, /* DEFAULT => nothing */ + 0, /* NULL => nothing */ + 0, /* PRIMARY => nothing */ + 0, /* UNIQUE => nothing */ + 0, /* CHECK => nothing */ + 0, /* REFERENCES => nothing */ + 0, /* COLLATE => nothing */ + 0, /* AUTOINCR => nothing */ + 0, /* ON => nothing */ + 0, /* DELETE => nothing */ + 0, /* UPDATE => nothing */ + 0, /* INSERT => nothing */ + 0, /* SET => nothing */ + 0, /* DEFERRABLE => nothing */ + 0, /* FOREIGN => nothing */ + 0, /* DROP => nothing */ + 0, /* UNION => nothing */ + 0, /* ALL => nothing */ + 0, /* EXCEPT => nothing */ + 0, /* INTERSECT => 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, /* INTEGER => nothing */ + 0, /* FLOAT => nothing */ + 0, /* BLOB => nothing */ + 0, /* REGISTER => nothing */ + 0, /* VARIABLE => nothing */ + 0, /* CASE => nothing */ + 0, /* WHEN => nothing */ + 0, /* THEN => nothing */ + 0, /* ELSE => nothing */ + 0, /* INDEX => nothing */ + 0, /* ALTER => nothing */ + 0, /* TO => nothing */ + 0, /* ADD => nothing */ + 0, /* COLUMNKW => nothing */ +}; +#endif /* YYFALLBACK */ + +/* 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 */ + sqlite3ParserARG_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 sqlite3ParserTrace(FILE *TraceFILE, char *zTracePrompt){ + yyTraceFILE = TraceFILE; + yyTracePrompt = zTracePrompt; + if( yyTraceFILE==0 ) yyTracePrompt = 0; + else if( yyTracePrompt==0 ) yyTraceFILE = 0; +} +#endif /* NDEBUG */ + +#ifndef NDEBUG +/* For tracing shifts, the names of all terminals and nonterminals +** are required. The following table supplies these names */ +static const char *const yyTokenName[] = { + "$", "SEMI", "EXPLAIN", "QUERY", + "PLAN", "BEGIN", "TRANSACTION", "DEFERRED", + "IMMEDIATE", "EXCLUSIVE", "COMMIT", "END", + "ROLLBACK", "CREATE", "TABLE", "IF", + "NOT", "EXISTS", "TEMP", "LP", + "RP", "AS", "COMMA", "ID", + "ABORT", "AFTER", "ANALYZE", "ASC", + "ATTACH", "BEFORE", "CASCADE", "CAST", + "CONFLICT", "DATABASE", "DESC", "DETACH", + "EACH", "FAIL", "FOR", "IGNORE", + "INITIALLY", "INSTEAD", "LIKE_KW", "MATCH", + "KEY", "OF", "OFFSET", "PRAGMA", + "RAISE", "REPLACE", "RESTRICT", "ROW", + "STATEMENT", "TRIGGER", "VACUUM", "VIEW", + "VIRTUAL", "REINDEX", "RENAME", "CTIME_KW", + "ANY", "OR", "AND", "IS", + "BETWEEN", "IN", "ISNULL", "NOTNULL", + "NE", "EQ", "GT", "LE", + "LT", "GE", "ESCAPE", "BITAND", + "BITOR", "LSHIFT", "RSHIFT", "PLUS", + "MINUS", "STAR", "SLASH", "REM", + "CONCAT", "UMINUS", "UPLUS", "BITNOT", + "STRING", "JOIN_KW", "CONSTRAINT", "DEFAULT", + "NULL", "PRIMARY", "UNIQUE", "CHECK", + "REFERENCES", "COLLATE", "AUTOINCR", "ON", + "DELETE", "UPDATE", "INSERT", "SET", + "DEFERRABLE", "FOREIGN", "DROP", "UNION", + "ALL", "EXCEPT", "INTERSECT", "SELECT", + "DISTINCT", "DOT", "FROM", "JOIN", + "USING", "ORDER", "BY", "GROUP", + "HAVING", "LIMIT", "WHERE", "INTO", + "VALUES", "INTEGER", "FLOAT", "BLOB", + "REGISTER", "VARIABLE", "CASE", "WHEN", + "THEN", "ELSE", "INDEX", "ALTER", + "TO", "ADD", "COLUMNKW", "error", + "input", "cmdlist", "ecmd", "cmdx", + "cmd", "explain", "transtype", "trans_opt", + "nm", "create_table", "create_table_args", "temp", + "ifnotexists", "dbnm", "columnlist", "conslist_opt", + "select", "column", "columnid", "type", + "carglist", "id", "ids", "typetoken", + "typename", "signed", "plus_num", "minus_num", + "carg", "ccons", "term", "expr", + "onconf", "sortorder", "autoinc", "idxlist_opt", + "refargs", "defer_subclause", "refarg", "refact", + "init_deferred_pred_opt", "conslist", "tcons", "idxlist", + "defer_subclause_opt", "orconf", "resolvetype", "raisetype", + "ifexists", "fullname", "oneselect", "multiselect_op", + "distinct", "selcollist", "from", "where_opt", + "groupby_opt", "having_opt", "orderby_opt", "limit_opt", + "sclp", "as", "seltablist", "stl_prefix", + "joinop", "on_opt", "using_opt", "seltablist_paren", + "joinop2", "inscollist", "sortlist", "sortitem", + "collate", "exprlist", "setlist", "insert_cmd", + "inscollist_opt", "itemlist", "likeop", "escape", + "between_op", "in_op", "case_operand", "case_exprlist", + "case_else", "expritem", "uniqueflag", "idxitem", + "plus_opt", "number", "trigger_decl", "trigger_cmd_list", + "trigger_time", "trigger_event", "foreach_clause", "when_clause", + "trigger_cmd", "database_kw_opt", "key_opt", "add_column_fullname", + "kwcolumn_opt", "create_vtab", "vtabarglist", "vtabarg", + "vtabargtoken", "lp", "anylist", +}; +#endif /* NDEBUG */ + +#ifndef NDEBUG +/* For tracing reduce actions, the names of all rules are required. +*/ +static const char *const yyRuleName[] = { + /* 0 */ "input ::= cmdlist", + /* 1 */ "cmdlist ::= cmdlist ecmd", + /* 2 */ "cmdlist ::= ecmd", + /* 3 */ "cmdx ::= cmd", + /* 4 */ "ecmd ::= SEMI", + /* 5 */ "ecmd ::= explain cmdx SEMI", + /* 6 */ "explain ::=", + /* 7 */ "explain ::= EXPLAIN", + /* 8 */ "explain ::= EXPLAIN QUERY PLAN", + /* 9 */ "cmd ::= BEGIN transtype trans_opt", + /* 10 */ "trans_opt ::=", + /* 11 */ "trans_opt ::= TRANSACTION", + /* 12 */ "trans_opt ::= TRANSACTION nm", + /* 13 */ "transtype ::=", + /* 14 */ "transtype ::= DEFERRED", + /* 15 */ "transtype ::= IMMEDIATE", + /* 16 */ "transtype ::= EXCLUSIVE", + /* 17 */ "cmd ::= COMMIT trans_opt", + /* 18 */ "cmd ::= END trans_opt", + /* 19 */ "cmd ::= ROLLBACK trans_opt", + /* 20 */ "cmd ::= create_table create_table_args", + /* 21 */ "create_table ::= CREATE temp TABLE ifnotexists nm dbnm", + /* 22 */ "ifnotexists ::=", + /* 23 */ "ifnotexists ::= IF NOT EXISTS", + /* 24 */ "temp ::= TEMP", + /* 25 */ "temp ::=", + /* 26 */ "create_table_args ::= LP columnlist conslist_opt RP", + /* 27 */ "create_table_args ::= AS select", + /* 28 */ "columnlist ::= columnlist COMMA column", + /* 29 */ "columnlist ::= column", + /* 30 */ "column ::= columnid type carglist", + /* 31 */ "columnid ::= nm", + /* 32 */ "id ::= ID", + /* 33 */ "ids ::= ID|STRING", + /* 34 */ "nm ::= ID", + /* 35 */ "nm ::= STRING", + /* 36 */ "nm ::= JOIN_KW", + /* 37 */ "type ::=", + /* 38 */ "type ::= typetoken", + /* 39 */ "typetoken ::= typename", + /* 40 */ "typetoken ::= typename LP signed RP", + /* 41 */ "typetoken ::= typename LP signed COMMA signed RP", + /* 42 */ "typename ::= ids", + /* 43 */ "typename ::= typename ids", + /* 44 */ "signed ::= plus_num", + /* 45 */ "signed ::= minus_num", + /* 46 */ "carglist ::= carglist carg", + /* 47 */ "carglist ::=", + /* 48 */ "carg ::= CONSTRAINT nm ccons", + /* 49 */ "carg ::= ccons", + /* 50 */ "carg ::= DEFAULT term", + /* 51 */ "carg ::= DEFAULT LP expr RP", + /* 52 */ "carg ::= DEFAULT PLUS term", + /* 53 */ "carg ::= DEFAULT MINUS term", + /* 54 */ "carg ::= DEFAULT id", + /* 55 */ "ccons ::= NULL onconf", + /* 56 */ "ccons ::= NOT NULL onconf", + /* 57 */ "ccons ::= PRIMARY KEY sortorder onconf autoinc", + /* 58 */ "ccons ::= UNIQUE onconf", + /* 59 */ "ccons ::= CHECK LP expr RP", + /* 60 */ "ccons ::= REFERENCES nm idxlist_opt refargs", + /* 61 */ "ccons ::= defer_subclause", + /* 62 */ "ccons ::= COLLATE id", + /* 63 */ "autoinc ::=", + /* 64 */ "autoinc ::= AUTOINCR", + /* 65 */ "refargs ::=", + /* 66 */ "refargs ::= refargs refarg", + /* 67 */ "refarg ::= MATCH nm", + /* 68 */ "refarg ::= ON DELETE refact", + /* 69 */ "refarg ::= ON UPDATE refact", + /* 70 */ "refarg ::= ON INSERT refact", + /* 71 */ "refact ::= SET NULL", + /* 72 */ "refact ::= SET DEFAULT", + /* 73 */ "refact ::= CASCADE", + /* 74 */ "refact ::= RESTRICT", + /* 75 */ "defer_subclause ::= NOT DEFERRABLE init_deferred_pred_opt", + /* 76 */ "defer_subclause ::= DEFERRABLE init_deferred_pred_opt", + /* 77 */ "init_deferred_pred_opt ::=", + /* 78 */ "init_deferred_pred_opt ::= INITIALLY DEFERRED", + /* 79 */ "init_deferred_pred_opt ::= INITIALLY IMMEDIATE", + /* 80 */ "conslist_opt ::=", + /* 81 */ "conslist_opt ::= COMMA conslist", + /* 82 */ "conslist ::= conslist COMMA tcons", + /* 83 */ "conslist ::= conslist tcons", + /* 84 */ "conslist ::= tcons", + /* 85 */ "tcons ::= CONSTRAINT nm", + /* 86 */ "tcons ::= PRIMARY KEY LP idxlist autoinc RP onconf", + /* 87 */ "tcons ::= UNIQUE LP idxlist RP onconf", + /* 88 */ "tcons ::= CHECK LP expr RP onconf", + /* 89 */ "tcons ::= FOREIGN KEY LP idxlist RP REFERENCES nm idxlist_opt refargs defer_subclause_opt", + /* 90 */ "defer_subclause_opt ::=", + /* 91 */ "defer_subclause_opt ::= defer_subclause", + /* 92 */ "onconf ::=", + /* 93 */ "onconf ::= ON CONFLICT resolvetype", + /* 94 */ "orconf ::=", + /* 95 */ "orconf ::= OR resolvetype", + /* 96 */ "resolvetype ::= raisetype", + /* 97 */ "resolvetype ::= IGNORE", + /* 98 */ "resolvetype ::= REPLACE", + /* 99 */ "cmd ::= DROP TABLE ifexists fullname", + /* 100 */ "ifexists ::= IF EXISTS", + /* 101 */ "ifexists ::=", + /* 102 */ "cmd ::= CREATE temp VIEW ifnotexists nm dbnm AS select", + /* 103 */ "cmd ::= DROP VIEW ifexists fullname", + /* 104 */ "cmd ::= select", + /* 105 */ "select ::= oneselect", + /* 106 */ "select ::= select multiselect_op oneselect", + /* 107 */ "multiselect_op ::= UNION", + /* 108 */ "multiselect_op ::= UNION ALL", + /* 109 */ "multiselect_op ::= EXCEPT|INTERSECT", + /* 110 */ "oneselect ::= SELECT distinct selcollist from where_opt groupby_opt having_opt orderby_opt limit_opt", + /* 111 */ "distinct ::= DISTINCT", + /* 112 */ "distinct ::= ALL", + /* 113 */ "distinct ::=", + /* 114 */ "sclp ::= selcollist COMMA", + /* 115 */ "sclp ::=", + /* 116 */ "selcollist ::= sclp expr as", + /* 117 */ "selcollist ::= sclp STAR", + /* 118 */ "selcollist ::= sclp nm DOT STAR", + /* 119 */ "as ::= AS nm", + /* 120 */ "as ::= ids", + /* 121 */ "as ::=", + /* 122 */ "from ::=", + /* 123 */ "from ::= FROM seltablist", + /* 124 */ "stl_prefix ::= seltablist joinop", + /* 125 */ "stl_prefix ::=", + /* 126 */ "seltablist ::= stl_prefix nm dbnm as on_opt using_opt", + /* 127 */ "seltablist ::= stl_prefix LP seltablist_paren RP as on_opt using_opt", + /* 128 */ "seltablist_paren ::= select", + /* 129 */ "seltablist_paren ::= seltablist", + /* 130 */ "dbnm ::=", + /* 131 */ "dbnm ::= DOT nm", + /* 132 */ "fullname ::= nm dbnm", + /* 133 */ "joinop ::= COMMA|JOIN", + /* 134 */ "joinop ::= JOIN_KW JOIN", + /* 135 */ "joinop ::= JOIN_KW nm JOIN", + /* 136 */ "joinop ::= JOIN_KW nm nm JOIN", + /* 137 */ "on_opt ::= ON expr", + /* 138 */ "on_opt ::=", + /* 139 */ "using_opt ::= USING LP inscollist RP", + /* 140 */ "using_opt ::=", + /* 141 */ "orderby_opt ::=", + /* 142 */ "orderby_opt ::= ORDER BY sortlist", + /* 143 */ "sortlist ::= sortlist COMMA sortitem collate sortorder", + /* 144 */ "sortlist ::= sortitem collate sortorder", + /* 145 */ "sortitem ::= expr", + /* 146 */ "sortorder ::= ASC", + /* 147 */ "sortorder ::= DESC", + /* 148 */ "sortorder ::=", + /* 149 */ "collate ::=", + /* 150 */ "collate ::= COLLATE id", + /* 151 */ "groupby_opt ::=", + /* 152 */ "groupby_opt ::= GROUP BY exprlist", + /* 153 */ "having_opt ::=", + /* 154 */ "having_opt ::= HAVING expr", + /* 155 */ "limit_opt ::=", + /* 156 */ "limit_opt ::= LIMIT expr", + /* 157 */ "limit_opt ::= LIMIT expr OFFSET expr", + /* 158 */ "limit_opt ::= LIMIT expr COMMA expr", + /* 159 */ "cmd ::= DELETE FROM fullname where_opt", + /* 160 */ "where_opt ::=", + /* 161 */ "where_opt ::= WHERE expr", + /* 162 */ "cmd ::= UPDATE orconf fullname SET setlist where_opt", + /* 163 */ "setlist ::= setlist COMMA nm EQ expr", + /* 164 */ "setlist ::= nm EQ expr", + /* 165 */ "cmd ::= insert_cmd INTO fullname inscollist_opt VALUES LP itemlist RP", + /* 166 */ "cmd ::= insert_cmd INTO fullname inscollist_opt select", + /* 167 */ "cmd ::= insert_cmd INTO fullname inscollist_opt DEFAULT VALUES", + /* 168 */ "insert_cmd ::= INSERT orconf", + /* 169 */ "insert_cmd ::= REPLACE", + /* 170 */ "itemlist ::= itemlist COMMA expr", + /* 171 */ "itemlist ::= expr", + /* 172 */ "inscollist_opt ::=", + /* 173 */ "inscollist_opt ::= LP inscollist RP", + /* 174 */ "inscollist ::= inscollist COMMA nm", + /* 175 */ "inscollist ::= nm", + /* 176 */ "expr ::= term", + /* 177 */ "expr ::= LP expr RP", + /* 178 */ "term ::= NULL", + /* 179 */ "expr ::= ID", + /* 180 */ "expr ::= JOIN_KW", + /* 181 */ "expr ::= nm DOT nm", + /* 182 */ "expr ::= nm DOT nm DOT nm", + /* 183 */ "term ::= INTEGER|FLOAT|BLOB", + /* 184 */ "term ::= STRING", + /* 185 */ "expr ::= REGISTER", + /* 186 */ "expr ::= VARIABLE", + /* 187 */ "expr ::= CAST LP expr AS typetoken RP", + /* 188 */ "expr ::= ID LP distinct exprlist RP", + /* 189 */ "expr ::= ID LP STAR RP", + /* 190 */ "term ::= CTIME_KW", + /* 191 */ "expr ::= expr AND expr", + /* 192 */ "expr ::= expr OR expr", + /* 193 */ "expr ::= expr LT|GT|GE|LE expr", + /* 194 */ "expr ::= expr EQ|NE expr", + /* 195 */ "expr ::= expr BITAND|BITOR|LSHIFT|RSHIFT expr", + /* 196 */ "expr ::= expr PLUS|MINUS expr", + /* 197 */ "expr ::= expr STAR|SLASH|REM expr", + /* 198 */ "expr ::= expr CONCAT expr", + /* 199 */ "likeop ::= LIKE_KW", + /* 200 */ "likeop ::= NOT LIKE_KW", + /* 201 */ "likeop ::= MATCH", + /* 202 */ "likeop ::= NOT MATCH", + /* 203 */ "escape ::= ESCAPE expr", + /* 204 */ "escape ::=", + /* 205 */ "expr ::= expr likeop expr escape", + /* 206 */ "expr ::= expr ISNULL|NOTNULL", + /* 207 */ "expr ::= expr IS NULL", + /* 208 */ "expr ::= expr NOT NULL", + /* 209 */ "expr ::= expr IS NOT NULL", + /* 210 */ "expr ::= NOT|BITNOT expr", + /* 211 */ "expr ::= MINUS expr", + /* 212 */ "expr ::= PLUS expr", + /* 213 */ "between_op ::= BETWEEN", + /* 214 */ "between_op ::= NOT BETWEEN", + /* 215 */ "expr ::= expr between_op expr AND expr", + /* 216 */ "in_op ::= IN", + /* 217 */ "in_op ::= NOT IN", + /* 218 */ "expr ::= expr in_op LP exprlist RP", + /* 219 */ "expr ::= LP select RP", + /* 220 */ "expr ::= expr in_op LP select RP", + /* 221 */ "expr ::= expr in_op nm dbnm", + /* 222 */ "expr ::= EXISTS LP select RP", + /* 223 */ "expr ::= CASE case_operand case_exprlist case_else END", + /* 224 */ "case_exprlist ::= case_exprlist WHEN expr THEN expr", + /* 225 */ "case_exprlist ::= WHEN expr THEN expr", + /* 226 */ "case_else ::= ELSE expr", + /* 227 */ "case_else ::=", + /* 228 */ "case_operand ::= expr", + /* 229 */ "case_operand ::=", + /* 230 */ "exprlist ::= exprlist COMMA expritem", + /* 231 */ "exprlist ::= expritem", + /* 232 */ "expritem ::= expr", + /* 233 */ "expritem ::=", + /* 234 */ "cmd ::= CREATE uniqueflag INDEX ifnotexists nm dbnm ON nm LP idxlist RP", + /* 235 */ "uniqueflag ::= UNIQUE", + /* 236 */ "uniqueflag ::=", + /* 237 */ "idxlist_opt ::=", + /* 238 */ "idxlist_opt ::= LP idxlist RP", + /* 239 */ "idxlist ::= idxlist COMMA idxitem collate sortorder", + /* 240 */ "idxlist ::= idxitem collate sortorder", + /* 241 */ "idxitem ::= nm", + /* 242 */ "cmd ::= DROP INDEX ifexists fullname", + /* 243 */ "cmd ::= VACUUM", + /* 244 */ "cmd ::= VACUUM nm", + /* 245 */ "cmd ::= PRAGMA nm dbnm EQ nm", + /* 246 */ "cmd ::= PRAGMA nm dbnm EQ ON", + /* 247 */ "cmd ::= PRAGMA nm dbnm EQ plus_num", + /* 248 */ "cmd ::= PRAGMA nm dbnm EQ minus_num", + /* 249 */ "cmd ::= PRAGMA nm dbnm LP nm RP", + /* 250 */ "cmd ::= PRAGMA nm dbnm", + /* 251 */ "plus_num ::= plus_opt number", + /* 252 */ "minus_num ::= MINUS number", + /* 253 */ "number ::= INTEGER|FLOAT", + /* 254 */ "plus_opt ::= PLUS", + /* 255 */ "plus_opt ::=", + /* 256 */ "cmd ::= CREATE trigger_decl BEGIN trigger_cmd_list END", + /* 257 */ "trigger_decl ::= temp TRIGGER ifnotexists nm dbnm trigger_time trigger_event ON fullname foreach_clause when_clause", + /* 258 */ "trigger_time ::= BEFORE", + /* 259 */ "trigger_time ::= AFTER", + /* 260 */ "trigger_time ::= INSTEAD OF", + /* 261 */ "trigger_time ::=", + /* 262 */ "trigger_event ::= DELETE|INSERT", + /* 263 */ "trigger_event ::= UPDATE", + /* 264 */ "trigger_event ::= UPDATE OF inscollist", + /* 265 */ "foreach_clause ::=", + /* 266 */ "foreach_clause ::= FOR EACH ROW", + /* 267 */ "foreach_clause ::= FOR EACH STATEMENT", + /* 268 */ "when_clause ::=", + /* 269 */ "when_clause ::= WHEN expr", + /* 270 */ "trigger_cmd_list ::= trigger_cmd_list trigger_cmd SEMI", + /* 271 */ "trigger_cmd_list ::=", + /* 272 */ "trigger_cmd ::= UPDATE orconf nm SET setlist where_opt", + /* 273 */ "trigger_cmd ::= insert_cmd INTO nm inscollist_opt VALUES LP itemlist RP", + /* 274 */ "trigger_cmd ::= insert_cmd INTO nm inscollist_opt select", + /* 275 */ "trigger_cmd ::= DELETE FROM nm where_opt", + /* 276 */ "trigger_cmd ::= select", + /* 277 */ "expr ::= RAISE LP IGNORE RP", + /* 278 */ "expr ::= RAISE LP raisetype COMMA nm RP", + /* 279 */ "raisetype ::= ROLLBACK", + /* 280 */ "raisetype ::= ABORT", + /* 281 */ "raisetype ::= FAIL", + /* 282 */ "cmd ::= DROP TRIGGER ifexists fullname", + /* 283 */ "cmd ::= ATTACH database_kw_opt expr AS expr key_opt", + /* 284 */ "key_opt ::=", + /* 285 */ "key_opt ::= KEY expr", + /* 286 */ "database_kw_opt ::= DATABASE", + /* 287 */ "database_kw_opt ::=", + /* 288 */ "cmd ::= DETACH database_kw_opt expr", + /* 289 */ "cmd ::= REINDEX", + /* 290 */ "cmd ::= REINDEX nm dbnm", + /* 291 */ "cmd ::= ANALYZE", + /* 292 */ "cmd ::= ANALYZE nm dbnm", + /* 293 */ "cmd ::= ALTER TABLE fullname RENAME TO nm", + /* 294 */ "cmd ::= ALTER TABLE add_column_fullname ADD kwcolumn_opt column", + /* 295 */ "add_column_fullname ::= fullname", + /* 296 */ "kwcolumn_opt ::=", + /* 297 */ "kwcolumn_opt ::= COLUMNKW", + /* 298 */ "cmd ::= create_vtab", + /* 299 */ "cmd ::= create_vtab LP vtabarglist RP", + /* 300 */ "create_vtab ::= CREATE VIRTUAL TABLE nm dbnm USING nm", + /* 301 */ "vtabarglist ::= vtabarg", + /* 302 */ "vtabarglist ::= vtabarglist COMMA vtabarg", + /* 303 */ "vtabarg ::=", + /* 304 */ "vtabarg ::= vtabarg vtabargtoken", + /* 305 */ "vtabargtoken ::= ANY", + /* 306 */ "vtabargtoken ::= lp anylist RP", + /* 307 */ "lp ::= LP", + /* 308 */ "anylist ::=", + /* 309 */ "anylist ::= anylist ANY", +}; +#endif /* NDEBUG */ + +/* +** This function returns the symbolic name associated with a token +** value. +*/ +const char *sqlite3ParserTokenName(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 sqlite3Parser and sqlite3ParserFree. +*/ +void *sqlite3ParserAlloc(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 156: + case 190: + case 207: +#line 374 "parse.y" +{sqlite3SelectDelete((yypminor->yy219));} +#line 1249 "parse.c" + break; + case 170: + case 171: + case 195: + case 197: + case 205: + case 211: + case 219: + case 222: + case 224: + case 225: + case 235: +#line 633 "parse.y" +{sqlite3ExprDelete((yypminor->yy172));} +#line 1264 "parse.c" + break; + case 175: + case 183: + case 193: + case 196: + case 198: + case 200: + case 210: + case 213: + case 214: + case 217: + case 223: +#line 870 "parse.y" +{sqlite3ExprListDelete((yypminor->yy174));} +#line 1279 "parse.c" + break; + case 189: + case 194: + case 202: + case 203: +#line 502 "parse.y" +{sqlite3SrcListDelete((yypminor->yy373));} +#line 1287 "parse.c" + break; + case 199: +#line 563 "parse.y" +{ + sqlite3ExprDelete((yypminor->yy234).pLimit); + sqlite3ExprDelete((yypminor->yy234).pOffset); +} +#line 1295 "parse.c" + break; + case 206: + case 209: + case 216: +#line 519 "parse.y" +{sqlite3IdListDelete((yypminor->yy432));} +#line 1302 "parse.c" + break; + case 231: + case 236: +#line 966 "parse.y" +{sqlite3DeleteTriggerStep((yypminor->yy243));} +#line 1308 "parse.c" + break; + case 233: +#line 950 "parse.y" +{sqlite3IdListDelete((yypminor->yy370).b);} +#line 1313 "parse.c" + break; + case 238: +#line 1034 "parse.y" +{sqlite3ExprDelete((yypminor->yy386));} +#line 1318 "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 sqlite3ParserAlloc. +** <li> A pointer to a function used to reclaim memory obtained +** from malloc. +** </ul> +*/ +void sqlite3ParserFree( + 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 */ + YYCODETYPE iLookAhead /* The look-ahead token */ +){ + int i; + int stateno = pParser->yystack[pParser->yyidx].stateno; + + if( stateno>YY_SHIFT_MAX || (i = yy_shift_ofst[stateno])==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 ){ + if( iLookAhead>0 ){ +#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 +#ifdef YYWILDCARD + { + int j = i - iLookAhead + YYWILDCARD; + if( j>=0 && j<YY_SZ_ACTTAB && yy_lookahead[j]==YYWILDCARD ){ +#ifndef NDEBUG + if( yyTraceFILE ){ + fprintf(yyTraceFILE, "%sWILDCARD %s => %s\n", + yyTracePrompt, yyTokenName[iLookAhead], yyTokenName[YYWILDCARD]); + } +#endif /* NDEBUG */ + return yy_action[j]; + } + } +#endif /* YYWILDCARD */ + } + return yy_default[stateno]; + }else{ + return yy_action[i]; + } +} + +/* +** Find the appropriate action for a parser given the non-terminal +** look-ahead token iLookAhead. +** +** If the look-ahead token is YYNOCODE, then check to see if the action is +** independent of the look-ahead. If it is, return the action, otherwise +** return YY_NO_ACTION. +*/ +static int yy_find_reduce_action( + int stateno, /* Current state number */ + YYCODETYPE iLookAhead /* The look-ahead token */ +){ + int i; + /* int stateno = pParser->yystack[pParser->yyidx].stateno; */ + + if( stateno>YY_REDUCE_MAX || + (i = yy_reduce_ofst[stateno])==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 ){ + sqlite3ParserARG_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 */ +#line 44 "parse.y" + + sqlite3ErrorMsg(pParse, "parser stack overflow"); + pParse->parseError = 1; +#line 1487 "parse.c" + sqlite3ParserARG_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 const struct { + YYCODETYPE lhs; /* Symbol on the left-hand side of the rule */ + unsigned char nrhs; /* Number of right-hand side symbols in the rule */ +} yyRuleInfo[] = { + { 140, 1 }, + { 141, 2 }, + { 141, 1 }, + { 143, 1 }, + { 142, 1 }, + { 142, 3 }, + { 145, 0 }, + { 145, 1 }, + { 145, 3 }, + { 144, 3 }, + { 147, 0 }, + { 147, 1 }, + { 147, 2 }, + { 146, 0 }, + { 146, 1 }, + { 146, 1 }, + { 146, 1 }, + { 144, 2 }, + { 144, 2 }, + { 144, 2 }, + { 144, 2 }, + { 149, 6 }, + { 152, 0 }, + { 152, 3 }, + { 151, 1 }, + { 151, 0 }, + { 150, 4 }, + { 150, 2 }, + { 154, 3 }, + { 154, 1 }, + { 157, 3 }, + { 158, 1 }, + { 161, 1 }, + { 162, 1 }, + { 148, 1 }, + { 148, 1 }, + { 148, 1 }, + { 159, 0 }, + { 159, 1 }, + { 163, 1 }, + { 163, 4 }, + { 163, 6 }, + { 164, 1 }, + { 164, 2 }, + { 165, 1 }, + { 165, 1 }, + { 160, 2 }, + { 160, 0 }, + { 168, 3 }, + { 168, 1 }, + { 168, 2 }, + { 168, 4 }, + { 168, 3 }, + { 168, 3 }, + { 168, 2 }, + { 169, 2 }, + { 169, 3 }, + { 169, 5 }, + { 169, 2 }, + { 169, 4 }, + { 169, 4 }, + { 169, 1 }, + { 169, 2 }, + { 174, 0 }, + { 174, 1 }, + { 176, 0 }, + { 176, 2 }, + { 178, 2 }, + { 178, 3 }, + { 178, 3 }, + { 178, 3 }, + { 179, 2 }, + { 179, 2 }, + { 179, 1 }, + { 179, 1 }, + { 177, 3 }, + { 177, 2 }, + { 180, 0 }, + { 180, 2 }, + { 180, 2 }, + { 155, 0 }, + { 155, 2 }, + { 181, 3 }, + { 181, 2 }, + { 181, 1 }, + { 182, 2 }, + { 182, 7 }, + { 182, 5 }, + { 182, 5 }, + { 182, 10 }, + { 184, 0 }, + { 184, 1 }, + { 172, 0 }, + { 172, 3 }, + { 185, 0 }, + { 185, 2 }, + { 186, 1 }, + { 186, 1 }, + { 186, 1 }, + { 144, 4 }, + { 188, 2 }, + { 188, 0 }, + { 144, 8 }, + { 144, 4 }, + { 144, 1 }, + { 156, 1 }, + { 156, 3 }, + { 191, 1 }, + { 191, 2 }, + { 191, 1 }, + { 190, 9 }, + { 192, 1 }, + { 192, 1 }, + { 192, 0 }, + { 200, 2 }, + { 200, 0 }, + { 193, 3 }, + { 193, 2 }, + { 193, 4 }, + { 201, 2 }, + { 201, 1 }, + { 201, 0 }, + { 194, 0 }, + { 194, 2 }, + { 203, 2 }, + { 203, 0 }, + { 202, 6 }, + { 202, 7 }, + { 207, 1 }, + { 207, 1 }, + { 153, 0 }, + { 153, 2 }, + { 189, 2 }, + { 204, 1 }, + { 204, 2 }, + { 204, 3 }, + { 204, 4 }, + { 205, 2 }, + { 205, 0 }, + { 206, 4 }, + { 206, 0 }, + { 198, 0 }, + { 198, 3 }, + { 210, 5 }, + { 210, 3 }, + { 211, 1 }, + { 173, 1 }, + { 173, 1 }, + { 173, 0 }, + { 212, 0 }, + { 212, 2 }, + { 196, 0 }, + { 196, 3 }, + { 197, 0 }, + { 197, 2 }, + { 199, 0 }, + { 199, 2 }, + { 199, 4 }, + { 199, 4 }, + { 144, 4 }, + { 195, 0 }, + { 195, 2 }, + { 144, 6 }, + { 214, 5 }, + { 214, 3 }, + { 144, 8 }, + { 144, 5 }, + { 144, 6 }, + { 215, 2 }, + { 215, 1 }, + { 217, 3 }, + { 217, 1 }, + { 216, 0 }, + { 216, 3 }, + { 209, 3 }, + { 209, 1 }, + { 171, 1 }, + { 171, 3 }, + { 170, 1 }, + { 171, 1 }, + { 171, 1 }, + { 171, 3 }, + { 171, 5 }, + { 170, 1 }, + { 170, 1 }, + { 171, 1 }, + { 171, 1 }, + { 171, 6 }, + { 171, 5 }, + { 171, 4 }, + { 170, 1 }, + { 171, 3 }, + { 171, 3 }, + { 171, 3 }, + { 171, 3 }, + { 171, 3 }, + { 171, 3 }, + { 171, 3 }, + { 171, 3 }, + { 218, 1 }, + { 218, 2 }, + { 218, 1 }, + { 218, 2 }, + { 219, 2 }, + { 219, 0 }, + { 171, 4 }, + { 171, 2 }, + { 171, 3 }, + { 171, 3 }, + { 171, 4 }, + { 171, 2 }, + { 171, 2 }, + { 171, 2 }, + { 220, 1 }, + { 220, 2 }, + { 171, 5 }, + { 221, 1 }, + { 221, 2 }, + { 171, 5 }, + { 171, 3 }, + { 171, 5 }, + { 171, 4 }, + { 171, 4 }, + { 171, 5 }, + { 223, 5 }, + { 223, 4 }, + { 224, 2 }, + { 224, 0 }, + { 222, 1 }, + { 222, 0 }, + { 213, 3 }, + { 213, 1 }, + { 225, 1 }, + { 225, 0 }, + { 144, 11 }, + { 226, 1 }, + { 226, 0 }, + { 175, 0 }, + { 175, 3 }, + { 183, 5 }, + { 183, 3 }, + { 227, 1 }, + { 144, 4 }, + { 144, 1 }, + { 144, 2 }, + { 144, 5 }, + { 144, 5 }, + { 144, 5 }, + { 144, 5 }, + { 144, 6 }, + { 144, 3 }, + { 166, 2 }, + { 167, 2 }, + { 229, 1 }, + { 228, 1 }, + { 228, 0 }, + { 144, 5 }, + { 230, 11 }, + { 232, 1 }, + { 232, 1 }, + { 232, 2 }, + { 232, 0 }, + { 233, 1 }, + { 233, 1 }, + { 233, 3 }, + { 234, 0 }, + { 234, 3 }, + { 234, 3 }, + { 235, 0 }, + { 235, 2 }, + { 231, 3 }, + { 231, 0 }, + { 236, 6 }, + { 236, 8 }, + { 236, 5 }, + { 236, 4 }, + { 236, 1 }, + { 171, 4 }, + { 171, 6 }, + { 187, 1 }, + { 187, 1 }, + { 187, 1 }, + { 144, 4 }, + { 144, 6 }, + { 238, 0 }, + { 238, 2 }, + { 237, 1 }, + { 237, 0 }, + { 144, 3 }, + { 144, 1 }, + { 144, 3 }, + { 144, 1 }, + { 144, 3 }, + { 144, 6 }, + { 144, 6 }, + { 239, 1 }, + { 240, 0 }, + { 240, 1 }, + { 144, 1 }, + { 144, 4 }, + { 241, 7 }, + { 242, 1 }, + { 242, 3 }, + { 243, 0 }, + { 243, 2 }, + { 244, 1 }, + { 244, 3 }, + { 245, 1 }, + { 246, 0 }, + { 246, 2 }, +}; + +static void yy_accept(yyParser*); /* Forward Declaration */ + +/* +** Perform a reduce action and the shift that must immediately +** follow the reduce. +*/ +static void yy_reduce( + yyParser *yypParser, /* The parser */ + int yyruleno /* Number of the rule by which to reduce */ +){ + int yygoto; /* The next state */ + int yyact; /* The next action */ + YYMINORTYPE yygotominor; /* The LHS of the rule reduced */ + yyStackEntry *yymsp; /* The top of the parser's stack */ + int yysize; /* Amount to pop the stack */ + sqlite3ParserARG_FETCH; + yymsp = &yypParser->yystack[yypParser->yyidx]; +#ifndef NDEBUG + if( yyTraceFILE && yyruleno>=0 + && yyruleno<(int)(sizeof(yyRuleName)/sizeof(yyRuleName[0])) ){ + fprintf(yyTraceFILE, "%sReduce [%s].\n", yyTracePrompt, + yyRuleName[yyruleno]); + } +#endif /* NDEBUG */ + +#ifndef NDEBUG + /* Silence complaints from purify about yygotominor being uninitialized + ** in some cases when it is copied into the stack after the following + ** switch. yygotominor is uninitialized when a rule reduces that does + ** not set the value of its left-hand side nonterminal. Leaving the + ** value of the nonterminal uninitialized is utterly harmless as long + ** as the value is never used. So really the only thing this code + ** accomplishes is to quieten purify. + */ + memset(&yygotominor, 0, sizeof(yygotominor)); +#endif + + switch( yyruleno ){ + /* Beginning here are the reduction cases. A typical example + ** follows: + ** case 0: + ** #line <lineno> <grammarfile> + ** { ... } // User supplied code + ** #line <lineno> <thisfile> + ** break; + */ + case 3: +#line 100 "parse.y" +{ sqlite3FinishCoding(pParse); } +#line 1875 "parse.c" + break; + case 6: +#line 103 "parse.y" +{ sqlite3BeginParse(pParse, 0); } +#line 1880 "parse.c" + break; + case 7: +#line 105 "parse.y" +{ sqlite3BeginParse(pParse, 1); } +#line 1885 "parse.c" + break; + case 8: +#line 106 "parse.y" +{ sqlite3BeginParse(pParse, 2); } +#line 1890 "parse.c" + break; + case 9: +#line 112 "parse.y" +{sqlite3BeginTransaction(pParse, yymsp[-1].minor.yy46);} +#line 1895 "parse.c" + break; + case 13: +#line 117 "parse.y" +{yygotominor.yy46 = TK_DEFERRED;} +#line 1900 "parse.c" + break; + case 14: + case 15: + case 16: + case 107: + case 109: +#line 118 "parse.y" +{yygotominor.yy46 = yymsp[0].major;} +#line 1909 "parse.c" + break; + case 17: + case 18: +#line 121 "parse.y" +{sqlite3CommitTransaction(pParse);} +#line 1915 "parse.c" + break; + case 19: +#line 123 "parse.y" +{sqlite3RollbackTransaction(pParse);} +#line 1920 "parse.c" + break; + case 21: +#line 128 "parse.y" +{ + sqlite3StartTable(pParse,&yymsp[-1].minor.yy410,&yymsp[0].minor.yy410,yymsp[-4].minor.yy46,0,0,yymsp[-2].minor.yy46); +} +#line 1927 "parse.c" + break; + case 22: + case 25: + case 63: + case 77: + case 79: + case 90: + case 101: + case 112: + case 113: + case 213: + case 216: +#line 132 "parse.y" +{yygotominor.yy46 = 0;} +#line 1942 "parse.c" + break; + case 23: + case 24: + case 64: + case 78: + case 100: + case 111: + case 214: + case 217: +#line 133 "parse.y" +{yygotominor.yy46 = 1;} +#line 1954 "parse.c" + break; + case 26: +#line 139 "parse.y" +{ + sqlite3EndTable(pParse,&yymsp[-1].minor.yy410,&yymsp[0].minor.yy0,0); +} +#line 1961 "parse.c" + break; + case 27: +#line 142 "parse.y" +{ + sqlite3EndTable(pParse,0,0,yymsp[0].minor.yy219); + sqlite3SelectDelete(yymsp[0].minor.yy219); +} +#line 1969 "parse.c" + break; + case 30: +#line 154 "parse.y" +{ + yygotominor.yy410.z = yymsp[-2].minor.yy410.z; + yygotominor.yy410.n = (pParse->sLastToken.z-yymsp[-2].minor.yy410.z) + pParse->sLastToken.n; +} +#line 1977 "parse.c" + break; + case 31: +#line 158 "parse.y" +{ + sqlite3AddColumn(pParse,&yymsp[0].minor.yy410); + yygotominor.yy410 = yymsp[0].minor.yy410; +} +#line 1985 "parse.c" + break; + case 32: + case 33: + case 34: + case 35: + case 36: + case 253: +#line 168 "parse.y" +{yygotominor.yy410 = yymsp[0].minor.yy0;} +#line 1995 "parse.c" + break; + case 38: +#line 228 "parse.y" +{sqlite3AddColumnType(pParse,&yymsp[0].minor.yy410);} +#line 2000 "parse.c" + break; + case 39: + case 42: + case 119: + case 120: + case 131: + case 150: + case 241: + case 251: + case 252: +#line 229 "parse.y" +{yygotominor.yy410 = yymsp[0].minor.yy410;} +#line 2013 "parse.c" + break; + case 40: +#line 230 "parse.y" +{ + yygotominor.yy410.z = yymsp[-3].minor.yy410.z; + yygotominor.yy410.n = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n] - yymsp[-3].minor.yy410.z; +} +#line 2021 "parse.c" + break; + case 41: +#line 234 "parse.y" +{ + yygotominor.yy410.z = yymsp[-5].minor.yy410.z; + yygotominor.yy410.n = &yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n] - yymsp[-5].minor.yy410.z; +} +#line 2029 "parse.c" + break; + case 43: +#line 240 "parse.y" +{yygotominor.yy410.z=yymsp[-1].minor.yy410.z; yygotominor.yy410.n=yymsp[0].minor.yy410.n+(yymsp[0].minor.yy410.z-yymsp[-1].minor.yy410.z);} +#line 2034 "parse.c" + break; + case 44: +#line 242 "parse.y" +{ yygotominor.yy46 = atoi((char*)yymsp[0].minor.yy410.z); } +#line 2039 "parse.c" + break; + case 45: +#line 243 "parse.y" +{ yygotominor.yy46 = -atoi((char*)yymsp[0].minor.yy410.z); } +#line 2044 "parse.c" + break; + case 50: + case 52: +#line 252 "parse.y" +{sqlite3AddDefaultValue(pParse,yymsp[0].minor.yy172);} +#line 2050 "parse.c" + break; + case 51: +#line 253 "parse.y" +{sqlite3AddDefaultValue(pParse,yymsp[-1].minor.yy172);} +#line 2055 "parse.c" + break; + case 53: +#line 255 "parse.y" +{ + Expr *p = sqlite3Expr(TK_UMINUS, yymsp[0].minor.yy172, 0, 0); + sqlite3AddDefaultValue(pParse,p); +} +#line 2063 "parse.c" + break; + case 54: +#line 259 "parse.y" +{ + Expr *p = sqlite3Expr(TK_STRING, 0, 0, &yymsp[0].minor.yy410); + sqlite3AddDefaultValue(pParse,p); +} +#line 2071 "parse.c" + break; + case 56: +#line 268 "parse.y" +{sqlite3AddNotNull(pParse, yymsp[0].minor.yy46);} +#line 2076 "parse.c" + break; + case 57: +#line 270 "parse.y" +{sqlite3AddPrimaryKey(pParse,0,yymsp[-1].minor.yy46,yymsp[0].minor.yy46,yymsp[-2].minor.yy46);} +#line 2081 "parse.c" + break; + case 58: +#line 271 "parse.y" +{sqlite3CreateIndex(pParse,0,0,0,0,yymsp[0].minor.yy46,0,0,0,0);} +#line 2086 "parse.c" + break; + case 59: +#line 272 "parse.y" +{sqlite3AddCheckConstraint(pParse,yymsp[-1].minor.yy172);} +#line 2091 "parse.c" + break; + case 60: +#line 274 "parse.y" +{sqlite3CreateForeignKey(pParse,0,&yymsp[-2].minor.yy410,yymsp[-1].minor.yy174,yymsp[0].minor.yy46);} +#line 2096 "parse.c" + break; + case 61: +#line 275 "parse.y" +{sqlite3DeferForeignKey(pParse,yymsp[0].minor.yy46);} +#line 2101 "parse.c" + break; + case 62: +#line 276 "parse.y" +{sqlite3AddCollateType(pParse, (char*)yymsp[0].minor.yy410.z, yymsp[0].minor.yy410.n);} +#line 2106 "parse.c" + break; + case 65: +#line 289 "parse.y" +{ yygotominor.yy46 = OE_Restrict * 0x010101; } +#line 2111 "parse.c" + break; + case 66: +#line 290 "parse.y" +{ yygotominor.yy46 = (yymsp[-1].minor.yy46 & yymsp[0].minor.yy405.mask) | yymsp[0].minor.yy405.value; } +#line 2116 "parse.c" + break; + case 67: +#line 292 "parse.y" +{ yygotominor.yy405.value = 0; yygotominor.yy405.mask = 0x000000; } +#line 2121 "parse.c" + break; + case 68: +#line 293 "parse.y" +{ yygotominor.yy405.value = yymsp[0].minor.yy46; yygotominor.yy405.mask = 0x0000ff; } +#line 2126 "parse.c" + break; + case 69: +#line 294 "parse.y" +{ yygotominor.yy405.value = yymsp[0].minor.yy46<<8; yygotominor.yy405.mask = 0x00ff00; } +#line 2131 "parse.c" + break; + case 70: +#line 295 "parse.y" +{ yygotominor.yy405.value = yymsp[0].minor.yy46<<16; yygotominor.yy405.mask = 0xff0000; } +#line 2136 "parse.c" + break; + case 71: +#line 297 "parse.y" +{ yygotominor.yy46 = OE_SetNull; } +#line 2141 "parse.c" + break; + case 72: +#line 298 "parse.y" +{ yygotominor.yy46 = OE_SetDflt; } +#line 2146 "parse.c" + break; + case 73: +#line 299 "parse.y" +{ yygotominor.yy46 = OE_Cascade; } +#line 2151 "parse.c" + break; + case 74: +#line 300 "parse.y" +{ yygotominor.yy46 = OE_Restrict; } +#line 2156 "parse.c" + break; + case 75: + case 76: + case 91: + case 93: + case 95: + case 96: + case 168: +#line 302 "parse.y" +{yygotominor.yy46 = yymsp[0].minor.yy46;} +#line 2167 "parse.c" + break; + case 80: +#line 312 "parse.y" +{yygotominor.yy410.n = 0; yygotominor.yy410.z = 0;} +#line 2172 "parse.c" + break; + case 81: +#line 313 "parse.y" +{yygotominor.yy410 = yymsp[-1].minor.yy0;} +#line 2177 "parse.c" + break; + case 86: +#line 319 "parse.y" +{sqlite3AddPrimaryKey(pParse,yymsp[-3].minor.yy174,yymsp[0].minor.yy46,yymsp[-2].minor.yy46,0);} +#line 2182 "parse.c" + break; + case 87: +#line 321 "parse.y" +{sqlite3CreateIndex(pParse,0,0,0,yymsp[-2].minor.yy174,yymsp[0].minor.yy46,0,0,0,0);} +#line 2187 "parse.c" + break; + case 88: +#line 322 "parse.y" +{sqlite3AddCheckConstraint(pParse,yymsp[-2].minor.yy172);} +#line 2192 "parse.c" + break; + case 89: +#line 324 "parse.y" +{ + sqlite3CreateForeignKey(pParse, yymsp[-6].minor.yy174, &yymsp[-3].minor.yy410, yymsp[-2].minor.yy174, yymsp[-1].minor.yy46); + sqlite3DeferForeignKey(pParse, yymsp[0].minor.yy46); +} +#line 2200 "parse.c" + break; + case 92: + case 94: +#line 338 "parse.y" +{yygotominor.yy46 = OE_Default;} +#line 2206 "parse.c" + break; + case 97: +#line 343 "parse.y" +{yygotominor.yy46 = OE_Ignore;} +#line 2211 "parse.c" + break; + case 98: + case 169: +#line 344 "parse.y" +{yygotominor.yy46 = OE_Replace;} +#line 2217 "parse.c" + break; + case 99: +#line 348 "parse.y" +{ + sqlite3DropTable(pParse, yymsp[0].minor.yy373, 0, yymsp[-1].minor.yy46); +} +#line 2224 "parse.c" + break; + case 102: +#line 358 "parse.y" +{ + sqlite3CreateView(pParse, &yymsp[-7].minor.yy0, &yymsp[-3].minor.yy410, &yymsp[-2].minor.yy410, yymsp[0].minor.yy219, yymsp[-6].minor.yy46, yymsp[-4].minor.yy46); +} +#line 2231 "parse.c" + break; + case 103: +#line 361 "parse.y" +{ + sqlite3DropTable(pParse, yymsp[0].minor.yy373, 1, yymsp[-1].minor.yy46); +} +#line 2238 "parse.c" + break; + case 104: +#line 368 "parse.y" +{ + sqlite3Select(pParse, yymsp[0].minor.yy219, SRT_Callback, 0, 0, 0, 0, 0); + sqlite3SelectDelete(yymsp[0].minor.yy219); +} +#line 2246 "parse.c" + break; + case 105: + case 128: +#line 378 "parse.y" +{yygotominor.yy219 = yymsp[0].minor.yy219;} +#line 2252 "parse.c" + break; + case 106: +#line 380 "parse.y" +{ + if( yymsp[0].minor.yy219 ){ + yymsp[0].minor.yy219->op = yymsp[-1].minor.yy46; + yymsp[0].minor.yy219->pPrior = yymsp[-2].minor.yy219; + } + yygotominor.yy219 = yymsp[0].minor.yy219; +} +#line 2263 "parse.c" + break; + case 108: +#line 389 "parse.y" +{yygotominor.yy46 = TK_ALL;} +#line 2268 "parse.c" + break; + case 110: +#line 393 "parse.y" +{ + yygotominor.yy219 = sqlite3SelectNew(yymsp[-6].minor.yy174,yymsp[-5].minor.yy373,yymsp[-4].minor.yy172,yymsp[-3].minor.yy174,yymsp[-2].minor.yy172,yymsp[-1].minor.yy174,yymsp[-7].minor.yy46,yymsp[0].minor.yy234.pLimit,yymsp[0].minor.yy234.pOffset); +} +#line 2275 "parse.c" + break; + case 114: + case 238: +#line 414 "parse.y" +{yygotominor.yy174 = yymsp[-1].minor.yy174;} +#line 2281 "parse.c" + break; + case 115: + case 141: + case 151: + case 237: +#line 415 "parse.y" +{yygotominor.yy174 = 0;} +#line 2289 "parse.c" + break; + case 116: +#line 416 "parse.y" +{ + yygotominor.yy174 = sqlite3ExprListAppend(yymsp[-2].minor.yy174,yymsp[-1].minor.yy172,yymsp[0].minor.yy410.n?&yymsp[0].minor.yy410:0); +} +#line 2296 "parse.c" + break; + case 117: +#line 419 "parse.y" +{ + yygotominor.yy174 = sqlite3ExprListAppend(yymsp[-1].minor.yy174, sqlite3Expr(TK_ALL, 0, 0, 0), 0); +} +#line 2303 "parse.c" + break; + case 118: +#line 422 "parse.y" +{ + Expr *pRight = sqlite3Expr(TK_ALL, 0, 0, 0); + Expr *pLeft = sqlite3Expr(TK_ID, 0, 0, &yymsp[-2].minor.yy410); + yygotominor.yy174 = sqlite3ExprListAppend(yymsp[-3].minor.yy174, sqlite3Expr(TK_DOT, pLeft, pRight, 0), 0); +} +#line 2312 "parse.c" + break; + case 121: +#line 434 "parse.y" +{yygotominor.yy410.n = 0;} +#line 2317 "parse.c" + break; + case 122: +#line 446 "parse.y" +{yygotominor.yy373 = sqliteMalloc(sizeof(*yygotominor.yy373));} +#line 2322 "parse.c" + break; + case 123: +#line 447 "parse.y" +{yygotominor.yy373 = yymsp[0].minor.yy373;} +#line 2327 "parse.c" + break; + case 124: +#line 452 "parse.y" +{ + yygotominor.yy373 = yymsp[-1].minor.yy373; + if( yygotominor.yy373 && yygotominor.yy373->nSrc>0 ) yygotominor.yy373->a[yygotominor.yy373->nSrc-1].jointype = yymsp[0].minor.yy46; +} +#line 2335 "parse.c" + break; + case 125: +#line 456 "parse.y" +{yygotominor.yy373 = 0;} +#line 2340 "parse.c" + break; + case 126: +#line 457 "parse.y" +{ + yygotominor.yy373 = sqlite3SrcListAppend(yymsp[-5].minor.yy373,&yymsp[-4].minor.yy410,&yymsp[-3].minor.yy410); + if( yymsp[-2].minor.yy410.n ) sqlite3SrcListAddAlias(yygotominor.yy373,&yymsp[-2].minor.yy410); + if( yymsp[-1].minor.yy172 ){ + if( yygotominor.yy373 && yygotominor.yy373->nSrc>1 ){ yygotominor.yy373->a[yygotominor.yy373->nSrc-2].pOn = yymsp[-1].minor.yy172; } + else { sqlite3ExprDelete(yymsp[-1].minor.yy172); } + } + if( yymsp[0].minor.yy432 ){ + if( yygotominor.yy373 && yygotominor.yy373->nSrc>1 ){ yygotominor.yy373->a[yygotominor.yy373->nSrc-2].pUsing = yymsp[0].minor.yy432; } + else { sqlite3IdListDelete(yymsp[0].minor.yy432); } + } +} +#line 2356 "parse.c" + break; + case 127: +#line 471 "parse.y" +{ + yygotominor.yy373 = sqlite3SrcListAppend(yymsp[-6].minor.yy373,0,0); + if( yygotominor.yy373 && yygotominor.yy373->nSrc>0 ) yygotominor.yy373->a[yygotominor.yy373->nSrc-1].pSelect = yymsp[-4].minor.yy219; + if( yymsp[-2].minor.yy410.n ) sqlite3SrcListAddAlias(yygotominor.yy373,&yymsp[-2].minor.yy410); + if( yymsp[-1].minor.yy172 ){ + if( yygotominor.yy373 && yygotominor.yy373->nSrc>1 ){ yygotominor.yy373->a[yygotominor.yy373->nSrc-2].pOn = yymsp[-1].minor.yy172; } + else { sqlite3ExprDelete(yymsp[-1].minor.yy172); } + } + if( yymsp[0].minor.yy432 ){ + if( yygotominor.yy373 && yygotominor.yy373->nSrc>1 ){ yygotominor.yy373->a[yygotominor.yy373->nSrc-2].pUsing = yymsp[0].minor.yy432; } + else { sqlite3IdListDelete(yymsp[0].minor.yy432); } + } + } +#line 2373 "parse.c" + break; + case 129: +#line 492 "parse.y" +{ + yygotominor.yy219 = sqlite3SelectNew(0,yymsp[0].minor.yy373,0,0,0,0,0,0,0); + } +#line 2380 "parse.c" + break; + case 130: +#line 498 "parse.y" +{yygotominor.yy410.z=0; yygotominor.yy410.n=0;} +#line 2385 "parse.c" + break; + case 132: +#line 503 "parse.y" +{yygotominor.yy373 = sqlite3SrcListAppend(0,&yymsp[-1].minor.yy410,&yymsp[0].minor.yy410);} +#line 2390 "parse.c" + break; + case 133: +#line 507 "parse.y" +{ yygotominor.yy46 = JT_INNER; } +#line 2395 "parse.c" + break; + case 134: +#line 508 "parse.y" +{ yygotominor.yy46 = sqlite3JoinType(pParse,&yymsp[-1].minor.yy0,0,0); } +#line 2400 "parse.c" + break; + case 135: +#line 509 "parse.y" +{ yygotominor.yy46 = sqlite3JoinType(pParse,&yymsp[-2].minor.yy0,&yymsp[-1].minor.yy410,0); } +#line 2405 "parse.c" + break; + case 136: +#line 511 "parse.y" +{ yygotominor.yy46 = sqlite3JoinType(pParse,&yymsp[-3].minor.yy0,&yymsp[-2].minor.yy410,&yymsp[-1].minor.yy410); } +#line 2410 "parse.c" + break; + case 137: + case 145: + case 154: + case 161: + case 176: + case 203: + case 226: + case 228: + case 232: +#line 515 "parse.y" +{yygotominor.yy172 = yymsp[0].minor.yy172;} +#line 2423 "parse.c" + break; + case 138: + case 153: + case 160: + case 204: + case 227: + case 229: + case 233: +#line 516 "parse.y" +{yygotominor.yy172 = 0;} +#line 2434 "parse.c" + break; + case 139: + case 173: +#line 520 "parse.y" +{yygotominor.yy432 = yymsp[-1].minor.yy432;} +#line 2440 "parse.c" + break; + case 140: + case 172: +#line 521 "parse.y" +{yygotominor.yy432 = 0;} +#line 2446 "parse.c" + break; + case 142: + case 152: +#line 532 "parse.y" +{yygotominor.yy174 = yymsp[0].minor.yy174;} +#line 2452 "parse.c" + break; + case 143: +#line 533 "parse.y" +{ + yygotominor.yy174 = sqlite3ExprListAppend(yymsp[-4].minor.yy174,yymsp[-2].minor.yy172,yymsp[-1].minor.yy410.n>0?&yymsp[-1].minor.yy410:0); + if( yygotominor.yy174 ) yygotominor.yy174->a[yygotominor.yy174->nExpr-1].sortOrder = yymsp[0].minor.yy46; +} +#line 2460 "parse.c" + break; + case 144: +#line 537 "parse.y" +{ + yygotominor.yy174 = sqlite3ExprListAppend(0,yymsp[-2].minor.yy172,yymsp[-1].minor.yy410.n>0?&yymsp[-1].minor.yy410:0); + if( yygotominor.yy174 && yygotominor.yy174->a ) yygotominor.yy174->a[0].sortOrder = yymsp[0].minor.yy46; +} +#line 2468 "parse.c" + break; + case 146: + case 148: +#line 546 "parse.y" +{yygotominor.yy46 = SQLITE_SO_ASC;} +#line 2474 "parse.c" + break; + case 147: +#line 547 "parse.y" +{yygotominor.yy46 = SQLITE_SO_DESC;} +#line 2479 "parse.c" + break; + case 149: +#line 549 "parse.y" +{yygotominor.yy410.z = 0; yygotominor.yy410.n = 0;} +#line 2484 "parse.c" + break; + case 155: +#line 567 "parse.y" +{yygotominor.yy234.pLimit = 0; yygotominor.yy234.pOffset = 0;} +#line 2489 "parse.c" + break; + case 156: +#line 568 "parse.y" +{yygotominor.yy234.pLimit = yymsp[0].minor.yy172; yygotominor.yy234.pOffset = 0;} +#line 2494 "parse.c" + break; + case 157: +#line 570 "parse.y" +{yygotominor.yy234.pLimit = yymsp[-2].minor.yy172; yygotominor.yy234.pOffset = yymsp[0].minor.yy172;} +#line 2499 "parse.c" + break; + case 158: +#line 572 "parse.y" +{yygotominor.yy234.pOffset = yymsp[-2].minor.yy172; yygotominor.yy234.pLimit = yymsp[0].minor.yy172;} +#line 2504 "parse.c" + break; + case 159: +#line 576 "parse.y" +{sqlite3DeleteFrom(pParse,yymsp[-1].minor.yy373,yymsp[0].minor.yy172);} +#line 2509 "parse.c" + break; + case 162: +#line 587 "parse.y" +{sqlite3Update(pParse,yymsp[-3].minor.yy373,yymsp[-1].minor.yy174,yymsp[0].minor.yy172,yymsp[-4].minor.yy46);} +#line 2514 "parse.c" + break; + case 163: +#line 593 "parse.y" +{yygotominor.yy174 = sqlite3ExprListAppend(yymsp[-4].minor.yy174,yymsp[0].minor.yy172,&yymsp[-2].minor.yy410);} +#line 2519 "parse.c" + break; + case 164: +#line 594 "parse.y" +{yygotominor.yy174 = sqlite3ExprListAppend(0,yymsp[0].minor.yy172,&yymsp[-2].minor.yy410);} +#line 2524 "parse.c" + break; + case 165: +#line 600 "parse.y" +{sqlite3Insert(pParse, yymsp[-5].minor.yy373, yymsp[-1].minor.yy174, 0, yymsp[-4].minor.yy432, yymsp[-7].minor.yy46);} +#line 2529 "parse.c" + break; + case 166: +#line 602 "parse.y" +{sqlite3Insert(pParse, yymsp[-2].minor.yy373, 0, yymsp[0].minor.yy219, yymsp[-1].minor.yy432, yymsp[-4].minor.yy46);} +#line 2534 "parse.c" + break; + case 167: +#line 604 "parse.y" +{sqlite3Insert(pParse, yymsp[-3].minor.yy373, 0, 0, yymsp[-2].minor.yy432, yymsp[-5].minor.yy46);} +#line 2539 "parse.c" + break; + case 170: + case 230: +#line 614 "parse.y" +{yygotominor.yy174 = sqlite3ExprListAppend(yymsp[-2].minor.yy174,yymsp[0].minor.yy172,0);} +#line 2545 "parse.c" + break; + case 171: + case 231: +#line 615 "parse.y" +{yygotominor.yy174 = sqlite3ExprListAppend(0,yymsp[0].minor.yy172,0);} +#line 2551 "parse.c" + break; + case 174: +#line 624 "parse.y" +{yygotominor.yy432 = sqlite3IdListAppend(yymsp[-2].minor.yy432,&yymsp[0].minor.yy410);} +#line 2556 "parse.c" + break; + case 175: +#line 625 "parse.y" +{yygotominor.yy432 = sqlite3IdListAppend(0,&yymsp[0].minor.yy410);} +#line 2561 "parse.c" + break; + case 177: +#line 636 "parse.y" +{yygotominor.yy172 = yymsp[-1].minor.yy172; sqlite3ExprSpan(yygotominor.yy172,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0); } +#line 2566 "parse.c" + break; + case 178: + case 183: + case 184: +#line 637 "parse.y" +{yygotominor.yy172 = sqlite3Expr(yymsp[0].major, 0, 0, &yymsp[0].minor.yy0);} +#line 2573 "parse.c" + break; + case 179: + case 180: +#line 638 "parse.y" +{yygotominor.yy172 = sqlite3Expr(TK_ID, 0, 0, &yymsp[0].minor.yy0);} +#line 2579 "parse.c" + break; + case 181: +#line 640 "parse.y" +{ + Expr *temp1 = sqlite3Expr(TK_ID, 0, 0, &yymsp[-2].minor.yy410); + Expr *temp2 = sqlite3Expr(TK_ID, 0, 0, &yymsp[0].minor.yy410); + yygotominor.yy172 = sqlite3Expr(TK_DOT, temp1, temp2, 0); +} +#line 2588 "parse.c" + break; + case 182: +#line 645 "parse.y" +{ + Expr *temp1 = sqlite3Expr(TK_ID, 0, 0, &yymsp[-4].minor.yy410); + Expr *temp2 = sqlite3Expr(TK_ID, 0, 0, &yymsp[-2].minor.yy410); + Expr *temp3 = sqlite3Expr(TK_ID, 0, 0, &yymsp[0].minor.yy410); + Expr *temp4 = sqlite3Expr(TK_DOT, temp2, temp3, 0); + yygotominor.yy172 = sqlite3Expr(TK_DOT, temp1, temp4, 0); +} +#line 2599 "parse.c" + break; + case 185: +#line 654 "parse.y" +{yygotominor.yy172 = sqlite3RegisterExpr(pParse, &yymsp[0].minor.yy0);} +#line 2604 "parse.c" + break; + case 186: +#line 655 "parse.y" +{ + Token *pToken = &yymsp[0].minor.yy0; + Expr *pExpr = yygotominor.yy172 = sqlite3Expr(TK_VARIABLE, 0, 0, pToken); + sqlite3ExprAssignVarNumber(pParse, pExpr); +} +#line 2613 "parse.c" + break; + case 187: +#line 661 "parse.y" +{ + yygotominor.yy172 = sqlite3Expr(TK_CAST, yymsp[-3].minor.yy172, 0, &yymsp[-1].minor.yy410); + sqlite3ExprSpan(yygotominor.yy172,&yymsp[-5].minor.yy0,&yymsp[0].minor.yy0); +} +#line 2621 "parse.c" + break; + case 188: +#line 666 "parse.y" +{ + yygotominor.yy172 = sqlite3ExprFunction(yymsp[-1].minor.yy174, &yymsp[-4].minor.yy0); + sqlite3ExprSpan(yygotominor.yy172,&yymsp[-4].minor.yy0,&yymsp[0].minor.yy0); + if( yymsp[-2].minor.yy46 && yygotominor.yy172 ){ + yygotominor.yy172->flags |= EP_Distinct; + } +} +#line 2632 "parse.c" + break; + case 189: +#line 673 "parse.y" +{ + yygotominor.yy172 = sqlite3ExprFunction(0, &yymsp[-3].minor.yy0); + sqlite3ExprSpan(yygotominor.yy172,&yymsp[-3].minor.yy0,&yymsp[0].minor.yy0); +} +#line 2640 "parse.c" + break; + case 190: +#line 677 "parse.y" +{ + /* The CURRENT_TIME, CURRENT_DATE, and CURRENT_TIMESTAMP values are + ** treated as functions that return constants */ + yygotominor.yy172 = sqlite3ExprFunction(0,&yymsp[0].minor.yy0); + if( yygotominor.yy172 ){ + yygotominor.yy172->op = TK_CONST_FUNC; + yygotominor.yy172->span = yymsp[0].minor.yy0; + } +} +#line 2653 "parse.c" + break; + case 191: + case 192: + case 193: + case 194: + case 195: + case 196: + case 197: + case 198: +#line 686 "parse.y" +{yygotominor.yy172 = sqlite3Expr(yymsp[-1].major, yymsp[-2].minor.yy172, yymsp[0].minor.yy172, 0);} +#line 2665 "parse.c" + break; + case 199: + case 201: +#line 696 "parse.y" +{yygotominor.yy72.eOperator = yymsp[0].minor.yy0; yygotominor.yy72.not = 0;} +#line 2671 "parse.c" + break; + case 200: + case 202: +#line 697 "parse.y" +{yygotominor.yy72.eOperator = yymsp[0].minor.yy0; yygotominor.yy72.not = 1;} +#line 2677 "parse.c" + break; + case 205: +#line 704 "parse.y" +{ + ExprList *pList; + pList = sqlite3ExprListAppend(0, yymsp[-1].minor.yy172, 0); + pList = sqlite3ExprListAppend(pList, yymsp[-3].minor.yy172, 0); + if( yymsp[0].minor.yy172 ){ + pList = sqlite3ExprListAppend(pList, yymsp[0].minor.yy172, 0); + } + yygotominor.yy172 = sqlite3ExprFunction(pList, &yymsp[-2].minor.yy72.eOperator); + if( yymsp[-2].minor.yy72.not ) yygotominor.yy172 = sqlite3Expr(TK_NOT, yygotominor.yy172, 0, 0); + sqlite3ExprSpan(yygotominor.yy172, &yymsp[-3].minor.yy172->span, &yymsp[-1].minor.yy172->span); + if( yygotominor.yy172 ) yygotominor.yy172->flags |= EP_InfixFunc; +} +#line 2693 "parse.c" + break; + case 206: +#line 717 "parse.y" +{ + yygotominor.yy172 = sqlite3Expr(yymsp[0].major, yymsp[-1].minor.yy172, 0, 0); + sqlite3ExprSpan(yygotominor.yy172,&yymsp[-1].minor.yy172->span,&yymsp[0].minor.yy0); +} +#line 2701 "parse.c" + break; + case 207: +#line 721 "parse.y" +{ + yygotominor.yy172 = sqlite3Expr(TK_ISNULL, yymsp[-2].minor.yy172, 0, 0); + sqlite3ExprSpan(yygotominor.yy172,&yymsp[-2].minor.yy172->span,&yymsp[0].minor.yy0); +} +#line 2709 "parse.c" + break; + case 208: +#line 725 "parse.y" +{ + yygotominor.yy172 = sqlite3Expr(TK_NOTNULL, yymsp[-2].minor.yy172, 0, 0); + sqlite3ExprSpan(yygotominor.yy172,&yymsp[-2].minor.yy172->span,&yymsp[0].minor.yy0); +} +#line 2717 "parse.c" + break; + case 209: +#line 729 "parse.y" +{ + yygotominor.yy172 = sqlite3Expr(TK_NOTNULL, yymsp[-3].minor.yy172, 0, 0); + sqlite3ExprSpan(yygotominor.yy172,&yymsp[-3].minor.yy172->span,&yymsp[0].minor.yy0); +} +#line 2725 "parse.c" + break; + case 210: +#line 733 "parse.y" +{ + yygotominor.yy172 = sqlite3Expr(yymsp[-1].major, yymsp[0].minor.yy172, 0, 0); + sqlite3ExprSpan(yygotominor.yy172,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy172->span); +} +#line 2733 "parse.c" + break; + case 211: +#line 737 "parse.y" +{ + yygotominor.yy172 = sqlite3Expr(TK_UMINUS, yymsp[0].minor.yy172, 0, 0); + sqlite3ExprSpan(yygotominor.yy172,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy172->span); +} +#line 2741 "parse.c" + break; + case 212: +#line 741 "parse.y" +{ + yygotominor.yy172 = sqlite3Expr(TK_UPLUS, yymsp[0].minor.yy172, 0, 0); + sqlite3ExprSpan(yygotominor.yy172,&yymsp[-1].minor.yy0,&yymsp[0].minor.yy172->span); +} +#line 2749 "parse.c" + break; + case 215: +#line 748 "parse.y" +{ + ExprList *pList = sqlite3ExprListAppend(0, yymsp[-2].minor.yy172, 0); + pList = sqlite3ExprListAppend(pList, yymsp[0].minor.yy172, 0); + yygotominor.yy172 = sqlite3Expr(TK_BETWEEN, yymsp[-4].minor.yy172, 0, 0); + if( yygotominor.yy172 ){ + yygotominor.yy172->pList = pList; + }else{ + sqlite3ExprListDelete(pList); + } + if( yymsp[-3].minor.yy46 ) yygotominor.yy172 = sqlite3Expr(TK_NOT, yygotominor.yy172, 0, 0); + sqlite3ExprSpan(yygotominor.yy172,&yymsp[-4].minor.yy172->span,&yymsp[0].minor.yy172->span); +} +#line 2765 "parse.c" + break; + case 218: +#line 764 "parse.y" +{ + yygotominor.yy172 = sqlite3Expr(TK_IN, yymsp[-4].minor.yy172, 0, 0); + if( yygotominor.yy172 ){ + yygotominor.yy172->pList = yymsp[-1].minor.yy174; + }else{ + sqlite3ExprListDelete(yymsp[-1].minor.yy174); + } + if( yymsp[-3].minor.yy46 ) yygotominor.yy172 = sqlite3Expr(TK_NOT, yygotominor.yy172, 0, 0); + sqlite3ExprSpan(yygotominor.yy172,&yymsp[-4].minor.yy172->span,&yymsp[0].minor.yy0); + } +#line 2779 "parse.c" + break; + case 219: +#line 774 "parse.y" +{ + yygotominor.yy172 = sqlite3Expr(TK_SELECT, 0, 0, 0); + if( yygotominor.yy172 ){ + yygotominor.yy172->pSelect = yymsp[-1].minor.yy219; + }else{ + sqlite3SelectDelete(yymsp[-1].minor.yy219); + } + sqlite3ExprSpan(yygotominor.yy172,&yymsp[-2].minor.yy0,&yymsp[0].minor.yy0); + } +#line 2792 "parse.c" + break; + case 220: +#line 783 "parse.y" +{ + yygotominor.yy172 = sqlite3Expr(TK_IN, yymsp[-4].minor.yy172, 0, 0); + if( yygotominor.yy172 ){ + yygotominor.yy172->pSelect = yymsp[-1].minor.yy219; + }else{ + sqlite3SelectDelete(yymsp[-1].minor.yy219); + } + if( yymsp[-3].minor.yy46 ) yygotominor.yy172 = sqlite3Expr(TK_NOT, yygotominor.yy172, 0, 0); + sqlite3ExprSpan(yygotominor.yy172,&yymsp[-4].minor.yy172->span,&yymsp[0].minor.yy0); + } +#line 2806 "parse.c" + break; + case 221: +#line 793 "parse.y" +{ + SrcList *pSrc = sqlite3SrcListAppend(0,&yymsp[-1].minor.yy410,&yymsp[0].minor.yy410); + yygotominor.yy172 = sqlite3Expr(TK_IN, yymsp[-3].minor.yy172, 0, 0); + if( yygotominor.yy172 ){ + yygotominor.yy172->pSelect = sqlite3SelectNew(0,pSrc,0,0,0,0,0,0,0); + }else{ + sqlite3SrcListDelete(pSrc); + } + if( yymsp[-2].minor.yy46 ) yygotominor.yy172 = sqlite3Expr(TK_NOT, yygotominor.yy172, 0, 0); + sqlite3ExprSpan(yygotominor.yy172,&yymsp[-3].minor.yy172->span,yymsp[0].minor.yy410.z?&yymsp[0].minor.yy410:&yymsp[-1].minor.yy410); + } +#line 2821 "parse.c" + break; + case 222: +#line 804 "parse.y" +{ + Expr *p = yygotominor.yy172 = sqlite3Expr(TK_EXISTS, 0, 0, 0); + if( p ){ + p->pSelect = yymsp[-1].minor.yy219; + sqlite3ExprSpan(p,&yymsp[-3].minor.yy0,&yymsp[0].minor.yy0); + }else{ + sqlite3SelectDelete(yymsp[-1].minor.yy219); + } + } +#line 2834 "parse.c" + break; + case 223: +#line 816 "parse.y" +{ + yygotominor.yy172 = sqlite3Expr(TK_CASE, yymsp[-3].minor.yy172, yymsp[-1].minor.yy172, 0); + if( yygotominor.yy172 ){ + yygotominor.yy172->pList = yymsp[-2].minor.yy174; + }else{ + sqlite3ExprListDelete(yymsp[-2].minor.yy174); + } + sqlite3ExprSpan(yygotominor.yy172, &yymsp[-4].minor.yy0, &yymsp[0].minor.yy0); +} +#line 2847 "parse.c" + break; + case 224: +#line 827 "parse.y" +{ + yygotominor.yy174 = sqlite3ExprListAppend(yymsp[-4].minor.yy174, yymsp[-2].minor.yy172, 0); + yygotominor.yy174 = sqlite3ExprListAppend(yygotominor.yy174, yymsp[0].minor.yy172, 0); +} +#line 2855 "parse.c" + break; + case 225: +#line 831 "parse.y" +{ + yygotominor.yy174 = sqlite3ExprListAppend(0, yymsp[-2].minor.yy172, 0); + yygotominor.yy174 = sqlite3ExprListAppend(yygotominor.yy174, yymsp[0].minor.yy172, 0); +} +#line 2863 "parse.c" + break; + case 234: +#line 858 "parse.y" +{ + sqlite3CreateIndex(pParse, &yymsp[-6].minor.yy410, &yymsp[-5].minor.yy410, sqlite3SrcListAppend(0,&yymsp[-3].minor.yy410,0), yymsp[-1].minor.yy174, yymsp[-9].minor.yy46, + &yymsp[-10].minor.yy0, &yymsp[0].minor.yy0, SQLITE_SO_ASC, yymsp[-7].minor.yy46); +} +#line 2871 "parse.c" + break; + case 235: + case 280: +#line 864 "parse.y" +{yygotominor.yy46 = OE_Abort;} +#line 2877 "parse.c" + break; + case 236: +#line 865 "parse.y" +{yygotominor.yy46 = OE_None;} +#line 2882 "parse.c" + break; + case 239: +#line 875 "parse.y" +{ + Expr *p = 0; + if( yymsp[-1].minor.yy410.n>0 ){ + p = sqlite3Expr(TK_COLUMN, 0, 0, 0); + if( p ) p->pColl = sqlite3LocateCollSeq(pParse, (char*)yymsp[-1].minor.yy410.z, yymsp[-1].minor.yy410.n); + } + yygotominor.yy174 = sqlite3ExprListAppend(yymsp[-4].minor.yy174, p, &yymsp[-2].minor.yy410); + if( yygotominor.yy174 ) yygotominor.yy174->a[yygotominor.yy174->nExpr-1].sortOrder = yymsp[0].minor.yy46; +} +#line 2895 "parse.c" + break; + case 240: +#line 884 "parse.y" +{ + Expr *p = 0; + if( yymsp[-1].minor.yy410.n>0 ){ + p = sqlite3Expr(TK_COLUMN, 0, 0, 0); + if( p ) p->pColl = sqlite3LocateCollSeq(pParse, (char*)yymsp[-1].minor.yy410.z, yymsp[-1].minor.yy410.n); + } + yygotominor.yy174 = sqlite3ExprListAppend(0, p, &yymsp[-2].minor.yy410); + if( yygotominor.yy174 ) yygotominor.yy174->a[yygotominor.yy174->nExpr-1].sortOrder = yymsp[0].minor.yy46; +} +#line 2908 "parse.c" + break; + case 242: +#line 898 "parse.y" +{sqlite3DropIndex(pParse, yymsp[0].minor.yy373, yymsp[-1].minor.yy46);} +#line 2913 "parse.c" + break; + case 243: + case 244: +#line 903 "parse.y" +{sqlite3Vacuum(pParse);} +#line 2919 "parse.c" + break; + case 245: + case 247: +#line 910 "parse.y" +{sqlite3Pragma(pParse,&yymsp[-3].minor.yy410,&yymsp[-2].minor.yy410,&yymsp[0].minor.yy410,0);} +#line 2925 "parse.c" + break; + case 246: +#line 911 "parse.y" +{sqlite3Pragma(pParse,&yymsp[-3].minor.yy410,&yymsp[-2].minor.yy410,&yymsp[0].minor.yy0,0);} +#line 2930 "parse.c" + break; + case 248: +#line 913 "parse.y" +{ + sqlite3Pragma(pParse,&yymsp[-3].minor.yy410,&yymsp[-2].minor.yy410,&yymsp[0].minor.yy410,1); +} +#line 2937 "parse.c" + break; + case 249: +#line 916 "parse.y" +{sqlite3Pragma(pParse,&yymsp[-4].minor.yy410,&yymsp[-3].minor.yy410,&yymsp[-1].minor.yy410,0);} +#line 2942 "parse.c" + break; + case 250: +#line 917 "parse.y" +{sqlite3Pragma(pParse,&yymsp[-1].minor.yy410,&yymsp[0].minor.yy410,0,0);} +#line 2947 "parse.c" + break; + case 256: +#line 929 "parse.y" +{ + Token all; + all.z = yymsp[-3].minor.yy410.z; + all.n = (yymsp[0].minor.yy0.z - yymsp[-3].minor.yy410.z) + yymsp[0].minor.yy0.n; + sqlite3FinishTrigger(pParse, yymsp[-1].minor.yy243, &all); +} +#line 2957 "parse.c" + break; + case 257: +#line 938 "parse.y" +{ + sqlite3BeginTrigger(pParse, &yymsp[-7].minor.yy410, &yymsp[-6].minor.yy410, yymsp[-5].minor.yy46, yymsp[-4].minor.yy370.a, yymsp[-4].minor.yy370.b, yymsp[-2].minor.yy373, yymsp[-1].minor.yy46, yymsp[0].minor.yy172, yymsp[-10].minor.yy46, yymsp[-8].minor.yy46); + yygotominor.yy410 = (yymsp[-6].minor.yy410.n==0?yymsp[-7].minor.yy410:yymsp[-6].minor.yy410); +} +#line 2965 "parse.c" + break; + case 258: + case 261: +#line 944 "parse.y" +{ yygotominor.yy46 = TK_BEFORE; } +#line 2971 "parse.c" + break; + case 259: +#line 945 "parse.y" +{ yygotominor.yy46 = TK_AFTER; } +#line 2976 "parse.c" + break; + case 260: +#line 946 "parse.y" +{ yygotominor.yy46 = TK_INSTEAD;} +#line 2981 "parse.c" + break; + case 262: + case 263: +#line 951 "parse.y" +{yygotominor.yy370.a = yymsp[0].major; yygotominor.yy370.b = 0;} +#line 2987 "parse.c" + break; + case 264: +#line 953 "parse.y" +{yygotominor.yy370.a = TK_UPDATE; yygotominor.yy370.b = yymsp[0].minor.yy432;} +#line 2992 "parse.c" + break; + case 265: + case 266: +#line 956 "parse.y" +{ yygotominor.yy46 = TK_ROW; } +#line 2998 "parse.c" + break; + case 267: +#line 958 "parse.y" +{ yygotominor.yy46 = TK_STATEMENT; } +#line 3003 "parse.c" + break; + case 268: +#line 962 "parse.y" +{ yygotominor.yy172 = 0; } +#line 3008 "parse.c" + break; + case 269: +#line 963 "parse.y" +{ yygotominor.yy172 = yymsp[0].minor.yy172; } +#line 3013 "parse.c" + break; + case 270: +#line 967 "parse.y" +{ + if( yymsp[-2].minor.yy243 ){ + yymsp[-2].minor.yy243->pLast->pNext = yymsp[-1].minor.yy243; + }else{ + yymsp[-2].minor.yy243 = yymsp[-1].minor.yy243; + } + yymsp[-2].minor.yy243->pLast = yymsp[-1].minor.yy243; + yygotominor.yy243 = yymsp[-2].minor.yy243; +} +#line 3026 "parse.c" + break; + case 271: +#line 976 "parse.y" +{ yygotominor.yy243 = 0; } +#line 3031 "parse.c" + break; + case 272: +#line 982 "parse.y" +{ yygotominor.yy243 = sqlite3TriggerUpdateStep(&yymsp[-3].minor.yy410, yymsp[-1].minor.yy174, yymsp[0].minor.yy172, yymsp[-4].minor.yy46); } +#line 3036 "parse.c" + break; + case 273: +#line 987 "parse.y" +{yygotominor.yy243 = sqlite3TriggerInsertStep(&yymsp[-5].minor.yy410, yymsp[-4].minor.yy432, yymsp[-1].minor.yy174, 0, yymsp[-7].minor.yy46);} +#line 3041 "parse.c" + break; + case 274: +#line 990 "parse.y" +{yygotominor.yy243 = sqlite3TriggerInsertStep(&yymsp[-2].minor.yy410, yymsp[-1].minor.yy432, 0, yymsp[0].minor.yy219, yymsp[-4].minor.yy46);} +#line 3046 "parse.c" + break; + case 275: +#line 994 "parse.y" +{yygotominor.yy243 = sqlite3TriggerDeleteStep(&yymsp[-1].minor.yy410, yymsp[0].minor.yy172);} +#line 3051 "parse.c" + break; + case 276: +#line 997 "parse.y" +{yygotominor.yy243 = sqlite3TriggerSelectStep(yymsp[0].minor.yy219); } +#line 3056 "parse.c" + break; + case 277: +#line 1000 "parse.y" +{ + yygotominor.yy172 = sqlite3Expr(TK_RAISE, 0, 0, 0); + if( yygotominor.yy172 ){ + yygotominor.yy172->iColumn = OE_Ignore; + sqlite3ExprSpan(yygotominor.yy172, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0); + } +} +#line 3067 "parse.c" + break; + case 278: +#line 1007 "parse.y" +{ + yygotominor.yy172 = sqlite3Expr(TK_RAISE, 0, 0, &yymsp[-1].minor.yy410); + if( yygotominor.yy172 ) { + yygotominor.yy172->iColumn = yymsp[-3].minor.yy46; + sqlite3ExprSpan(yygotominor.yy172, &yymsp[-5].minor.yy0, &yymsp[0].minor.yy0); + } +} +#line 3078 "parse.c" + break; + case 279: +#line 1017 "parse.y" +{yygotominor.yy46 = OE_Rollback;} +#line 3083 "parse.c" + break; + case 281: +#line 1019 "parse.y" +{yygotominor.yy46 = OE_Fail;} +#line 3088 "parse.c" + break; + case 282: +#line 1024 "parse.y" +{ + sqlite3DropTrigger(pParse,yymsp[0].minor.yy373,yymsp[-1].minor.yy46); +} +#line 3095 "parse.c" + break; + case 283: +#line 1030 "parse.y" +{ + sqlite3Attach(pParse, yymsp[-3].minor.yy172, yymsp[-1].minor.yy172, yymsp[0].minor.yy386); +} +#line 3102 "parse.c" + break; + case 284: +#line 1035 "parse.y" +{ yygotominor.yy386 = 0; } +#line 3107 "parse.c" + break; + case 285: +#line 1036 "parse.y" +{ yygotominor.yy386 = yymsp[0].minor.yy172; } +#line 3112 "parse.c" + break; + case 288: +#line 1042 "parse.y" +{ + sqlite3Detach(pParse, yymsp[0].minor.yy172); +} +#line 3119 "parse.c" + break; + case 289: +#line 1048 "parse.y" +{sqlite3Reindex(pParse, 0, 0);} +#line 3124 "parse.c" + break; + case 290: +#line 1049 "parse.y" +{sqlite3Reindex(pParse, &yymsp[-1].minor.yy410, &yymsp[0].minor.yy410);} +#line 3129 "parse.c" + break; + case 291: +#line 1054 "parse.y" +{sqlite3Analyze(pParse, 0, 0);} +#line 3134 "parse.c" + break; + case 292: +#line 1055 "parse.y" +{sqlite3Analyze(pParse, &yymsp[-1].minor.yy410, &yymsp[0].minor.yy410);} +#line 3139 "parse.c" + break; + case 293: +#line 1060 "parse.y" +{ + sqlite3AlterRenameTable(pParse,yymsp[-3].minor.yy373,&yymsp[0].minor.yy410); +} +#line 3146 "parse.c" + break; + case 294: +#line 1063 "parse.y" +{ + sqlite3AlterFinishAddColumn(pParse, &yymsp[0].minor.yy410); +} +#line 3153 "parse.c" + break; + case 295: +#line 1066 "parse.y" +{ + sqlite3AlterBeginAddColumn(pParse, yymsp[0].minor.yy373); +} +#line 3160 "parse.c" + break; + case 298: +#line 1075 "parse.y" +{sqlite3VtabFinishParse(pParse,0);} +#line 3165 "parse.c" + break; + case 299: +#line 1076 "parse.y" +{sqlite3VtabFinishParse(pParse,&yymsp[0].minor.yy0);} +#line 3170 "parse.c" + break; + case 300: +#line 1077 "parse.y" +{ + sqlite3VtabBeginParse(pParse, &yymsp[-3].minor.yy410, &yymsp[-2].minor.yy410, &yymsp[0].minor.yy410); +} +#line 3177 "parse.c" + break; + case 303: +#line 1082 "parse.y" +{sqlite3VtabArgInit(pParse);} +#line 3182 "parse.c" + break; + case 305: + case 306: + case 307: + case 309: +#line 1084 "parse.y" +{sqlite3VtabArgExtend(pParse,&yymsp[0].minor.yy0);} +#line 3190 "parse.c" + break; + }; + yygoto = yyRuleInfo[yyruleno].lhs; + yysize = yyRuleInfo[yyruleno].nrhs; + yypParser->yyidx -= yysize; + yyact = yy_find_reduce_action(yymsp[-yysize].stateno,yygoto); + if( yyact < YYNSTATE ){ +#ifdef NDEBUG + /* If we are not debugging and the reduce action popped at least + ** one element off the stack, then we can push the new element back + ** onto the stack here, and skip the stack overflow test in yy_shift(). + ** That gives a significant speed improvement. */ + if( yysize ){ + yypParser->yyidx++; + yymsp -= yysize-1; + yymsp->stateno = yyact; + yymsp->major = yygoto; + yymsp->minor = yygotominor; + }else +#endif + { + 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 */ +){ + sqlite3ParserARG_FETCH; +#ifndef NDEBUG + if( yyTraceFILE ){ + fprintf(yyTraceFILE,"%sFail!\n",yyTracePrompt); + } +#endif + while( yypParser->yyidx>=0 ) yy_pop_parser_stack(yypParser); + /* Here code is inserted which will be executed whenever the + ** parser fails */ + sqlite3ParserARG_STORE; /* Suppress warning about unused %extra_argument variable */ +} + +/* +** The following code executes when a syntax error first occurs. +*/ +static void yy_syntax_error( + yyParser *yypParser, /* The parser */ + int yymajor, /* The major type of the error token */ + YYMINORTYPE yyminor /* The minor type of the error token */ +){ + sqlite3ParserARG_FETCH; +#define TOKEN (yyminor.yy0) +#line 34 "parse.y" + + if( !pParse->parseError ){ + if( TOKEN.z[0] ){ + sqlite3ErrorMsg(pParse, "near \"%T\": syntax error", &TOKEN); + }else{ + sqlite3ErrorMsg(pParse, "incomplete SQL statement"); + } + pParse->parseError = 1; + } +#line 3258 "parse.c" + sqlite3ParserARG_STORE; /* Suppress warning about unused %extra_argument variable */ +} + +/* +** The following is executed when the parser accepts +*/ +static void yy_accept( + yyParser *yypParser /* The parser */ +){ + sqlite3ParserARG_FETCH; +#ifndef NDEBUG + if( yyTraceFILE ){ + fprintf(yyTraceFILE,"%sAccept!\n",yyTracePrompt); + } +#endif + while( yypParser->yyidx>=0 ) yy_pop_parser_stack(yypParser); + /* Here code is inserted which will be executed whenever the + ** parser accepts */ + sqlite3ParserARG_STORE; /* Suppress warning about unused %extra_argument variable */ +} + +/* The main parser program. +** The first argument is a pointer to a structure obtained from +** "sqlite3ParserAlloc" which describes the current state of the parser. +** The second argument is the major token number. The third is +** the minor token. The fourth optional argument is whatever the +** user wants (and specified in the grammar) and is available for +** use by the action routines. +** +** Inputs: +** <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 sqlite3Parser( + void *yyp, /* The parser */ + int yymajor, /* The major token code number */ + sqlite3ParserTOKENTYPE yyminor /* The value for the token */ + sqlite3ParserARG_PDECL /* Optional %extra_argument parameter */ +){ + YYMINORTYPE yyminorunion; + int yyact; /* The parser action. */ + 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; // not sure why this was here... */ + yypParser->yyidx = 0; + yypParser->yyerrcnt = -1; + yypParser->yystack[0].stateno = 0; + yypParser->yystack[0].major = 0; + } + yyminorunion.yy0 = yyminor; + yyendofinput = (yymajor==0); + sqlite3ParserARG_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_reduce_action( + yypParser->yystack[yypParser->yyidx].stateno, + 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; +} Added: freeswitch/trunk/libs/win32/sqlite/parse.h ============================================================================== --- (empty file) +++ freeswitch/trunk/libs/win32/sqlite/parse.h Tue Dec 19 18:09:46 2006 @@ -0,0 +1,153 @@ +#define TK_SEMI 1 +#define TK_EXPLAIN 2 +#define TK_QUERY 3 +#define TK_PLAN 4 +#define TK_BEGIN 5 +#define TK_TRANSACTION 6 +#define TK_DEFERRED 7 +#define TK_IMMEDIATE 8 +#define TK_EXCLUSIVE 9 +#define TK_COMMIT 10 +#define TK_END 11 +#define TK_ROLLBACK 12 +#define TK_CREATE 13 +#define TK_TABLE 14 +#define TK_IF 15 +#define TK_NOT 16 +#define TK_EXISTS 17 +#define TK_TEMP 18 +#define TK_LP 19 +#define TK_RP 20 +#define TK_AS 21 +#define TK_COMMA 22 +#define TK_ID 23 +#define TK_ABORT 24 +#define TK_AFTER 25 +#define TK_ANALYZE 26 +#define TK_ASC 27 +#define TK_ATTACH 28 +#define TK_BEFORE 29 +#define TK_CASCADE 30 +#define TK_CAST 31 +#define TK_CONFLICT 32 +#define TK_DATABASE 33 +#define TK_DESC 34 +#define TK_DETACH 35 +#define TK_EACH 36 +#define TK_FAIL 37 +#define TK_FOR 38 +#define TK_IGNORE 39 +#define TK_INITIALLY 40 +#define TK_INSTEAD 41 +#define TK_LIKE_KW 42 +#define TK_MATCH 43 +#define TK_KEY 44 +#define TK_OF 45 +#define TK_OFFSET 46 +#define TK_PRAGMA 47 +#define TK_RAISE 48 +#define TK_REPLACE 49 +#define TK_RESTRICT 50 +#define TK_ROW 51 +#define TK_STATEMENT 52 +#define TK_TRIGGER 53 +#define TK_VACUUM 54 +#define TK_VIEW 55 +#define TK_VIRTUAL 56 +#define TK_REINDEX 57 +#define TK_RENAME 58 +#define TK_CTIME_KW 59 +#define TK_ANY 60 +#define TK_OR 61 +#define TK_AND 62 +#define TK_IS 63 +#define TK_BETWEEN 64 +#define TK_IN 65 +#define TK_ISNULL 66 +#define TK_NOTNULL 67 +#define TK_NE 68 +#define TK_EQ 69 +#define TK_GT 70 +#define TK_LE 71 +#define TK_LT 72 +#define TK_GE 73 +#define TK_ESCAPE 74 +#define TK_BITAND 75 +#define TK_BITOR 76 +#define TK_LSHIFT 77 +#define TK_RSHIFT 78 +#define TK_PLUS 79 +#define TK_MINUS 80 +#define TK_STAR 81 +#define TK_SLASH 82 +#define TK_REM 83 +#define TK_CONCAT 84 +#define TK_UMINUS 85 +#define TK_UPLUS 86 +#define TK_BITNOT 87 +#define TK_STRING 88 +#define TK_JOIN_KW 89 +#define TK_CONSTRAINT 90 +#define TK_DEFAULT 91 +#define TK_NULL 92 +#define TK_PRIMARY 93 +#define TK_UNIQUE 94 +#define TK_CHECK 95 +#define TK_REFERENCES 96 +#define TK_COLLATE 97 +#define TK_AUTOINCR 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_EXCEPT 109 +#define TK_INTERSECT 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_INTEGER 125 +#define TK_FLOAT 126 +#define TK_BLOB 127 +#define TK_REGISTER 128 +#define TK_VARIABLE 129 +#define TK_CASE 130 +#define TK_WHEN 131 +#define TK_THEN 132 +#define TK_ELSE 133 +#define TK_INDEX 134 +#define TK_ALTER 135 +#define TK_TO 136 +#define TK_ADD 137 +#define TK_COLUMNKW 138 +#define TK_TO_TEXT 139 +#define TK_TO_BLOB 140 +#define TK_TO_NUMERIC 141 +#define TK_TO_INT 142 +#define TK_TO_REAL 143 +#define TK_END_OF_FILE 144 +#define TK_ILLEGAL 145 +#define TK_SPACE 146 +#define TK_UNCLOSED_STRING 147 +#define TK_COMMENT 148 +#define TK_FUNCTION 149 +#define TK_COLUMN 150 +#define TK_AGG_FUNCTION 151 +#define TK_AGG_COLUMN 152 +#define TK_CONST_FUNC 153 Modified: freeswitch/trunk/libs/win32/sqlite/sqlite.vcproj ============================================================================== --- freeswitch/trunk/libs/win32/sqlite/sqlite.vcproj (original) +++ freeswitch/trunk/libs/win32/sqlite/sqlite.vcproj Tue Dec 19 18:09:46 2006 @@ -25,7 +25,7 @@ > <Tool Name="VCPreBuildEventTool" - CommandLine="" + CommandLine="if not exist "$(ProjectDir)..\..\sqlite\src\sqlite3.h" type "$(ProjectDir)sqlite3.h" > "$(ProjectDir)..\..\sqlite\src\sqlite3.h" if not exist "$(ProjectDir)..\..\sqlite\src\parse.h" type "$(ProjectDir)parse.h" > "$(ProjectDir)..\..\sqlite\src\parse.h" if not exist "$(ProjectDir)..\..\sqlite\src\parse.c" type "$(ProjectDir)parse.c" > "$(ProjectDir)..\..\sqlite\src\parse.c" if not exist "$(ProjectDir)..\..\sqlite\src\opcodes.h" type "$(ProjectDir)opcodes.h" > "$(ProjectDir)..\..\sqlite\src\opcodes.h" if not exist "$(ProjectDir)..\..\sqlite\src\opcodes.c" type "$(ProjectDir)opcodes.c" > "$(ProjectDir)..\..\sqlite\src\opcodes.c" if not exist "$(ProjectDir)..\..\sqlite\src\keywordhash.h" type "$(ProjectDir)keywordhash.h" > "$(ProjectDir)..\..\sqlite\src\keywordhash.h" " /> <Tool Name="VCCustomBuildTool" @@ -77,7 +77,7 @@ /> <Tool Name="VCPostBuildEventTool" - CommandLine="if not exist "$(ProjectDir)..\..\include\" md "$(ProjectDir)..\..\include\" xcopy "$(ProjectDir)..\..\sqlite-source-3_3_6\*.h" "$(ProjectDir)..\..\include\" /C /D /Y " + CommandLine="if not exist "$(ProjectDir)..\..\include\" md "$(ProjectDir)..\..\include\" xcopy "$(ProjectDir)..\..\sqlite\src\*.h" "$(ProjectDir)..\..\include\" /C /D /Y " /> </Configuration> <Configuration @@ -90,7 +90,7 @@ > <Tool Name="VCPreBuildEventTool" - CommandLine="" + CommandLine="if not exist "$(ProjectDir)..\..\sqlite\src\sqlite3.h" type "$(ProjectDir)sqlite3.h" > "$(ProjectDir)..\..\sqlite\src\sqlite3.h" if not exist "$(ProjectDir)..\..\sqlite\src\parse.h" type "$(ProjectDir)parse.h" > "$(ProjectDir)..\..\sqlite\src\parse.h" if not exist "$(ProjectDir)..\..\sqlite\src\parse.c" type "$(ProjectDir)parse.c" > "$(ProjectDir)..\..\sqlite\src\parse.c" if not exist "$(ProjectDir)..\..\sqlite\src\opcodes.h" type "$(ProjectDir)opcodes.h" > "$(ProjectDir)..\..\sqlite\src\opcodes.h" if not exist "$(ProjectDir)..\..\sqlite\src\opcodes.c" type "$(ProjectDir)opcodes.c" > "$(ProjectDir)..\..\sqlite\src\opcodes.c" if not exist "$(ProjectDir)..\..\sqlite\src\keywordhash.h" type "$(ProjectDir)keywordhash.h" > "$(ProjectDir)..\..\sqlite\src\keywordhash.h" " /> <Tool Name="VCCustomBuildTool" @@ -140,7 +140,7 @@ /> <Tool Name="VCPostBuildEventTool" - CommandLine="if not exist "$(ProjectDir)..\..\include\" md "$(ProjectDir)..\..\include\" xcopy "$(ProjectDir)..\..\sqlite-source-3_3_6\*.h" "$(ProjectDir)..\..\include\" /C /D /Y " + CommandLine="if not exist "$(ProjectDir)..\..\include\" md "$(ProjectDir)..\..\include\" xcopy "$(ProjectDir)..\..\sqlite\src\*.h" "$(ProjectDir)..\..\include\" /C /D /Y " /> </Configuration> <Configuration @@ -153,7 +153,7 @@ > <Tool Name="VCPreBuildEventTool" - CommandLine="" + CommandLine="if not exist "$(ProjectDir)..\..\sqlite\src\sqlite3.h" type "$(ProjectDir)sqlite3.h" > "$(ProjectDir)..\..\sqlite\src\sqlite3.h" if not exist "$(ProjectDir)..\..\sqlite\src\parse.h" type "$(ProjectDir)parse.h" > "$(ProjectDir)..\..\sqlite\src\parse.h" if not exist "$(ProjectDir)..\..\sqlite\src\parse.c" type "$(ProjectDir)parse.c" > "$(ProjectDir)..\..\sqlite\src\parse.c" if not exist "$(ProjectDir)..\..\sqlite\src\opcodes.h" type "$(ProjectDir)opcodes.h" > "$(ProjectDir)..\..\sqlite\src\opcodes.h" if not exist "$(ProjectDir)..\..\sqlite\src\opcodes.c" type "$(ProjectDir)opcodes.c" > "$(ProjectDir)..\..\sqlite\src\opcodes.c" if not exist "$(ProjectDir)..\..\sqlite\src\keywordhash.h" type "$(ProjectDir)keywordhash.h" > "$(ProjectDir)..\..\sqlite\src\keywordhash.h" " /> <Tool Name="VCCustomBuildTool" @@ -191,7 +191,7 @@ <Tool Name="VCLinkerTool" LinkIncremental="1" - ModuleDefinitionFile="../../sqlite-source-3_3_6/sqlite3.def" + ModuleDefinitionFile="sqlite3.def" GenerateDebugInformation="true" ProgramDatabaseFile="$(IntDir)\$(ProjectName).pdb" SubSystem="2" @@ -221,7 +221,7 @@ /> <Tool Name="VCPostBuildEventTool" - CommandLine="if not exist "$(ProjectDir)..\..\include\" md "$(ProjectDir)..\..\include\" xcopy "$(ProjectDir)..\..\sqlite-source-3_3_6\*.h" "$(ProjectDir)..\..\include\" /C /D /Y " + CommandLine="if not exist "$(ProjectDir)..\..\include\" md "$(ProjectDir)..\..\include\" xcopy "$(ProjectDir)..\..\sqlite\src\*.h" "$(ProjectDir)..\..\include\" /C /D /Y " /> </Configuration> <Configuration @@ -234,7 +234,7 @@ > <Tool Name="VCPreBuildEventTool" - CommandLine="" + CommandLine="if not exist "$(ProjectDir)..\..\sqlite\src\sqlite3.h" type "$(ProjectDir)sqlite3.h" > "$(ProjectDir)..\..\sqlite\src\sqlite3.h" if not exist "$(ProjectDir)..\..\sqlite\src\parse.h" type "$(ProjectDir)parse.h" > "$(ProjectDir)..\..\sqlite\src\parse.h" if not exist "$(ProjectDir)..\..\sqlite\src\parse.c" type "$(ProjectDir)parse.c" > "$(ProjectDir)..\..\sqlite\src\parse.c" if not exist "$(ProjectDir)..\..\sqlite\src\opcodes.h" type "$(ProjectDir)opcodes.h" > "$(ProjectDir)..\..\sqlite\src\opcodes.h" if not exist "$(ProjectDir)..\..\sqlite\src\opcodes.c" type "$(ProjectDir)opcodes.c" > "$(ProjectDir)..\..\sqlite\src\opcodes.c" if not exist "$(ProjectDir)..\..\sqlite\src\keywordhash.h" type "$(ProjectDir)keywordhash.h" > "$(ProjectDir)..\..\sqlite\src\keywordhash.h" " /> <Tool Name="VCCustomBuildTool" @@ -269,7 +269,7 @@ <Tool Name="VCLinkerTool" LinkIncremental="1" - ModuleDefinitionFile="../../sqlite-source-3_3_6/sqlite3.def" + ModuleDefinitionFile="sqlite3.def" ImportLibrary="$(IntDir)/$(TargetName).lib" /> <Tool @@ -295,7 +295,7 @@ /> <Tool Name="VCPostBuildEventTool" - CommandLine="if not exist "$(ProjectDir)..\..\include\" md "$(ProjectDir)..\..\include\" xcopy "$(ProjectDir)..\..\sqlite-source-3_3_6\*.h" "$(ProjectDir)..\..\include\" /C /D /Y " + CommandLine="if not exist "$(ProjectDir)..\..\include\" md "$(ProjectDir)..\..\include\" xcopy "$(ProjectDir)..\..\sqlite\src\*.h" "$(ProjectDir)..\..\include\" /C /D /Y " /> </Configuration> </Configurations> @@ -308,169 +308,177 @@ UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}" > <File - RelativePath="..\..\sqlite-source-3_3_6\alter.c" + RelativePath="..\..\sqlite\src\alter.c" > </File> <File - RelativePath="..\..\sqlite-source-3_3_6\analyze.c" + RelativePath="..\..\sqlite\src\analyze.c" > </File> <File - RelativePath="..\..\sqlite-source-3_3_6\attach.c" + RelativePath="..\..\sqlite\src\attach.c" > </File> <File - RelativePath="..\..\sqlite-source-3_3_6\auth.c" + RelativePath="..\..\sqlite\src\auth.c" > </File> <File - RelativePath="..\..\sqlite-source-3_3_6\btree.c" + RelativePath="..\..\sqlite\src\btree.c" > </File> <File - RelativePath="..\..\sqlite-source-3_3_6\build.c" + RelativePath="..\..\sqlite\src\build.c" > </File> <File - RelativePath="..\..\sqlite-source-3_3_6\callback.c" + RelativePath="..\..\sqlite\src\callback.c" > </File> <File - RelativePath="..\..\sqlite-source-3_3_6\complete.c" + RelativePath="..\..\sqlite\src\complete.c" > </File> <File - RelativePath="..\..\sqlite-source-3_3_6\date.c" + RelativePath="..\..\sqlite\src\date.c" > </File> <File - RelativePath="..\..\sqlite-source-3_3_6\delete.c" + RelativePath="..\..\sqlite\src\delete.c" > </File> <File - RelativePath="..\..\sqlite-source-3_3_6\expr.c" + RelativePath="..\..\sqlite\src\expr.c" > </File> <File - RelativePath="..\..\sqlite-source-3_3_6\func.c" + RelativePath="..\..\sqlite\src\func.c" > </File> <File - RelativePath="..\..\sqlite-source-3_3_6\hash.c" + RelativePath="..\..\sqlite\src\hash.c" > </File> <File - RelativePath="..\..\sqlite-source-3_3_6\insert.c" + RelativePath="..\..\sqlite\src\insert.c" > </File> <File - RelativePath="..\..\sqlite-source-3_3_6\legacy.c" + RelativePath="..\..\sqlite\src\legacy.c" > </File> <File - RelativePath="..\..\sqlite-source-3_3_6\main.c" + RelativePath="..\..\sqlite\src\loadext.c" > </File> <File - RelativePath="..\..\sqlite-source-3_3_6\opcodes.c" + RelativePath="..\..\sqlite\src\main.c" > </File> <File - RelativePath="..\..\sqlite-source-3_3_6\os.c" + RelativePath="..\..\sqlite\src\opcodes.c" > </File> <File - RelativePath="..\..\sqlite-source-3_3_6\os_unix.c" + RelativePath="..\..\sqlite\src\os.c" > </File> <File - RelativePath="..\..\sqlite-source-3_3_6\os_win.c" + RelativePath="..\..\sqlite\src\os_unix.c" > </File> <File - RelativePath="..\..\sqlite-source-3_3_6\pager.c" + RelativePath="..\..\sqlite\src\os_win.c" > </File> <File - RelativePath="..\..\sqlite-source-3_3_6\parse.c" + RelativePath="..\..\sqlite\src\pager.c" > </File> <File - RelativePath="..\..\sqlite-source-3_3_6\pragma.c" + RelativePath="..\..\sqlite\src\parse.c" > </File> <File - RelativePath="..\..\sqlite-source-3_3_6\prepare.c" + RelativePath="..\..\sqlite\src\pragma.c" > </File> <File - RelativePath="..\..\sqlite-source-3_3_6\printf.c" + RelativePath="..\..\sqlite\src\prepare.c" > </File> <File - RelativePath="..\..\sqlite-source-3_3_6\random.c" + RelativePath="..\..\sqlite\src\printf.c" > </File> <File - RelativePath="..\..\sqlite-source-3_3_6\select.c" + RelativePath="..\..\sqlite\src\random.c" > </File> <File - RelativePath="..\..\sqlite-source-3_3_6\shell.c" + RelativePath="..\..\sqlite\src\select.c" > </File> <File - RelativePath="..\..\sqlite-source-3_3_6\table.c" + RelativePath="..\..\sqlite\src\shell.c" > </File> <File - RelativePath="..\..\sqlite-source-3_3_6\tokenize.c" + RelativePath="..\..\sqlite\src\table.c" > </File> <File - RelativePath="..\..\sqlite-source-3_3_6\trigger.c" + RelativePath="..\..\sqlite\src\tokenize.c" > </File> <File - RelativePath="..\..\sqlite-source-3_3_6\update.c" + RelativePath="..\..\sqlite\src\trigger.c" > </File> <File - RelativePath="..\..\sqlite-source-3_3_6\utf.c" + RelativePath="..\..\sqlite\src\update.c" > </File> <File - RelativePath="..\..\sqlite-source-3_3_6\util.c" + RelativePath="..\..\sqlite\src\utf.c" > </File> <File - RelativePath="..\..\sqlite-source-3_3_6\vacuum.c" + RelativePath="..\..\sqlite\src\util.c" > </File> <File - RelativePath="..\..\sqlite-source-3_3_6\vdbe.c" + RelativePath="..\..\sqlite\src\vacuum.c" > </File> <File - RelativePath="..\..\sqlite-source-3_3_6\vdbeapi.c" + RelativePath="..\..\sqlite\src\vdbe.c" > </File> <File - RelativePath="..\..\sqlite-source-3_3_6\vdbeaux.c" + RelativePath="..\..\sqlite\src\vdbeapi.c" > </File> <File - RelativePath="..\..\sqlite-source-3_3_6\vdbefifo.c" + RelativePath="..\..\sqlite\src\vdbeaux.c" > </File> <File - RelativePath="..\..\sqlite-source-3_3_6\vdbemem.c" + RelativePath="..\..\sqlite\src\vdbefifo.c" > </File> <File - RelativePath="..\..\sqlite-source-3_3_6\where.c" + RelativePath="..\..\sqlite\src\vdbemem.c" > </File> + <File + RelativePath="..\..\sqlite\src\vtab.c" + > + </File> + <File + RelativePath="..\..\sqlite\src\where.c" + > + </File> </Filter> <Filter Name="Header Files" @@ -478,51 +486,51 @@ UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}" > <File - RelativePath="..\..\sqlite-source-3_3_6\btree.h" + RelativePath="..\..\sqlite\src\btree.h" > </File> <File - RelativePath="..\..\sqlite-source-3_3_6\hash.h" + RelativePath="..\..\sqlite\src\hash.h" > </File> <File - RelativePath="..\..\sqlite-source-3_3_6\keywordhash.h" + RelativePath="..\..\sqlite\src\keywordhash.h" > </File> <File - RelativePath="..\..\sqlite-source-3_3_6\opcodes.h" + RelativePath="..\..\sqlite\src\opcodes.h" > </File> <File - RelativePath="..\..\sqlite-source-3_3_6\os.h" + RelativePath="..\..\sqlite\src\os.h" > </File> <File - RelativePath="..\..\sqlite-source-3_3_6\os_common.h" + RelativePath="..\..\sqlite\src\os_common.h" > </File> <File - RelativePath="..\..\sqlite-source-3_3_6\pager.h" + RelativePath="..\..\sqlite\src\pager.h" > </File> <File - RelativePath="..\..\sqlite-source-3_3_6\parse.h" + RelativePath="..\..\sqlite\src\parse.h" > </File> <File - RelativePath="..\..\sqlite-source-3_3_6\sqlite3.h" + RelativePath="..\..\sqlite\src\sqlite3.h" > </File> <File - RelativePath="..\..\sqlite-source-3_3_6\sqliteInt.h" + RelativePath="..\..\sqlite\src\sqliteInt.h" > </File> <File - RelativePath="..\..\sqlite-source-3_3_6\vdbe.h" + RelativePath="..\..\sqlite\src\vdbe.h" > </File> <File - RelativePath="..\..\sqlite-source-3_3_6\vdbeInt.h" + RelativePath="..\..\sqlite\src\vdbeInt.h" > </File> </Filter> Added: freeswitch/trunk/libs/win32/sqlite/sqlite3.def ============================================================================== --- (empty file) +++ freeswitch/trunk/libs/win32/sqlite/sqlite3.def Tue Dec 19 18:09:46 2006 @@ -0,0 +1,101 @@ +EXPORTS +sqlite3_aggregate_context +sqlite3_aggregate_count +sqlite3_bind_blob +sqlite3_bind_double +sqlite3_bind_int +sqlite3_bind_int64 +sqlite3_bind_null +sqlite3_bind_parameter_count +sqlite3_bind_parameter_index +sqlite3_bind_parameter_name +sqlite3_bind_text +sqlite3_bind_text16 +sqlite3_busy_handler +sqlite3_busy_timeout +sqlite3_changes +sqlite3_close +sqlite3_collation_needed +sqlite3_collation_needed16 +sqlite3_column_blob +sqlite3_column_bytes +sqlite3_column_bytes16 +sqlite3_column_count +sqlite3_column_decltype +sqlite3_column_decltype16 +sqlite3_column_double +sqlite3_column_int +sqlite3_column_int64 +sqlite3_column_name +sqlite3_column_name16 +sqlite3_column_text +sqlite3_column_text16 +sqlite3_column_type +sqlite3_commit_hook +sqlite3_complete +sqlite3_complete16 +sqlite3_create_collation +sqlite3_create_collation16 +sqlite3_create_function +sqlite3_create_function16 +sqlite3_data_count +sqlite3_db_handle +sqlite3_enable_shared_cache +sqlite3_errcode +sqlite3_errmsg +sqlite3_errmsg16 +sqlite3_exec +sqlite3_expired +sqlite3_finalize +sqlite3_free +sqlite3_free_table +sqlite3_get_autocommit +sqlite3_get_auxdata +sqlite3_get_table +sqlite3_global_recover +sqlite3_interrupt +sqlite3_last_insert_rowid +sqlite3_libversion +sqlite3_libversion_number +sqlite3_mprintf +sqlite3_open +sqlite3_open16 +sqlite3_prepare +sqlite3_prepare16 +sqlite3_progress_handler +sqlite3_reset +sqlite3_result_blob +sqlite3_result_double +sqlite3_result_error +sqlite3_result_error16 +sqlite3_result_int +sqlite3_result_int64 +sqlite3_result_null +sqlite3_result_text +sqlite3_result_text16 +sqlite3_result_text16be +sqlite3_result_text16le +sqlite3_result_value +sqlite3_rollback_hook +sqlite3_set_authorizer +sqlite3_set_auxdata +sqlite3_snprintf +sqlite3_step +sqlite3_thread_cleanup +sqlite3_total_changes +sqlite3_trace +sqlite3_transfer_bindings +sqlite3_update_hook +sqlite3_user_data +sqlite3_value_blob +sqlite3_value_bytes +sqlite3_value_bytes16 +sqlite3_value_double +sqlite3_value_int +sqlite3_value_int64 +sqlite3_value_text +sqlite3_value_text16 +sqlite3_value_text16be +sqlite3_value_text16le +sqlite3_value_type +sqlite3_vmprintf Added: freeswitch/trunk/libs/win32/sqlite/sqlite3.h ============================================================================== --- (empty file) +++ freeswitch/trunk/libs/win32/sqlite/sqlite3.h Tue Dec 19 18:09:46 2006 @@ -0,0 +1,1826 @@ +/* +** 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.in,v 1.194 2006/09/16 21:45:14 drh Exp $ +*/ +#ifndef _SQLITE3_H_ +#define _SQLITE3_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. +*/ +#ifdef SQLITE_VERSION +# undef SQLITE_VERSION +#endif +#define SQLITE_VERSION "3.3.8" + +/* +** The format of the version string is "X.Y.Z<trailing string>", where +** X is the major version number, Y is the minor version number and Z +** is the release number. The trailing string is often "alpha" or "beta". +** For example "3.1.1beta". +** +** The SQLITE_VERSION_NUMBER is an integer with the value +** (X*100000 + Y*1000 + Z). For example, for version "3.1.1beta", +** SQLITE_VERSION_NUMBER is set to 3001001. To detect if they are using +** version 3.1.1 or greater at compile time, programs may use the test +** (SQLITE_VERSION_NUMBER>=3001001). +*/ +#ifdef SQLITE_VERSION_NUMBER +# undef SQLITE_VERSION_NUMBER +#endif +#define SQLITE_VERSION_NUMBER 3003008 + +/* +** The version string is also compiled into the library so that a program +** can check to make sure that the lib*.a file and the *.h file are from +** the same version. The sqlite3_libversion() function returns a pointer +** to the sqlite3_version variable - useful in DLLs which cannot access +** global variables. +*/ +extern const char sqlite3_version[]; +const char *sqlite3_libversion(void); + +/* +** Return the value of the SQLITE_VERSION_NUMBER macro when the +** library was compiled. +*/ +int sqlite3_libversion_number(void); + +/* +** Each open sqlite database is represented by an instance of the +** following opaque structure. +*/ +typedef struct sqlite3 sqlite3; + + +/* +** Some compilers do not support the "long long" datatype. So we have +** to do a typedef that for 64-bit integers that depends on what compiler +** is being used. +*/ +#ifdef SQLITE_INT64_TYPE + typedef SQLITE_INT64_TYPE sqlite_int64; + typedef unsigned SQLITE_INT64_TYPE sqlite_uint64; +#elif defined(_MSC_VER) || defined(__BORLANDC__) + typedef __int64 sqlite_int64; + typedef unsigned __int64 sqlite_uint64; +#else + typedef long long int sqlite_int64; + typedef unsigned long long int sqlite_uint64; +#endif + +/* +** If compiling for a processor that lacks floating point support, +** substitute integer for floating-point +*/ +#ifdef SQLITE_OMIT_FLOATING_POINT +# define double sqlite_int64 +#endif + +/* +** A function to close the database. +** +** Call this function with a pointer to a structure that was previously +** returned from sqlite3_open() and the corresponding database will by closed. +** +** All SQL statements prepared using sqlite3_prepare() or +** sqlite3_prepare16() must be deallocated using sqlite3_finalize() before +** this routine is called. Otherwise, SQLITE_BUSY is returned and the +** database connection remains open. +*/ +int sqlite3_close(sqlite3 *); + +/* +** The type for a callback function. +*/ +typedef int (*sqlite3_callback)(void*,int,char**, char**); + +/* +** A function to executes one or more statements of SQL. +** +** If one or more of the SQL statements are queries, then +** the callback function specified by the 3rd parameter is +** invoked once for each row of the query result. This callback +** should normally return 0. If the callback returns a non-zero +** value then the query is aborted, all subsequent SQL statements +** are skipped and the sqlite3_exec() function returns the SQLITE_ABORT. +** +** The 4th parameter is an arbitrary pointer that is passed +** to the callback function as its first parameter. +** +** The 2nd parameter to the callback function is the number of +** columns in the query result. The 3rd parameter to the callback +** is an array of strings holding the values for each column. +** The 4th parameter to the callback is an array of strings holding +** the names of each column. +** +** The callback function may be NULL, even for queries. A NULL +** callback is not an error. It just means that no callback +** will be invoked. +** +** If an error occurs while parsing or evaluating the SQL (but +** not while executing the callback) then an appropriate error +** message is written into memory obtained from malloc() and +** *errmsg is made to point to that message. The calling function +** is responsible for freeing the memory that holds the error +** message. Use sqlite3_free() for this. If errmsg==NULL, +** then no error message is ever written. +** +** The return value is is SQLITE_OK if there are no errors and +** some other return code if there is an error. The particular +** return value depends on the type of error. +** +** If the query could not be executed because a database file is +** locked or busy, then this function returns SQLITE_BUSY. (This +** behavior can be modified somewhat using the sqlite3_busy_handler() +** and sqlite3_busy_timeout() functions below.) +*/ +int sqlite3_exec( + sqlite3*, /* An open database */ + const char *sql, /* SQL to be executed */ + sqlite3_callback, /* Callback function */ + void *, /* 1st argument to callback function */ + char **errmsg /* Error msg written here */ +); + +/* +** Return values for sqlite3_exec() and sqlite3_step() +*/ +#define SQLITE_OK 0 /* Successful result */ +/* beginning-of-error-codes */ +#define SQLITE_ERROR 1 /* SQL error or missing database */ +#define SQLITE_INTERNAL 2 /* NOT USED. Internal logic error in SQLite */ +#define SQLITE_PERM 3 /* Access permission denied */ +#define SQLITE_ABORT 4 /* Callback routine requested an abort */ +#define SQLITE_BUSY 5 /* The database file is locked */ +#define SQLITE_LOCKED 6 /* A table in the database is locked */ +#define SQLITE_NOMEM 7 /* A malloc() failed */ +#define SQLITE_READONLY 8 /* Attempt to write a readonly database */ +#define SQLITE_INTERRUPT 9 /* Operation terminated by sqlite3_interrupt()*/ +#define SQLITE_IOERR 10 /* Some kind of disk I/O error occurred */ +#define SQLITE_CORRUPT 11 /* The database disk image is malformed */ +#define SQLITE_NOTFOUND 12 /* NOT USED. Table or record not found */ +#define SQLITE_FULL 13 /* Insertion failed because database is full */ +#define SQLITE_CANTOPEN 14 /* Unable to open the database file */ +#define SQLITE_PROTOCOL 15 /* Database lock protocol error */ +#define SQLITE_EMPTY 16 /* Database is empty */ +#define SQLITE_SCHEMA 17 /* The database schema changed */ +#define SQLITE_TOOBIG 18 /* NOT USED. Too much data for one row */ +#define SQLITE_CONSTRAINT 19 /* Abort due to contraint violation */ +#define SQLITE_MISMATCH 20 /* Data type mismatch */ +#define SQLITE_MISUSE 21 /* Library used incorrectly */ +#define SQLITE_NOLFS 22 /* Uses OS features not supported on host */ +#define SQLITE_AUTH 23 /* Authorization denied */ +#define SQLITE_FORMAT 24 /* Auxiliary database format error */ +#define SQLITE_RANGE 25 /* 2nd parameter to sqlite3_bind out of range */ +#define SQLITE_NOTADB 26 /* File opened that is not a database file */ +#define SQLITE_ROW 100 /* sqlite3_step() has another row ready */ +#define SQLITE_DONE 101 /* sqlite3_step() has finished executing */ +/* end-of-error-codes */ + +/* +** Using the sqlite3_extended_result_codes() API, you can cause +** SQLite to return result codes with additional information in +** their upper bits. The lower 8 bits will be the same as the +** primary result codes above. But the upper bits might contain +** more specific error information. +** +** To extract the primary result code from an extended result code, +** simply mask off the lower 8 bits. +** +** primary = extended & 0xff; +** +** New result error codes may be added from time to time. Software +** that uses the extended result codes should plan accordingly and be +** sure to always handle new unknown codes gracefully. +** +** The SQLITE_OK result code will never be extended. It will always +** be exactly zero. +** +** The extended result codes always have the primary result code +** as a prefix. Primary result codes only contain a single "_" +** character. Extended result codes contain two or more "_" characters. +*/ +#define SQLITE_IOERR_READ (SQLITE_IOERR | (1<<8)) +#define SQLITE_IOERR_SHORT_READ (SQLITE_IOERR | (2<<8)) +#define SQLITE_IOERR_WRITE (SQLITE_IOERR | (3<<8)) +#define SQLITE_IOERR_FSYNC (SQLITE_IOERR | (4<<8)) +#define SQLITE_IOERR_DIR_FSYNC (SQLITE_IOERR | (5<<8)) +#define SQLITE_IOERR_TRUNCATE (SQLITE_IOERR | (6<<8)) +#define SQLITE_IOERR_FSTAT (SQLITE_IOERR | (7<<8)) +#define SQLITE_IOERR_UNLOCK (SQLITE_IOERR | (8<<8)) +#define SQLITE_IOERR_RDLOCK (SQLITE_IOERR | (9<<8)) + +/* +** Enable or disable the extended result codes. +*/ +int sqlite3_extended_result_codes(sqlite3*, int onoff); + +/* +** Each entry in an SQLite table has a unique integer key. (The key is +** the value of the INTEGER PRIMARY KEY column if there is such a column, +** otherwise the key is generated at random. The unique key is always +** available as the ROWID, OID, or _ROWID_ column.) The following routine +** returns the integer key of the most recent insert in the database. +** +** This function is similar to the mysql_insert_id() function from MySQL. +*/ +sqlite_int64 sqlite3_last_insert_rowid(sqlite3*); + +/* +** This function returns the number of database rows that were changed +** (or inserted or deleted) by the most recent called sqlite3_exec(). +** +** All changes are counted, even if they were later undone by a +** ROLLBACK or ABORT. Except, changes associated with creating and +** dropping tables are not counted. +** +** If a callback invokes sqlite3_exec() recursively, then the changes +** in the inner, recursive call are counted together with the changes +** in the outer call. +** +** SQLite implements the command "DELETE FROM table" without a WHERE clause +** by dropping and recreating the table. (This is much faster than going +** through and deleting individual elements form the table.) Because of +** this optimization, the change count for "DELETE FROM table" will be +** zero regardless of the number of elements that were originally in the +** table. To get an accurate count of the number of rows deleted, use +** "DELETE FROM table WHERE 1" instead. +*/ +int sqlite3_changes(sqlite3*); + +/* +** This function returns the number of database rows that have been +** modified by INSERT, UPDATE or DELETE statements since the database handle +** was opened. This includes UPDATE, INSERT and DELETE statements executed +** as part of trigger programs. All changes are counted as soon as the +** statement that makes them is completed (when the statement handle is +** passed to sqlite3_reset() or sqlite_finalise()). +** +** SQLite implements the command "DELETE FROM table" without a WHERE clause +** by dropping and recreating the table. (This is much faster than going +** through and deleting individual elements form the table.) Because of +** this optimization, the change count for "DELETE FROM table" will be +** zero regardless of the number of elements that were originally in the +** table. To get an accurate count of the number of rows deleted, use +** "DELETE FROM table WHERE 1" instead. +*/ +int sqlite3_total_changes(sqlite3*); + +/* This function causes any pending database operation to abort and +** return at its earliest opportunity. This routine is typically +** called in response to a user action such as pressing "Cancel" +** or Ctrl-C where the user wants a long query operation to halt +** immediately. +*/ +void sqlite3_interrupt(sqlite3*); + + +/* These functions return true if the given input string comprises +** one or more complete SQL statements. For the sqlite3_complete() call, +** the parameter must be a nul-terminated UTF-8 string. For +** sqlite3_complete16(), a nul-terminated machine byte order UTF-16 string +** is required. +** +** The algorithm is simple. If the last token other than spaces +** and comments is a semicolon, then return true. otherwise return +** false. +*/ +int sqlite3_complete(const char *sql); +int sqlite3_complete16(const void *sql); + +/* +** This routine identifies a callback function that is invoked +** whenever an attempt is made to open a database table that is +** currently locked by another process or thread. If the busy callback +** is NULL, then sqlite3_exec() returns SQLITE_BUSY immediately if +** it finds a locked table. If the busy callback is not NULL, then +** sqlite3_exec() invokes the callback with three arguments. The +** second argument is the name of the locked table and the third +** argument is the number of times the table has been busy. If the +** busy callback returns 0, then sqlite3_exec() immediately returns +** SQLITE_BUSY. If the callback returns non-zero, then sqlite3_exec() +** tries to open the table again and the cycle repeats. +** +** The default busy callback is NULL. +** +** Sqlite is re-entrant, so the busy handler may start a new query. +** (It is not clear why anyone would every want to do this, but it +** is allowed, in theory.) But the busy handler may not close the +** database. Closing the database from a busy handler will delete +** data structures out from under the executing query and will +** probably result in a coredump. +*/ +int sqlite3_busy_handler(sqlite3*, int(*)(void*,int), void*); + +/* +** This routine sets a busy handler that sleeps for a while when a +** table is locked. The handler will sleep multiple times until +** at least "ms" milleseconds of sleeping have been done. After +** "ms" milleseconds of sleeping, the handler returns 0 which +** causes sqlite3_exec() to return SQLITE_BUSY. +** +** Calling this routine with an argument less than or equal to zero +** turns off all busy handlers. +*/ +int sqlite3_busy_timeout(sqlite3*, int ms); + +/* +** This next routine is really just a wrapper around sqlite3_exec(). +** Instead of invoking a user-supplied callback for each row of the +** result, this routine remembers each row of the result in memory +** obtained from malloc(), then returns all of the result after the +** query has finished. +** +** As an example, suppose the query result where this table: +** +** Name | Age +** ----------------------- +** Alice | 43 +** Bob | 28 +** Cindy | 21 +** +** If the 3rd argument were &azResult then after the function returns +** azResult will contain the following data: +** +** azResult[0] = "Name"; +** azResult[1] = "Age"; +** azResult[2] = "Alice"; +** azResult[3] = "43"; +** azResult[4] = "Bob"; +** azResult[5] = "28"; +** azResult[6] = "Cindy"; +** azResult[7] = "21"; +** +** Notice that there is an extra row of data containing the column +** headers. But the *nrow return value is still 3. *ncolumn is +** set to 2. In general, the number of values inserted into azResult +** will be ((*nrow) + 1)*(*ncolumn). +** +** After the calling function has finished using the result, it should +** pass the result data pointer to sqlite3_free_table() in order to +** release the memory that was malloc-ed. Because of the way the +** malloc() happens, the calling function must not try to call +** free() directly. Only sqlite3_free_table() is able to release +** the memory properly and safely. +** +** The return value of this routine is the same as from sqlite3_exec(). +*/ +int sqlite3_get_table( + sqlite3*, /* An open database */ + const char *sql, /* SQL to be executed */ + char ***resultp, /* Result written to a char *[] that this points to */ + int *nrow, /* Number of result rows written here */ + int *ncolumn, /* Number of result columns written here */ + char **errmsg /* Error msg written here */ +); + +/* +** Call this routine to free the memory that sqlite3_get_table() allocated. +*/ +void sqlite3_free_table(char **result); + +/* +** The following routines are variants of the "sprintf()" from the +** standard C library. The resulting string is written into memory +** obtained from malloc() so that there is never a possiblity of buffer +** overflow. These routines also implement some additional formatting +** options that are useful for constructing SQL statements. +** +** The strings returned by these routines should be freed by calling +** sqlite3_free(). +** +** All of the usual printf formatting options apply. In addition, there +** is a "%q" option. %q works like %s in that it substitutes a null-terminated +** string from the argument list. But %q also doubles every '\'' character. +** %q is designed for use inside a string literal. By doubling each '\'' +** character it escapes that character and allows it to be inserted into +** the string. +** +** For example, so some string variable contains text as follows: +** +** char *zText = "It's a happy day!"; +** +** We can use this text in an SQL statement as follows: +** +** char *z = sqlite3_mprintf("INSERT INTO TABLES('%q')", zText); +** sqlite3_exec(db, z, callback1, 0, 0); +** sqlite3_free(z); +** +** Because the %q format string is used, the '\'' character in zText +** is escaped and the SQL generated is as follows: +** +** INSERT INTO table1 VALUES('It''s a happy day!') +** +** This is correct. Had we used %s instead of %q, the generated SQL +** would have looked like this: +** +** INSERT INTO table1 VALUES('It's a happy day!'); +** +** This second example is an SQL syntax error. As a general rule you +** should always use %q instead of %s when inserting text into a string +** literal. +*/ +char *sqlite3_mprintf(const char*,...); +char *sqlite3_vmprintf(const char*, va_list); +char *sqlite3_snprintf(int,char*,const char*, ...); + +/* +** SQLite uses its own memory allocator. On many installations, this +** memory allocator is identical to the standard malloc()/realloc()/free() +** and can be used interchangable. On others, the implementations are +** different. For maximum portability, it is best not to mix calls +** to the standard malloc/realloc/free with the sqlite versions. +*/ +void *sqlite3_malloc(int); +void *sqlite3_realloc(void*, int); +void sqlite3_free(void*); + +#ifndef SQLITE_OMIT_AUTHORIZATION +/* +** This routine registers a callback with the SQLite library. The +** callback is invoked (at compile-time, not at run-time) for each +** attempt to access a column of a table in the database. The callback +** returns SQLITE_OK if access is allowed, SQLITE_DENY if the entire +** SQL statement should be aborted with an error and SQLITE_IGNORE +** if the column should be treated as a NULL value. +*/ +int sqlite3_set_authorizer( + sqlite3*, + int (*xAuth)(void*,int,const char*,const char*,const char*,const char*), + void *pUserData +); +#endif + +/* +** The second parameter to the access authorization function above will +** be one of the values below. These values signify what kind of operation +** is to be authorized. The 3rd and 4th parameters to the authorization +** function will be parameters or NULL depending on which of the following +** codes is used as the second parameter. The 5th parameter is the name +** of the database ("main", "temp", etc.) if applicable. The 6th parameter +** is the name of the inner-most trigger or view that is responsible for +** the access attempt or NULL if this access attempt is directly from +** input SQL code. +** +** Arg-3 Arg-4 +*/ +#define SQLITE_COPY 0 /* Table Name File Name */ +#define SQLITE_CREATE_INDEX 1 /* Index Name Table Name */ +#define SQLITE_CREATE_TABLE 2 /* Table Name NULL */ +#define SQLITE_CREATE_TEMP_INDEX 3 /* Index Name Table Name */ +#define SQLITE_CREATE_TEMP_TABLE 4 /* Table Name NULL */ +#define SQLITE_CREATE_TEMP_TRIGGER 5 /* Trigger Name Table Name */ +#define SQLITE_CREATE_TEMP_VIEW 6 /* View Name NULL */ +#define SQLITE_CREATE_TRIGGER 7 /* Trigger Name Table Name */ +#define SQLITE_CREATE_VIEW 8 /* View Name NULL */ +#define SQLITE_DELETE 9 /* Table Name NULL */ +#define SQLITE_DROP_INDEX 10 /* Index Name Table Name */ +#define SQLITE_DROP_TABLE 11 /* Table Name NULL */ +#define SQLITE_DROP_TEMP_INDEX 12 /* Index Name Table Name */ +#define SQLITE_DROP_TEMP_TABLE 13 /* Table Name NULL */ +#define SQLITE_DROP_TEMP_TRIGGER 14 /* Trigger Name Table Name */ +#define SQLITE_DROP_TEMP_VIEW 15 /* View Name NULL */ +#define SQLITE_DROP_TRIGGER 16 /* Trigger Name Table Name */ +#define SQLITE_DROP_VIEW 17 /* View Name NULL */ +#define SQLITE_INSERT 18 /* Table Name NULL */ +#define SQLITE_PRAGMA 19 /* Pragma Name 1st arg or NULL */ +#define SQLITE_READ 20 /* Table Name Column Name */ +#define SQLITE_SELECT 21 /* NULL NULL */ +#define SQLITE_TRANSACTION 22 /* NULL NULL */ +#define SQLITE_UPDATE 23 /* Table Name Column Name */ +#define SQLITE_ATTACH 24 /* Filename NULL */ +#define SQLITE_DETACH 25 /* Database Name NULL */ +#define SQLITE_ALTER_TABLE 26 /* Database Name Table Name */ +#define SQLITE_REINDEX 27 /* Index Name NULL */ +#define SQLITE_ANALYZE 28 /* Table Name NULL */ +#define SQLITE_CREATE_VTABLE 29 /* Table Name Module Name */ +#define SQLITE_DROP_VTABLE 30 /* Table Name Module Name */ +#define SQLITE_FUNCTION 31 /* Function Name NULL */ + +/* +** The return value of the authorization function should be one of the +** following constants: +*/ +/* #define SQLITE_OK 0 // Allow access (This is actually defined above) */ +#define SQLITE_DENY 1 /* Abort the SQL statement with an error */ +#define SQLITE_IGNORE 2 /* Don't allow access, but don't generate an error */ + +/* +** Register a function for tracing SQL command evaluation. The function +** registered by sqlite3_trace() is invoked at the first sqlite3_step() +** for the evaluation of an SQL statement. The function registered by +** sqlite3_profile() runs at the end of each SQL statement and includes +** information on how long that statement ran. +** +** The sqlite3_profile() API is currently considered experimental and +** is subject to change. +*/ +void *sqlite3_trace(sqlite3*, void(*xTrace)(void*,const char*), void*); +void *sqlite3_profile(sqlite3*, + void(*xProfile)(void*,const char*,sqlite_uint64), void*); + +/* +** This routine configures a callback function - the progress callback - that +** is invoked periodically during long running calls to sqlite3_exec(), +** sqlite3_step() and sqlite3_get_table(). An example use for this API is to +** keep a GUI updated during a large query. +** +** The progress callback is invoked once for every N virtual machine opcodes, +** where N is the second argument to this function. The progress callback +** itself is identified by the third argument to this function. The fourth +** argument to this function is a void pointer passed to the progress callback +** function each time it is invoked. +** +** If a call to sqlite3_exec(), sqlite3_step() or sqlite3_get_table() results +** in less than N opcodes being executed, then the progress callback is not +** invoked. +** +** To remove the progress callback altogether, pass NULL as the third +** argument to this function. +** +** If the progress callback returns a result other than 0, then the current +** query is immediately terminated and any database changes rolled back. If the +** query was part of a larger transaction, then the transaction is not rolled +** back and remains active. The sqlite3_exec() call returns SQLITE_ABORT. +** +******* THIS IS AN EXPERIMENTAL API AND IS SUBJECT TO CHANGE ****** +*/ +void sqlite3_progress_handler(sqlite3*, int, int(*)(void*), void*); + +/* +** Register a callback function to be invoked whenever a new transaction +** is committed. The pArg argument is passed through to the callback. +** callback. If the callback function returns non-zero, then the commit +** is converted into a rollback. +** +** If another function was previously registered, its pArg value is returned. +** Otherwise NULL is returned. +** +** Registering a NULL function disables the callback. +** +******* THIS IS AN EXPERIMENTAL API AND IS SUBJECT TO CHANGE ****** +*/ +void *sqlite3_commit_hook(sqlite3*, int(*)(void*), void*); + +/* +** Open the sqlite database file "filename". The "filename" is UTF-8 +** encoded for sqlite3_open() and UTF-16 encoded in the native byte order +** for sqlite3_open16(). An sqlite3* handle is returned in *ppDb, even +** if an error occurs. If the database is opened (or created) successfully, +** then SQLITE_OK is returned. Otherwise an error code is returned. The +** sqlite3_errmsg() or sqlite3_errmsg16() routines can be used to obtain +** an English language description of the error. +** +** If the database file does not exist, then a new database is created. +** The encoding for the database is UTF-8 if sqlite3_open() is called and +** UTF-16 if sqlite3_open16 is used. +** +** Whether or not an error occurs when it is opened, resources associated +** with the sqlite3* handle should be released by passing it to +** sqlite3_close() when it is no longer required. +*/ +int sqlite3_open( + const char *filename, /* Database filename (UTF-8) */ + sqlite3 **ppDb /* OUT: SQLite db handle */ +); +int sqlite3_open16( + const void *filename, /* Database filename (UTF-16) */ + sqlite3 **ppDb /* OUT: SQLite db handle */ +); + +/* +** Return the error code for the most recent sqlite3_* API call associated +** with sqlite3 handle 'db'. SQLITE_OK is returned if the most recent +** API call was successful. +** +** Calls to many sqlite3_* functions set the error code and string returned +** by sqlite3_errcode(), sqlite3_errmsg() and sqlite3_errmsg16() +** (overwriting the previous values). Note that calls to sqlite3_errcode(), +** sqlite3_errmsg() and sqlite3_errmsg16() themselves do not affect the +** results of future invocations. +** +** Assuming no other intervening sqlite3_* API calls are made, the error +** code returned by this function is associated with the same error as +** the strings returned by sqlite3_errmsg() and sqlite3_errmsg16(). +*/ +int sqlite3_errcode(sqlite3 *db); + +/* +** Return a pointer to a UTF-8 encoded string describing in english the +** error condition for the most recent sqlite3_* API call. The returned +** string is always terminated by an 0x00 byte. +** +** The string "not an error" is returned when the most recent API call was +** successful. +*/ +const char *sqlite3_errmsg(sqlite3*); + +/* +** Return a pointer to a UTF-16 native byte order encoded string describing +** in english the error condition for the most recent sqlite3_* API call. +** The returned string is always terminated by a pair of 0x00 bytes. +** +** The string "not an error" is returned when the most recent API call was +** successful. +*/ +const void *sqlite3_errmsg16(sqlite3*); + +/* +** An instance of the following opaque structure is used to represent +** a compiled SQL statment. +*/ +typedef struct sqlite3_stmt sqlite3_stmt; + +/* +** To execute an SQL query, it must first be compiled into a byte-code +** program using one of the following routines. The only difference between +** them is that the second argument, specifying the SQL statement to +** compile, is assumed to be encoded in UTF-8 for the sqlite3_prepare() +** function and UTF-16 for sqlite3_prepare16(). +** +** The first parameter "db" is an SQLite database handle. The second +** parameter "zSql" is the statement to be compiled, encoded as either +** UTF-8 or UTF-16 (see above). If the next parameter, "nBytes", is less +** than zero, then zSql is read up to the first nul terminator. If +** "nBytes" is not less than zero, then it is the length of the string zSql +** in bytes (not characters). +** +** *pzTail is made to point to the first byte past the end of the first +** SQL statement in zSql. This routine only compiles the first statement +** in zSql, so *pzTail is left pointing to what remains uncompiled. +** +** *ppStmt is left pointing to a compiled SQL statement that can be +** executed using sqlite3_step(). Or if there is an error, *ppStmt may be +** set to NULL. If the input text contained no SQL (if the input is and +** empty string or a comment) then *ppStmt is set to NULL. +** +** On success, SQLITE_OK is returned. Otherwise an error code is returned. +*/ +int sqlite3_prepare( + sqlite3 *db, /* Database handle */ + const char *zSql, /* SQL statement, UTF-8 encoded */ + int nBytes, /* Length of zSql in bytes. */ + sqlite3_stmt **ppStmt, /* OUT: Statement handle */ + const char **pzTail /* OUT: Pointer to unused portion of zSql */ +); +int sqlite3_prepare16( + sqlite3 *db, /* Database handle */ + const void *zSql, /* SQL statement, UTF-16 encoded */ + int nBytes, /* Length of zSql in bytes. */ + sqlite3_stmt **ppStmt, /* OUT: Statement handle */ + const void **pzTail /* OUT: Pointer to unused portion of zSql */ +); + +/* +** Pointers to the following two opaque structures are used to communicate +** with the implementations of user-defined functions. +*/ +typedef struct sqlite3_context sqlite3_context; +typedef struct Mem sqlite3_value; + +/* +** In the SQL strings input to sqlite3_prepare() and sqlite3_prepare16(), +** one or more literals can be replace by parameters "?" or ":AAA" or +** "$VVV" where AAA is an identifer and VVV is a variable name according +** to the syntax rules of the TCL programming language. +** The value of these parameters (also called "host parameter names") can +** be set using the routines listed below. +** +** In every case, the first parameter is a pointer to the sqlite3_stmt +** structure returned from sqlite3_prepare(). The second parameter is the +** index of the parameter. The first parameter as an index of 1. For +** named parameters (":AAA" or "$VVV") you can use +** sqlite3_bind_parameter_index() to get the correct index value given +** the parameters name. If the same named parameter occurs more than +** once, it is assigned the same index each time. +** +** The fifth parameter to sqlite3_bind_blob(), sqlite3_bind_text(), and +** sqlite3_bind_text16() is a destructor used to dispose of the BLOB or +** text after SQLite has finished with it. If the fifth argument is the +** special value SQLITE_STATIC, then the library assumes that the information +** is in static, unmanaged space and does not need to be freed. If the +** fifth argument has the value SQLITE_TRANSIENT, then SQLite makes its +** own private copy of the data. +** +** The sqlite3_bind_* routine must be called before sqlite3_step() after +** an sqlite3_prepare() or sqlite3_reset(). Unbound parameterss are +** interpreted as NULL. +*/ +int sqlite3_bind_blob(sqlite3_stmt*, int, const void*, int n, void(*)(void*)); +int sqlite3_bind_double(sqlite3_stmt*, int, double); +int sqlite3_bind_int(sqlite3_stmt*, int, int); +int sqlite3_bind_int64(sqlite3_stmt*, int, sqlite_int64); +int sqlite3_bind_null(sqlite3_stmt*, int); +int sqlite3_bind_text(sqlite3_stmt*, int, const char*, int n, void(*)(void*)); +int sqlite3_bind_text16(sqlite3_stmt*, int, const void*, int, void(*)(void*)); +int sqlite3_bind_value(sqlite3_stmt*, int, const sqlite3_value*); + +/* +** Return the number of parameters in a compiled SQL statement. This +** routine was added to support DBD::SQLite. +*/ +int sqlite3_bind_parameter_count(sqlite3_stmt*); + +/* +** Return the name of the i-th parameter. Ordinary parameters "?" are +** nameless and a NULL is returned. For parameters of the form :AAA or +** $VVV the complete text of the parameter name is returned, including +** the initial ":" or "$". NULL is returned if the index is out of range. +*/ +const char *sqlite3_bind_parameter_name(sqlite3_stmt*, int); + +/* +** Return the index of a parameter with the given name. The name +** must match exactly. If no parameter with the given name is found, +** return 0. +*/ +int sqlite3_bind_parameter_index(sqlite3_stmt*, const char *zName); + +/* +** Set all the parameters in the compiled SQL statement to NULL. +*/ +int sqlite3_clear_bindings(sqlite3_stmt*); + +/* +** Return the number of columns in the result set returned by the compiled +** SQL statement. This routine returns 0 if pStmt is an SQL statement +** that does not return data (for example an UPDATE). +*/ +int sqlite3_column_count(sqlite3_stmt *pStmt); + +/* +** The first parameter is a compiled SQL statement. This function returns +** the column heading for the Nth column of that statement, where N is the +** second function parameter. The string returned is UTF-8 for +** sqlite3_column_name() and UTF-16 for sqlite3_column_name16(). +*/ +const char *sqlite3_column_name(sqlite3_stmt*,int); +const void *sqlite3_column_name16(sqlite3_stmt*,int); + +/* +** The first parameter to the following calls is a compiled SQL statement. +** These functions return information about the Nth column returned by +** the statement, where N is the second function argument. +** +** If the Nth column returned by the statement is not a column value, +** then all of the functions return NULL. Otherwise, the return the +** name of the attached database, table and column that the expression +** extracts a value from. +** +** As with all other SQLite APIs, those postfixed with "16" return UTF-16 +** encoded strings, the other functions return UTF-8. The memory containing +** the returned strings is valid until the statement handle is finalized(). +** +** These APIs are only available if the library was compiled with the +** SQLITE_ENABLE_COLUMN_METADATA preprocessor symbol defined. +*/ +const char *sqlite3_column_database_name(sqlite3_stmt*,int); +const void *sqlite3_column_database_name16(sqlite3_stmt*,int); +const char *sqlite3_column_table_name(sqlite3_stmt*,int); +const void *sqlite3_column_table_name16(sqlite3_stmt*,int); +const char *sqlite3_column_origin_name(sqlite3_stmt*,int); +const void *sqlite3_column_origin_name16(sqlite3_stmt*,int); + +/* +** The first parameter is a compiled SQL statement. If this statement +** is a SELECT statement, the Nth column of the returned result set +** of the SELECT is a table column then the declared type of the table +** column is returned. If the Nth column of the result set is not at table +** column, then a NULL pointer is returned. The returned string is always +** UTF-8 encoded. For example, in the database schema: +** +** CREATE TABLE t1(c1 VARIANT); +** +** And the following statement compiled: +** +** SELECT c1 + 1, c1 FROM t1; +** +** Then this routine would return the string "VARIANT" for the second +** result column (i==1), and a NULL pointer for the first result column +** (i==0). +*/ +const char *sqlite3_column_decltype(sqlite3_stmt *, int i); + +/* +** The first parameter is a compiled SQL statement. If this statement +** is a SELECT statement, the Nth column of the returned result set +** of the SELECT is a table column then the declared type of the table +** column is returned. If the Nth column of the result set is not at table +** column, then a NULL pointer is returned. The returned string is always +** UTF-16 encoded. For example, in the database schema: +** +** CREATE TABLE t1(c1 INTEGER); +** +** And the following statement compiled: +** +** SELECT c1 + 1, c1 FROM t1; +** +** Then this routine would return the string "INTEGER" for the second +** result column (i==1), and a NULL pointer for the first result column +** (i==0). +*/ +const void *sqlite3_column_decltype16(sqlite3_stmt*,int); + +/* +** After an SQL query has been compiled with a call to either +** sqlite3_prepare() or sqlite3_prepare16(), then this function must be +** called one or more times to execute the statement. +** +** The return value will be either SQLITE_BUSY, SQLITE_DONE, +** SQLITE_ROW, SQLITE_ERROR, or SQLITE_MISUSE. +** +** SQLITE_BUSY means that the database engine attempted to open +** a locked database and there is no busy callback registered. +** Call sqlite3_step() again to retry the open. +** +** SQLITE_DONE means that the statement has finished executing +** successfully. sqlite3_step() should not be called again on this virtual +** machine. +** +** If the SQL statement being executed returns any data, then +** SQLITE_ROW is returned each time a new row of data is ready +** for processing by the caller. The values may be accessed using +** the sqlite3_column_*() functions described below. sqlite3_step() +** is called again to retrieve the next row of data. +** +** SQLITE_ERROR means that a run-time error (such as a constraint +** violation) has occurred. sqlite3_step() should not be called again on +** the VM. More information may be found by calling sqlite3_errmsg(). +** +** SQLITE_MISUSE means that the this routine was called inappropriately. +** Perhaps it was called on a virtual machine that had already been +** finalized or on one that had previously returned SQLITE_ERROR or +** SQLITE_DONE. Or it could be the case the the same database connection +** is being used simulataneously by two or more threads. +*/ +int sqlite3_step(sqlite3_stmt*); + +/* +** Return the number of values in the current row of the result set. +** +** After a call to sqlite3_step() that returns SQLITE_ROW, this routine +** will return the same value as the sqlite3_column_count() function. +** After sqlite3_step() has returned an SQLITE_DONE, SQLITE_BUSY or +** error code, or before sqlite3_step() has been called on a +** compiled SQL statement, this routine returns zero. +*/ +int sqlite3_data_count(sqlite3_stmt *pStmt); + +/* +** Values are stored in the database in one of the following fundamental +** types. +*/ +#define SQLITE_INTEGER 1 +#define SQLITE_FLOAT 2 +/* #define SQLITE_TEXT 3 // See below */ +#define SQLITE_BLOB 4 +#define SQLITE_NULL 5 + +/* +** SQLite version 2 defines SQLITE_TEXT differently. To allow both +** version 2 and version 3 to be included, undefine them both if a +** conflict is seen. Define SQLITE3_TEXT to be the version 3 value. +*/ +#ifdef SQLITE_TEXT +# undef SQLITE_TEXT +#else +# define SQLITE_TEXT 3 +#endif +#define SQLITE3_TEXT 3 + +/* +** The next group of routines returns information about the information +** in a single column of the current result row of a query. In every +** case the first parameter is a pointer to the SQL statement that is being +** executed (the sqlite_stmt* that was returned from sqlite3_prepare()) and +** the second argument is the index of the column for which information +** should be returned. iCol is zero-indexed. The left-most column as an +** index of 0. +** +** If the SQL statement is not currently point to a valid row, or if the +** the colulmn index is out of range, the result is undefined. +** +** These routines attempt to convert the value where appropriate. For +** example, if the internal representation is FLOAT and a text result +** is requested, sprintf() is used internally to do the conversion +** automatically. The following table details the conversions that +** are applied: +** +** Internal Type Requested Type Conversion +** ------------- -------------- -------------------------- +** NULL INTEGER Result is 0 +** NULL FLOAT Result is 0.0 +** NULL TEXT Result is an empty string +** NULL BLOB Result is a zero-length BLOB +** INTEGER FLOAT Convert from integer to float +** INTEGER TEXT ASCII rendering of the integer +** INTEGER BLOB Same as for INTEGER->TEXT +** FLOAT INTEGER Convert from float to integer +** FLOAT TEXT ASCII rendering of the float +** FLOAT BLOB Same as FLOAT->TEXT +** TEXT INTEGER Use atoi() +** TEXT FLOAT Use atof() +** TEXT BLOB No change +** BLOB INTEGER Convert to TEXT then use atoi() +** BLOB FLOAT Convert to TEXT then use atof() +** BLOB TEXT Add a \000 terminator if needed +** +** The following access routines are provided: +** +** _type() Return the datatype of the result. This is one of +** SQLITE_INTEGER, SQLITE_FLOAT, SQLITE_TEXT, SQLITE_BLOB, +** or SQLITE_NULL. +** _blob() Return the value of a BLOB. +** _bytes() Return the number of bytes in a BLOB value or the number +** of bytes in a TEXT value represented as UTF-8. The \000 +** terminator is included in the byte count for TEXT values. +** _bytes16() Return the number of bytes in a BLOB value or the number +** of bytes in a TEXT value represented as UTF-16. The \u0000 +** terminator is included in the byte count for TEXT values. +** _double() Return a FLOAT value. +** _int() Return an INTEGER value in the host computer's native +** integer representation. This might be either a 32- or 64-bit +** integer depending on the host. +** _int64() Return an INTEGER value as a 64-bit signed integer. +** _text() Return the value as UTF-8 text. +** _text16() Return the value as UTF-16 text. +*/ +const void *sqlite3_column_blob(sqlite3_stmt*, int iCol); +int sqlite3_column_bytes(sqlite3_stmt*, int iCol); +int sqlite3_column_bytes16(sqlite3_stmt*, int iCol); +double sqlite3_column_double(sqlite3_stmt*, int iCol); +int sqlite3_column_int(sqlite3_stmt*, int iCol); +sqlite_int64 sqlite3_column_int64(sqlite3_stmt*, int iCol); +const unsigned char *sqlite3_column_text(sqlite3_stmt*, int iCol); +const void *sqlite3_column_text16(sqlite3_stmt*, int iCol); +int sqlite3_column_type(sqlite3_stmt*, int iCol); +int sqlite3_column_numeric_type(sqlite3_stmt*, int iCol); +sqlite3_value *sqlite3_column_value(sqlite3_stmt*, int iCol); + +/* +** The sqlite3_finalize() function is called to delete a compiled +** SQL statement obtained by a previous call to sqlite3_prepare() +** or sqlite3_prepare16(). If the statement was executed successfully, or +** not executed at all, then SQLITE_OK is returned. If execution of the +** statement failed then an error code is returned. +** +** This routine can be called at any point during the execution of the +** virtual machine. If the virtual machine has not completed execution +** when this routine is called, that is like encountering an error or +** an interrupt. (See sqlite3_interrupt().) Incomplete updates may be +** rolled back and transactions cancelled, depending on the circumstances, +** and the result code returned will be SQLITE_ABORT. +*/ +int sqlite3_finalize(sqlite3_stmt *pStmt); + +/* +** The sqlite3_reset() function is called to reset a compiled SQL +** statement obtained by a previous call to sqlite3_prepare() or +** sqlite3_prepare16() back to it's initial state, ready to be re-executed. +** Any SQL statement variables that had values bound to them using +** the sqlite3_bind_*() API retain their values. +*/ +int sqlite3_reset(sqlite3_stmt *pStmt); + +/* +** The following two functions are used to add user functions or aggregates +** implemented in C to the SQL langauge interpreted by SQLite. The +** difference only between the two is that the second parameter, the +** name of the (scalar) function or aggregate, is encoded in UTF-8 for +** sqlite3_create_function() and UTF-16 for sqlite3_create_function16(). +** +** The first argument is the database handle that the new function or +** aggregate is to be added to. If a single program uses more than one +** database handle internally, then user functions or aggregates must +** be added individually to each database handle with which they will be +** used. +** +** The third parameter is the number of arguments that the function or +** aggregate takes. If this parameter is negative, then the function or +** aggregate may take any number of arguments. +** +** The fourth parameter is one of SQLITE_UTF* values defined below, +** indicating the encoding that the function is most likely to handle +** values in. This does not change the behaviour of the programming +** interface. However, if two versions of the same function are registered +** with different encoding values, SQLite invokes the version likely to +** minimize conversions between text encodings. +** +** The seventh, eighth and ninth parameters, xFunc, xStep and xFinal, are +** pointers to user implemented C functions that implement the user +** function or aggregate. A scalar function requires an implementation of +** the xFunc callback only, NULL pointers should be passed as the xStep +** and xFinal parameters. An aggregate function requires an implementation +** of xStep and xFinal, but NULL should be passed for xFunc. To delete an +** existing user function or aggregate, pass NULL for all three function +** callback. Specifying an inconstent set of callback values, such as an +** xFunc and an xFinal, or an xStep but no xFinal, SQLITE_ERROR is +** returned. +*/ +int sqlite3_create_function( + sqlite3 *, + const char *zFunctionName, + int nArg, + int eTextRep, + void*, + void (*xFunc)(sqlite3_context*,int,sqlite3_value**), + void (*xStep)(sqlite3_context*,int,sqlite3_value**), + void (*xFinal)(sqlite3_context*) +); +int sqlite3_create_function16( + sqlite3*, + const void *zFunctionName, + int nArg, + int eTextRep, + void*, + void (*xFunc)(sqlite3_context*,int,sqlite3_value**), + void (*xStep)(sqlite3_context*,int,sqlite3_value**), + void (*xFinal)(sqlite3_context*) +); + +/* +** This function is deprecated. Do not use it. It continues to exist +** so as not to break legacy code. But new code should avoid using it. +*/ +int sqlite3_aggregate_count(sqlite3_context*); + +/* +** The next group of routines returns information about parameters to +** a user-defined function. Function implementations use these routines +** to access their parameters. These routines are the same as the +** sqlite3_column_* routines except that these routines take a single +** sqlite3_value* pointer instead of an sqlite3_stmt* and an integer +** column number. +*/ +const void *sqlite3_value_blob(sqlite3_value*); +int sqlite3_value_bytes(sqlite3_value*); +int sqlite3_value_bytes16(sqlite3_value*); +double sqlite3_value_double(sqlite3_value*); +int sqlite3_value_int(sqlite3_value*); +sqlite_int64 sqlite3_value_int64(sqlite3_value*); +const unsigned char *sqlite3_value_text(sqlite3_value*); +const void *sqlite3_value_text16(sqlite3_value*); +const void *sqlite3_value_text16le(sqlite3_value*); +const void *sqlite3_value_text16be(sqlite3_value*); +int sqlite3_value_type(sqlite3_value*); +int sqlite3_value_numeric_type(sqlite3_value*); + +/* +** Aggregate functions use the following routine to allocate +** a structure for storing their state. The first time this routine +** is called for a particular aggregate, a new structure of size nBytes +** is allocated, zeroed, and returned. On subsequent calls (for the +** same aggregate instance) the same buffer is returned. The implementation +** of the aggregate can use the returned buffer to accumulate data. +** +** The buffer allocated is freed automatically by SQLite. +*/ +void *sqlite3_aggregate_context(sqlite3_context*, int nBytes); + +/* +** The pUserData parameter to the sqlite3_create_function() +** routine used to register user functions is available to +** the implementation of the function using this call. +*/ +void *sqlite3_user_data(sqlite3_context*); + +/* +** The following two functions may be used by scalar user functions to +** associate meta-data with argument values. If the same value is passed to +** multiple invocations of the user-function during query execution, under +** some circumstances the associated meta-data may be preserved. This may +** be used, for example, to add a regular-expression matching scalar +** function. The compiled version of the regular expression is stored as +** meta-data associated with the SQL value passed as the regular expression +** pattern. +** +** Calling sqlite3_get_auxdata() returns a pointer to the meta data +** associated with the Nth argument value to the current user function +** call, where N is the second parameter. If no meta-data has been set for +** that value, then a NULL pointer is returned. +** +** The sqlite3_set_auxdata() is used to associate meta data with a user +** function argument. The third parameter is a pointer to the meta data +** to be associated with the Nth user function argument value. The fourth +** parameter specifies a 'delete function' that will be called on the meta +** data pointer to release it when it is no longer required. If the delete +** function pointer is NULL, it is not invoked. +** +** In practice, meta-data is preserved between function calls for +** expressions that are constant at compile time. This includes literal +** values and SQL variables. +*/ +void *sqlite3_get_auxdata(sqlite3_context*, int); +void sqlite3_set_auxdata(sqlite3_context*, int, void*, void (*)(void*)); + + +/* +** These are special value for the destructor that is passed in as the +** final argument to routines like sqlite3_result_blob(). If the destructor +** argument is SQLITE_STATIC, it means that the content pointer is constant +** and will never change. It does not need to be destroyed. The +** SQLITE_TRANSIENT value means that the content will likely change in +** the near future and that SQLite should make its own private copy of +** the content before returning. +*/ +#define SQLITE_STATIC ((void(*)(void *))0) +#define SQLITE_TRANSIENT ((void(*)(void *))-1) + +/* +** User-defined functions invoke the following routines in order to +** set their return value. +*/ +void sqlite3_result_blob(sqlite3_context*, const void*, int, void(*)(void*)); +void sqlite3_result_double(sqlite3_context*, double); +void sqlite3_result_error(sqlite3_context*, const char*, int); +void sqlite3_result_error16(sqlite3_context*, const void*, int); +void sqlite3_result_int(sqlite3_context*, int); +void sqlite3_result_int64(sqlite3_context*, sqlite_int64); +void sqlite3_result_null(sqlite3_context*); +void sqlite3_result_text(sqlite3_context*, const char*, int, void(*)(void*)); +void sqlite3_result_text16(sqlite3_context*, const void*, int, void(*)(void*)); +void sqlite3_result_text16le(sqlite3_context*, const void*, int,void(*)(void*)); +void sqlite3_result_text16be(sqlite3_context*, const void*, int,void(*)(void*)); +void sqlite3_result_value(sqlite3_context*, sqlite3_value*); + +/* +** These are the allowed values for the eTextRep argument to +** sqlite3_create_collation and sqlite3_create_function. +*/ +#define SQLITE_UTF8 1 +#define SQLITE_UTF16LE 2 +#define SQLITE_UTF16BE 3 +#define SQLITE_UTF16 4 /* Use native byte order */ +#define SQLITE_ANY 5 /* sqlite3_create_function only */ +#define SQLITE_UTF16_ALIGNED 8 /* sqlite3_create_collation only */ + +/* +** These two functions are used to add new collation sequences to the +** sqlite3 handle specified as the first argument. +** +** The name of the new collation sequence is specified as a UTF-8 string +** for sqlite3_create_collation() and a UTF-16 string for +** sqlite3_create_collation16(). In both cases the name is passed as the +** second function argument. +** +** The third argument must be one of the constants SQLITE_UTF8, +** SQLITE_UTF16LE or SQLITE_UTF16BE, indicating that the user-supplied +** routine expects to be passed pointers to strings encoded using UTF-8, +** UTF-16 little-endian or UTF-16 big-endian respectively. +** +** A pointer to the user supplied routine must be passed as the fifth +** argument. If it is NULL, this is the same as deleting the collation +** sequence (so that SQLite cannot call it anymore). Each time the user +** supplied function is invoked, it is passed a copy of the void* passed as +** the fourth argument to sqlite3_create_collation() or +** sqlite3_create_collation16() as its first parameter. +** +** The remaining arguments to the user-supplied routine are two strings, +** each represented by a [length, data] pair and encoded in the encoding +** that was passed as the third argument when the collation sequence was +** registered. The user routine should return negative, zero or positive if +** the first string is less than, equal to, or greater than the second +** string. i.e. (STRING1 - STRING2). +*/ +int sqlite3_create_collation( + sqlite3*, + const char *zName, + int eTextRep, + void*, + int(*xCompare)(void*,int,const void*,int,const void*) +); +int sqlite3_create_collation16( + sqlite3*, + const char *zName, + int eTextRep, + void*, + int(*xCompare)(void*,int,const void*,int,const void*) +); + +/* +** To avoid having to register all collation sequences before a database +** can be used, a single callback function may be registered with the +** database handle to be called whenever an undefined collation sequence is +** required. +** +** If the function is registered using the sqlite3_collation_needed() API, +** then it is passed the names of undefined collation sequences as strings +** encoded in UTF-8. If sqlite3_collation_needed16() is used, the names +** are passed as UTF-16 in machine native byte order. A call to either +** function replaces any existing callback. +** +** When the user-function is invoked, the first argument passed is a copy +** of the second argument to sqlite3_collation_needed() or +** sqlite3_collation_needed16(). The second argument is the database +** handle. The third argument is one of SQLITE_UTF8, SQLITE_UTF16BE or +** SQLITE_UTF16LE, indicating the most desirable form of the collation +** sequence function required. The fourth parameter is the name of the +** required collation sequence. +** +** The collation sequence is returned to SQLite by a collation-needed +** callback using the sqlite3_create_collation() or +** sqlite3_create_collation16() APIs, described above. +*/ +int sqlite3_collation_needed( + sqlite3*, + void*, + void(*)(void*,sqlite3*,int eTextRep,const char*) +); +int sqlite3_collation_needed16( + sqlite3*, + void*, + void(*)(void*,sqlite3*,int eTextRep,const void*) +); + +/* +** Specify the key for an encrypted database. This routine should be +** called right after sqlite3_open(). +** +** The code to implement this API is not available in the public release +** of SQLite. +*/ +int sqlite3_key( + sqlite3 *db, /* Database to be rekeyed */ + const void *pKey, int nKey /* The key */ +); + +/* +** Change the key on an open database. If the current database is not +** encrypted, this routine will encrypt it. If pNew==0 or nNew==0, the +** database is decrypted. +** +** The code to implement this API is not available in the public release +** of SQLite. +*/ +int sqlite3_rekey( + sqlite3 *db, /* Database to be rekeyed */ + const void *pKey, int nKey /* The new key */ +); + +/* +** Sleep for a little while. The second parameter is the number of +** miliseconds to sleep for. +** +** If the operating system does not support sleep requests with +** milisecond time resolution, then the time will be rounded up to +** the nearest second. The number of miliseconds of sleep actually +** requested from the operating system is returned. +*/ +int sqlite3_sleep(int); + +/* +** Return TRUE (non-zero) if the statement supplied as an argument needs +** to be recompiled. A statement needs to be recompiled whenever the +** execution environment changes in a way that would alter the program +** that sqlite3_prepare() generates. For example, if new functions or +** collating sequences are registered or if an authorizer function is +** added or changed. +** +*/ +int sqlite3_expired(sqlite3_stmt*); + +/* +** Move all bindings from the first prepared statement over to the second. +** This routine is useful, for example, if the first prepared statement +** fails with an SQLITE_SCHEMA error. The same SQL can be prepared into +** the second prepared statement then all of the bindings transfered over +** to the second statement before the first statement is finalized. +*/ +int sqlite3_transfer_bindings(sqlite3_stmt*, sqlite3_stmt*); + +/* +** If the following global variable is made to point to a +** string which is the name of a directory, then all temporary files +** created by SQLite will be placed in that directory. If this variable +** is NULL pointer, then SQLite does a search for an appropriate temporary +** file directory. +** +** Once sqlite3_open() has been called, changing this variable will invalidate +** the current temporary database, if any. +*/ +extern char *sqlite3_temp_directory; + +/* +** This function is called to recover from a malloc() failure that occured +** within the SQLite library. Normally, after a single malloc() fails the +** library refuses to function (all major calls return SQLITE_NOMEM). +** This function restores the library state so that it can be used again. +** +** All existing statements (sqlite3_stmt pointers) must be finalized or +** reset before this call is made. Otherwise, SQLITE_BUSY is returned. +** If any in-memory databases are in use, either as a main or TEMP +** database, SQLITE_ERROR is returned. In either of these cases, the +** library is not reset and remains unusable. +** +** This function is *not* threadsafe. Calling this from within a threaded +** application when threads other than the caller have used SQLite is +** dangerous and will almost certainly result in malfunctions. +** +** This functionality can be omitted from a build by defining the +** SQLITE_OMIT_GLOBALRECOVER at compile time. +*/ +int sqlite3_global_recover(void); + +/* +** Test to see whether or not the database connection is in autocommit +** mode. Return TRUE if it is and FALSE if not. Autocommit mode is on +** by default. Autocommit is disabled by a BEGIN statement and reenabled +** by the next COMMIT or ROLLBACK. +*/ +int sqlite3_get_autocommit(sqlite3*); + +/* +** Return the sqlite3* database handle to which the prepared statement given +** in the argument belongs. This is the same database handle that was +** the first argument to the sqlite3_prepare() that was used to create +** the statement in the first place. +*/ +sqlite3 *sqlite3_db_handle(sqlite3_stmt*); + +/* +** Register a callback function with the database connection identified by the +** first argument to be invoked whenever a row is updated, inserted or deleted. +** Any callback set by a previous call to this function for the same +** database connection is overridden. +** +** The second argument is a pointer to the function to invoke when a +** row is updated, inserted or deleted. The first argument to the callback is +** a copy of the third argument to sqlite3_update_hook. The second callback +** argument is one of SQLITE_INSERT, SQLITE_DELETE or SQLITE_UPDATE, depending +** on the operation that caused the callback to be invoked. The third and +** fourth arguments to the callback contain pointers to the database and +** table name containing the affected row. The final callback parameter is +** the rowid of the row. In the case of an update, this is the rowid after +** the update takes place. +** +** The update hook is not invoked when internal system tables are +** modified (i.e. sqlite_master and sqlite_sequence). +** +** If another function was previously registered, its pArg value is returned. +** Otherwise NULL is returned. +*/ +void *sqlite3_update_hook( + sqlite3*, + void(*)(void *,int ,char const *,char const *,sqlite_int64), + void* +); + +/* +** Register a callback to be invoked whenever a transaction is rolled +** back. +** +** The new callback function overrides any existing rollback-hook +** callback. If there was an existing callback, then it's pArg value +** (the third argument to sqlite3_rollback_hook() when it was registered) +** is returned. Otherwise, NULL is returned. +** +** For the purposes of this API, a transaction is said to have been +** rolled back if an explicit "ROLLBACK" statement is executed, or +** an error or constraint causes an implicit rollback to occur. The +** callback is not invoked if a transaction is automatically rolled +** back because the database connection is closed. +*/ +void *sqlite3_rollback_hook(sqlite3*, void(*)(void *), void*); + +/* +** This function is only available if the library is compiled without +** the SQLITE_OMIT_SHARED_CACHE macro defined. It is used to enable or +** disable (if the argument is true or false, respectively) the +** "shared pager" feature. +*/ +int sqlite3_enable_shared_cache(int); + +/* +** Attempt to free N bytes of heap memory by deallocating non-essential +** memory allocations held by the database library (example: memory +** used to cache database pages to improve performance). +** +** This function is not a part of standard builds. It is only created +** if SQLite is compiled with the SQLITE_ENABLE_MEMORY_MANAGEMENT macro. +*/ +int sqlite3_release_memory(int); + +/* +** Place a "soft" limit on the amount of heap memory that may be allocated by +** SQLite within the current thread. If an internal allocation is requested +** that would exceed the specified limit, sqlite3_release_memory() is invoked +** one or more times to free up some space before the allocation is made. +** +** The limit is called "soft", because if sqlite3_release_memory() cannot free +** sufficient memory to prevent the limit from being exceeded, the memory is +** allocated anyway and the current operation proceeds. +** +** This function is only available if the library was compiled with the +** SQLITE_ENABLE_MEMORY_MANAGEMENT option set. +** memory-management has been enabled. +*/ +void sqlite3_soft_heap_limit(int); + +/* +** This routine makes sure that all thread-local storage has been +** deallocated for the current thread. +** +** This routine is not technically necessary. All thread-local storage +** will be automatically deallocated once memory-management and +** shared-cache are disabled and the soft heap limit has been set +** to zero. This routine is provided as a convenience for users who +** want to make absolutely sure they have not forgotten something +** prior to killing off a thread. +*/ +void sqlite3_thread_cleanup(void); + +/* +** Return meta information about a specific column of a specific database +** table accessible using the connection handle passed as the first function +** argument. +** +** The column is identified by the second, third and fourth parameters to +** this function. The second parameter is either the name of the database +** (i.e. "main", "temp" or an attached database) containing the specified +** table or NULL. If it is NULL, then all attached databases are searched +** for the table using the same algorithm as the database engine uses to +** resolve unqualified table references. +** +** The third and fourth parameters to this function are the table and column +** name of the desired column, respectively. Neither of these parameters +** may be NULL. +** +** Meta information is returned by writing to the memory locations passed as +** the 5th and subsequent parameters to this function. Any of these +** arguments may be NULL, in which case the corresponding element of meta +** information is ommitted. +** +** Parameter Output Type Description +** ----------------------------------- +** +** 5th const char* Data type +** 6th const char* Name of the default collation sequence +** 7th int True if the column has a NOT NULL constraint +** 8th int True if the column is part of the PRIMARY KEY +** 9th int True if the column is AUTOINCREMENT +** +** +** The memory pointed to by the character pointers returned for the +** declaration type and collation sequence is valid only until the next +** call to any sqlite API function. +** +** If the specified table is actually a view, then an error is returned. +** +** If the specified column is "rowid", "oid" or "_rowid_" and an +** INTEGER PRIMARY KEY column has been explicitly declared, then the output +** parameters are set for the explicitly declared column. If there is no +** explicitly declared IPK column, then the output parameters are set as +** follows: +** +** data type: "INTEGER" +** collation sequence: "BINARY" +** not null: 0 +** primary key: 1 +** auto increment: 0 +** +** This function may load one or more schemas from database files. If an +** error occurs during this process, or if the requested table or column +** cannot be found, an SQLITE error code is returned and an error message +** left in the database handle (to be retrieved using sqlite3_errmsg()). +** +** This API is only available if the library was compiled with the +** SQLITE_ENABLE_COLUMN_METADATA preprocessor symbol defined. +*/ +int sqlite3_table_column_metadata( + sqlite3 *db, /* Connection handle */ + const char *zDbName, /* Database name or NULL */ + const char *zTableName, /* Table name */ + const char *zColumnName, /* Column name */ + char const **pzDataType, /* OUTPUT: Declared data type */ + char const **pzCollSeq, /* OUTPUT: Collation sequence name */ + int *pNotNull, /* OUTPUT: True if NOT NULL constraint exists */ + int *pPrimaryKey, /* OUTPUT: True if column part of PK */ + int *pAutoinc /* OUTPUT: True if colums is auto-increment */ +); + +/* +****** EXPERIMENTAL - subject to change without notice ************** +** +** Attempt to load an SQLite extension library contained in the file +** zFile. The entry point is zProc. zProc may be 0 in which case the +** name of the entry point defaults to "sqlite3_extension_init". +** +** Return SQLITE_OK on success and SQLITE_ERROR if something goes wrong. +** +** If an error occurs and pzErrMsg is not 0, then fill *pzErrMsg with +** error message text. The calling function should free this memory +** by calling sqlite3_free(). +** +** Extension loading must be enabled using sqlite3_enable_load_extension() +** prior to calling this API or an error will be returned. +** +****** EXPERIMENTAL - subject to change without notice ************** +*/ +int sqlite3_load_extension( + sqlite3 *db, /* Load the extension into this database connection */ + const char *zFile, /* Name of the shared library containing extension */ + const char *zProc, /* Entry point. Derived from zFile if 0 */ + char **pzErrMsg /* Put error message here if not 0 */ +); + +/* +** So as not to open security holes in older applications that are +** unprepared to deal with extension load, and as a means of disabling +** extension loading while executing user-entered SQL, the following +** API is provided to turn the extension loading mechanism on and +** off. It is off by default. See ticket #1863. +** +** Call this routine with onoff==1 to turn extension loading on +** and call it with onoff==0 to turn it back off again. +*/ +int sqlite3_enable_load_extension(sqlite3 *db, int onoff); + +/* +****** EXPERIMENTAL - subject to change without notice ************** +** +** Register an extension entry point that is automatically invoked +** whenever a new database connection is opened. +** +** This API can be invoked at program startup in order to register +** one or more statically linked extensions that will be available +** to all new database connections. +** +** Duplicate extensions are detected so calling this routine multiple +** times with the same extension is harmless. +** +** This routine stores a pointer to the extension in an array +** that is obtained from malloc(). If you run a memory leak +** checker on your program and it reports a leak because of this +** array, then invoke sqlite3_automatic_extension_reset() prior +** to shutdown to free the memory. +** +** Automatic extensions apply across all threads. +*/ +int sqlite3_auto_extension(void *xEntryPoint); + + +/* +****** EXPERIMENTAL - subject to change without notice ************** +** +** Disable all previously registered automatic extensions. This +** routine undoes the effect of all prior sqlite3_automatic_extension() +** calls. +** +** This call disabled automatic extensions in all threads. +*/ +void sqlite3_reset_auto_extension(void); + + +/* +****** EXPERIMENTAL - subject to change without notice ************** +** +** The interface to the virtual-table mechanism is currently considered +** to be experimental. The interface might change in incompatible ways. +** If this is a problem for you, do not use the interface at this time. +** +** When the virtual-table mechanism stablizes, we will declare the +** interface fixed, support it indefinitely, and remove this comment. +*/ + +/* +** Structures used by the virtual table interface +*/ +typedef struct sqlite3_vtab sqlite3_vtab; +typedef struct sqlite3_index_info sqlite3_index_info; +typedef struct sqlite3_vtab_cursor sqlite3_vtab_cursor; +typedef struct sqlite3_module sqlite3_module; + +/* +** A module is a class of virtual tables. Each module is defined +** by an instance of the following structure. This structure consists +** mostly of methods for the module. +*/ +struct sqlite3_module { + int iVersion; + int (*xCreate)(sqlite3*, void *pAux, + int argc, const char *const*argv, + sqlite3_vtab **ppVTab, char**); + int (*xConnect)(sqlite3*, void *pAux, + int argc, const char *const*argv, + sqlite3_vtab **ppVTab, char**); + int (*xBestIndex)(sqlite3_vtab *pVTab, sqlite3_index_info*); + int (*xDisconnect)(sqlite3_vtab *pVTab); + int (*xDestroy)(sqlite3_vtab *pVTab); + int (*xOpen)(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCursor); + int (*xClose)(sqlite3_vtab_cursor*); + int (*xFilter)(sqlite3_vtab_cursor*, int idxNum, const char *idxStr, + int argc, sqlite3_value **argv); + int (*xNext)(sqlite3_vtab_cursor*); + int (*xEof)(sqlite3_vtab_cursor*); + int (*xColumn)(sqlite3_vtab_cursor*, sqlite3_context*, int); + int (*xRowid)(sqlite3_vtab_cursor*, sqlite_int64 *pRowid); + int (*xUpdate)(sqlite3_vtab *, int, sqlite3_value **, sqlite_int64 *); + int (*xBegin)(sqlite3_vtab *pVTab); + int (*xSync)(sqlite3_vtab *pVTab); + int (*xCommit)(sqlite3_vtab *pVTab); + int (*xRollback)(sqlite3_vtab *pVTab); + int (*xFindFunction)(sqlite3_vtab *pVtab, int nArg, const char *zName, + void (**pxFunc)(sqlite3_context*,int,sqlite3_value**), + void **ppArg); +}; + +/* +** The sqlite3_index_info structure and its substructures is used to +** pass information into and receive the reply from the xBestIndex +** method of an sqlite3_module. The fields under **Inputs** are the +** inputs to xBestIndex and are read-only. xBestIndex inserts its +** results into the **Outputs** fields. +** +** The aConstraint[] array records WHERE clause constraints of the +** form: +** +** column OP expr +** +** Where OP is =, <, <=, >, or >=. The particular operator is stored +** in aConstraint[].op. The index of the column is stored in +** aConstraint[].iColumn. aConstraint[].usable is TRUE if the +** expr on the right-hand side can be evaluated (and thus the constraint +** is usable) and false if it cannot. +** +** The optimizer automatically inverts terms of the form "expr OP column" +** and makes other simplificatinos to the WHERE clause in an attempt to +** get as many WHERE clause terms into the form shown above as possible. +** The aConstraint[] array only reports WHERE clause terms in the correct +** form that refer to the particular virtual table being queried. +** +** Information about the ORDER BY clause is stored in aOrderBy[]. +** Each term of aOrderBy records a column of the ORDER BY clause. +** +** The xBestIndex method must fill aConstraintUsage[] with information +** about what parameters to pass to xFilter. If argvIndex>0 then +** the right-hand side of the corresponding aConstraint[] is evaluated +** and becomes the argvIndex-th entry in argv. If aConstraintUsage[].omit +** is true, then the constraint is assumed to be fully handled by the +** virtual table and is not checked again by SQLite. +** +** The idxNum and idxPtr values are recorded and passed into xFilter. +** sqlite3_free() is used to free idxPtr if needToFreeIdxPtr is true. +** +** The orderByConsumed means that output from xFilter will occur in +** the correct order to satisfy the ORDER BY clause so that no separate +** sorting step is required. +** +** The estimatedCost value is an estimate of the cost of doing the +** particular lookup. A full scan of a table with N entries should have +** a cost of N. A binary search of a table of N entries should have a +** cost of approximately log(N). +*/ +struct sqlite3_index_info { + /* Inputs */ + const int nConstraint; /* Number of entries in aConstraint */ + const struct sqlite3_index_constraint { + int iColumn; /* Column on left-hand side of constraint */ + unsigned char op; /* Constraint operator */ + unsigned char usable; /* True if this constraint is usable */ + int iTermOffset; /* Used internally - xBestIndex should ignore */ + } *const aConstraint; /* Table of WHERE clause constraints */ + const int nOrderBy; /* Number of terms in the ORDER BY clause */ + const struct sqlite3_index_orderby { + int iColumn; /* Column number */ + unsigned char desc; /* True for DESC. False for ASC. */ + } *const aOrderBy; /* The ORDER BY clause */ + + /* Outputs */ + struct sqlite3_index_constraint_usage { + int argvIndex; /* if >0, constraint is part of argv to xFilter */ + unsigned char omit; /* Do not code a test for this constraint */ + } *const aConstraintUsage; + int idxNum; /* Number used to identify the index */ + char *idxStr; /* String, possibly obtained from sqlite3_malloc */ + int needToFreeIdxStr; /* Free idxStr using sqlite3_free() if true */ + int orderByConsumed; /* True if output is already ordered */ + double estimatedCost; /* Estimated cost of using this index */ +}; +#define SQLITE_INDEX_CONSTRAINT_EQ 2 +#define SQLITE_INDEX_CONSTRAINT_GT 4 +#define SQLITE_INDEX_CONSTRAINT_LE 8 +#define SQLITE_INDEX_CONSTRAINT_LT 16 +#define SQLITE_INDEX_CONSTRAINT_GE 32 +#define SQLITE_INDEX_CONSTRAINT_MATCH 64 + +/* +** This routine is used to register a new module name with an SQLite +** connection. Module names must be registered before creating new +** virtual tables on the module, or before using preexisting virtual +** tables of the module. +*/ +int sqlite3_create_module( + sqlite3 *db, /* SQLite connection to register module with */ + const char *zName, /* Name of the module */ + const sqlite3_module *, /* Methods for the module */ + void * /* Client data for xCreate/xConnect */ +); + +/* +** Every module implementation uses a subclass of the following structure +** to describe a particular instance of the module. Each subclass will +** be taylored to the specific needs of the module implementation. The +** purpose of this superclass is to define certain fields that are common +** to all module implementations. +** +** Virtual tables methods can set an error message by assigning a +** string obtained from sqlite3_mprintf() to zErrMsg. The method should +** take care that any prior string is freed by a call to sqlite3_free() +** prior to assigning a new string to zErrMsg. After the error message +** is delivered up to the client application, the string will be automatically +** freed by sqlite3_free() and the zErrMsg field will be zeroed. Note +** that sqlite3_mprintf() and sqlite3_free() are used on the zErrMsg field +** since virtual tables are commonly implemented in loadable extensions which +** do not have access to sqlite3MPrintf() or sqlite3Free(). +*/ +struct sqlite3_vtab { + const sqlite3_module *pModule; /* The module for this virtual table */ + int nRef; /* Used internally */ + char *zErrMsg; /* Error message from sqlite3_mprintf() */ + /* Virtual table implementations will typically add additional fields */ +}; + +/* Every module implementation uses a subclass of the following structure +** to describe cursors that point into the virtual table and are used +** to loop through the virtual table. Cursors are created using the +** xOpen method of the module. Each module implementation will define +** the content of a cursor structure to suit its own needs. +** +** This superclass exists in order to define fields of the cursor that +** are common to all implementations. +*/ +struct sqlite3_vtab_cursor { + sqlite3_vtab *pVtab; /* Virtual table of this cursor */ + /* Virtual table implementations will typically add additional fields */ +}; + +/* +** The xCreate and xConnect methods of a module use the following API +** to declare the format (the names and datatypes of the columns) of +** the virtual tables they implement. +*/ +int sqlite3_declare_vtab(sqlite3*, const char *zCreateTable); + +/* +** Virtual tables can provide alternative implementations of functions +** using the xFindFunction method. But global versions of those functions +** must exist in order to be overloaded. +** +** This API makes sure a global version of a function with a particular +** name and number of parameters exists. If no such function exists +** before this API is called, a new function is created. The implementation +** of the new function always causes an exception to be thrown. So +** the new function is not good for anything by itself. Its only +** purpose is to be a place-holder function that can be overloaded +** by virtual tables. +** +** This API should be considered part of the virtual table interface, +** which is experimental and subject to change. +*/ +int sqlite3_overload_function(sqlite3*, const char *zFuncName, int nArg); + +/* +** The interface to the virtual-table mechanism defined above (back up +** to a comment remarkably similar to this one) is currently considered +** to be experimental. The interface might change in incompatible ways. +** If this is a problem for you, do not use the interface at this time. +** +** When the virtual-table mechanism stablizes, we will declare the +** interface fixed, support it indefinitely, and remove this comment. +** +****** EXPERIMENTAL - subject to change without notice ************** +*/ + +/* +** Undo the hack that converts floating point types to integer for +** builds on processors without floating point support. +*/ +#ifdef SQLITE_OMIT_FLOATING_POINT +# undef double +#endif + +#ifdef __cplusplus +} /* End of the 'extern "C"' block */ +#endif +#endif