-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1
-C Add\sthe\s".log"\scommand\sto\sthe\sshell.\s\sThis\sshows\sthat\ssome\serrors\sare\slogged\nmultiple\stimes\sand\sother\serrors\sare\snever\slogged\sat\sall.
-D 2010-02-23T01:47:00
+C Remove\sthe\sobsolete\ssqlite3SafetyOn()\smechanism.\s\sAdd\sadditional\slogging\noutput\sfor\sCORRUPT,\sand\sCANTOPEN\serrors.
+D 2010-02-23T17:36:33
F Makefile.arm-wince-mingw32ce-gcc fcd5e9cd67fe88836360bb4f9ef4cb7f8e2fb5a0
F Makefile.in c5827ead754ab32b9585487177c93bb00b9497b3
F Makefile.linux-gcc d53183f4aa6a9192d249731c90dbdffbd2c68654
F sqlite3.1 6be1ad09113570e1fc8dcaff84c9b0b337db5ffc
F sqlite3.pc.in ae6f59a76e862f5c561eb32a380228a02afc3cad
F src/alter.c e6f4d11b1c0b23642fc46bac9abe0753c4294e05
-F src/analyze.c 55155f05ee9ab4ce33b7a4d19c449053f8935200
-F src/attach.c f6d33268019460724e4c57aeec543eaaa55d8310
+F src/analyze.c 92a65a5a402898a52b03695c7f0cd383724d711f
+F src/attach.c d855b36c7ebe31643bb64b8f2a4f799599f57f97
F src/auth.c 523da7fb4979469955d822ff9298352d6b31de34
F src/backup.c b293534bc2df23c57668a585b17ee7faaaef0939
F src/bitvec.c 06ad2c36a9c3819c0b9cbffec7b15f58d5d834e0
F src/btmutex.c 96a12f50f7a17475155971a241d85ec5171573ff
-F src/btree.c b7ac4420d10662259ad3421145eab16a279f5bd3
+F src/btree.c ae804d16fb1ed8d3a0087b0fba2dcf37f312275c
F src/btree.h 0e193b7e90f1d78b79c79474040e3d66a553a4fa
F src/btreeInt.h 71ed5e7f009caf17b7dc304350b3cb64b5970135
F src/build.c 254a273acb8923f3bdecc933d787f4f67737c489
F src/callback.c 908f3e0172c3d4058f4ca0acd42c637c52e9669f
-F src/complete.c 4c8a742c4a4a6d9c835912648f5c8f032ea36c7b
+F src/complete.c dc1d136c0feee03c2f7550bafc0d29075e36deac
F src/date.c 485a4409a384310e6d93fd1104a9d0a8658becd9
F src/delete.c 610dc008e88a9599f905f5cbe9577ac9c36e0581
F src/expr.c d0a345e1d8995e142bc5d9f39a97b9981d7d8f23
F src/legacy.c 16f385490f377c2c80a6c7357391d499087defed
F src/lempar.c 7f026423f4d71d989e719a743f98a1cbd4e6d99e
F src/loadext.c 1c7a61ce1281041f437333f366a96aa0d29bb581
-F src/main.c 36c1c11ee2677ae247e0c947f9293749ee5ac85f
+F src/main.c fb31256305eb419c9d9ab3092cce4e8c6a065610
F src/malloc.c 5fa175797f982b178eaf38afba9c588a866be729
F src/mem0.c 6a55ebe57c46ca1a7d98da93aaa07f99f1059645
F src/mem1.c 86f33483a343873bab8ae1b648c2eac55462da74
F src/os.h 534b082c3cb349ad05fa6fa0b06087e022af282c
F src/os_common.h 240c88b163b02c21a9f21f87d49678a0aa21ff30
F src/os_os2.c 75a8c7b9a00a2cf1a65f9fa4afbc27d46634bb2f
-F src/os_unix.c 0af0a55e2dd55bc4f4c3ccf04cc8f1f4a2e2e65f
-F src/os_win.c 5ffab20249a61e0625f869efe157fa009747039b
-F src/pager.c d0e53cd301c82d3b67ee69c7b900b56e5b17070d
+F src/os_unix.c 13b5d1ffc04cc420ff9fab2938d0093e62a327bf
+F src/os_win.c 1c7453c2df4dab26d90ff6f91272aea18bcf7053
+F src/pager.c ace73a84f53a551fb8b9334205af210a29874b2c
F src/pager.h 1b32faf2e578ac3e7bcf9c9d11217128261c5c54
F src/parse.y ace5c7a125d9f2a410e431ee3209034105045f7e
F src/pcache.c 815bcb3cf0e14b23212efd3f4981f667a5fd633e
F src/pcache.h c683390d50f856d4cd8e24342ae62027d1bb6050
F src/pcache1.c 2bb2261190b42a348038f5b1c285c8cef415fcc8
F src/pragma.c 5febf8b5d88cc331effb3f2e14d0473488649b1e
-F src/prepare.c d4cd38ccfb51f1424d0e61d4878a810b7e1ebb60
+F src/prepare.c bd9e778f46d2cff460b5f238a3cc13ee0ffe1300
F src/printf.c f5c160b471e4a4dd22b756cb4ffe0c6979fd6d24
F src/random.c cd4a67b3953b88019f8cd4ccd81394a8ddfaba50
F src/resolve.c a1648d98e869937b29f4f697461fe4d60f220a7b
F src/shell.c 31cd555125a1fda4a6d8dce019690f043a8e5d75
F src/sqlite.h.in 16f33c1ceb971bfa7a04a73039947630f445146e
F src/sqlite3ext.h 69dfb8116af51b84a029cddb3b35062354270c89
-F src/sqliteInt.h d5fe1c8335b5bf376639837fa42124327cdb6767
+F src/sqliteInt.h 32e6eb47d2f6fad587e16b0abbbfe3f7d55f2ec0
F src/sqliteLimit.h 3afab2291762b5d09ae20c18feb8e9fa935a60a6
F src/status.c e651be6b30d397d86384c6867bc016e4913bcac7
F src/table.c 2cd62736f845d82200acfa1287e33feb3c15d62e
F src/trigger.c 340c9eca0fb24b1197468d96ba059f867c9834c7
F src/update.c c0dc6b75ad28b76b619042d934f337b02acee208
F src/utf.c dad16adcc0c35ef2437dca125a4b07419d361052
-F src/util.c 5b5353ff9427422b0bb89a5bc8ddf818399c0401
+F src/util.c 32a7a4ce395b818b5659ff9c1fc7eff09932ccad
F src/vacuum.c 28ee5a4963d16cf2477075d85966c0f461cd79de
-F src/vdbe.c 428411c6fbd49e9a4ce043dad87a0b079d403714
+F src/vdbe.c b0769a0751cdf7eb52311ef94d44f379ea103a72
F src/vdbe.h bea1f0cd530775bdb58a340265f3cf3ee920e9b2
F src/vdbeInt.h e276691b6835da5c0008cc5beaaecedcd7bdba8e
-F src/vdbeapi.c a8b6a6617fc9a0492e4f7d6626d3afe994ddd3f2
-F src/vdbeaux.c 8f30e619a8077ee516fa1494fa603550fa951726
-F src/vdbeblob.c 84f924700a7a889152aeebef77ca5f4e3875ffb4
+F src/vdbeapi.c c1432e2aaa97e918901a55186199e23aa9047805
+F src/vdbeaux.c 417ee0c5677188b3b72a0ccdda5668183e28bb51
+F src/vdbeblob.c 94d4715bb782b91ef183c999a4b81f4dd5494ab5
F src/vdbemem.c aeba77b59f3553d3cc5b72c18a8267c6fba546b9
F src/vdbetrace.c 864cef96919323482ebd9986f2132435115e9cc2
-F src/vtab.c 7c7713d66cda699f16bf1cc601d8d4f5070ab935
+F src/vtab.c 08df673f3341a0376037f795afbeb669d30d30a2
F src/walker.c 3112bb3afe1d85dc52317cb1d752055e9a781f8f
-F src/where.c 1041ef1174ad36679d078188510f56f2801737a5
+F src/where.c 9269ec75e1e36e69748fd918ac5a636020c85e7e
F test/aggerror.test a867e273ef9e3d7919f03ef4f0e8c0d2767944f2
F test/alias.test 4529fbc152f190268a15f9384a5651bbbabc9d87
F test/all.test 14165b3e32715b700b5f0cbf8f6e3833dda0be45
F test/rowhash.test 97f56043ba11f0679920416c0cdbc72e5272267b
F test/rowid.test e58e0acef38b527ed1b0b70d3ada588f804af287
F test/rtree.test 55466a200af3591946c5da77ad5dbfbc1e5e05f9
-F test/safety.test b69e2b2dd5d52a3f78e216967086884bbc1a09c6
F test/savepoint.test f2ede4b643ad87ead36c041c72d774a1f5c8a564
F test/savepoint2.test 427c8b20f43d3edf17a290c6788ae9e2703ac51c
F test/savepoint3.test e328085853b14898d78ceea00dfe7db18bb6a9ec
F tool/speedtest8.c 2902c46588c40b55661e471d7a86e4dd71a18224
F tool/speedtest8inst1.c 293327bc76823f473684d589a8160bde1f52c14e
F tool/vdbe-compress.tcl d70ea6d8a19e3571d7ab8c9b75cba86d1173ff0f
-P c4401fc93b66c5339422d7e765a4a32b1ef96bdb
-R 1b44bf57e7d9a663688d30603c70b44c
+P 6d910245ad0097521cf1619449cc3d202137b8b8
+R 4a55fdf9e3eb291dfcc82c0590d9deb7
U drh
-Z 75784795cda6fd26f0b8feb0805d2536
+Z 26147ac467d0ee1674ecf48b84753d80
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.4.6 (GNU/Linux)
-iD8DBQFLgzOYoxKgR168RlERAgluAJ9q3mIeRrQvfpzpmiNDDWtRun1WrQCeME9w
-x+Fdmmhc/ksLrbX58/ixhCk=
-=d2xc
+iD8DBQFLhBIkoxKgR168RlERAl/sAJ9uSxPewxWPXcY00iSJJIp+Q1yjKQCcCt45
+2X5N2P2VUOeqI8eEiWATH4s=
+=TuL6
-----END PGP SIGNATURE-----
-6d910245ad0097521cf1619449cc3d202137b8b8
\ No newline at end of file
+7c4cca6d1a23a6d1591b62f58c3716a944969947
\ No newline at end of file
if( zSql==0 ){
rc = SQLITE_NOMEM;
}else{
- (void)sqlite3SafetyOff(db);
rc = sqlite3_exec(db, zSql, analysisLoader, &sInfo, 0);
- (void)sqlite3SafetyOn(db);
sqlite3DbFree(db, zSql);
}
if( !zSql ){
rc = SQLITE_NOMEM;
}else{
- (void)sqlite3SafetyOff(db);
rc = sqlite3_prepare(db, zSql, -1, &pStmt, 0);
- (void)sqlite3SafetyOn(db);
sqlite3DbFree(db, zSql);
}
if( rc==SQLITE_OK ){
- (void)sqlite3SafetyOff(db);
while( sqlite3_step(pStmt)==SQLITE_ROW ){
char *zIndex = (char *)sqlite3_column_text(pStmt, 0);
Index *pIdx = sqlite3FindIndex(db, zIndex, sInfo.zDatabase);
}
}
rc = sqlite3_finalize(pStmt);
- (void)sqlite3SafetyOn(db);
}
}
#endif
** we found it.
*/
if( rc==SQLITE_OK ){
- (void)sqlite3SafetyOn(db);
sqlite3BtreeEnterAll(db);
rc = sqlite3Init(db, &zErrDyn);
sqlite3BtreeLeaveAll(db);
- (void)sqlite3SafetyOff(db);
}
if( rc ){
int iDb = db->nDb - 1;
if( leafData ){ i--; }
subtotal = 0;
k++;
- if( k>NB+1 ){ rc = SQLITE_CORRUPT; goto balance_cleanup; }
+ if( k>NB+1 ){ rc = SQLITE_CORRUPT_BKPT; goto balance_cleanup; }
}
}
szNew[k] = subtotal;
** Allocate k new pages. Reuse old pages where possible.
*/
if( apOld[0]->pgno<=1 ){
- rc = SQLITE_CORRUPT;
+ rc = SQLITE_CORRUPT_BKPT;
goto balance_cleanup;
}
pageFlags = apOld[0]->aData[0];
-/*\r
-** 2001 September 15\r
-**\r
-** The author disclaims copyright to this source code. In place of\r
-** a legal notice, here is a blessing:\r
-**\r
-** May you do good and not evil.\r
-** May you find forgiveness for yourself and forgive others.\r
-** May you share freely, never taking more than you give.\r
-**\r
-*************************************************************************\r
-** An tokenizer for SQL\r
-**\r
-** This file contains C code that implements the sqlite3_complete() API.\r
-** This code used to be part of the tokenizer.c source file. But by\r
-** separating it out, the code will be automatically omitted from\r
-** static links that do not use it.\r
-*/\r
-#include "sqliteInt.h"\r
-#ifndef SQLITE_OMIT_COMPLETE\r
-\r
-/*\r
-** This is defined in tokenize.c. We just have to import the definition.\r
-*/\r
-#ifndef SQLITE_AMALGAMATION\r
-#ifdef SQLITE_ASCII\r
-#define IdChar(C) ((sqlite3CtypeMap[(unsigned char)C]&0x46)!=0)\r
-#endif\r
-#ifdef SQLITE_EBCDIC\r
-extern const char sqlite3IsEbcdicIdChar[];\r
-#define IdChar(C) (((c=C)>=0x42 && sqlite3IsEbcdicIdChar[c-0x40]))\r
-#endif\r
-#endif /* SQLITE_AMALGAMATION */\r
-\r
-\r
-/*\r
-** Token types used by the sqlite3_complete() routine. See the header\r
-** comments on that procedure for additional information.\r
-*/\r
-#define tkSEMI 0\r
-#define tkWS 1\r
-#define tkOTHER 2\r
-#ifndef SQLITE_OMIT_TRIGGER\r
-#define tkEXPLAIN 3\r
-#define tkCREATE 4\r
-#define tkTEMP 5\r
-#define tkTRIGGER 6\r
-#define tkEND 7\r
-#endif\r
-\r
-/*\r
-** Return TRUE if the given SQL string ends in a semicolon.\r
-**\r
-** Special handling is require for CREATE TRIGGER statements.\r
-** Whenever the CREATE TRIGGER keywords are seen, the statement\r
-** must end with ";END;".\r
-**\r
-** This implementation uses a state machine with 8 states:\r
-**\r
-** (0) INVALID We have not yet seen a non-whitespace character.\r
-**\r
-** (1) START At the beginning or end of an SQL statement. This routine\r
-** returns 1 if it ends in the START state and 0 if it ends\r
-** in any other state.\r
-**\r
-** (2) NORMAL We are in the middle of statement which ends with a single\r
-** semicolon.\r
-**\r
-** (3) EXPLAIN The keyword EXPLAIN has been seen at the beginning of \r
-** a statement.\r
-**\r
-** (4) CREATE The keyword CREATE has been seen at the beginning of a\r
-** statement, possibly preceeded by EXPLAIN and/or followed by\r
-** TEMP or TEMPORARY\r
-**\r
-** (5) TRIGGER We are in the middle of a trigger definition that must be\r
-** ended by a semicolon, the keyword END, and another semicolon.\r
-**\r
-** (6) SEMI We've seen the first semicolon in the ";END;" that occurs at\r
-** the end of a trigger definition.\r
-**\r
-** (7) END We've seen the ";END" of the ";END;" that occurs at the end\r
-** of a trigger difinition.\r
-**\r
-** Transitions between states above are determined by tokens extracted\r
-** from the input. The following tokens are significant:\r
-**\r
-** (0) tkSEMI A semicolon.\r
-** (1) tkWS Whitespace.\r
-** (2) tkOTHER Any other SQL token.\r
-** (3) tkEXPLAIN The "explain" keyword.\r
-** (4) tkCREATE The "create" keyword.\r
-** (5) tkTEMP The "temp" or "temporary" keyword.\r
-** (6) tkTRIGGER The "trigger" keyword.\r
-** (7) tkEND The "end" keyword.\r
-**\r
-** Whitespace never causes a state transition and is always ignored.\r
-** This means that a SQL string of all whitespace is invalid.\r
-**\r
-** If we compile with SQLITE_OMIT_TRIGGER, all of the computation needed\r
-** to recognize the end of a trigger can be omitted. All we have to do\r
-** is look for a semicolon that is not part of an string or comment.\r
-*/\r
-int sqlite3_complete(const char *zSql){\r
- u8 state = 0; /* Current state, using numbers defined in header comment */\r
- u8 token; /* Value of the next token */\r
-\r
-#ifndef SQLITE_OMIT_TRIGGER\r
- /* A complex statement machine used to detect the end of a CREATE TRIGGER\r
- ** statement. This is the normal case.\r
- */\r
- static const u8 trans[8][8] = {\r
- /* Token: */\r
- /* State: ** SEMI WS OTHER EXPLAIN CREATE TEMP TRIGGER END */\r
- /* 0 INVALID: */ { 1, 0, 2, 3, 4, 2, 2, 2, },\r
- /* 1 START: */ { 1, 1, 2, 3, 4, 2, 2, 2, },\r
- /* 2 NORMAL: */ { 1, 2, 2, 2, 2, 2, 2, 2, },\r
- /* 3 EXPLAIN: */ { 1, 3, 3, 2, 4, 2, 2, 2, },\r
- /* 4 CREATE: */ { 1, 4, 2, 2, 2, 4, 5, 2, },\r
- /* 5 TRIGGER: */ { 6, 5, 5, 5, 5, 5, 5, 5, },\r
- /* 6 SEMI: */ { 6, 6, 5, 5, 5, 5, 5, 7, },\r
- /* 7 END: */ { 1, 7, 5, 5, 5, 5, 5, 5, },\r
- };\r
-#else\r
- /* If triggers are not supported by this compile then the statement machine\r
- ** used to detect the end of a statement is much simplier\r
- */\r
- static const u8 trans[3][3] = {\r
- /* Token: */\r
- /* State: ** SEMI WS OTHER */\r
- /* 0 INVALID: */ { 1, 0, 2, },\r
- /* 1 START: */ { 1, 1, 2, },\r
- /* 2 NORMAL: */ { 1, 2, 2, },\r
- };\r
-#endif /* SQLITE_OMIT_TRIGGER */\r
-\r
- while( *zSql ){\r
- switch( *zSql ){\r
- case ';': { /* A semicolon */\r
- token = tkSEMI;\r
- break;\r
- }\r
- case ' ':\r
- case '\r':\r
- case '\t':\r
- case '\n':\r
- case '\f': { /* White space is ignored */\r
- token = tkWS;\r
- break;\r
- }\r
- case '/': { /* C-style comments */\r
- if( zSql[1]!='*' ){\r
- token = tkOTHER;\r
- break;\r
- }\r
- zSql += 2;\r
- while( zSql[0] && (zSql[0]!='*' || zSql[1]!='/') ){ zSql++; }\r
- if( zSql[0]==0 ) return 0;\r
- zSql++;\r
- token = tkWS;\r
- break;\r
- }\r
- case '-': { /* SQL-style comments from "--" to end of line */\r
- if( zSql[1]!='-' ){\r
- token = tkOTHER;\r
- break;\r
- }\r
- while( *zSql && *zSql!='\n' ){ zSql++; }\r
- if( *zSql==0 ) return state==1;\r
- token = tkWS;\r
- break;\r
- }\r
- case '[': { /* Microsoft-style identifiers in [...] */\r
- zSql++;\r
- while( *zSql && *zSql!=']' ){ zSql++; }\r
- if( *zSql==0 ) return 0;\r
- token = tkOTHER;\r
- break;\r
- }\r
- case '`': /* Grave-accent quoted symbols used by MySQL */\r
- case '"': /* single- and double-quoted strings */\r
- case '\'': {\r
- int c = *zSql;\r
- zSql++;\r
- while( *zSql && *zSql!=c ){ zSql++; }\r
- if( *zSql==0 ) return 0;\r
- token = tkOTHER;\r
- break;\r
- }\r
- default: {\r
-#ifdef SQLITE_EBCDIC\r
- unsigned char c;\r
-#endif\r
- if( IdChar((u8)*zSql) ){\r
- /* Keywords and unquoted identifiers */\r
- int nId;\r
- for(nId=1; IdChar(zSql[nId]); nId++){}\r
-#ifdef SQLITE_OMIT_TRIGGER\r
- token = tkOTHER;\r
-#else\r
- switch( *zSql ){\r
- case 'c': case 'C': {\r
- if( nId==6 && sqlite3StrNICmp(zSql, "create", 6)==0 ){\r
- token = tkCREATE;\r
- }else{\r
- token = tkOTHER;\r
- }\r
- break;\r
- }\r
- case 't': case 'T': {\r
- if( nId==7 && sqlite3StrNICmp(zSql, "trigger", 7)==0 ){\r
- token = tkTRIGGER;\r
- }else if( nId==4 && sqlite3StrNICmp(zSql, "temp", 4)==0 ){\r
- token = tkTEMP;\r
- }else if( nId==9 && sqlite3StrNICmp(zSql, "temporary", 9)==0 ){\r
- token = tkTEMP;\r
- }else{\r
- token = tkOTHER;\r
- }\r
- break;\r
- }\r
- case 'e': case 'E': {\r
- if( nId==3 && sqlite3StrNICmp(zSql, "end", 3)==0 ){\r
- token = tkEND;\r
- }else\r
-#ifndef SQLITE_OMIT_EXPLAIN\r
- if( nId==7 && sqlite3StrNICmp(zSql, "explain", 7)==0 ){\r
- token = tkEXPLAIN;\r
- }else\r
-#endif\r
- {\r
- token = tkOTHER;\r
- }\r
- break;\r
- }\r
- default: {\r
- token = tkOTHER;\r
- break;\r
- }\r
- }\r
-#endif /* SQLITE_OMIT_TRIGGER */\r
- zSql += nId-1;\r
- }else{\r
- /* Operators and special symbols */\r
- token = tkOTHER;\r
- }\r
- break;\r
- }\r
- }\r
- state = trans[state][token];\r
- zSql++;\r
- }\r
- return state==1;\r
-}\r
-\r
-#ifndef SQLITE_OMIT_UTF16\r
-/*\r
-** This routine is the same as the sqlite3_complete() routine described\r
-** above, except that the parameter is required to be UTF-16 encoded, not\r
-** UTF-8.\r
-*/\r
-int sqlite3_complete16(const void *zSql){\r
- sqlite3_value *pVal;\r
- char const *zSql8;\r
- int rc = SQLITE_NOMEM;\r
-\r
-#ifndef SQLITE_OMIT_AUTOINIT\r
- rc = sqlite3_initialize();\r
- if( rc ) return rc;\r
-#endif\r
- pVal = sqlite3ValueNew(0);\r
- sqlite3ValueSetStr(pVal, -1, zSql, SQLITE_UTF16NATIVE, SQLITE_STATIC);\r
- zSql8 = sqlite3ValueText(pVal, SQLITE_UTF8);\r
- if( zSql8 ){\r
- rc = sqlite3_complete(zSql8);\r
- }else{\r
- rc = SQLITE_NOMEM;\r
- }\r
- sqlite3ValueFree(pVal);\r
- return sqlite3ApiExit(0, rc);\r
-}\r
-#endif /* SQLITE_OMIT_UTF16 */\r
-#endif /* SQLITE_OMIT_COMPLETE */\r
+/*
+** 2001 September 15
+**
+** The author disclaims copyright to this source code. In place of
+** a legal notice, here is a blessing:
+**
+** May you do good and not evil.
+** May you find forgiveness for yourself and forgive others.
+** May you share freely, never taking more than you give.
+**
+*************************************************************************
+** An tokenizer for SQL
+**
+** This file contains C code that implements the sqlite3_complete() API.
+** This code used to be part of the tokenizer.c source file. But by
+** separating it out, the code will be automatically omitted from
+** static links that do not use it.
+*/
+#include "sqliteInt.h"
+#ifndef SQLITE_OMIT_COMPLETE
+
+/*
+** This is defined in tokenize.c. We just have to import the definition.
+*/
+#ifndef SQLITE_AMALGAMATION
+#ifdef SQLITE_ASCII
+#define IdChar(C) ((sqlite3CtypeMap[(unsigned char)C]&0x46)!=0)
+#endif
+#ifdef SQLITE_EBCDIC
+extern const char sqlite3IsEbcdicIdChar[];
+#define IdChar(C) (((c=C)>=0x42 && sqlite3IsEbcdicIdChar[c-0x40]))
+#endif
+#endif /* SQLITE_AMALGAMATION */
+
+
+/*
+** Token types used by the sqlite3_complete() routine. See the header
+** comments on that procedure for additional information.
+*/
+#define tkSEMI 0
+#define tkWS 1
+#define tkOTHER 2
+#ifndef SQLITE_OMIT_TRIGGER
+#define tkEXPLAIN 3
+#define tkCREATE 4
+#define tkTEMP 5
+#define tkTRIGGER 6
+#define tkEND 7
+#endif
+
+/*
+** Return TRUE if the given SQL string ends in a semicolon.
+**
+** Special handling is require for CREATE TRIGGER statements.
+** Whenever the CREATE TRIGGER keywords are seen, the statement
+** must end with ";END;".
+**
+** This implementation uses a state machine with 8 states:
+**
+** (0) INVALID We have not yet seen a non-whitespace character.
+**
+** (1) START At the beginning or end of an SQL statement. This routine
+** returns 1 if it ends in the START state and 0 if it ends
+** in any other state.
+**
+** (2) NORMAL We are in the middle of statement which ends with a single
+** semicolon.
+**
+** (3) EXPLAIN The keyword EXPLAIN has been seen at the beginning of
+** a statement.
+**
+** (4) CREATE The keyword CREATE has been seen at the beginning of a
+** statement, possibly preceeded by EXPLAIN and/or followed by
+** TEMP or TEMPORARY
+**
+** (5) TRIGGER We are in the middle of a trigger definition that must be
+** ended by a semicolon, the keyword END, and another semicolon.
+**
+** (6) SEMI We've seen the first semicolon in the ";END;" that occurs at
+** the end of a trigger definition.
+**
+** (7) END We've seen the ";END" of the ";END;" that occurs at the end
+** of a trigger difinition.
+**
+** Transitions between states above are determined by tokens extracted
+** from the input. The following tokens are significant:
+**
+** (0) tkSEMI A semicolon.
+** (1) tkWS Whitespace.
+** (2) tkOTHER Any other SQL token.
+** (3) tkEXPLAIN The "explain" keyword.
+** (4) tkCREATE The "create" keyword.
+** (5) tkTEMP The "temp" or "temporary" keyword.
+** (6) tkTRIGGER The "trigger" keyword.
+** (7) tkEND The "end" keyword.
+**
+** Whitespace never causes a state transition and is always ignored.
+** This means that a SQL string of all whitespace is invalid.
+**
+** If we compile with SQLITE_OMIT_TRIGGER, all of the computation needed
+** to recognize the end of a trigger can be omitted. All we have to do
+** is look for a semicolon that is not part of an string or comment.
+*/
+int sqlite3_complete(const char *zSql){
+ u8 state = 0; /* Current state, using numbers defined in header comment */
+ u8 token; /* Value of the next token */
+
+#ifndef SQLITE_OMIT_TRIGGER
+ /* A complex statement machine used to detect the end of a CREATE TRIGGER
+ ** statement. This is the normal case.
+ */
+ static const u8 trans[8][8] = {
+ /* Token: */
+ /* State: ** SEMI WS OTHER EXPLAIN CREATE TEMP TRIGGER END */
+ /* 0 INVALID: */ { 1, 0, 2, 3, 4, 2, 2, 2, },
+ /* 1 START: */ { 1, 1, 2, 3, 4, 2, 2, 2, },
+ /* 2 NORMAL: */ { 1, 2, 2, 2, 2, 2, 2, 2, },
+ /* 3 EXPLAIN: */ { 1, 3, 3, 2, 4, 2, 2, 2, },
+ /* 4 CREATE: */ { 1, 4, 2, 2, 2, 4, 5, 2, },
+ /* 5 TRIGGER: */ { 6, 5, 5, 5, 5, 5, 5, 5, },
+ /* 6 SEMI: */ { 6, 6, 5, 5, 5, 5, 5, 7, },
+ /* 7 END: */ { 1, 7, 5, 5, 5, 5, 5, 5, },
+ };
+#else
+ /* If triggers are not supported by this compile then the statement machine
+ ** used to detect the end of a statement is much simplier
+ */
+ static const u8 trans[3][3] = {
+ /* Token: */
+ /* State: ** SEMI WS OTHER */
+ /* 0 INVALID: */ { 1, 0, 2, },
+ /* 1 START: */ { 1, 1, 2, },
+ /* 2 NORMAL: */ { 1, 2, 2, },
+ };
+#endif /* SQLITE_OMIT_TRIGGER */
+
+ while( *zSql ){
+ switch( *zSql ){
+ case ';': { /* A semicolon */
+ token = tkSEMI;
+ break;
+ }
+ case ' ':
+ case '\r':
+ case '\t':
+ case '\n':
+ case '\f': { /* White space is ignored */
+ token = tkWS;
+ break;
+ }
+ case '/': { /* C-style comments */
+ if( zSql[1]!='*' ){
+ token = tkOTHER;
+ break;
+ }
+ zSql += 2;
+ while( zSql[0] && (zSql[0]!='*' || zSql[1]!='/') ){ zSql++; }
+ if( zSql[0]==0 ) return 0;
+ zSql++;
+ token = tkWS;
+ break;
+ }
+ case '-': { /* SQL-style comments from "--" to end of line */
+ if( zSql[1]!='-' ){
+ token = tkOTHER;
+ break;
+ }
+ while( *zSql && *zSql!='\n' ){ zSql++; }
+ if( *zSql==0 ) return state==1;
+ token = tkWS;
+ break;
+ }
+ case '[': { /* Microsoft-style identifiers in [...] */
+ zSql++;
+ while( *zSql && *zSql!=']' ){ zSql++; }
+ if( *zSql==0 ) return 0;
+ token = tkOTHER;
+ break;
+ }
+ case '`': /* Grave-accent quoted symbols used by MySQL */
+ case '"': /* single- and double-quoted strings */
+ case '\'': {
+ int c = *zSql;
+ zSql++;
+ while( *zSql && *zSql!=c ){ zSql++; }
+ if( *zSql==0 ) return 0;
+ token = tkOTHER;
+ break;
+ }
+ default: {
+#ifdef SQLITE_EBCDIC
+ unsigned char c;
+#endif
+ if( IdChar((u8)*zSql) ){
+ /* Keywords and unquoted identifiers */
+ int nId;
+ for(nId=1; IdChar(zSql[nId]); nId++){}
+#ifdef SQLITE_OMIT_TRIGGER
+ token = tkOTHER;
+#else
+ switch( *zSql ){
+ case 'c': case 'C': {
+ if( nId==6 && sqlite3StrNICmp(zSql, "create", 6)==0 ){
+ token = tkCREATE;
+ }else{
+ token = tkOTHER;
+ }
+ break;
+ }
+ case 't': case 'T': {
+ if( nId==7 && sqlite3StrNICmp(zSql, "trigger", 7)==0 ){
+ token = tkTRIGGER;
+ }else if( nId==4 && sqlite3StrNICmp(zSql, "temp", 4)==0 ){
+ token = tkTEMP;
+ }else if( nId==9 && sqlite3StrNICmp(zSql, "temporary", 9)==0 ){
+ token = tkTEMP;
+ }else{
+ token = tkOTHER;
+ }
+ break;
+ }
+ case 'e': case 'E': {
+ if( nId==3 && sqlite3StrNICmp(zSql, "end", 3)==0 ){
+ token = tkEND;
+ }else
+#ifndef SQLITE_OMIT_EXPLAIN
+ if( nId==7 && sqlite3StrNICmp(zSql, "explain", 7)==0 ){
+ token = tkEXPLAIN;
+ }else
+#endif
+ {
+ token = tkOTHER;
+ }
+ break;
+ }
+ default: {
+ token = tkOTHER;
+ break;
+ }
+ }
+#endif /* SQLITE_OMIT_TRIGGER */
+ zSql += nId-1;
+ }else{
+ /* Operators and special symbols */
+ token = tkOTHER;
+ }
+ break;
+ }
+ }
+ state = trans[state][token];
+ zSql++;
+ }
+ return state==1;
+}
+
+#ifndef SQLITE_OMIT_UTF16
+/*
+** This routine is the same as the sqlite3_complete() routine described
+** above, except that the parameter is required to be UTF-16 encoded, not
+** UTF-8.
+*/
+int sqlite3_complete16(const void *zSql){
+ sqlite3_value *pVal;
+ char const *zSql8;
+ int rc = SQLITE_NOMEM;
+
+#ifndef SQLITE_OMIT_AUTOINIT
+ rc = sqlite3_initialize();
+ if( rc ) return rc;
+#endif
+ pVal = sqlite3ValueNew(0);
+ sqlite3ValueSetStr(pVal, -1, zSql, SQLITE_UTF16NATIVE, SQLITE_STATIC);
+ zSql8 = sqlite3ValueText(pVal, SQLITE_UTF8);
+ if( zSql8 ){
+ rc = sqlite3_complete(zSql8);
+ }else{
+ rc = SQLITE_NOMEM;
+ }
+ sqlite3ValueFree(pVal);
+ return sqlite3ApiExit(0, rc);
+}
+#endif /* SQLITE_OMIT_UTF16 */
+#endif /* SQLITE_OMIT_COMPLETE */
return db->autoCommit;
}
-#ifdef SQLITE_DEBUG
/*
-** The following routine is subtituted for constant SQLITE_CORRUPT in
-** debugging builds. This provides a way to set a breakpoint for when
-** corruption is first detected.
+** The following routines are subtitutes for constants SQLITE_CORRUPT,
+** SQLITE_MISUSE, SQLITE_CANTOPEN, SQLITE_IOERR and possibly other error
+** constants. They server two purposes:
+**
+** 1. Serve as a convenient place to set a breakpoint in a debugger
+** to detect when version error conditions occurs.
+**
+** 2. Invoke sqlite3_log() to provide the source code location where
+** a low-level error is first detected.
*/
-int sqlite3Corrupt(void){
+int sqlite3CorruptError(int lineno){
+ sqlite3_log(SQLITE_CORRUPT,
+ "database corruption found by source line %d", lineno);
return SQLITE_CORRUPT;
}
-#endif
+int sqlite3MisuseError(int lineno){
+ sqlite3_log(SQLITE_MISUSE, "misuse detected by source line %d", lineno);
+ return SQLITE_MISUSE;
+}
+int sqlite3CantopenError(int lineno){
+ sqlite3_log(SQLITE_CANTOPEN, "cannot open file at source line %d", lineno);
+ return SQLITE_CANTOPEN;
+}
+
#ifndef SQLITE_OMIT_DEPRECATED
/*
/* Ensure the database schema has been loaded */
sqlite3_mutex_enter(db->mutex);
- (void)sqlite3SafetyOn(db);
sqlite3BtreeEnterAll(db);
rc = sqlite3Init(db, &zErrMsg);
if( SQLITE_OK!=rc ){
error_out:
sqlite3BtreeLeaveAll(db);
- (void)sqlite3SafetyOff(db);
/* Whether the function call succeeded or failed, set the output parameters
** to whatever their local counterparts contain. If an error did occur,
}
}
*pFd = fd;
- return (fd>=0?SQLITE_OK:SQLITE_CANTOPEN);
+ return (fd>=0?SQLITE_OK:SQLITE_CANTOPEN_BKPT);
}
/*
fd = open(zName, openFlags, openMode);
}
if( fd<0 ){
- rc = SQLITE_CANTOPEN;
+ rc = SQLITE_CANTOPEN_BKPT;
goto open_finished;
}
}
}else{
int nCwd;
if( getcwd(zOut, nOut-1)==0 ){
- return SQLITE_CANTOPEN;
+ return SQLITE_CANTOPEN_BKPT;
}
nCwd = (int)strlen(zOut);
sqlite3_snprintf(nOut-nCwd, &zOut[nCwd], "/%s", zPath);
case EIO:
return SQLITE_IOERR_LOCK; /* even though it is the conch */
default:
- return SQLITE_CANTOPEN;
+ return SQLITE_CANTOPEN_BKPT;
}
}
if( fd>=0 ){
pFile->h = fd;
}else{
- rc=SQLITE_CANTOPEN; /* SQLITE_BUSY? proxyTakeConch called
+ rc=SQLITE_CANTOPEN_BKPT; /* SQLITE_BUSY? proxyTakeConch called
during locking */
}
}
return winOpen(pVfs, zName, id,
((flags|SQLITE_OPEN_READONLY)&~SQLITE_OPEN_READWRITE), pOutFlags);
}else{
- return SQLITE_CANTOPEN;
+ return SQLITE_CANTOPEN_BKPT;
}
}
if( pOutFlags ){
){
CloseHandle(h);
free(zConverted);
- return SQLITE_CANTOPEN;
+ return SQLITE_CANTOPEN_BKPT;
}
if( isTemp ){
pFile->zDeleteOnClose = zConverted;
** as it will not be possible to open the journal file or even
** check for a hot-journal before reading.
*/
- rc = SQLITE_CANTOPEN;
+ rc = SQLITE_CANTOPEN_BKPT;
}
if( rc!=SQLITE_OK ){
sqlite3_free(zPathname);
rc = sqlite3OsOpen(pVfs, pPager->zJournal, pPager->jfd, f, &fout);
assert( rc!=SQLITE_OK || isOpen(pPager->jfd) );
if( rc==SQLITE_OK && fout&SQLITE_OPEN_READONLY ){
- rc = SQLITE_CANTOPEN;
+ rc = SQLITE_CANTOPEN_BKPT;
sqlite3OsClose(pPager->jfd);
}
}else{
initData.iDb = iDb;
initData.rc = SQLITE_OK;
initData.pzErrMsg = pzErrMsg;
- (void)sqlite3SafetyOff(db);
sqlite3InitCallback(&initData, 3, (char **)azArg, 0);
- (void)sqlite3SafetyOn(db);
if( initData.rc ){
rc = initData.rc;
goto error_out;
zSql = sqlite3MPrintf(db,
"SELECT name, rootpage, sql FROM '%q'.%s ORDER BY rowid",
db->aDb[iDb].zName, zMasterName);
- (void)sqlite3SafetyOff(db);
#ifndef SQLITE_OMIT_AUTHORIZATION
{
int (*xAuth)(void*,int,const char*,const char*,const char*,const char*);
}
#endif
if( rc==SQLITE_OK ) rc = initData.rc;
- (void)sqlite3SafetyOn(db);
sqlite3DbFree(db, zSql);
#ifndef SQLITE_OMIT_ANALYZE
if( rc==SQLITE_OK ){
goto end_prepare;
}
pParse->pReprepare = pReprepare;
-
- if( sqlite3SafetyOn(db) ){
- rc = SQLITE_MISUSE;
- goto end_prepare;
- }
assert( ppStmt && *ppStmt==0 );
assert( !db->mallocFailed );
assert( sqlite3_mutex_held(db->mutex) );
if( rc ){
const char *zDb = db->aDb[i].zName;
sqlite3Error(db, rc, "database schema is locked: %s", zDb);
- (void)sqlite3SafetyOff(db);
testcase( db->flags & SQLITE_ReadUncommitted );
goto end_prepare;
}
testcase( nBytes==mxLen+1 );
if( nBytes>mxLen ){
sqlite3Error(db, SQLITE_TOOBIG, "statement too long");
- (void)sqlite3SafetyOff(db);
rc = sqlite3ApiExit(db, SQLITE_TOOBIG);
goto end_prepare;
}
}
#endif
- if( sqlite3SafetyOff(db) ){
- rc = SQLITE_MISUSE;
- }
-
assert( db->init.busy==0 || saveSqlFlag==0 );
if( db->init.busy==0 ){
Vdbe *pVdbe = pParse->pVdbe;
}
/*
-** The SQLITE_CORRUPT_BKPT macro can be either a constant (for production
-** builds) or a function call (for debugging). If it is a function call,
-** it allows the operator to set a breakpoint at the spot where database
-** corruption is first detected.
+** The SQLITE_*_BKPT macros are substitutes for the error codes with
+** the same name but without the _BKPT suffix. These macros invoke
+** routines that report the line-number on which the error originated
+** using sqlite3_log(). The routines also provide a convenient place
+** to set a debugger breakpoint.
*/
-#ifdef SQLITE_DEBUG
- int sqlite3Corrupt(void);
-# define SQLITE_CORRUPT_BKPT sqlite3Corrupt()
-#else
-# define SQLITE_CORRUPT_BKPT SQLITE_CORRUPT
-#endif
+int sqlite3CorruptError(int);
+int sqlite3MisuseError(int);
+int sqlite3CantopenError(int);
+#define SQLITE_CORRUPT_BKPT sqlite3CorruptError(__LINE__)
+#define SQLITE_MISUSE_BKPT sqlite3MisuseError(__LINE__)
+#define SQLITE_CANTOPEN_BKPT sqlite3CantopenError(__LINE__)
+
/*
** FTS4 is really an extension for FTS3. It is enabled using the
void sqlite3RegisterBuiltinFunctions(sqlite3*);
void sqlite3RegisterDateTimeFunctions(void);
void sqlite3RegisterGlobalFunctions(void);
-#ifdef SQLITE_DEBUG
- int sqlite3SafetyOn(sqlite3*);
- int sqlite3SafetyOff(sqlite3*);
-#else
-# define sqlite3SafetyOn(A) 0
-# define sqlite3SafetyOff(A) 0
-#endif
int sqlite3SafetyCheckOk(sqlite3*);
int sqlite3SafetyCheckSickOrOk(sqlite3*);
void sqlite3ChangeCookie(Parse*, int);
va_start(ap, zFormat);
z = sqlite3VMPrintf(db, zFormat, ap);
va_end(ap);
- sqlite3_log(err_code, "%s", z);
sqlite3ValueSetStr(db->pErr, -1, z, SQLITE_UTF8, SQLITE_DYNAMIC);
}else{
sqlite3ValueSetStr(db->pErr, 0, 0, SQLITE_UTF8, SQLITE_STATIC);
#endif /* !SQLITE_OMIT_BLOB_LITERAL || SQLITE_HAS_CODEC */
-/*
-** Change the sqlite.magic from SQLITE_MAGIC_OPEN to SQLITE_MAGIC_BUSY.
-** Return an error (non-zero) if the magic was not SQLITE_MAGIC_OPEN
-** when this routine is called.
-**
-** This routine is called when entering an SQLite API. The SQLITE_MAGIC_OPEN
-** value indicates that the database connection passed into the API is
-** open and is not being used by another thread. By changing the value
-** to SQLITE_MAGIC_BUSY we indicate that the connection is in use.
-** sqlite3SafetyOff() below will change the value back to SQLITE_MAGIC_OPEN
-** when the API exits.
-**
-** This routine is a attempt to detect if two threads use the
-** same sqlite* pointer at the same time. There is a race
-** condition so it is possible that the error is not detected.
-** But usually the problem will be seen. The result will be an
-** error which can be used to debug the application that is
-** using SQLite incorrectly.
-**
-** Ticket #202: If db->magic is not a valid open value, take care not
-** to modify the db structure at all. It could be that db is a stale
-** pointer. In other words, it could be that there has been a prior
-** call to sqlite3_close(db) and db has been deallocated. And we do
-** not want to write into deallocated memory.
-*/
-#ifdef SQLITE_DEBUG
-int sqlite3SafetyOn(sqlite3 *db){
- if( db->magic==SQLITE_MAGIC_OPEN ){
- db->magic = SQLITE_MAGIC_BUSY;
- assert( sqlite3_mutex_held(db->mutex) );
- return 0;
- }else if( db->magic==SQLITE_MAGIC_BUSY ){
- db->magic = SQLITE_MAGIC_ERROR;
- db->u1.isInterrupted = 1;
- }
- return 1;
-}
-#endif
-
-/*
-** Change the magic from SQLITE_MAGIC_BUSY to SQLITE_MAGIC_OPEN.
-** Return an error (non-zero) if the magic was not SQLITE_MAGIC_BUSY
-** when this routine is called.
-*/
-#ifdef SQLITE_DEBUG
-int sqlite3SafetyOff(sqlite3 *db){
- if( db->magic==SQLITE_MAGIC_BUSY ){
- db->magic = SQLITE_MAGIC_OPEN;
- assert( sqlite3_mutex_held(db->mutex) );
- return 0;
- }else{
- db->magic = SQLITE_MAGIC_ERROR;
- db->u1.isInterrupted = 1;
- return 1;
- }
-}
-#endif
-
/*
** Check to make sure we have a valid db pointer. This test is not
** foolproof but it does provide some measure of protection against
u32 magic;
if( db==0 ) return 0;
magic = db->magic;
- if( magic!=SQLITE_MAGIC_OPEN
-#ifdef SQLITE_DEBUG
- && magic!=SQLITE_MAGIC_BUSY
-#endif
- ){
+ if( magic!=SQLITE_MAGIC_OPEN ){
return 0;
}else{
return 1;
/*** INSERT STACK UNION HERE ***/
assert( p->magic==VDBE_MAGIC_RUN ); /* sqlite3_step() verifies this */
- assert( db->magic==SQLITE_MAGIC_BUSY );
sqlite3VdbeMutexArrayEnter(p);
if( p->rc==SQLITE_NOMEM ){
/* This happens if a malloc() inside a call to sqlite3_column_text() or
if( checkProgress ){
if( db->nProgressOps==nProgressOps ){
int prc;
- if( sqlite3SafetyOff(db) ) goto abort_due_to_misuse;
- prc =db->xProgress(db->pProgressArg);
- if( sqlite3SafetyOn(db) ) goto abort_due_to_misuse;
+ prc = db->xProgress(db->pProgressArg);
if( prc!=0 ){
rc = SQLITE_INTERRUPT;
goto vdbe_error_halt;
assert( pOp[-1].opcode==OP_CollSeq );
ctx.pColl = pOp[-1].p4.pColl;
}
- if( sqlite3SafetyOff(db) ) goto abort_due_to_misuse;
(*ctx.pFunc->xFunc)(&ctx, n, apVal);
- if( sqlite3SafetyOn(db) ){
- sqlite3VdbeMemRelease(&ctx.s);
- goto abort_due_to_misuse;
- }
if( db->mallocFailed ){
/* Even though a malloc() has failed, the implementation of the
** user function may have called an sqlite3_result_XXX() function
** to return a value. The following call releases any resources
** associated with such a value.
- **
- ** Note: Maybe MemRelease() should be called if sqlite3SafetyOn()
- ** fails also (the if(...) statement above). But if people are
- ** misusing sqlite, they have bigger problems than a leaked value.
*/
sqlite3VdbeMemRelease(&ctx.s);
goto no_mem;
pVtab = pC->pVtabCursor->pVtab;
pModule = pVtab->pModule;
assert( pModule->xRowid );
- if( sqlite3SafetyOff(db) ) goto abort_due_to_misuse;
rc = pModule->xRowid(pC->pVtabCursor, &v);
sqlite3DbFree(db, p->zErrMsg);
p->zErrMsg = pVtab->zErrMsg;
pVtab->zErrMsg = 0;
- if( sqlite3SafetyOn(db) ) goto abort_due_to_misuse;
#endif /* SQLITE_OMIT_VIRTUALTABLE */
}else{
assert( pC->pCursor!=0 );
if( zSql==0 ){
rc = SQLITE_NOMEM;
}else{
- (void)sqlite3SafetyOff(db);
assert( db->init.busy==0 );
db->init.busy = 1;
initData.rc = SQLITE_OK;
if( rc==SQLITE_OK ) rc = initData.rc;
sqlite3DbFree(db, zSql);
db->init.busy = 0;
- (void)sqlite3SafetyOn(db);
}
}
sqlite3BtreeLeaveAll(db);
** a transaction.
*/
case OP_Vacuum: {
- if( sqlite3SafetyOff(db) ) goto abort_due_to_misuse;
rc = sqlite3RunVacuum(&p->zErrMsg, db);
- if( sqlite3SafetyOn(db) ) goto abort_due_to_misuse;
break;
}
#endif
pVtab = pOp->p4.pVtab->pVtab;
pModule = (sqlite3_module *)pVtab->pModule;
assert(pVtab && pModule);
- if( sqlite3SafetyOff(db) ) goto abort_due_to_misuse;
rc = pModule->xOpen(pVtab, &pVtabCursor);
sqlite3DbFree(db, p->zErrMsg);
p->zErrMsg = pVtab->zErrMsg;
pVtab->zErrMsg = 0;
- if( sqlite3SafetyOn(db) ) goto abort_due_to_misuse;
if( SQLITE_OK==rc ){
/* Initialize sqlite3_vtab_cursor base class */
pVtabCursor->pVtab = pVtab;
sqlite3VdbeMemStoreType(apArg[i]);
}
- if( sqlite3SafetyOff(db) ) goto abort_due_to_misuse;
p->inVtabMethod = 1;
rc = pModule->xFilter(pVtabCursor, iQuery, pOp->p4.z, nArg, apArg);
p->inVtabMethod = 0;
if( rc==SQLITE_OK ){
res = pModule->xEof(pVtabCursor);
}
- if( sqlite3SafetyOn(db) ) goto abort_due_to_misuse;
if( res ){
pc = pOp->p2 - 1;
sqlite3VdbeMemMove(&sContext.s, pDest);
MemSetTypeFlag(&sContext.s, MEM_Null);
- if( sqlite3SafetyOff(db) ) goto abort_due_to_misuse;
rc = pModule->xColumn(pCur->pVtabCursor, &sContext, pOp->p2);
sqlite3DbFree(db, p->zErrMsg);
p->zErrMsg = pVtab->zErrMsg;
REGISTER_TRACE(pOp->p3, pDest);
UPDATE_MAX_BLOBSIZE(pDest);
- if( sqlite3SafetyOn(db) ){
- goto abort_due_to_misuse;
- }
if( sqlite3VdbeMemTooBig(pDest) ){
goto too_big;
}
** data is available) and the error code returned when xColumn or
** some other method is next invoked on the save virtual table cursor.
*/
- if( sqlite3SafetyOff(db) ) goto abort_due_to_misuse;
p->inVtabMethod = 1;
rc = pModule->xNext(pCur->pVtabCursor);
p->inVtabMethod = 0;
if( rc==SQLITE_OK ){
res = pModule->xEof(pCur->pVtabCursor);
}
- if( sqlite3SafetyOn(db) ) goto abort_due_to_misuse;
if( !res ){
/* If there is data, jump to P2 */
assert( pVtab->pModule->xRename );
REGISTER_TRACE(pOp->p1, pName);
assert( pName->flags & MEM_Str );
- if( sqlite3SafetyOff(db) ) goto abort_due_to_misuse;
rc = pVtab->pModule->xRename(pVtab, pName->z);
sqlite3DbFree(db, p->zErrMsg);
p->zErrMsg = pVtab->zErrMsg;
pVtab->zErrMsg = 0;
- if( sqlite3SafetyOn(db) ) goto abort_due_to_misuse;
break;
}
apArg[i] = pX;
pX++;
}
- if( sqlite3SafetyOff(db) ) goto abort_due_to_misuse;
rc = pModule->xUpdate(pVtab, nArg, apArg, &rowid);
sqlite3DbFree(db, p->zErrMsg);
p->zErrMsg = pVtab->zErrMsg;
pVtab->zErrMsg = 0;
- if( sqlite3SafetyOn(db) ) goto abort_due_to_misuse;
if( rc==SQLITE_OK && pOp->p1 ){
assert( nArg>1 && apArg[0] && (apArg[0]->flags&MEM_Null) );
db->lastRowid = rowid;
rc = SQLITE_ERROR;
goto end_of_step;
}
- if( sqlite3SafetyOn(db) ){
- p->rc = SQLITE_MISUSE;
- return SQLITE_MISUSE;
- }
if( p->pc<0 ){
/* If there are no other statements currently running, then
** reset the interrupt flag. This prevents a call to sqlite3_interrupt
rc = sqlite3VdbeExec(p);
}
- if( sqlite3SafetyOff(db) ){
- rc = SQLITE_MISUSE;
- }
-
#ifndef SQLITE_OMIT_TRACE
/* Invoke the profile callback if there is one
*/
assert( p->explain );
assert( p->magic==VDBE_MAGIC_RUN );
- assert( db->magic==SQLITE_MAGIC_BUSY );
assert( p->rc==SQLITE_OK || p->rc==SQLITE_BUSY || p->rc==SQLITE_NOMEM );
/* Even though this opcode does not use dynamic strings for
sqlite3_vtab_cursor *pVtabCursor = pCx->pVtabCursor;
const sqlite3_module *pModule = pCx->pModule;
p->inVtabMethod = 1;
- (void)sqlite3SafetyOff(p->db);
pModule->xClose(pVtabCursor);
- (void)sqlite3SafetyOn(p->db);
p->inVtabMethod = 0;
}
#endif
/* If there are any write-transactions at all, invoke the commit hook */
if( needXcommit && db->xCommitCallback ){
- (void)sqlite3SafetyOff(db);
rc = db->xCommitCallback(db->pCommitArg);
- (void)sqlite3SafetyOn(db);
if( rc ){
return SQLITE_CONSTRAINT;
}
** error, then it might not have been halted properly. So halt
** it now.
*/
- (void)sqlite3SafetyOn(db);
sqlite3VdbeHalt(p);
- (void)sqlite3SafetyOff(db);
/* If the VDBE has be run even partially, then transfer the error code
** and error message from the VDBE into the main database structure. But
** that btreeParseCellPtr() and sqlite3GetVarint32() are implemented */
if( nCellKey<=0 || nCellKey>0x7fffffff ){
*res = 0;
- return SQLITE_CORRUPT;
+ return SQLITE_CORRUPT_BKPT;
}
memset(&m, 0, sizeof(m));
rc = sqlite3VdbeMemFromBtree(pC->pCursor, 0, (int)nCellKey, 1, &m);
memset(pParse, 0, sizeof(Parse));
pParse->db = db;
- if( sqlite3SafetyOn(db) ){
- sqlite3DbFree(db, zErr);
- sqlite3StackFree(db, pParse);
- sqlite3_mutex_leave(db->mutex);
- return SQLITE_MISUSE;
- }
-
sqlite3BtreeEnterAll(db);
pTab = sqlite3LocateTable(pParse, 0, zTable, zDb);
if( pTab && IsVirtual(pTab) ){
pParse->zErrMsg = 0;
}
rc = SQLITE_ERROR;
- (void)sqlite3SafetyOff(db);
sqlite3BtreeLeaveAll(db);
goto blob_open_out;
}
sqlite3DbFree(db, zErr);
zErr = sqlite3MPrintf(db, "no such column: \"%s\"", zColumn);
rc = SQLITE_ERROR;
- (void)sqlite3SafetyOff(db);
sqlite3BtreeLeaveAll(db);
goto blob_open_out;
}
sqlite3DbFree(db, zErr);
zErr = sqlite3MPrintf(db, "cannot open %s column for writing", zFault);
rc = SQLITE_ERROR;
- (void)sqlite3SafetyOff(db);
sqlite3BtreeLeaveAll(db);
goto blob_open_out;
}
}
sqlite3BtreeLeaveAll(db);
- rc = sqlite3SafetyOff(db);
- if( NEVER(rc!=SQLITE_OK) || db->mallocFailed ){
+ if( db->mallocFailed ){
goto blob_open_out;
}
if( pVTab->nRef==0 ){
sqlite3_vtab *p = pVTab->pVtab;
if( p ){
-#ifdef SQLITE_DEBUG
- if( pVTab->db->magic==SQLITE_MAGIC_BUSY ){
- (void)sqlite3SafetyOff(db);
- p->pModule->xDisconnect(p);
- (void)sqlite3SafetyOn(db);
- } else
-#endif
- {
- p->pModule->xDisconnect(p);
- }
+ p->pModule->xDisconnect(p);
}
sqlite3DbFree(db, pVTab);
}
db->pVTab = pTab;
/* Invoke the virtual table constructor */
- (void)sqlite3SafetyOff(db);
rc = xConstruct(db, pMod->pAux, nArg, azArg, &pVTable->pVtab, &zErr);
- (void)sqlite3SafetyOn(db);
if( rc==SQLITE_NOMEM ) db->mallocFailed = 1;
if( SQLITE_OK!=rc ){
if( ALWAYS(pTab!=0 && pTab->pVTable!=0) ){
VTable *p = vtabDisconnectAll(db, pTab);
- rc = sqlite3SafetyOff(db);
assert( rc==SQLITE_OK );
rc = p->pMod->pModule->xDestroy(p->pVtab);
- (void)sqlite3SafetyOn(db);
/* Remove the sqlite3_vtab* from the aVTrans[] array, if applicable */
if( rc==SQLITE_OK ){
int sqlite3VtabSync(sqlite3 *db, char **pzErrmsg){
int i;
int rc = SQLITE_OK;
- int rcsafety;
VTable **aVTrans = db->aVTrans;
- rc = sqlite3SafetyOff(db);
db->aVTrans = 0;
for(i=0; rc==SQLITE_OK && i<db->nVTrans; i++){
int (*x)(sqlite3_vtab *);
}
}
db->aVTrans = aVTrans;
- rcsafety = sqlite3SafetyOn(db);
-
- if( rc==SQLITE_OK ){
- rc = rcsafety;
- }
return rc;
}
int i;
int rc;
- (void)sqlite3SafetyOff(pParse->db);
WHERETRACE(("xBestIndex for %s\n", pTab->zName));
TRACE_IDX_INPUTS(p);
rc = pVtab->pModule->xBestIndex(pVtab, p);
TRACE_IDX_OUTPUTS(p);
- (void)sqlite3SafetyOn(pParse->db);
if( rc!=SQLITE_OK ){
if( rc==SQLITE_NOMEM ){
+++ /dev/null
-# 2005 January 11
-#
-# The author disclaims copyright to this source code. In place of
-# a legal notice, here is a blessing:
-#
-# May you do good and not evil.
-# May you find forgiveness for yourself and forgive others.
-# May you share freely, never taking more than you give.
-#
-#***********************************************************************
-# This file implements regression tests for SQLite library. The
-# focus of this file is testing the sqlite3SafetyOn and sqlite3SafetyOff
-# functions. Those routines are not strictly necessary - they are
-# designed to detect misuse of the library.
-#
-# $Id: safety.test,v 1.4 2008/03/18 13:46:53 drh Exp $
-
-set testdir [file dirname $argv0]
-source $testdir/tester.tcl
-
-ifcapable !debug {
- puts "Skipping safety tests since SQLITE_DEBUG is off"
- finish_test
- return
-}
-
-# Return the UTF-8 representation of the supplied UTF-16 string $str.
-proc utf8 {str} {
- # If $str ends in two 0x00 0x00 bytes, knock these off before
- # converting to UTF-8 using TCL.
- binary scan $str \c* vals
- if {[lindex $vals end]==0 && [lindex $vals end-1]==0} {
- set str [binary format \c* [lrange $vals 0 end-2]]
- }
-
- set r [encoding convertfrom unicode $str]
- return $r
-}
-
-
-do_test safety-1.1 {
- set DB [sqlite3_connection_pointer db]
- db eval {CREATE TABLE t1(a)}
- sqlite_set_magic $DB SQLITE_MAGIC_BUSY
- catchsql {
- SELECT name FROM sqlite_master;
- }
-} {1 {library routine called out of sequence}}
-do_test safety-1.2 {
- sqlite_set_magic $DB SQLITE_MAGIC_OPEN
- catchsql {
- SELECT name FROM sqlite_master
- }
-} {0 t1}
-
-do_test safety-2.1 {
- proc safety_on {} "sqlite_set_magic $DB SQLITE_MAGIC_BUSY"
- db function safety_on safety_on
- catchsql {
- SELECT safety_on(), name FROM sqlite_master
- }
-} {1 {library routine called out of sequence}}
-ifcapable {utf16} {
- do_test safety-2.1.1 {
- utf8 [sqlite3_errmsg16 db]
- } {library routine called out of sequence}
-}
-do_test safety-2.2 {
- catchsql {
- SELECT 'hello'
- }
-} {1 {library routine called out of sequence}}
-do_test safety-2.3 {
- sqlite3_close $DB
-} {SQLITE_MISUSE}
-do_test safety-2.4 {
- sqlite_set_magic $DB SQLITE_MAGIC_OPEN
- execsql {
- SELECT name FROM sqlite_master
- }
-} {t1}
-
-do_test safety-3.1 {
- set rc [catch {
- db eval {SELECT name FROM sqlite_master} {
- sqlite_set_magic $DB SQLITE_MAGIC_BUSY
- }
- } msg]
- lappend rc $msg
-} {1 {library routine called out of sequence}}
-sqlite_set_magic $DB SQLITE_MAGIC_OPEN
-
-finish_test
projects / thirdparty / sqlite.git / commitdiff
