mirrors/sqlite
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

More work on refactoring of malloc() interfaces. There are still many errors. (CVS 4233)

Browse Source 
FossilOrigin-Name: 77b1671351fe94b0ebc126a63140643deae2aa64
This commit is contained in:
danielk1977 2007-08-16 10:09:01 +00:00
parent 9fb3ecbc5b
commit 1e5369531e
44 changed files with 492 additions and 418 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
main.mk
View File

@ -172,7 +172,6 @@ TESTSRC = \
$(TOP)/src/date.c \
$(TOP)/src/func.c \
$(TOP)/src/insert.c \
$(TOP)/src/main.c \
$(TOP)/src/malloc.c \
$(TOP)/src/os.c \
$(TOP)/src/os_os2.c \

94
manifest
View File

@ -1,5 +1,5 @@
C Add\sa\stest\sfor\smalloc()\sfailure\swhen\scompiling\sa\strigger\sstep\sof\sthe\sform\s"INSERT\sINTO\s...\sSELECT\s...".\sCurrently\scauses\sa\ssegfault.\s(CVS\s4232)
D 2007-08-16T04:39:01
C More\swork\son\srefactoring\sof\smalloc()\sinterfaces.\sThere\sare\sstill\smany\serrors.\s(CVS\s4233)
D 2007-08-16T10:09:02
F Makefile.in 0c0e53720f658c7a551046442dd7afba0b72bfbe
F Makefile.linux-gcc 65241babba6faf1152bf86574477baab19190499
F README 9c4e2d6706bdcc3efdd773ce752a8cdab4f90028
@ -51,7 +51,7 @@ F ext/icu/README.txt 3b130aa66e7a681136f6add198b076a2f90d1e33
F ext/icu/icu.c 61a345d8126686aa3487aa8d2d0f68abd655f7a4
F install-sh 9d4de14ab9fb0facae2f48780b874848cbf2f895
F ltmain.sh 56abb507100ed2d4261f6dd1653dec3cf4066387
F main.mk dad2269dd2a097892536482c12acaab001e930c2
F main.mk 659cad1c400ab92948087d46c499e0330215db7b
F mkdll.sh 37fa8a7412e51b5ab2bc6d4276135f022a0feffb
F mkextu.sh 416f9b7089d80e5590a29692c9d9280a10dbad9f
F mkextw.sh 1a866b53637dab137191341cc875575a5ca110fb
@ -64,33 +64,33 @@ F sqlite.pc.in 30552343140c53304c2a658c080fbe810cd09ca2
F sqlite3.1 6be1ad09113570e1fc8dcaff84c9b0b337db5ffc
F sqlite3.def a96c1d0d39362b763d2ddba220a32da41a15c4b4
F sqlite3.pc.in 985b9bf34192a549d7d370e0f0b6b34a4f61369a
F src/alter.c 27b0c0d371a825f9a8b7198a3f3f94c2e027f25e
F src/analyze.c e2bbd2510b4009bc9839e32ceac21ac1bd711f37
F src/alter.c f0aac0060ae8102e58f210b44d35b53438d53173
F src/analyze.c a14237d869c6bea0846493b59317e4097e81a0b6
F src/attach.c a52225c75b107be8c5bc144a2b6d20201be3f8f8
F src/auth.c 5ea90bc93dfea46e9fe4bf531e14c7cd98219ecb
F src/btree.c 1f7c009817a03a3cbf4f78d4d373543d89ebc890
F src/btree.c f371e9d7a24ba330c108bf1bb795280051f696ac
F src/btree.h 1d527bf61ed176f980c34999d5793a0fd45dcf8c
F src/btreeInt.h ac1ab1fb624ffbe571786cd2bd9559f9ae336355
F src/build.c a25bf9d25623c7730bc58922e0e84204ad98c968
F src/callback.c 5680c2b84177e52c54b42e94291d30b4b6ed2126
F src/complete.c 7d1a44be8f37de125fcafd3d3a018690b3799675
F src/date.c 6c6ae019e78fec543988c8d907fa9524dc2c2934
F src/build.c 923d6643c8f59fbcd10cd9e2f2690e82f48db69e
F src/callback.c 143436453bb93e831c9574fea0b9b9eb90e40ff3
F src/complete.c ea63834e798a0ab14159bdc6e6cabc3df21aa346
F src/date.c c44aa498ee9a289ba2b2c62e8269b74b1b81351f
F src/delete.c 849846d06d29851dde0d9f424a5de5817eb140d1
F src/experimental.c 1b2d1a6cd62ecc39610e97670332ca073c50792b
F src/expr.c 002266066377f542e776448e04816d2a887d7dc3
F src/func.c bd94a8aabeecc741df71afba856133738f1c1638
F src/hash.c 05ebefb85d77caed0454408ee1e069702d289bff
F src/expr.c beb6b40974ddb22d683b8239d635c37f28b16f95
F src/func.c 4195c626d09662a2cc040a35057f2b3828dd7465
F src/hash.c 2f322979071dd2bdba7503b5276d66f028744382
F src/hash.h 3ad3da76bfb954978d227bf495568b0e6da2c19e
F src/insert.c bca11ad7b7ab4a1ba4808b6e0a6fd842923f88bb
F src/legacy.c 6013a7cb7da1b72550b3d35d4fc598b3c3e5b8c1
F src/limits.h 71ab25f17e35e0a9f3f6f234b8ed49cc56731d35
F src/loadext.c aa1c6e584d39cc241226ec9390387bc2d4a23e8f
F src/main.c 7850774e64fc1f804a3f91a8a66ba4215e9fa05b
F src/malloc.c bec719bda3db0ea797b03c5e6536b125d0e618ff
F src/main.c 47c6d4918394cf86e38502527ca652ac0602fac1
F src/malloc.c 613c65f12ff0ee4edd017aa458209ab7a23cd7b1
F src/md5.c c5fdfa5c2593eaee2e32a5ce6c6927c986eaf217
F src/mem1.c 6d4b9efe51242fcc63d410fb326824f1208b3d4e
F src/mem2.c d0ba3b23da2e95bced1818ade8a8a2dc9526111c
F src/mutex.c 667dae0de95f8fb92a3ffc8c3f20c0d26115a1a6
F src/mutex.c b4f963ebdcb0622b3026937826afefd8a05884e1
F src/os.c e2faefbe0f5a8ca5e3b1c49ee1b5c6cfa0f0e279
F src/os.h 8eff07babf74e5bc3f895f8a6c7c294dad5ff997
F src/os_common.h a5c446d3b93f09f369d13bf217de4bed3437dd1c
@ -98,34 +98,34 @@ F src/os_os2.c cba4e96fadb949076c717108fe0599d1a3c2e446
F src/os_os2.h e5f17dd69333632bbc3112881ea407c37d245eb3
F src/os_test.c 49833426101f99aee4bb5f6a44b7c4b2029fda1c
F src/os_test.h 903c93554c23d88f34f667f1979e4a1cee792af3
F src/os_unix.c 67601899b573c8a7a23aee9d3eeeb7aa724501ee
F src/os_unix.c 7c7dcb7dcc93fcecf870d070fe9de8e2e7a44167
F src/os_unix.h 5768d56d28240d3fe4537fac08cc85e4fb52279e
F src/os_win.c d868d5f9e95ec9c1b9e2a30c54c996053db6dddd
F src/os_win.h 41a946bea10f61c158ce8645e7646b29d44f122b
F src/pager.c ddb0279c4030128b2f06cdd02b68ae266a8f4fe7
F src/pager.c 812a3f78ea398764991d668d2d3d81a951e58fa3
F src/pager.h 94110a5570dca30d54a883e880a3633b2e4c05ae
F src/parse.y 4934dc7e7a679f71359420de11aae7c281a73151
F src/pragma.c 9ecc2bcd790fc1723a5f78ff46493ce4d2b77ced
F src/prepare.c 237ed8ce0509da9e28a4773b96ec4c44015b970e
F src/printf.c 326386450a8fa31853503b3a8cc758d72d41fc7e
F src/parse.y c03529c3b82702ada98ce405b390e3a9409708cf
F src/pragma.c 873b0b2ab56248ef76d0387193b8f7a87782b73c
F src/prepare.c 03292beeffce2d65debab12508a8ec1f5aec7241
F src/printf.c a8f46e0ed360c18d40e89aa636533be300b406c2
F src/random.c 6119474a6f6917f708c1dee25b9a8e519a620e88
F src/select.c 4df152ea0cd13b37cc4e41c56cad7c8ed2d9718c
F src/select.c 98c367bce3f38c5adfcc97de9ab5c79b0e5dc2b2
F src/server.c 087b92a39d883e3fa113cae259d64e4c7438bc96
F src/shell.c ac29402b538515fa4697282387be9c1205e6e9eb
F src/sqlite.h.in 165913eb3426fbaa8a2a51d87f84593bfe5bee15
F src/sqlite3ext.h a27bedc222df5e5f0f458ac99726d0483b953a91
F src/sqliteInt.h acdc2d5b997504c3b1d1cc7ac31ec064f23c26b5
F src/sqlite3ext.h 647a6b8a8f76ff6c9611e4a071531d8e63ff2d6b
F src/sqliteInt.h 2649e0cbf0073e0d5c88080c642de4a3bac58c09
F src/sqliteLimit.h f14609c27636ebc217c9603ade26dbdd7d0f6afa
F src/table.c a8de75bcedf84d4060d804264b067ab3b1a3561d
F src/table.c c725e47f6f3092b9a7b569fc58e408e2173ee008
F src/tclsqlite.c 0606c4f31711492eb4d7480a981eebb80914f3d9
F src/test1.c b5b36bdf40a78e351cb0def7bc900991adcc4c4f
F src/test2.c 5c3edc610852a8f67990cd08c5d5dbb79e3f8db9
F src/test3.c 497ed07038ea79ab683b0beba6a39c89540ce632
F src/test1.c f2969f28574433743f7439da62f0cfd9063fc26b
F src/test2.c 4db48e4a487d4d18c2926d9600875613ad286ba8
F src/test3.c c337cff70c3bf9c30f77e953106ef7ddf655dd51
F src/test4.c d22cb3ab4f9fdfd0a595b70d5328cee923b7322c
F src/test5.c 27f3aa4eebfec94769d199f85212708ec77536c7
F src/test6.c b0aea6299100bee055ff9d8f30d87e393384e607
F src/test5.c 7bc8a87c2b6fd076ec2ca9972946e71a367883ad
F src/test6.c 14919eef8504da6814db7ab19608c786d836fcb2
F src/test7.c 91d914c2c2b2806157213f41f4185ad3a4970c07
F src/test8.c 95c9e0639e555768e15f88c87ae805c10340d8c2
F src/test8.c 0dc64e1a676df556cbcc3f7fcbaa583d7f234826
F src/test9.c c0f38f7795cc51d37db6c63874d90f40f10d0f0e
F src/test_async.c 871ffbe4a520be74b403aca87aa622ebdb690232
F src/test_autoext.c 855157d97aa28cf84233847548bfacda21807436
@ -138,22 +138,22 @@ F src/test_md5.c d9f828765b242ff86f58cd879259c3da4eaede02
F src/test_schema.c 12c9de7661d6294eec2d57afbb52e2af1128084f
F src/test_server.c 76c0baf509abe65ca6e5c7974ab0097cfdd8b833
F src/test_tclvar.c 51f69f526ed4a044dc7c13c7badccd33cb41132b
F src/tokenize.c 418842048447c6d0889fd2e0b414288615d28aaa
F src/trigger.c f29b1d40a329f33dd683b500cc5d493f2acb9558
F src/update.c b20d7730bfe46367a8d3f540a0b0632840c82fec
F src/utf.c e2212080d74559a1a351ab4d235b97f522132995
F src/util.c c831d17623ffb0e09a3710f8f679eeeb42a423c2
F src/tokenize.c 3a3fd71cfb2abb8e11ed6ab6b764b790c534defc
F src/trigger.c dccc6fbf37d12193c90ede5b026bbd195d505ff4
F src/update.c e89b980b443d44b68bfc0b1746cdb6308e049ac9
F src/utf.c 853f97ce0d3cff8dbaef517a6dc475f7001a67c5
F src/util.c 0273ba16dbf9bab423b1b84c6d548d8f14c25f64
F src/vacuum.c f45bd9d3aad8d68bb3b85cf89d7a797be5075fde
F src/vdbe.c dd6f17be86fde2ca07d4b065ed79815a617615cd
F src/vdbe.c 10052a4f1e42e629aee0466b40983e2b61e0295a
F src/vdbe.h 001c5b257567c1d3de7feb2203aac71d0d7b16a3
F src/vdbeInt.h 0629275fd265cf1ba039c08e1d41c91258f02f64
F src/vdbeapi.c fce4ee6ab2cb8fd209f53b8a9261603c82993b8c
F src/vdbeaux.c e59e50659a5e19298e6b3e21e7ae309d43607305
F src/vdbeInt.h e0bd068cf607dcb10021aefa9390b96f56fc3e03
F src/vdbeapi.c ca82e14ac4ef0c15d7ed8851b0bf9377d7eb0058
F src/vdbeaux.c aa079bb65d3ebe81eab4765c26c3e69deabc6825
F src/vdbeblob.c cf9ee3c7d9977cbd896f8b118da4fb4268637f4f
F src/vdbefifo.c 334c838c8f42d61a94813d136019ee566b5dc2f6
F src/vdbemem.c 59fde3ec6178bee1e6200a524c2cf5937cfe33ab
F src/vtab.c ea2557202d0e6d01dc810be9007a63e1ef357820
F src/where.c 366bfb2b03b1b1fa63dc6a1b14f86509fe0d12ed
F src/vdbemem.c 52ec18736ff0203cd34a1b55043027a312f23646
F src/vtab.c 8d65679ab4ef3efce5d946d7f2d2dac5a33313b4
F src/where.c b5af62312d2ac6b22897cd0f06fb0eca477d8589
F tclinstaller.tcl 4356d9d94d2b5ed5e68f9f0c80c4df3048dd7617
F test/aggerror.test a867e273ef9e3d7919f03ef4f0e8c0d2767944f2
F test/all.test 56bc526a6cbb262c5b678dd606de8c92ae39705e
@ -529,7 +529,7 @@ F www/tclsqlite.tcl 8be95ee6dba05eabcd27a9d91331c803f2ce2130
F www/vdbe.tcl 87a31ace769f20d3627a64fa1fade7fed47b90d0
F www/version3.tcl 890248cf7b70e60c383b0e84d77d5132b3ead42b
F www/whentouse.tcl fc46eae081251c3c181bd79c5faef8195d7991a5
P deb7ecd65f7b83eaf0ba610eeef3b0ede61db1c3
R cf90298b3b3d07ca81013abb6b566a4c
P 161643a694458e76849cd663f277892ae7c6b729
R 78bb61c2e514dbedee0545c75b0d9447
U danielk1977
Z d365a125dcbfa4a995190ff632cb9301
Z 4f8b342764fab083222a09714d137d45

2
manifest.uuid
View File

@ -1 +1 @@
161643a694458e76849cd663f277892ae7c6b729
77b1671351fe94b0ebc126a63140643deae2aa64

25
src/alter.c
View File

@ -12,7 +12,7 @@
** This file contains C code routines that used to generate VDBE code
** that implements the ALTER TABLE command.
**
** $Id: alter.c,v 1.28 2007/08/16 04:30:39 drh Exp $
** $Id: alter.c,v 1.29 2007/08/16 10:09:02 danielk1977 Exp $
*/
#include "sqliteInt.h"
#include <ctype.h>
@ -51,6 +51,8 @@ static void renameTableFunc(
int len = 0;
char *zRet;
sqlite3 *db = sqlite3_user_data(context);
/* The principle used to locate the table name in the CREATE TABLE
** statement is that the table name is the first token that is immediatedly
** followed by a left parenthesis - TK_LP - or "USING" TK_USING.
@ -76,9 +78,9 @@ static void renameTableFunc(
assert( len>0 );
} while( token!=TK_LP && token!=TK_USING );
zRet = sqlite3MPrintf("%.*s%Q%s", tname.z - zSql, zSql,
zRet = sqlite3MPrintf(db, "%.*s%Q%s", tname.z - zSql, zSql,
zTableName, tname.z+tname.n);
sqlite3_result_text(context, zRet, -1, sqlite3FreeX);
sqlite3_result_text(context, zRet, -1, sqlite3_free);
}
}
@ -105,6 +107,8 @@ static void renameTriggerFunc(
int len = 0;
char *zRet;
sqlite3 *db = sqlite3_user_data(context);
/* The principle used to locate the table name in the CREATE TRIGGER
** statement is that the table name is the first token that is immediatedly
** preceded by either TK_ON or TK_DOT and immediatedly followed by one
@ -149,9 +153,9 @@ static void renameTriggerFunc(
/* Variable tname now contains the token that is the old table-name
** in the CREATE TRIGGER statement.
*/
zRet = sqlite3MPrintf("%.*s%Q%s", tname.z - zSql, zSql,
zRet = sqlite3MPrintf(db, "%.*s%Q%s", tname.z - zSql, zSql,
zTableName, tname.z+tname.n);
sqlite3_result_text(context, zRet, -1, sqlite3FreeX);
sqlite3_result_text(context, zRet, -1, sqlite3_free);
}
}
#endif /* !SQLITE_OMIT_TRIGGER */
@ -174,7 +178,7 @@ void sqlite3AlterFunctions(sqlite3 *db){
for(i=0; i<sizeof(aFuncs)/sizeof(aFuncs[0]); i++){
sqlite3CreateFunc(db, aFuncs[i].zName, aFuncs[i].nArg,
SQLITE_UTF8, 0, aFuncs[i].xFunc, 0, 0);
SQLITE_UTF8, (void *)db, aFuncs[i].xFunc, 0, 0);
}
}
@ -196,13 +200,14 @@ static char *whereTempTriggers(Parse *pParse, Table *pTab){
** expression being built up in zWhere.
*/
if( pTab->pSchema!=pTempSchema ){
sqlite3 *db = pParse->db;
for( pTrig=pTab->pTrigger; pTrig; pTrig=pTrig->pNext ){
if( pTrig->pSchema==pTempSchema ){
if( !zWhere ){
zWhere = sqlite3MPrintf("name=%Q", pTrig->name);
zWhere = sqlite3MPrintf(db, "name=%Q", pTrig->name);
}else{
tmp = zWhere;
zWhere = sqlite3MPrintf("%s OR name=%Q", zWhere, pTrig->name);
zWhere = sqlite3MPrintf(db, "%s OR name=%Q", zWhere, pTrig->name);
sqlite3_free(tmp);
}
}
@ -245,7 +250,7 @@ static void reloadTableSchema(Parse *pParse, Table *pTab, const char *zName){
sqlite3VdbeOp3(v, OP_DropTable, iDb, 0, pTab->zName, 0);
/* Reload the table, index and permanent trigger schemas. */
zWhere = sqlite3MPrintf("tbl_name=%Q", zName);
zWhere = sqlite3MPrintf(pParse->db, "tbl_name=%Q", zName);
if( !zWhere ) return;
sqlite3VdbeOp3(v, OP_ParseSchema, iDb, 0, zWhere, P3_DYNAMIC);
@ -487,7 +492,7 @@ void sqlite3AlterFinishAddColumn(Parse *pParse, Token *pColDef){
*/
if( pDflt ){
sqlite3_value *pVal;
if( sqlite3ValueFromExpr(pDflt, SQLITE_UTF8, SQLITE_AFF_NONE, &pVal) ){
if( sqlite3ValueFromExpr(db, pDflt, SQLITE_UTF8, SQLITE_AFF_NONE, &pVal) ){
db->mallocFailed = 1;
return;
}

4
src/analyze.c
View File

@ -11,7 +11,7 @@
*************************************************************************
** This file contains code associated with the ANALYZE command.
**
** @(#) $Id: analyze.c,v 1.20 2007/08/16 04:30:39 drh Exp $
** @(#) $Id: analyze.c,v 1.21 2007/08/16 10:09:02 danielk1977 Exp $
*/
#ifndef SQLITE_OMIT_ANALYZE
#include "sqliteInt.h"
@ -397,7 +397,7 @@ int sqlite3AnalysisLoad(sqlite3 *db, int iDb){
/* Load new statistics out of the sqlite_stat1 table */
zSql = sqlite3MPrintf("SELECT idx, stat FROM %Q.sqlite_stat1",
zSql = sqlite3MPrintf(db, "SELECT idx, stat FROM %Q.sqlite_stat1",
sInfo.zDatabase);
sqlite3SafetyOff(db);
rc = sqlite3_exec(db, zSql, analysisLoader, &sInfo, 0);

6
src/btree.c
View File

@ -9,7 +9,7 @@
** May you share freely, never taking more than you give.
**
*************************************************************************
** $Id: btree.c,v 1.397 2007/08/16 04:30:39 drh Exp $
** $Id: btree.c,v 1.398 2007/08/16 10:09:02 danielk1977 Exp $
**
** This file implements a external (disk-based) database using BTrees.
** See the header comment on "btreeInt.h" for additional information.
@ -5741,7 +5741,7 @@ static void checkAppendMsg(
pCheck->mxErr--;
pCheck->nErr++;
va_start(ap, zFormat);
zMsg2 = sqlite3VMPrintf(zFormat, ap);
zMsg2 = sqlite3VMPrintf(0, zFormat, ap);
va_end(ap);
if( zMsg1==0 ) zMsg1 = "";
if( pCheck->zErrMsg ){
@ -6091,7 +6091,7 @@ char *sqlite3BtreeIntegrityCheck(
if( !sCheck.anRef ){
unlockBtreeIfUnused(pBt);
*pnErr = 1;
return sqlite3MPrintf("Unable to malloc %d bytes",
return sqlite3MPrintf(p->pSqlite, "Unable to malloc %d bytes",
(sCheck.nPage+1)*sizeof(sCheck.anRef[0]));
}
for(i=0; i<=sCheck.nPage; i++){ sCheck.anRef[i] = 0; }

21
src/build.c
View File

@ -22,7 +22,7 @@
** COMMIT
** ROLLBACK
**
** $Id: build.c,v 1.434 2007/08/16 04:30:39 drh Exp $
** $Id: build.c,v 1.435 2007/08/16 10:09:02 danielk1977 Exp $
*/
#include "sqliteInt.h"
#include <ctype.h>
@ -235,10 +235,9 @@ void sqlite3NestedParse(Parse *pParse, const char *zFormat, ...){
if( pParse->nErr ) return;
assert( pParse->nested<10 ); /* Nesting should only be of limited depth */
va_start(ap, zFormat);
zSql = sqlite3VMPrintf(zFormat, ap);
zSql = sqlite3VMPrintf(pParse->db, zFormat, ap);
va_end(ap);
if( zSql==0 ){
pParse->db->mallocFailed = 1;
return; /* A malloc must have failed */
}
pParse->nested++;
@ -1498,10 +1497,12 @@ void sqlite3EndTable(
/* Compute the complete text of the CREATE statement */
if( pSelect ){
zStmt = createTableStmt(p, p->pSchema==pParse->db->aDb[1].pSchema);
zStmt = createTableStmt(p, p->pSchema==db->aDb[1].pSchema);
}else{
n = pEnd->z - pParse->sNameToken.z + 1;
zStmt = sqlite3MPrintf("CREATE %s %.*s", zType2, n, pParse->sNameToken.z);
zStmt = sqlite3MPrintf(db,
"CREATE %s %.*s", zType2, n, pParse->sNameToken.z
);
}
/* A slot for the record has already been allocated in the
@ -1540,7 +1541,7 @@ void sqlite3EndTable(
/* Reparse everything to update our internal data structures */
sqlite3VdbeOp3(v, OP_ParseSchema, iDb, 0,
sqlite3MPrintf("tbl_name='%q'",p->zName), P3_DYNAMIC);
sqlite3MPrintf(db, "tbl_name='%q'",p->zName), P3_DYNAMIC);
}
@ -2405,7 +2406,7 @@ void sqlite3CreateIndex(
if( pList==0 ){
nullId.z = (u8*)pTab->aCol[pTab->nCol-1].zName;
nullId.n = strlen((char*)nullId.z);
pList = sqlite3ExprListAppend(0, 0, &nullId);
pList = sqlite3ExprListAppend(pParse, 0, 0, &nullId);
if( pList==0 ) goto exit_create_index;
pList->a[0].sortOrder = sortOrder;
}
@ -2607,7 +2608,7 @@ void sqlite3CreateIndex(
*/
if( pStart && pEnd ){
/* A named index with an explicit CREATE INDEX statement */
zStmt = sqlite3MPrintf("CREATE%s INDEX %.*s",
zStmt = sqlite3MPrintf(db, "CREATE%s INDEX %.*s",
onError==OE_None ? "" : " UNIQUE",
pEnd->z - pName->z + 1,
pName->z);
@ -2636,7 +2637,7 @@ void sqlite3CreateIndex(
sqlite3RefillIndex(pParse, pIndex, iMem);
sqlite3ChangeCookie(db, v, iDb);
sqlite3VdbeOp3(v, OP_ParseSchema, iDb, 0,
sqlite3MPrintf("name='%q'", pIndex->zName), P3_DYNAMIC);
sqlite3MPrintf(db, "name='%q'", pIndex->zName), P3_DYNAMIC);
sqlite3VdbeAddOp(v, OP_Expire, 0, 0);
}
}
@ -3366,7 +3367,7 @@ KeyInfo *sqlite3IndexKeyinfo(Parse *pParse, Index *pIdx){
int i;
int nCol = pIdx->nColumn;
int nBytes = sizeof(KeyInfo) + (nCol-1)*sizeof(CollSeq*) + nCol;
KeyInfo *pKey = (KeyInfo *)sqlite3DbMallocZer(pParse->db, nBytes);
KeyInfo *pKey = (KeyInfo *)sqlite3DbMallocZero(pParse->db, nBytes);
if( pKey ){
pKey->aSortOrder = (u8 *)&(pKey->aColl[nCol]);

8
src/callback.c
View File

@ -13,7 +13,7 @@
** This file contains functions used to access the internal hash tables
** of user defined functions and collation sequences.
**
** $Id: callback.c,v 1.19 2007/08/16 04:30:39 drh Exp $
** $Id: callback.c,v 1.20 2007/08/16 10:09:02 danielk1977 Exp $
*/
#include "sqliteInt.h"
@ -35,9 +35,9 @@ static void callCollNeeded(sqlite3 *db, const char *zName, int nName){
#ifndef SQLITE_OMIT_UTF16
if( db->xCollNeeded16 ){
char const *zExternal;
sqlite3_value *pTmp = sqlite3ValueNew();
sqlite3ValueSetStr(pTmp, nName, zName, SQLITE_UTF8, SQLITE_STATIC);
zExternal = sqlite3ValueText(pTmp, SQLITE_UTF16NATIVE);
sqlite3_value *pTmp = sqlite3ValueNew(db);
sqlite3ValueSetStr(db, pTmp, nName, zName, SQLITE_UTF8, SQLITE_STATIC);
zExternal = sqlite3ValueText(db, pTmp, SQLITE_UTF16NATIVE);
if( zExternal ){
db->xCollNeeded16(db->pCollNeededArg, db, (int)ENC(db), zExternal);
}

10
src/complete.c
View File

@ -16,7 +16,7 @@
** separating it out, the code will be automatically omitted from
** static links that do not use it.
**
** $Id: complete.c,v 1.3 2006/01/18 15:25:17 danielk1977 Exp $
** $Id: complete.c,v 1.4 2007/08/16 10:09:02 danielk1977 Exp $
*/
#include "sqliteInt.h"
#ifndef SQLITE_OMIT_COMPLETE
@ -248,11 +248,11 @@ int sqlite3_complete(const char *zSql){
int sqlite3_complete16(const void *zSql){
sqlite3_value *pVal;
char const *zSql8;
int rc = 0;
int rc = SQLITE_NOMEM;
pVal = sqlite3ValueNew();
sqlite3ValueSetStr(pVal, -1, zSql, SQLITE_UTF16NATIVE, SQLITE_STATIC);
zSql8 = sqlite3ValueText(pVal, SQLITE_UTF8);
pVal = sqlite3ValueNew(0);
sqlite3ValueSetStr(0, pVal, -1, zSql, SQLITE_UTF16NATIVE, SQLITE_STATIC);
zSql8 = sqlite3ValueText(0, pVal, SQLITE_UTF8);
if( zSql8 ){
rc = sqlite3_complete(zSql8);
}

14
src/date.c
View File

@ -16,7 +16,7 @@
** sqlite3RegisterDateTimeFunctions() found at the bottom of the file.
** All other code has file scope.
**
** $Id: date.c,v 1.67 2007/08/16 04:30:40 drh Exp $
** $Id: date.c,v 1.68 2007/08/16 10:09:03 danielk1977 Exp $
**
** SQLite processes all times and dates as Julian Day numbers. The
** dates and times are stored as the number of days since noon
@ -894,9 +894,9 @@ static void ctimeFunc(
int argc,
sqlite3_value **argv
){
sqlite3_value *pVal = sqlite3ValueNew();
sqlite3_value *pVal = sqlite3ValueNew(0);
if( pVal ){
sqlite3ValueSetStr(pVal, -1, "now", SQLITE_UTF8, SQLITE_STATIC);
sqlite3ValueSetStr(0, pVal, -1, "now", SQLITE_UTF8, SQLITE_STATIC);
timeFunc(context, 1, &pVal);
sqlite3ValueFree(pVal);
}
@ -912,9 +912,9 @@ static void cdateFunc(
int argc,
sqlite3_value **argv
){
sqlite3_value *pVal = sqlite3ValueNew();
sqlite3_value *pVal = sqlite3ValueNew(0);
if( pVal ){
sqlite3ValueSetStr(pVal, -1, "now", SQLITE_UTF8, SQLITE_STATIC);
sqlite3ValueSetStr(0, pVal, -1, "now", SQLITE_UTF8, SQLITE_STATIC);
dateFunc(context, 1, &pVal);
sqlite3ValueFree(pVal);
}
@ -930,9 +930,9 @@ static void ctimestampFunc(
int argc,
sqlite3_value **argv
){
sqlite3_value *pVal = sqlite3ValueNew();
sqlite3_value *pVal = sqlite3ValueNew(0);
if( pVal ){
sqlite3ValueSetStr(pVal, -1, "now", SQLITE_UTF8, SQLITE_STATIC);
sqlite3ValueSetStr(0, pVal, -1, "now", SQLITE_UTF8, SQLITE_STATIC);
datetimeFunc(context, 1, &pVal);
sqlite3ValueFree(pVal);
}

22
src/expr.c
View File

@ -12,7 +12,7 @@
** This file contains routines used for analyzing expressions and
** for generating VDBE code that evaluates expressions in SQLite.
**
** $Id: expr.c,v 1.304 2007/08/16 04:30:40 drh Exp $
** $Id: expr.c,v 1.305 2007/08/16 10:09:03 danielk1977 Exp $
*/
#include "sqliteInt.h"
#include <ctype.h>
@ -318,7 +318,7 @@ Expr *sqlite3RegisterExpr(Parse *pParse, Token *pToken){
** Join two expressions using an AND operator. If either expression is
** NULL, then just return the other expression.
*/
Expr *sqlite3ExprAnd(sqlite *db, Expr *pLeft, Expr *pRight){
Expr *sqlite3ExprAnd(sqlite3 *db, Expr *pLeft, Expr *pRight){
if( pLeft==0 ){
return pRight;
}else if( pRight==0 ){
@ -328,6 +328,7 @@ Expr *sqlite3ExprAnd(sqlite *db, Expr *pLeft, Expr *pRight){
if( p==0 ){
db->mallocFailed = 1;
}
return p;
}
}
@ -491,7 +492,7 @@ void sqlite3DequoteExpr(sqlite3 *db, Expr *p){
**
** Any tables that the SrcList might point to are not duplicated.
*/
Expr *sqlite3ExprDup(sqlite *db, Expr *p){
Expr *sqlite3ExprDup(sqlite3 *db, Expr *p){
Expr *pNew;
if( p==0 ) return 0;
pNew = sqlite3DbMallocRaw(db, sizeof(*p) );
@ -1179,7 +1180,7 @@ static int lookupName(
sqlite3_free(zCol);
return 2;
}
pDup = sqlite3ExprDup(pOrig);
pDup = sqlite3ExprDup(db, pOrig);
if( pExpr->flags & EP_ExpCollate ){
pDup->pColl = pExpr->pColl;
pDup->flags |= EP_ExpCollate;
@ -1780,7 +1781,7 @@ void sqlite3ExprCode(Parse *pParse, Expr *pExpr){
case TK_STRING: {
assert( TK_FLOAT==OP_Real );
assert( TK_STRING==OP_String8 );
sqlite3DequoteExpr(pExpr);
sqlite3DequoteExpr(pParse->db, pExpr);
sqlite3VdbeOp3(v, op, 0, 0, (char*)pExpr->token.z, pExpr->token.n);
break;
}
@ -1883,7 +1884,7 @@ void sqlite3ExprCode(Parse *pParse, Expr *pExpr){
assert( pLeft );
if( pLeft->op==TK_FLOAT || pLeft->op==TK_INTEGER ){
Token *p = &pLeft->token;
char *z = sqlite3MPrintf("-%.*s", p->n, p->z);
char *z = sqlite3MPrintf(pParse->db, "-%.*s", p->n, p->z);
if( pLeft->op==TK_FLOAT ){
sqlite3VdbeOp3(v, OP_Real, 0, 0, z, p->n+1);
}else{
@ -2095,7 +2096,7 @@ void sqlite3ExprCode(Parse *pParse, Expr *pExpr){
assert( pExpr->iColumn==OE_Rollback ||
pExpr->iColumn == OE_Abort ||
pExpr->iColumn == OE_Fail );
sqlite3DequoteExpr(pExpr);
sqlite3DequoteExpr(pParse->db, pExpr);
sqlite3VdbeOp3(v, OP_Halt, SQLITE_CONSTRAINT, pExpr->iColumn,
(char*)pExpr->token.z, pExpr->token.n);
} else {
@ -2465,7 +2466,6 @@ static int analyzeAggregate(void *pArg, Expr *pExpr){
Parse *pParse = pNC->pParse;
SrcList *pSrcList = pNC->pSrcList;
AggInfo *pAggInfo = pNC->pAggInfo;
switch( pExpr->op ){
case TK_AGG_COLUMN:
@ -2491,7 +2491,9 @@ static int analyzeAggregate(void *pArg, Expr *pExpr){
break;
}
}
if( k>=pAggInfo->nColumn && (k = addAggInfoColumn(pAggInfo))>=0 ){
if( (k>=pAggInfo->nColumn)
&& (k = addAggInfoColumn(pParse->db, pAggInfo))>=0
){
pCol = &pAggInfo->aCol[k];
pCol->pTab = pExpr->pTab;
pCol->iTable = pExpr->iTable;
@ -2548,7 +2550,7 @@ static int analyzeAggregate(void *pArg, Expr *pExpr){
/* pExpr is original. Make a new entry in pAggInfo->aFunc[]
*/
u8 enc = ENC(pParse->db);
i = addAggInfoFunc(pAggInfo);
i = addAggInfoFunc(pParse->db, pAggInfo);
if( i>=0 ){
pItem = &pAggInfo->aFunc[i];
pItem->pExpr = pExpr;

18
src/func.c
View File

@ -16,7 +16,7 @@
** sqliteRegisterBuildinFunctions() found at the bottom of the file.
** All other code has file scope.
**
** $Id: func.c,v 1.164 2007/08/16 04:30:40 drh Exp $
** $Id: func.c,v 1.165 2007/08/16 10:09:03 danielk1977 Exp $
*/
#include "sqliteInt.h"
#include <ctype.h>
@ -1064,13 +1064,13 @@ static void test_destructor(
test_destructor_count_var++;
assert( nArg==1 );
if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return;
len = sqlite3ValueBytes(argv[0], ENC(db));
zVal = sqliteMalloc(len+3);
len = sqlite3ValueBytes(0, argv[0], ENC(db));
zVal = sqlite3_malloc(len+3);
zVal[len] = 0;
zVal[len-1] = 0;
assert( zVal );
zVal++;
memcpy(zVal, sqlite3ValueText(argv[0], ENC(db)), len);
memcpy(zVal, sqlite3ValueText(0, argv[0], ENC(db)), len);
if( ENC(db)==SQLITE_UTF8 ){
sqlite3_result_text(pCtx, zVal, -1, destructor);
#ifndef SQLITE_OMIT_UTF16
@ -1109,7 +1109,7 @@ static void test_auxdata(
sqlite3_value **argv
){
int i;
char *zRet = sqliteMalloc(nArg*2);
char *zRet = sqlite3_malloc(nArg*2);
if( !zRet ) return;
for(i=0; i<nArg; i++){
char const *z = (char*)sqlite3_value_text(argv[i]);
@ -1273,10 +1273,10 @@ static void minmaxStep(sqlite3_context *context, int argc, sqlite3_value **argv)
max = sqlite3_user_data(context)!=0;
cmp = sqlite3MemCompare(pBest, pArg, pColl);
if( (max && cmp<0) || (!max && cmp>0) ){
sqlite3VdbeMemCopy(pBest, pArg);
sqlite3VdbeMemCopy(0, pBest, pArg);
}
}else{
sqlite3VdbeMemCopy(pBest, pArg);
sqlite3VdbeMemCopy(0, pBest, pArg);
}
}
static void minMaxFinalize(sqlite3_context *context){
@ -1408,11 +1408,11 @@ void sqlite3RegisterBuiltinFunctions(sqlite3 *db){
}
}
sqlite3RegisterDateTimeFunctions(db);
if( !sqlite3MallocFailed() ){
if( !db->mallocFailed ){
int rc = sqlite3_overload_function(db, "MATCH", 2);
assert( rc==SQLITE_NOMEM || rc==SQLITE_OK );
if( rc==SQLITE_NOMEM ){
sqlite3FailedMalloc();
db->mallocFailed = 1;
}
}
#ifdef SQLITE_SSE

4
src/hash.c
View File

@ -12,7 +12,7 @@
** This is the implementation of generic hash-tables
** used in SQLite.
**
** $Id: hash.c,v 1.20 2007/08/16 04:30:40 drh Exp $
** $Id: hash.c,v 1.21 2007/08/16 10:09:03 danielk1977 Exp $
*/
#include "sqliteInt.h"
#include <assert.h>
@ -222,7 +222,7 @@ static void rehash(Hash *pH, int new_size){
int (*xHash)(const void*,int); /* The hash function */
assert( (new_size & (new_size-1))==0 );
new_ht = (struct _ht *)sqlite3_malloc( new_size*sizeof(struct _ht) );
new_ht = (struct _ht *)sqlite3MallocZero( new_size*sizeof(struct _ht) );
if( new_ht==0 ) return;
if( pH->ht ) sqlite3_free(pH->ht);
pH->ht = new_ht;

20
src/main.c
View File

@ -14,7 +14,7 @@
** other files are for internal use by SQLite and should not be
** accessed by users of the library.
**
** $Id: main.c,v 1.380 2007/08/16 04:30:40 drh Exp $
** $Id: main.c,v 1.381 2007/08/16 10:09:03 danielk1977 Exp $
*/
#include "sqliteInt.h"
#include "os.h"
@ -219,7 +219,7 @@ int sqlite3_close(sqlite3 *db){
*/
sqlite3_free(db->aDb[1].pSchema);
sqlite3_free(db);
sqlite3ReleaseThreadData();
/* sqlite3ReleaseThreadData(); */
return SQLITE_OK;
}
@ -542,7 +542,7 @@ int sqlite3_create_function16(
char *zFunc8;
assert( !db->mallocFailed );
zFunc8 = sqlite3Utf16to8(zFunctionName, -1);
zFunc8 = sqlite3Utf16to8(db, zFunctionName, -1);
rc = sqlite3CreateFunc(db, zFunc8, nArg, eTextRep, p, xFunc, xStep, xFinal);
sqlite3_free(zFunc8);
@ -780,7 +780,7 @@ const void *sqlite3_errmsg16(sqlite3 *db){
}
z = sqlite3_value_text16(db->pErr);
if( z==0 ){
sqlite3ValueSetStr(db->pErr, -1, sqlite3ErrStr(db->errCode),
sqlite3ValueSetStr(db, db->pErr, -1, sqlite3ErrStr(db->errCode),
SQLITE_UTF8, SQLITE_STATIC);
z = sqlite3_value_text16(db->pErr);
}
@ -1044,15 +1044,15 @@ int sqlite3_open16(
sqlite3 **ppDb
){
char const *zFilename8; /* zFilename encoded in UTF-8 instead of UTF-16 */
int rc = SQLITE_OK;
sqlite3_value *pVal;
int rc = SQLITE_NOMEM;
assert( zFilename );
assert( ppDb );
*ppDb = 0;
pVal = sqlite3ValueNew();
sqlite3ValueSetStr(pVal, -1, zFilename, SQLITE_UTF16NATIVE, SQLITE_STATIC);
zFilename8 = sqlite3ValueText(pVal, SQLITE_UTF8);
pVal = sqlite3ValueNew(0);
sqlite3ValueSetStr(0, pVal, -1, zFilename, SQLITE_UTF16NATIVE, SQLITE_STATIC);
zFilename8 = sqlite3ValueText(0, pVal, SQLITE_UTF8);
if( zFilename8 ){
rc = openDatabase(zFilename8, ppDb);
if( rc==SQLITE_OK && *ppDb ){
@ -1155,7 +1155,7 @@ int sqlite3_create_collation16(
int rc = SQLITE_OK;
char *zName8;
assert( !db->mallocFailed );
zName8 = sqlite3Utf16to8(zName, -1);
zName8 = sqlite3Utf16to8(db, zName, -1);
if( zName8 ){
rc = createCollation(db, zName8, enc, pCtx, xCompare, 0);
sqlite3_free(zName8);
@ -1258,7 +1258,7 @@ int sqlite3_enable_shared_cache(int enable){
}
pTd->useSharedData = enable;
sqlite3ReleaseThreadData();
/* sqlite3ReleaseThreadData(); */
}
return sqlite3ApiExit(0, SQLITE_OK);
}

37
src/malloc.c
View File

@ -12,7 +12,7 @@
** Memory allocation functions used throughout sqlite.
**
**
** $Id: malloc.c,v 1.5 2007/08/16 04:30:40 drh Exp $
** $Id: malloc.c,v 1.6 2007/08/16 10:09:03 danielk1977 Exp $
*/
#include "sqliteInt.h"
#include "os.h"
@ -24,18 +24,24 @@
** value indicates no limit.
*/
void sqlite3_soft_heap_limit(int n){
#ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT
ThreadData *pTd = sqlite3ThreadData();
if( pTd ){
pTd->nSoftHeapLimit = n;
}
sqlite3ReleaseThreadData();
#endif
}
/*
** Release memory held by SQLite instances created by the current thread.
*/
int sqlite3_release_memory(int n){
#if defined(SQLITE_ENABLE_MEMORY_MANAGEMENT) && !defined(SQLITE_OMIT_DISKIO)
return sqlite3PagerReleaseMemory(n);
#else
return SQLITE_OK;
#endif
}
@ -84,7 +90,7 @@ void *sqlite3DbReallocOrFree(sqlite3 *db, void *p, int n){
void *pNew;
pNew = sqlite3_realloc(p, n);
if( !pNew ){
sqlite3FreeX(p);
sqlite3_free(p);
db->mallocFailed = 1;
}
return pNew;
@ -103,14 +109,14 @@ char *sqlite3StrDup(const char *z){
int n;
if( z==0 ) return 0;
n = strlen(z)+1;
zNew = sqlite3MallocRaw(n, 1);
zNew = sqlite3_malloc(n);
if( zNew ) memcpy(zNew, z, n);
return zNew;
}
char *sqlite3StrNDup(const char *z, int n){
char *zNew;
if( z==0 ) return 0;
zNew = sqlite3MallocRaw(n+1, 1);
zNew = sqlite3_malloc(n+1);
if( zNew ){
memcpy(zNew, z, n);
zNew[n] = 0;
@ -118,6 +124,21 @@ char *sqlite3StrNDup(const char *z, int n){
return zNew;
}
char *sqlite3DbStrDup(sqlite3 *db, const char *z){
char *zNew = sqlite3StrDup(z);
if( z && !zNew ){
db->mallocFailed = 1;
}
return zNew;
}
char *sqlite3DbStrNDup(sqlite3 *db, const char *z, int n){
char *zNew = sqlite3StrNDup(z, n);
if( z && !zNew ){
db->mallocFailed = 1;
}
return zNew;
}
/*
** Create a string from the 2nd and subsequent arguments (up to the
** first NULL argument), store the string in memory obtained from
@ -138,8 +159,8 @@ void sqlite3SetString(char **pz, ...){
nByte += strlen(z);
}
va_end(ap);
sqliteFree(*pz);
*pz = zResult = sqliteMallocRaw( nByte );
sqlite3_free(*pz);
*pz = zResult = sqlite3_malloc(nByte);
if( zResult==0 ){
return;
}
@ -169,7 +190,7 @@ void sqlite3SetString(char **pz, ...){
** is set to SQLITE_NOMEM.
*/
int sqlite3ApiExit(sqlite3* db, int rc){
if( db->mallocFailed ){
if( db && db->mallocFailed ){
sqlite3Error(db, SQLITE_NOMEM, 0);
db->mallocFailed = 0;
rc = SQLITE_NOMEM;
@ -182,6 +203,7 @@ int sqlite3ApiExit(sqlite3* db, int rc){
** This function sets a flag in the thread-specific-data structure that will
** cause an assert to fail if sqliteMalloc() or sqliteRealloc() is called.
*/
#if 0
void sqlite3MallocDisallow(){
#if 0
assert( sqlite3_mallocDisallowed>=0 );
@ -200,3 +222,4 @@ void sqlite3MallocAllow(){
#endif
}
#endif
#endif

3
src/mutex.c
View File

@ -12,7 +12,7 @@
** This file contains the C functions that implement mutexes for
** use by the SQLite core.
**
** $Id: mutex.c,v 1.1 2007/08/15 13:04:54 drh Exp $
** $Id: mutex.c,v 1.2 2007/08/16 10:09:03 danielk1977 Exp $
*/
/*
@ -92,6 +92,7 @@ void sqlite3_mutex_leave(sqlite3_mutex *pNotUsed){
*/
int sqlite3_mutex_serialize(void (*xCallback)(void*), void *pArg){
xCallback(pArg);
return SQLITE_OK;
}
#if 0

4
src/os_unix.c
View File

@ -2296,7 +2296,7 @@ char *sqlite3UnixFullPathname(const char *zRelative){
zBuf[0] = 0;
sqlite3SetString(&zFull, getcwd(zBuf, 5000), "/", zRelative,
(char*)0);
sqliteFree(zBuf);
sqlite3_free(zBuf);
}
#if 0
@ -2899,11 +2899,13 @@ ThreadData *sqlite3UnixThreadSpecificData(int allocateFlag){
static ThreadData *pTsd = 0;
if( allocateFlag>0 ){
if( pTsd==0 ){
#if 0
if( !sqlite3TestMallocFail() ){
pTsd = sqlite3OsMalloc( sizeof(zeroData) );
}
#ifdef SQLITE_MEMDEBUG
sqlite3_isFail = 0;
#endif
#endif
if( pTsd ){
*pTsd = zeroData;

12
src/pager.c
View File

@ -18,7 +18,7 @@
** file simultaneously, or one process from reading the database while
** another is writing.
**
** @(#) $Id: pager.c,v 1.357 2007/08/16 04:30:40 drh Exp $
** @(#) $Id: pager.c,v 1.358 2007/08/16 10:09:03 danielk1977 Exp $
*/
#ifndef SQLITE_OMIT_DISKIO
#include "sqliteInt.h"
@ -2745,7 +2745,15 @@ int sqlite3PagerReleaseMemory(int nReq){
for( pTmp=pPager->pAll; pTmp->pNextAll!=pPg; pTmp=pTmp->pNextAll ){}
pTmp->pNextAll = pPg->pNextAll;
}
#if 0
nReleased += sqliteAllocSize(pPg);
#else
nReleased += (
sizeof(*pPg) + pPager->pageSize
+ sizeof(u32) + pPager->nExtra
+ MEMDB*sizeof(PgHistory)
);
#endif
IOTRACE(("PGFREE %p %d *\n", pPager, pPg->pgno));
PAGER_INCR(sqlite3_pager_pgfree_count);
sqlite3_free(pPg);
@ -3121,7 +3129,9 @@ int sqlite3PagerAcquire(
pPg->pgno = pgno;
assert( !MEMDB || pgno>pPager->stmtSize );
if( pPager->aInJournal && (int)pgno<=pPager->origDbSize ){
#if 0
sqlite3CheckMemory(pPager->aInJournal, pgno/8);
#endif
assert( pPager->journalOpen );
pPg->inJournal = (pPager->aInJournal[pgno/8] & (1<<(pgno&7)))!=0;
pPg->needSync = 0;

6
src/parse.y
View File

@ -14,7 +14,7 @@
** the parser. Lemon will also generate a header file containing
** numeric codes for all of the tokens.
**
** @(#) $Id: parse.y,v 1.232 2007/08/16 04:30:40 drh Exp $
** @(#) $Id: parse.y,v 1.233 2007/08/16 10:09:03 danielk1977 Exp $
*/
// All token codes are small integers with #defines that begin with "TK_"
@ -419,7 +419,7 @@ selcollist(A) ::= sclp(P) expr(X) as(Y). {
A = sqlite3ExprListAppend(pParse,P,X,Y.n?&Y:0);
}
selcollist(A) ::= sclp(P) STAR. {
Expr *p = sqlite3Expr(pParse, TK_ALL, 0, 0, 0);
Expr *p = sqlite3PExpr(pParse, TK_ALL, 0, 0, 0);
A = sqlite3ExprListAppend(pParse, P, p, 0);
}
selcollist(A) ::= sclp(P) nm(X) DOT STAR. {
@ -806,7 +806,7 @@ expr(A) ::= expr(W) between_op(N) expr(X) AND expr(Y). [BETWEEN] {
SrcList *pSrc = sqlite3SrcListAppend(pParse->db, 0,&Y,&Z);
A = sqlite3PExpr(pParse, TK_IN, X, 0, 0);
if( A ){
A->pSelect = sqlite3SelectNew(0,pSrc,0,0,0,0,0,0,0);
A->pSelect = sqlite3SelectNew(pParse, 0,pSrc,0,0,0,0,0,0,0);
sqlite3ExprSetHeight(A);
}else{
sqlite3SrcListDelete(pSrc);

4
src/pragma.c
View File

@ -11,7 +11,7 @@
*************************************************************************
** This file contains code used to implement the PRAGMA command.
**
** $Id: pragma.c,v 1.143 2007/08/16 04:30:40 drh Exp $
** $Id: pragma.c,v 1.144 2007/08/16 10:09:03 danielk1977 Exp $
*/
#include "sqliteInt.h"
#include "os.h"
@ -864,7 +864,7 @@ void sqlite3Pragma(
sqlite3VdbeAddOp(v, OP_IntegrityCk, 0, i);
addr = sqlite3VdbeAddOp(v, OP_IsNull, -1, 0);
sqlite3VdbeOp3(v, OP_String8, 0, 0,
sqlite3MPrintf("*** in database %s ***\n", db->aDb[i].zName),
sqlite3MPrintf(db, "*** in database %s ***\n", db->aDb[i].zName),
P3_DYNAMIC);
sqlite3VdbeAddOp(v, OP_Pull, 1, 0);
sqlite3VdbeAddOp(v, OP_Concat, 0, 0);

8
src/prepare.c
View File

@ -13,7 +13,7 @@
** interface, and routines that contribute to loading the database schema
** from disk.
**
** $Id: prepare.c,v 1.53 2007/08/16 04:30:40 drh Exp $
** $Id: prepare.c,v 1.54 2007/08/16 10:09:03 danielk1977 Exp $
*/
#include "sqliteInt.h"
#include "os.h"
@ -290,7 +290,7 @@ static int sqlite3InitOne(sqlite3 *db, int iDb, char **pzErrMsg){
rc = SQLITE_OK;
}else{
char *zSql;
zSql = sqlite3MPrintf(
zSql = sqlite3MPrintf(db,
"SELECT name, rootpage, sql FROM '%q'.%s",
db->aDb[iDb].zName, zMasterName);
sqlite3SafetyOff(db);
@ -560,7 +560,7 @@ int sqlite3Prepare(
}
rc = sqlite3ApiExit(db, rc);
sqlite3ReleaseThreadData();
/* sqlite3ReleaseThreadData(); */
assert( (rc&db->errMask)==rc );
return rc;
}
@ -647,7 +647,7 @@ static int sqlite3Prepare16(
if( sqlite3SafetyCheck(db) ){
return SQLITE_MISUSE;
}
zSql8 = sqlite3Utf16to8(zSql, nBytes);
zSql8 = sqlite3Utf16to8(db, zSql, nBytes);
if( zSql8 ){
rc = sqlite3Prepare(db, zSql8, -1, saveSqlFlag, ppStmt, &zTail8);
}

10
src/printf.c
View File

@ -701,7 +701,7 @@ static int vxprintf(
}
}
if( zExtra ){
sqliteFree(zExtra);
sqlite3_free(zExtra);
}
}/* End for loop over the format string */
return errorflag ? -1 : count;
@ -717,7 +717,7 @@ struct sgMprintf {
int nChar; /* Length of the string so far */
int nTotal; /* Output size if unconstrained */
int nAlloc; /* Amount of space allocated in zText */
void *(*xRealloc)(void*,int); /* Function used to realloc memory */
void *(*xRealloc)(void*, unsigned int); /* Function used to realloc memory */
};
/*
@ -769,7 +769,7 @@ static void mout(void *arg, const char *zNewText, int nNewChar){
** the consumer.
*/
static char *base_vprintf(
void *(*xRealloc)(void*,int), /* Routine to realloc memory. May be NULL */
void *(*xRealloc)(void*, unsigned int), /* realloc() function. May be NULL */
int useInternal, /* Use internal %-conversions if true */
char *zInitBuf, /* Initially write here, before mallocing */
int nInitBuf, /* Size of zInitBuf[] */
@ -801,8 +801,8 @@ static char *base_vprintf(
/*
** Realloc that is a real function, not a macro.
*/
static void *printf_realloc(void *old, int size){
return sqlite3_realloc(old,size);
static void *printf_realloc(void *old, unsigned int size){
return sqlite3_realloc(old, size);
}
/*

39
src/select.c
View File

@ -12,7 +12,7 @@
** This file contains C code routines that are called by the parser
** to handle SELECT statements in SQLite.
**
** $Id: select.c,v 1.355 2007/08/16 04:30:40 drh Exp $
** $Id: select.c,v 1.356 2007/08/16 10:09:03 danielk1977 Exp $
*/
#include "sqliteInt.h"
@ -193,11 +193,13 @@ static void setToken(Token *p, const char *z){
**
** {a"bc} -> {"a""bc"}
*/
static void setQuotedToken(Token *p, const char *z){
p->z = (u8 *)sqlite3MPrintf("\"%w\"", z);
static void setQuotedToken(Parse *pParse, Token *p, const char *z){
p->z = (u8 *)sqlite3MPrintf(0, "\"%w\"", z);
p->dyn = 1;
if( p->z ){
p->n = strlen((char *)p->z);
}else{
pParse->db->mallocFailed = 1;
}
}
@ -241,7 +243,7 @@ static void addWhereTerm(
pE2b = sqlite3CreateIdExpr(pParse, zAlias2);
pE1c = sqlite3PExpr(pParse, TK_DOT, pE1b, pE1a, 0);
pE2c = sqlite3PExpr(pParse, TK_DOT, pE2b, pE2a, 0);
pE = sqlite3DbExpr(pParse, TK_EQ, pE1c, pE2c, 0);
pE = sqlite3PExpr(pParse, TK_EQ, pE1c, pE2c, 0);
if( pE ){
ExprSetProperty(pE, EP_FromJoin);
pE->iRightJoinTable = iRightJoinTable;
@ -328,7 +330,7 @@ static int sqliteProcessJoin(Parse *pParse, Select *p){
for(j=0; j<pLeftTab->nCol; j++){
char *zName = pLeftTab->aCol[j].zName;
if( columnIndex(pRightTab, zName)>=0 ){
addWhereTerm(zName, pLeftTab, pLeft->zAlias,
addWhereTerm(pParse, zName, pLeftTab, pLeft->zAlias,
pRightTab, pRight->zAlias,
pRight->iCursor, &p->pWhere);
@ -369,7 +371,7 @@ static int sqliteProcessJoin(Parse *pParse, Select *p){
"not present in both tables", zName);
return 1;
}
addWhereTerm(zName, pLeftTab, pLeft->zAlias,
addWhereTerm(pParse, zName, pLeftTab, pLeft->zAlias,
pRightTab, pRight->zAlias,
pRight->iCursor, &p->pWhere);
}
@ -1139,7 +1141,7 @@ Table *sqlite3ResultSetOfSelect(Parse *pParse, char *zTabName, Select *pSelect){
for(j=cnt=0; j<i; j++){
if( sqlite3StrICmp(aCol[j].zName, zName)==0 ){
zName[nName] = 0;
zName = sqlite3MPrintf("%z:%d", zName, ++cnt);
zName = sqlite3MPrintf(db, "%z:%d", zName, ++cnt);
j = -1;
if( zName==0 ) break;
}
@ -1225,7 +1227,7 @@ static int prepSelectStmt(Parse *pParse, Select *p){
assert( pFrom->pSelect!=0 );
if( pFrom->zAlias==0 ){
pFrom->zAlias =
sqlite3MPrintf("sqlite_subquery_%p_", (void*)pFrom->pSelect);
sqlite3MPrintf(db, "sqlite_subquery_%p_", (void*)pFrom->pSelect);
}
assert( pFrom->pTab==0 );
pFrom->pTab = pTab =
@ -1364,13 +1366,14 @@ static int prepSelectStmt(Parse *pParse, Select *p){
}
pRight = sqlite3Expr(TK_ID, 0, 0, 0);
if( pRight==0 ) break;
setQuotedToken(&pRight->token, zName);
setQuotedToken(pParse, &pRight->token, zName);
if( zTabName && (longNames || pTabList->nSrc>1) ){
Expr *pLeft = sqlite3Expr(TK_ID, 0, 0, 0);
pExpr = sqlite3Expr(TK_DOT, pLeft, pRight, 0);
if( pExpr==0 ) break;
setQuotedToken(&pLeft->token, zTabName);
setToken(&pExpr->span, sqlite3MPrintf("%s.%s", zTabName, zName));
setQuotedToken(pParse, &pLeft->token, zTabName);
setToken(&pExpr->span,
sqlite3MPrintf(db, "%s.%s", zTabName, zName));
pExpr->span.dyn = 1;
pExpr->token.z = 0;
pExpr->token.n = 0;
@ -2354,17 +2357,17 @@ static int flattenSubquery(
sqlite3DbStrNDup(db, (char*)pExpr->span.z, pExpr->span.n);
}
}
substExprList(p->pEList, iParent, pSub->pEList);
substExprList(db, p->pEList, iParent, pSub->pEList);
if( isAgg ){
substExprList(p->pGroupBy, iParent, pSub->pEList);
substExpr(p->pHaving, iParent, pSub->pEList);
substExprList(db, p->pGroupBy, iParent, pSub->pEList);
substExpr(db, p->pHaving, iParent, pSub->pEList);
}
if( pSub->pOrderBy ){
assert( p->pOrderBy==0 );
p->pOrderBy = pSub->pOrderBy;
pSub->pOrderBy = 0;
}else if( p->pOrderBy ){
substExprList(p->pOrderBy, iParent, pSub->pEList);
substExprList(db, p->pOrderBy, iParent, pSub->pEList);
}
if( pSub->pWhere ){
pWhere = sqlite3ExprDup(db, pSub->pWhere);
@ -2375,13 +2378,13 @@ static int flattenSubquery(
assert( p->pHaving==0 );
p->pHaving = p->pWhere;
p->pWhere = pWhere;
substExpr(p->pHaving, iParent, pSub->pEList);
substExpr(db, p->pHaving, iParent, pSub->pEList);
p->pHaving = sqlite3ExprAnd(db, p->pHaving,
sqlite3ExprDup(db, pSub->pHaving));
assert( p->pGroupBy==0 );
p->pGroupBy = sqlite3ExprListDup(db, pSub->pGroupBy);
}else{
substExpr(p->pWhere, iParent, pSub->pEList);
substExpr(db, p->pWhere, iParent, pSub->pEList);
p->pWhere = sqlite3ExprAnd(db, p->pWhere, pWhere);
}
@ -2718,7 +2721,7 @@ int sqlite3SelectResolve(
}
}
if( db->mallocFailed ){
if( pParse->db->mallocFailed ){
return SQLITE_NOMEM;
}

6
src/sqlite3ext.h
View File

@ -15,7 +15,7 @@
** as extensions by SQLite should #include this file instead of
** sqlite3.h.
**
** @(#) $Id: sqlite3ext.h,v 1.12 2007/07/20 10:48:36 drh Exp $
** @(#) $Id: sqlite3ext.h,v 1.13 2007/08/16 10:09:03 danielk1977 Exp $
*/
#ifndef _SQLITE3EXT_H_
#define _SQLITE3EXT_H_
@ -102,7 +102,7 @@ struct sqlite3_api_routines {
sqlite_int64 (*last_insert_rowid)(sqlite3*);
const char * (*libversion)(void);
int (*libversion_number)(void);
void *(*malloc)(int);
void *(*malloc)(unsigned int);
char * (*mprintf)(const char*,...);
int (*open)(const char*,sqlite3**);
int (*open16)(const void*,sqlite3**);
@ -110,7 +110,7 @@ struct sqlite3_api_routines {
int (*prepare16)(sqlite3*,const void*,int,sqlite3_stmt**,const void**);
void * (*profile)(sqlite3*,void(*)(void*,const char*,sqlite_uint64),void*);
void (*progress_handler)(sqlite3*,int,int(*)(void*),void*);
void *(*realloc)(void*,int);
void *(*realloc)(void*,unsigned int);
int (*reset)(sqlite3_stmt*pStmt);
void (*result_blob)(sqlite3_context*,const void*,int,void(*)(void*));
void (*result_double)(sqlite3_context*,double);

30
src/sqliteInt.h
View File

@ -11,7 +11,7 @@
*************************************************************************
** Internal interface definitions for SQLite.
**
** @(#) $Id: sqliteInt.h,v 1.587 2007/08/16 04:30:40 drh Exp $
** @(#) $Id: sqliteInt.h,v 1.588 2007/08/16 10:09:03 danielk1977 Exp $
*/
#ifndef _SQLITEINT_H_
#define _SQLITEINT_H_
@ -1606,7 +1606,7 @@ void sqlite3FinishCoding(Parse*);
Expr *sqlite3Expr(int, Expr*, Expr*, const Token*);
Expr *sqlite3PExpr(Parse*, int, Expr*, Expr*, const Token*);
Expr *sqlite3RegisterExpr(Parse*,Token*);
Expr *sqlite3ExprAnd(sqlite*,Expr*, Expr*);
Expr *sqlite3ExprAnd(sqlite3*,Expr*, Expr*);
void sqlite3ExprSpan(Expr*,Token*,Token*);
Expr *sqlite3ExprFunction(Parse*,ExprList*, Token*);
void sqlite3ExprAssignVarNumber(Parse*, Expr*);
@ -1685,7 +1685,7 @@ int sqlite3ExprResolveNames(NameContext *, Expr *);
int sqlite3ExprAnalyzeAggregates(NameContext*, Expr*);
int sqlite3ExprAnalyzeAggList(NameContext*,ExprList*);
Vdbe *sqlite3GetVdbe(Parse*);
Expr *sqlite3CreateIdExpr(const char*);
Expr *sqlite3CreateIdExpr(Parse *, const char*);
void sqlite3Randomness(int, void*);
void sqlite3RollbackAll(sqlite3*);
void sqlite3CodeVerifySchema(Parse*, int);
@ -1786,7 +1786,7 @@ int sqlite3IndexAffinityOk(Expr *pExpr, char idx_affinity);
char sqlite3ExprAffinity(Expr *pExpr);
int sqlite3Atoi64(const char*, i64*);
void sqlite3Error(sqlite3*, int, const char*,...);
void *sqlite3HexToBlob(const char *z);
void *sqlite3HexToBlob(sqlite3*, const char *z);
int sqlite3TwoPartName(Parse *, Token *, Token *, Token **);
const char *sqlite3ErrStr(int);
int sqlite3ReadSchema(Parse *pParse);
@ -1798,14 +1798,15 @@ int sqlite3CheckCollSeq(Parse *, CollSeq *);
int sqlite3CheckObjectName(Parse *, const char *);
void sqlite3VdbeSetChanges(sqlite3 *, int);
const void *sqlite3ValueText(sqlite3_value*, u8);
int sqlite3ValueBytes(sqlite3_value*, u8);
void sqlite3ValueSetStr(sqlite3_value*, int, const void *,u8, void(*)(void*));
const void *sqlite3ValueText(sqlite3 *db, sqlite3_value*, u8);
int sqlite3ValueBytes(sqlite3 *db, sqlite3_value*, u8);
void sqlite3ValueSetStr(sqlite3 *,sqlite3_value*, int, const void *,u8,
void(*)(void*));
void sqlite3ValueFree(sqlite3_value*);
sqlite3_value *sqlite3ValueNew(void);
char *sqlite3Utf16to8(const void*, int);
int sqlite3ValueFromExpr(Expr *, u8, u8, sqlite3_value **);
void sqlite3ValueApplyAffinity(sqlite3_value *, u8, u8);
sqlite3_value *sqlite3ValueNew(sqlite3 *);
char *sqlite3Utf16to8(sqlite3 *, const void*, int);
int sqlite3ValueFromExpr(sqlite3 *, Expr *, u8, u8, sqlite3_value **);
void sqlite3ValueApplyAffinity(sqlite3 *, sqlite3_value *, u8, u8);
extern const unsigned char sqlite3UpperToLower[];
void sqlite3RootPageMoved(Db*, int, int);
void sqlite3Reindex(Parse*, Token*, Token*);
@ -1834,7 +1835,7 @@ void sqlite3ReleaseThreadData(void);
void sqlite3AttachFunctions(sqlite3 *);
void sqlite3MinimumFileFormat(Parse*, int, int);
void sqlite3SchemaFree(void *);
Schema *sqlite3SchemaGet(Btree *);
Schema *sqlite3SchemaGet(sqlite3 *, Btree *);
int sqlite3SchemaToIndex(sqlite3 *db, Schema *);
KeyInfo *sqlite3IndexKeyinfo(Parse *, Index *);
int sqlite3CreateFunc(sqlite3 *, const char *, int, int, void *,
@ -1845,6 +1846,9 @@ void sqlite3FailedMalloc(void);
void sqlite3AbortOtherActiveVdbes(sqlite3 *, Vdbe *);
int sqlite3OpenTempDatabase(Parse *);
void *sqlite3DbReallocOrFree(sqlite3 *, void *, int);
sqlite3 *sqlite3DbOfVdbe(Vdbe *);
/*
** The interface to the LEMON-generated parser
*/
@ -1898,7 +1902,7 @@ int sqlite3VtabCallCreate(sqlite3*, int, const char *, char **);
int sqlite3VtabCallConnect(Parse*, Table*);
int sqlite3VtabCallDestroy(sqlite3*, int, const char *);
int sqlite3VtabBegin(sqlite3 *, sqlite3_vtab *);
FuncDef *sqlite3VtabOverloadFunction(FuncDef*, int nArg, Expr*);
FuncDef *sqlite3VtabOverloadFunction(sqlite3 *,FuncDef*, int nArg, Expr*);
void sqlite3InvalidFunction(sqlite3_context*,int,sqlite3_value**);
int sqlite3Reprepare(Vdbe*);
void sqlite3ExprListCheckLength(Parse*, ExprList*, int, const char*);

4
src/table.c
View File

@ -154,12 +154,12 @@ int sqlite3_get_table(
sqlite3_free(*pzErrMsg);
*pzErrMsg = sqlite3_mprintf("%s",res.zErrMsg);
}
sqliteFree(res.zErrMsg);
sqlite3_free(res.zErrMsg);
}
db->errCode = res.rc;
return res.rc & db->errMask;
}
sqliteFree(res.zErrMsg);
sqlite3_free(res.zErrMsg);
if( rc!=SQLITE_OK ){
sqlite3_free_table(&res.azResult[1]);
return rc & db->errMask;

50
src/test1.c
View File

@ -13,7 +13,7 @@
** is not included in the SQLite library. It is used for automated
** testing of the SQLite library.
**
** $Id: test1.c,v 1.260 2007/08/16 04:30:40 drh Exp $
** $Id: test1.c,v 1.261 2007/08/16 10:09:03 danielk1977 Exp $
*/
#include "sqliteInt.h"
#include "tcl.h"
@ -192,9 +192,9 @@ static int getStmtPointer(
static int getFilePointer(
Tcl_Interp *interp,
const char *zArg,
OsFile **ppFile
sqlite3_file **ppFile
){
*ppFile = (OsFile*)sqlite3TextToPtr(zArg);
*ppFile = (sqlite3_file*)sqlite3TextToPtr(zArg);
return TCL_OK;
}
@ -412,7 +412,7 @@ static int test_mprintf_z(
int i;
for(i=2; i<argc; i++){
zResult = sqlite3MPrintf("%z%s%s", zResult, argv[1], argv[i]);
zResult = sqlite3MPrintf(0, "%z%s%s", zResult, argv[1], argv[i]);
}
Tcl_AppendResult(interp, zResult, 0);
sqlite3_free(zResult);
@ -433,7 +433,7 @@ static int test_mprintf_n(
){
char *zStr;
int n = 0;
zStr = sqlite3MPrintf("%s%n", argv[1], &n);
zStr = sqlite3MPrintf(0, "%s%n", argv[1], &n);
sqlite3_free(zStr);
Tcl_SetObjResult(interp, Tcl_NewIntObj(n));
return TCL_OK;
@ -917,15 +917,15 @@ static int test_create_function(
** because it is not tested anywhere else. */
if( rc==SQLITE_OK ){
sqlite3_value *pVal;
#ifdef 0
#if 0
if( sqlite3_iMallocFail>0 ){
sqlite3_iMallocFail++;
}
#endif
pVal = sqlite3ValueNew();
sqlite3ValueSetStr(pVal, -1, "x_sqlite_exec", SQLITE_UTF8, SQLITE_STATIC);
pVal = sqlite3ValueNew(0);
sqlite3ValueSetStr(0,pVal, -1, "x_sqlite_exec", SQLITE_UTF8, SQLITE_STATIC);
rc = sqlite3_create_function16(db,
sqlite3ValueText(pVal, SQLITE_UTF16NATIVE),
sqlite3ValueText(0, pVal, SQLITE_UTF16NATIVE),
1, SQLITE_UTF16, db, sqlite3ExecFunc, 0, 0);
sqlite3ValueFree(pVal);
}
@ -2055,12 +2055,12 @@ static int test_collate_func(
assert(0);
}
pVal = sqlite3ValueNew();
sqlite3ValueSetStr(pVal, nA, zA, encin, SQLITE_STATIC);
pVal = sqlite3ValueNew(0);
sqlite3ValueSetStr(0, pVal, nA, zA, encin, SQLITE_STATIC);
n = sqlite3_value_bytes(pVal);
Tcl_ListObjAppendElement(i,pX,
Tcl_NewStringObj((char*)sqlite3_value_text(pVal),n));
sqlite3ValueSetStr(pVal, nB, zB, encin, SQLITE_STATIC);
sqlite3ValueSetStr(0, pVal, nB, zB, encin, SQLITE_STATIC);
n = sqlite3_value_bytes(pVal);
Tcl_ListObjAppendElement(i,pX,
Tcl_NewStringObj((char*)sqlite3_value_text(pVal),n));
@ -2100,10 +2100,10 @@ static int test_collate(
sqlite3_iMallocFail++;
}
#endif
pVal = sqlite3ValueNew();
sqlite3ValueSetStr(pVal, -1, "test_collate", SQLITE_UTF8, SQLITE_STATIC);
pVal = sqlite3ValueNew(0);
sqlite3ValueSetStr(0, pVal, -1, "test_collate", SQLITE_UTF8, SQLITE_STATIC);
rc = sqlite3_create_collation16(db,
sqlite3ValueText(pVal, SQLITE_UTF16NATIVE), SQLITE_UTF16BE,
sqlite3ValueText(0, pVal, SQLITE_UTF16NATIVE), SQLITE_UTF16BE,
(void *)SQLITE_UTF16BE, val?test_collate_func:0);
sqlite3ValueFree(pVal);
}
@ -2269,8 +2269,8 @@ static void test_function_utf8(
Tcl_EvalObjEx(interp, pX, 0);
Tcl_DecrRefCount(pX);
sqlite3_result_text(pCtx, Tcl_GetStringResult(interp), -1, SQLITE_TRANSIENT);
pVal = sqlite3ValueNew();
sqlite3ValueSetStr(pVal, -1, Tcl_GetStringResult(interp),
pVal = sqlite3ValueNew(0);
sqlite3ValueSetStr(0, pVal, -1, Tcl_GetStringResult(interp),
SQLITE_UTF8, SQLITE_STATIC);
sqlite3_result_text16be(pCtx, sqlite3_value_text16be(pVal),
-1, SQLITE_TRANSIENT);
@ -2292,8 +2292,8 @@ static void test_function_utf16le(
Tcl_NewStringObj((char*)sqlite3_value_text(argv[0]), -1));
Tcl_EvalObjEx(interp, pX, 0);
Tcl_DecrRefCount(pX);
pVal = sqlite3ValueNew();
sqlite3ValueSetStr(pVal, -1, Tcl_GetStringResult(interp),
pVal = sqlite3ValueNew(0);
sqlite3ValueSetStr(0, pVal, -1, Tcl_GetStringResult(interp),
SQLITE_UTF8, SQLITE_STATIC);
sqlite3_result_text(pCtx,(char*)sqlite3_value_text(pVal),-1,SQLITE_TRANSIENT);
sqlite3ValueFree(pVal);
@ -2314,8 +2314,8 @@ static void test_function_utf16be(
Tcl_NewStringObj((char*)sqlite3_value_text(argv[0]), -1));
Tcl_EvalObjEx(interp, pX, 0);
Tcl_DecrRefCount(pX);
pVal = sqlite3ValueNew();
sqlite3ValueSetStr(pVal, -1, Tcl_GetStringResult(interp),
pVal = sqlite3ValueNew(0);
sqlite3ValueSetStr(0, pVal, -1, Tcl_GetStringResult(interp),
SQLITE_UTF8, SQLITE_STATIC);
sqlite3_result_text16le(pCtx, sqlite3_value_text16le(pVal),
-1, SQLITE_TRANSIENT);
@ -3595,7 +3595,7 @@ static int test_sqlite3OsOpenReadWrite(
int objc,
Tcl_Obj *CONST objv[]
){
OsFile *pFile;
sqlite3_file *pFile;
int rc;
int dummy;
char zBuf[100];
@ -3625,7 +3625,7 @@ static int test_sqlite3OsClose(
int objc,
Tcl_Obj *CONST objv[]
){
OsFile *pFile;
sqlite3_file *pFile;
int rc;
if( objc!=2 ){
@ -3654,7 +3654,7 @@ static int test_sqlite3OsLock(
int objc,
Tcl_Obj *CONST objv[]
){
OsFile * pFile;
sqlite3_file * pFile;
int rc;
if( objc!=3 ){
@ -3702,7 +3702,7 @@ static int test_sqlite3OsUnlock(
int objc,
Tcl_Obj *CONST objv[]
){
OsFile * pFile;
sqlite3_file * pFile;
int rc;
if( objc!=2 ){

4
src/test2.c
View File

@ -13,7 +13,7 @@
** is not included in the SQLite library. It is used for automated
** testing of the SQLite library.
**
** $Id: test2.c,v 1.44 2007/08/15 17:08:46 danielk1977 Exp $
** $Id: test2.c,v 1.45 2007/08/16 10:09:03 danielk1977 Exp $
*/
#include "sqliteInt.h"
#include "os.h"
@ -531,7 +531,7 @@ static int fake_big_file(
int rc;
int n;
i64 offset;
OsFile *fd = 0;
sqlite3_file *fd = 0;
int readOnly = 0;
if( argc!=3 ){
Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],

4
src/test3.c
View File

@ -13,7 +13,7 @@
** is not included in the SQLite library. It is used for automated
** testing of the SQLite library.
**
** $Id: test3.c,v 1.76 2007/08/16 04:30:40 drh Exp $
** $Id: test3.c,v 1.77 2007/08/16 10:09:03 danielk1977 Exp $
*/
#include "sqliteInt.h"
#include "pager.h"
@ -589,7 +589,7 @@ static int btree_integrity_check(
sqlite3_free((void*)aRoot);
if( zResult ){
Tcl_AppendResult(interp, zResult, 0);
sqliteFree(zResult);
sqlite3_free(zResult);
}
return TCL_OK;
}

14
src/test5.c
View File

@ -15,7 +15,7 @@
** is used for testing the SQLite routines for converting between
** the various supported unicode encodings.
**
** $Id: test5.c,v 1.17 2007/08/16 04:30:40 drh Exp $
** $Id: test5.c,v 1.18 2007/08/16 10:09:03 danielk1977 Exp $
*/
#include "sqliteInt.h"
#include "vdbeInt.h"
@ -142,7 +142,7 @@ static int test_translate(
return TCL_ERROR;
}
if( objc==5 ){
xDel = sqlite3FreeX;
xDel = sqlite3_free;
}
enc_from = name_to_enc(interp, objv[2]);
@ -150,14 +150,14 @@ static int test_translate(
enc_to = name_to_enc(interp, objv[3]);
if( !enc_to ) return TCL_ERROR;
pVal = sqlite3ValueNew();
pVal = sqlite3ValueNew(0);
if( enc_from==SQLITE_UTF8 ){
z = Tcl_GetString(objv[1]);
if( objc==5 ){
z = sqlite3StrDup(z);
}
sqlite3ValueSetStr(pVal, -1, z, enc_from, xDel);
sqlite3ValueSetStr(0, pVal, -1, z, enc_from, xDel);
}else{
z = (char*)Tcl_GetByteArrayFromObj(objv[1], &len);
if( objc==5 ){
@ -165,11 +165,11 @@ static int test_translate(
z = sqlite3_malloc(len);
memcpy(z, zTmp, len);
}
sqlite3ValueSetStr(pVal, -1, z, enc_from, xDel);
sqlite3ValueSetStr(0, pVal, -1, z, enc_from, xDel);
}
z = (char *)sqlite3ValueText(pVal, enc_to);
len = sqlite3ValueBytes(pVal, enc_to) + (enc_to==SQLITE_UTF8?1:2);
z = (char *)sqlite3ValueText(0, pVal, enc_to);
len = sqlite3ValueBytes(0, pVal, enc_to) + (enc_to==SQLITE_UTF8?1:2);
Tcl_SetObjResult(interp, Tcl_NewByteArrayObj((u8*)z, len));
sqlite3ValueFree(pVal);

42
src/test6.c
View File

@ -125,7 +125,7 @@ struct WriteBuffer {
struct CrashFile {
const sqlite3_io_methods *pMethod; /* Must be first */
sqlite3_file *pRealFile; /* Underlying "real" file handle */
const char *zName;
char *zName;
};
struct CrashGlobal {
@ -224,7 +224,7 @@ static int writeListSync(CrashFile *pFile, int isCrash){
for(i=iFirst; rc==SQLITE_OK && i<=iLast; i++){
sqlite3Randomness(g.iSectorSize, zGarbage);
rc = sqlite3OsWrite(
pFile->pRealFile, i*g.iSectorSize, zGarbage, g.iSectorSize
pFile->pRealFile, zGarbage, g.iSectorSize, i*g.iSectorSize
);
}
sqlite3_free(zGarbage);
@ -286,7 +286,7 @@ static int writeListAppend(
/*
** Close a crash-file.
*/
int cfClose(sqlite3_file *pFile){
static int cfClose(sqlite3_file *pFile){
CrashFile *pCrash = (CrashFile *)pFile;
writeListSync(pCrash, 0);
sqlite3OsClose(&pCrash->pRealFile);
@ -296,7 +296,12 @@ int cfClose(sqlite3_file *pFile){
/*
** Read data from a crash-file.
*/
int cfRead(sqlite3_file *pFile, void *zBuf, int iAmt, sqlite_int64 iOfst){
static int cfRead(
sqlite3_file *pFile,
void *zBuf,
int iAmt,
sqlite_int64 iOfst
){
CrashFile *pCrash = (CrashFile *)pFile;
sqlite3_int64 iSize;
int rc;
@ -361,21 +366,26 @@ int cfRead(sqlite3_file *pFile, void *zBuf, int iAmt, sqlite_int64 iOfst){
/*
** Write data to a crash-file.
*/
int cfWrite(sqlite3_file *pFile, void *zBuf, int iAmt, sqlite_int64 iOfst){
static int cfWrite(
sqlite3_file *pFile,
const void *zBuf,
int iAmt,
sqlite_int64 iOfst
){
return writeListAppend(pFile, iOfst, zBuf, iAmt);
}
/*
** Truncate a crash-file.
*/
int cfTruncate(sqlite3_file *pFile, sqlite_int64 size){
static int cfTruncate(sqlite3_file *pFile, sqlite_int64 size){
return writeListAppend(pFile, size, 0, 0);
}
/*
** Sync a crash-file.
*/
int cfSync(sqlite3_file *pFile, int flags){
static int cfSync(sqlite3_file *pFile, int flags){
CrashFile *pCrash = (CrashFile *)pFile;
int isCrash = 0;
@ -391,7 +401,7 @@ int cfSync(sqlite3_file *pFile, int flags){
/*
** Return the current file-size of the crash-file.
*/
int cfFileSize(sqlite3_file *pFile, sqlite_int64 *pSize){
static int cfFileSize(sqlite3_file *pFile, sqlite_int64 *pSize){
CrashFile *pCrash = (CrashFile *)pFile;
WriteBuffer *pWrite;
int rc;
@ -416,16 +426,16 @@ int cfFileSize(sqlite3_file *pFile, sqlite_int64 *pSize){
/*
** Calls related to file-locks are passed on to the real file handle.
*/
int cfLock(sqlite3_file *pFile, int eLock){
static int cfLock(sqlite3_file *pFile, int eLock){
return sqlite3OsLock(((CrashFile *)pFile)->pRealFile, eLock);
}
int cfUnlock(sqlite3_file *pFile, int eLock){
static int cfUnlock(sqlite3_file *pFile, int eLock){
return sqlite3OsUnlock(((CrashFile *)pFile)->pRealFile, eLock);
}
int cfCheckReservedLock(sqlite3_file *pFile){
static int cfCheckReservedLock(sqlite3_file *pFile){
return sqlite3OsCheckReservedLock(((CrashFile *)pFile)->pRealFile);
}
int cfBreakLock(sqlite3_file *pFile){
static int cfBreakLock(sqlite3_file *pFile){
return sqlite3OsBreakLock(((CrashFile *)pFile)->pRealFile);
}
@ -434,10 +444,10 @@ int cfBreakLock(sqlite3_file *pFile){
** the global values configured by the [sqlite_crashparams] tcl
* interface.
*/
int cfSectorSize(sqlite3_file *pFile){
static int cfSectorSize(sqlite3_file *pFile){
return g.iSectorSize;
}
int cfDeviceCharacteristics(sqlite3_file *pFile){
static int cfDeviceCharacteristics(sqlite3_file *pFile){
return g.iDeviceCharacteristics;
}
@ -474,7 +484,7 @@ int sqlite3CrashFileOpen(
pReal = (sqlite3_file *)sqlite3_malloc(pVfs->szOsFile);
if( pReal ){
pWrapper->pMethod = &CrashFileVtab;
pWrapper->zName = zName;
pWrapper->zName = (char *)zName;
rc = pVfs->xOpen(pVfs->pAppData, zName, pReal, flags, pOutFlags);
if( rc==SQLITE_OK ){
pWrapper->pRealFile = pFile;
@ -498,7 +508,7 @@ int sqlite3CrashFileWrap(
pWrapper->pMethod = &CrashFileVtab;
pWrapper->pRealFile = pFile;
pWrapper->zName = &pWrapper[1];
pWrapper->zName = (char *)&pWrapper[1];
memcpy(pWrapper->zName, zName, strlen(zName)+1);
*ppWrapper = (sqlite3_file *)pWrapper;

20
src/test8.c
View File

@ -13,7 +13,7 @@
** is not included in the SQLite library. It is used for automated
** testing of the SQLite library.
**
** $Id: test8.c,v 1.49 2007/08/16 04:30:40 drh Exp $
** $Id: test8.c,v 1.50 2007/08/16 10:09:03 danielk1977 Exp $
*/
#include "sqliteInt.h"
#include "tcl.h"
@ -220,7 +220,7 @@ static int getIndexArray(
}
/* Compile an sqlite pragma to loop through all indices on table zTab */
zSql = sqlite3MPrintf("PRAGMA index_list(%s)", zTab);
zSql = sqlite3MPrintf(0, "PRAGMA index_list(%s)", zTab);
if( !zSql ){
rc = SQLITE_NOMEM;
goto get_index_array_out;
@ -234,7 +234,7 @@ static int getIndexArray(
while( pStmt && sqlite3_step(pStmt)==SQLITE_ROW ){
const char *zIdx = (const char *)sqlite3_column_text(pStmt, 1);
sqlite3_stmt *pStmt2 = 0;
zSql = sqlite3MPrintf("PRAGMA index_info(%s)", zIdx);
zSql = sqlite3MPrintf(0, "PRAGMA index_info(%s)", zIdx);
if( !zSql ){
rc = SQLITE_NOMEM;
goto get_index_array_out;
@ -372,7 +372,7 @@ static int echoConstructor(
pVtab->db = db;
/* Allocate echo_vtab.zThis */
pVtab->zThis = sqlite3MPrintf("%s", argv[2]);
pVtab->zThis = sqlite3MPrintf(0, "%s", argv[2]);
if( !pVtab->zThis ){
echoDestructor((sqlite3_vtab *)pVtab);
return SQLITE_NOMEM;
@ -380,10 +380,10 @@ static int echoConstructor(
/* Allocate echo_vtab.zTableName */
if( argc>3 ){
pVtab->zTableName = sqlite3MPrintf("%s", argv[3]);
pVtab->zTableName = sqlite3MPrintf(0, "%s", argv[3]);
dequoteString(pVtab->zTableName);
if( pVtab->zTableName && pVtab->zTableName[0]=='*' ){
char *z = sqlite3MPrintf("%s%s", argv[2], &(pVtab->zTableName[1]));
char *z = sqlite3MPrintf(0, "%s%s", argv[2], &(pVtab->zTableName[1]));
sqlite3_free(pVtab->zTableName);
pVtab->zTableName = z;
pVtab->isPattern = 1;
@ -440,8 +440,8 @@ static int echoCreate(
if( rc==SQLITE_OK && argc==5 ){
char *zSql;
echo_vtab *pVtab = *(echo_vtab **)ppVtab;
pVtab->zLogName = sqlite3MPrintf("%s", argv[4]);
zSql = sqlite3MPrintf("CREATE TABLE %Q(logmsg)", pVtab->zLogName);
pVtab->zLogName = sqlite3MPrintf(0, "%s", argv[4]);
zSql = sqlite3MPrintf(0, "CREATE TABLE %Q(logmsg)", pVtab->zLogName);
rc = sqlite3_exec(db, zSql, 0, 0, 0);
sqlite3_free(zSql);
}
@ -482,7 +482,7 @@ static int echoDestroy(sqlite3_vtab *pVtab){
/* Drop the "log" table, if one exists (see echoCreate() for details) */
if( p && p->zLogName ){
char *zSql;
zSql = sqlite3MPrintf("DROP TABLE %Q", p->zLogName);
zSql = sqlite3MPrintf(0, "DROP TABLE %Q", p->zLogName);
rc = sqlite3_exec(p->db, zSql, 0, 0, 0);
sqlite3_free(zSql);
}
@ -1037,7 +1037,7 @@ static int echoRename(sqlite3_vtab *vtab, const char *zNewName){
if( p->isPattern ){
int nThis = strlen(p->zThis);
char *zSql = sqlite3MPrintf("ALTER TABLE %s RENAME TO %s%s",
char *zSql = sqlite3MPrintf(0, "ALTER TABLE %s RENAME TO %s%s",
p->zTableName, zNewName, &p->zTableName[nThis]
);
rc = sqlite3_exec(p->db, zSql, 0, 0, 0);

4
src/tokenize.c
View File

@ -15,7 +15,7 @@
** individual tokens and sends those tokens one-by-one over to the
** parser for analysis.
**
** $Id: tokenize.c,v 1.132 2007/08/16 04:30:40 drh Exp $
** $Id: tokenize.c,v 1.133 2007/08/16 10:09:03 danielk1977 Exp $
*/
#include "sqliteInt.h"
#include "os.h"
@ -435,7 +435,7 @@ int sqlite3RunParser(Parse *pParse, const char *zSql, char **pzErrMsg){
case TK_ILLEGAL: {
if( pzErrMsg ){
sqlite3_free(*pzErrMsg);
*pzErrMsg = sqlite3MPrintf("unrecognized token: \"%T\"",
*pzErrMsg = sqlite3MPrintf(db, "unrecognized token: \"%T\"",
&pParse->sLastToken);
}
nErr++;

5
src/trigger.c
View File

@ -253,8 +253,9 @@ void sqlite3FinishTrigger(
sqlite3VdbeChangeP3(v, addr+6, (char*)pAll->z, pAll->n);
sqlite3ChangeCookie(db, v, iDb);
sqlite3VdbeAddOp(v, OP_Close, 0, 0);
sqlite3VdbeOp3(v, OP_ParseSchema, iDb, 0,
sqlite3MPrintf("type='trigger' AND name='%q'", pTrig->name), P3_DYNAMIC);
sqlite3VdbeOp3(v, OP_ParseSchema, iDb, 0, sqlite3MPrintf(
db, "type='trigger' AND name='%q'", pTrig->name), P3_DYNAMIC
);
}
if( db->init.busy ){

4
src/update.c
View File

@ -12,7 +12,7 @@
** This file contains C code routines that are called by the parser
** to handle UPDATE statements.
**
** $Id: update.c,v 1.139 2007/08/16 04:30:40 drh Exp $
** $Id: update.c,v 1.140 2007/08/16 10:09:03 danielk1977 Exp $
*/
#include "sqliteInt.h"
@ -60,7 +60,7 @@ void sqlite3ColumnDefault(Vdbe *v, Table *pTab, int i){
u8 enc = ENC(sqlite3VdbeDb(v));
Column *pCol = &pTab->aCol[i];
assert( i<pTab->nCol );
sqlite3ValueFromExpr(pCol->pDflt, enc, pCol->affinity, &pValue);
sqlite3ValueFromExpr(sqlite3VdbeDb(v), pCol->pDflt, enc, pCol->affinity, &pValue);
if( pValue ){
sqlite3VdbeChangeP3(v, -1, (const char *)pValue, P3_MEM);
}else{

11
src/utf.c
View File

@ -12,7 +12,7 @@
** This file contains routines used to translate between UTF-8,
** UTF-16, UTF-16BE, and UTF-16LE.
**
** $Id: utf.c,v 1.54 2007/08/16 04:30:40 drh Exp $
** $Id: utf.c,v 1.55 2007/08/16 10:09:03 danielk1977 Exp $
**
** Notes on UTF-8:
**
@ -216,7 +216,7 @@ int sqlite3VdbeMemTranslate(sqlite3 *db, Mem *pMem, u8 desiredEnc){
if( pMem->enc!=SQLITE_UTF8 && desiredEnc!=SQLITE_UTF8 ){
u8 temp;
int rc;
rc = sqlite3VdbeMemMakeWriteable(pMem);
rc = sqlite3VdbeMemMakeWriteable(db, pMem);
if( rc!=SQLITE_OK ){
assert( rc==SQLITE_NOMEM );
return SQLITE_NOMEM;
@ -336,7 +336,7 @@ translate_out:
** The allocation (static, dynamic etc.) and encoding of the Mem may be
** changed by this function.
*/
int sqlite3VdbeMemHandleBom(Mem *pMem){
int sqlite3VdbeMemHandleBom(sqlite3 *db, Mem *pMem){
int rc = SQLITE_OK;
u8 bom = 0;
@ -364,10 +364,11 @@ int sqlite3VdbeMemHandleBom(Mem *pMem){
char *z = pMem->z;
pMem->z = 0;
pMem->xDel = 0;
rc = sqlite3VdbeMemSetStr(pMem, &z[2], pMem->n-2, bom, SQLITE_TRANSIENT);
rc = sqlite3VdbeMemSetStr(db, pMem, &z[2], pMem->n-2, bom,
SQLITE_TRANSIENT);
xDel(z);
}else{
rc = sqlite3VdbeMemSetStr(pMem, &pMem->z[2], pMem->n-2, bom,
rc = sqlite3VdbeMemSetStr(db, pMem, &pMem->z[2], pMem->n-2, bom,
SQLITE_TRANSIENT);
}
}

16
src/util.c
View File

@ -14,7 +14,7 @@
** This file contains functions for allocating memory, comparing
** strings, and stuff like that.
**
** $Id: util.c,v 1.208 2007/08/16 04:30:40 drh Exp $
** $Id: util.c,v 1.209 2007/08/16 10:09:03 danielk1977 Exp $
*/
#include "sqliteInt.h"
#include "os.h"
@ -44,17 +44,17 @@
** to NULL.
*/
void sqlite3Error(sqlite3 *db, int err_code, const char *zFormat, ...){
if( db && (db->pErr || (db->pErr = sqlite3ValueNew())!=0) ){
if( db && (db->pErr || (db->pErr = sqlite3ValueNew(db))!=0) ){
db->errCode = err_code;
if( zFormat ){
char *z;
va_list ap;
va_start(ap, zFormat);
z = sqlite3VMPrintf(zFormat, ap);
z = sqlite3VMPrintf(db, zFormat, ap);
va_end(ap);
sqlite3ValueSetStr(db->pErr, -1, z, SQLITE_UTF8, sqlite3FreeX);
sqlite3ValueSetStr(db, db->pErr, -1, z, SQLITE_UTF8, sqlite3_free);
}else{
sqlite3ValueSetStr(db->pErr, 0, 0, SQLITE_UTF8, SQLITE_STATIC);
sqlite3ValueSetStr(db, db->pErr, 0, 0, SQLITE_UTF8, SQLITE_STATIC);
}
}
}
@ -79,9 +79,9 @@ void sqlite3Error(sqlite3 *db, int err_code, const char *zFormat, ...){
void sqlite3ErrorMsg(Parse *pParse, const char *zFormat, ...){
va_list ap;
pParse->nErr++;
sqliteFree(pParse->zErrMsg);
sqlite3_free(pParse->zErrMsg);
va_start(ap, zFormat);
pParse->zErrMsg = sqlite3VMPrintf(zFormat, ap);
pParse->zErrMsg = sqlite3VMPrintf(pParse->db, zFormat, ap);
va_end(ap);
if( pParse->rc==SQLITE_OK ){
pParse->rc = SQLITE_ERROR;
@ -92,7 +92,7 @@ void sqlite3ErrorMsg(Parse *pParse, const char *zFormat, ...){
** Clear the error message in pParse, if any
*/
void sqlite3ErrorClear(Parse *pParse){
sqliteFree(pParse->zErrMsg);
sqlite3_free(pParse->zErrMsg);
pParse->zErrMsg = 0;
pParse->nErr = 0;
}

118
src/vdbe.c
View File

@ -43,7 +43,7 @@
** in this file for details. If in doubt, do not deviate from existing
** commenting and indentation practices when changing or adding code.
**
** $Id: vdbe.c,v 1.640 2007/08/16 04:30:40 drh Exp $
** $Id: vdbe.c,v 1.641 2007/08/16 10:09:03 danielk1977 Exp $
*/
#include "sqliteInt.h"
#include "os.h"
@ -106,8 +106,8 @@ int sqlite3_max_blobsize = 0;
** Convert the given stack entity into a string if it isn't one
** already. Return non-zero if a malloc() fails.
*/
#define Stringify(P, enc) \
if(((P)->flags&(MEM_Str|MEM_Blob))==0 && sqlite3VdbeMemStringify(P,enc)) \
#define Stringify(db, P, enc) \
if(((P)->flags&(MEM_Str|MEM_Blob))==0 && sqlite3VdbeMemStringify(db,P,enc)) \
{ goto no_mem; }
/*
@ -138,15 +138,15 @@ int sqlite3_max_blobsize = 0;
** string that the stack entry itself controls. In other words, it
** converts an MEM_Ephem string into an MEM_Dyn string.
*/
#define Deephemeralize(P) \
#define Deephemeralize(db,P) \
if( ((P)->flags&MEM_Ephem)!=0 \
&& sqlite3VdbeMemMakeWriteable(P) ){ goto no_mem;}
&& sqlite3VdbeMemMakeWriteable(db, P) ){ goto no_mem;}
/*
** Call sqlite3VdbeMemExpandBlob() on the supplied value (type Mem*)
** P if required.
*/
#define ExpandBlob(P) (((P)->flags&MEM_Zero)?sqlite3VdbeMemExpandBlob(P):0)
#define ExpandBlob(D,P) (((P)->flags&MEM_Zero)?sqlite3VdbeMemExpandBlob(D,P):0)
/*
** Argument pMem points at a memory cell that will be passed to a
@ -282,7 +282,7 @@ static void applyAffinity(
*/
int sqlite3_value_numeric_type(sqlite3_value *pVal){
Mem *pMem = (Mem*)pVal;
applyNumericAffinity(pMem);
applyNumericAffinity(0, pMem);
storeTypeInfo(pMem, 0);
return pMem->type;
}
@ -291,8 +291,13 @@ int sqlite3_value_numeric_type(sqlite3_value *pVal){
** Exported version of applyAffinity(). This one works on sqlite3_value*,
** not the internal Mem* type.
*/
void sqlite3ValueApplyAffinity(sqlite3_value *pVal, u8 affinity, u8 enc){
applyAffinity((Mem *)pVal, affinity, enc);
void sqlite3ValueApplyAffinity(
sqlite3 *db,
sqlite3_value *pVal,
u8 affinity,
u8 enc
){
applyAffinity(db, (Mem *)pVal, affinity, enc);
}
#ifdef SQLITE_DEBUG
@ -728,7 +733,7 @@ case OP_Real: { /* same as TK_FLOAT, */
pTos->enc = SQLITE_UTF8;
pTos->r = sqlite3VdbeRealValue(pTos);
pTos->flags |= MEM_Real;
sqlite3VdbeChangeEncoding(pTos, encoding);
sqlite3VdbeChangeEncoding(db, pTos, encoding);
break;
}
@ -747,8 +752,8 @@ case OP_String8: { /* same as TK_STRING */
#ifndef SQLITE_OMIT_UTF16
if( encoding!=SQLITE_UTF8 ){
pTos++;
sqlite3VdbeMemSetStr(pTos, pOp->p3, -1, SQLITE_UTF8, SQLITE_STATIC);
if( SQLITE_OK!=sqlite3VdbeChangeEncoding(pTos, encoding) ) goto no_mem;
sqlite3VdbeMemSetStr(db, pTos, pOp->p3, -1, SQLITE_UTF8, SQLITE_STATIC);
if( SQLITE_OK!=sqlite3VdbeChangeEncoding(db, pTos, encoding) ) goto no_mem;
if( SQLITE_OK!=sqlite3VdbeMemDynamicify(db, pTos) ) goto no_mem;
pTos->flags &= ~(MEM_Dyn);
pTos->flags |= MEM_Static;
@ -807,7 +812,7 @@ case OP_HexBlob: { /* same as TK_BLOB */
assert( SQLITE_MAX_SQL_LENGTH < SQLITE_MAX_LENGTH );
assert( pOp->p1 < SQLITE_MAX_LENGTH );
if( pOp->p1 ){
char *zBlob = sqlite3HexToBlob(pOp->p3);
char *zBlob = sqlite3HexToBlob(db, pOp->p3);
if( !zBlob ) goto no_mem;
if( pOp->p3type==P3_DYNAMIC ){
sqlite3_free(pOp->p3);
@ -837,7 +842,7 @@ case OP_HexBlob: { /* same as TK_BLOB */
case OP_Blob: {
pTos++;
assert( pOp->p1 < SQLITE_MAX_LENGTH ); /* Due to SQLITE_MAX_SQL_LENGTH */
sqlite3VdbeMemSetStr(pTos, pOp->p3, pOp->p1, 0, 0);
sqlite3VdbeMemSetStr(db, pTos, pOp->p3, pOp->p1, 0, 0);
pTos->enc = encoding;
break;
}
@ -898,7 +903,7 @@ case OP_Dup: {
pTos++;
sqlite3VdbeMemShallowCopy(pTos, pFrom, MEM_Ephem);
if( pOp->p2 ){
Deephemeralize(pTos);
Deephemeralize(db, pTos);
}
break;
}
@ -919,9 +924,9 @@ case OP_Pull: { /* no-push */
Mem ts;
ts = *pFrom;
Deephemeralize(pTos);
Deephemeralize(db, pTos);
for(i=0; i<pOp->p1; i++, pFrom++){
Deephemeralize(&pFrom[1]);
Deephemeralize(db, &pFrom[1]);
assert( (pFrom[1].flags & MEM_Ephem)==0 );
*pFrom = pFrom[1];
if( pFrom->flags & MEM_Short ){
@ -949,7 +954,7 @@ case OP_Push: { /* no-push */
Mem *pTo = &pTos[-pOp->p1];
assert( pTo>=p->aStack );
sqlite3VdbeMemMove(pTo, pTos);
sqlite3VdbeMemMove(db, pTo, pTos);
pTos--;
break;
}
@ -977,7 +982,7 @@ case OP_Callback: { /* no-push */
*/
pFirstColumn = &pTos[0-pOp->p1];
for(pMem = p->aStack; pMem<pFirstColumn; pMem++){
Deephemeralize(pMem);
Deephemeralize(db, pMem);
}
/* Invalidate all ephemeral cursor row caches */
@ -988,7 +993,7 @@ case OP_Callback: { /* no-push */
** as side effect.
*/
for(; pMem<=pTos; pMem++ ){
sqlite3VdbeMemNulTerminate(pMem);
sqlite3VdbeMemNulTerminate(db, pMem);
storeTypeInfo(pMem, encoding);
}
@ -1030,8 +1035,8 @@ case OP_Concat: { /* same as TK_CONCAT */
nByte = -1;
break;
}
ExpandBlob(pTerm);
Stringify(pTerm, encoding);
ExpandBlob(db, pTerm);
Stringify(db, pTerm, encoding);
nByte += pTerm->n;
}
@ -1316,10 +1321,10 @@ case OP_Function: {
}
/* Copy the result of the function to the top of the stack */
sqlite3VdbeChangeEncoding(&ctx.s, encoding);
sqlite3VdbeChangeEncoding(db, &ctx.s, encoding);
pTos++;
pTos->flags = 0;
sqlite3VdbeMemMove(pTos, &ctx.s);
sqlite3VdbeMemMove(db, pTos, &ctx.s);
if( sqlite3VdbeMemTooBig(pTos) ){
goto too_big;
}
@ -1412,7 +1417,7 @@ case OP_AddImm: { /* no-push */
case OP_ForceInt: { /* no-push */
i64 v;
assert( pTos>=p->aStack );
applyAffinity(pTos, SQLITE_AFF_NUMERIC, encoding);
applyAffinity(db, pTos, SQLITE_AFF_NUMERIC, encoding);
if( (pTos->flags & (MEM_Int|MEM_Real))==0 ){
Release(pTos);
pTos--;
@ -1447,7 +1452,7 @@ case OP_ForceInt: { /* no-push */
*/
case OP_MustBeInt: { /* no-push */
assert( pTos>=p->aStack );
applyAffinity(pTos, SQLITE_AFF_NUMERIC, encoding);
applyAffinity(db, pTos, SQLITE_AFF_NUMERIC, encoding);
if( (pTos->flags & MEM_Int)==0 ){
if( pOp->p2==0 ){
rc = SQLITE_MISMATCH;
@ -1495,8 +1500,8 @@ case OP_ToText: { /* same as TK_TO_TEXT, no-push */
if( pTos->flags & MEM_Null ) break;
assert( MEM_Str==(MEM_Blob>>3) );
pTos->flags |= (pTos->flags&MEM_Blob)>>3;
applyAffinity(pTos, SQLITE_AFF_TEXT, encoding);
rc = ExpandBlob(pTos);
applyAffinity(db, pTos, SQLITE_AFF_TEXT, encoding);
rc = ExpandBlob(db, pTos);
assert( pTos->flags & MEM_Str );
pTos->flags &= ~(MEM_Int|MEM_Real|MEM_Blob);
break;
@ -1515,7 +1520,7 @@ case OP_ToBlob: { /* same as TK_TO_BLOB, no-push */
assert( pTos>=p->aStack );
if( pTos->flags & MEM_Null ) break;
if( (pTos->flags & MEM_Blob)==0 ){
applyAffinity(pTos, SQLITE_AFF_TEXT, encoding);
applyAffinity(db, pTos, SQLITE_AFF_TEXT, encoding);
assert( pTos->flags & MEM_Str );
pTos->flags |= MEM_Blob;
}
@ -1696,13 +1701,13 @@ case OP_Ge: { /* same as TK_GE, no-push */
affinity = pOp->p1 & 0xFF;
if( affinity ){
applyAffinity(pNos, affinity, encoding);
applyAffinity(pTos, affinity, encoding);
applyAffinity(db, pNos, affinity, encoding);
applyAffinity(db, pTos, affinity, encoding);
}
assert( pOp->p3type==P3_COLLSEQ || pOp->p3==0 );
ExpandBlob(pNos);
ExpandBlob(pTos);
ExpandBlob(db, pNos);
ExpandBlob(db, pTos);
res = sqlite3MemCompare(pNos, pTos, (CollSeq*)pOp->p3);
switch( pOp->opcode ){
case OP_Eq: res = res==0; break;
@ -2113,7 +2118,7 @@ case OP_Column: {
** acquire the complete header text.
*/
if( !zRec && avail<offset ){
rc = sqlite3VdbeMemFromBtree(pCrsr, 0, offset, pC->isIndex, &sMem);
rc = sqlite3VdbeMemFromBtree(db, pCrsr, 0, offset, pC->isIndex, &sMem);
if( rc!=SQLITE_OK ){
goto op_column_out;
}
@ -2167,7 +2172,8 @@ case OP_Column: {
zData = &zRec[aOffset[p2]];
}else{
len = sqlite3VdbeSerialTypeLen(aType[p2]);
rc = sqlite3VdbeMemFromBtree(pCrsr, aOffset[p2], len, pC->isIndex,&sMem);
rc = sqlite3VdbeMemFromBtree(
db, pCrsr, aOffset[p2], len, pC->isIndex, &sMem);
if( rc!=SQLITE_OK ){
goto op_column_out;
}
@ -2199,7 +2205,7 @@ case OP_Column: {
/* pTos->z might be pointing to sMem.zShort[]. Fix that so that we
** can abandon sMem */
rc = sqlite3VdbeMemMakeWriteable(pTos);
rc = sqlite3VdbeMemMakeWriteable(db, pTos);
op_column_out:
break;
@ -2295,13 +2301,13 @@ case OP_MakeRecord: {
for(pRec=pData0; pRec<=pTos; pRec++){
int len;
if( zAffinity ){
applyAffinity(pRec, zAffinity[pRec-pData0], encoding);
applyAffinity(db, pRec, zAffinity[pRec-pData0], encoding);
}
if( pRec->flags&MEM_Null ){
containsNull = 1;
}
if( pRec->flags&MEM_Zero && pRec->n>0 ){
ExpandBlob(pRec);
ExpandBlob(db, pRec);
}
serial_type = sqlite3VdbeSerialType(pRec, file_format);
len = sqlite3VdbeSerialTypeLen(serial_type);
@ -2967,7 +2973,7 @@ case OP_MoveGt: { /* no-push */
pC->rowidIsValid = res==0;
}else{
assert( pTos->flags & MEM_Blob );
ExpandBlob(pTos);
ExpandBlob(db, pTos);
rc = sqlite3BtreeMoveto(pC->pCursor, pTos->z, pTos->n, 0, &res);
if( rc!=SQLITE_OK ){
goto abort_due_to_error;
@ -3075,7 +3081,7 @@ case OP_Found: { /* no-push */
int res, rx;
assert( pC->isTable==0 );
assert( pTos->flags & MEM_Blob );
Stringify(pTos, encoding);
Stringify(db, pTos, encoding);
rx = sqlite3BtreeMoveto(pC->pCursor, pTos->z, pTos->n, 0, &res);
alreadyExists = rx==SQLITE_OK && res==0;
pC->deferredMoveto = 0;
@ -3143,7 +3149,7 @@ case OP_IsUnique: { /* no-push */
/* Make sure K is a string and make zKey point to K
*/
assert( pNos->flags & MEM_Blob );
Stringify(pNos, encoding);
Stringify(db, pNos, encoding);
zKey = pNos->z;
nKey = pNos->n;
@ -3166,7 +3172,7 @@ case OP_IsUnique: { /* no-push */
break;
}
}
rc = sqlite3VdbeIdxKeyCompare(pCx, len, (u8*)zKey, &res);
rc = sqlite3VdbeIdxKeyCompare(db, pCx, len, (u8*)zKey, &res);
if( rc!=SQLITE_OK ) goto abort_due_to_error;
if( res>0 ){
pc = pOp->p2 - 1;
@ -3178,7 +3184,7 @@ case OP_IsUnique: { /* no-push */
** final rowid column is different from R. If it equals R then jump
** immediately to P2.
*/
rc = sqlite3VdbeIdxRowid(pCrsr, &v);
rc = sqlite3VdbeIdxRowid(db, pCrsr, &v);
if( rc!=SQLITE_OK ){
goto abort_due_to_error;
}
@ -3870,7 +3876,7 @@ case OP_IdxInsert: { /* no-push */
assert( pTos->flags & MEM_Blob );
if( (pCrsr = (pC = p->apCsr[i])->pCursor)!=0 ){
assert( pC->isTable==0 );
rc = ExpandBlob(pTos);
rc = ExpandBlob(db, pTos);
if( rc==SQLITE_OK ){
int nKey = pTos->n;
const char *zKey = pTos->z;
@ -3937,7 +3943,7 @@ case OP_IdxRowid: {
if( pC->nullRow ){
pTos->flags = MEM_Null;
}else{
rc = sqlite3VdbeIdxRowid(pCrsr, &rowid);
rc = sqlite3VdbeIdxRowid(db, pCrsr, &rowid);
if( rc!=SQLITE_OK ){
goto abort_due_to_error;
}
@ -4006,10 +4012,10 @@ case OP_IdxGE: { /* no-push */
assert( pTos->flags & MEM_Blob ); /* Created using OP_MakeRecord */
assert( pC->deferredMoveto==0 );
ExpandBlob(pTos);
ExpandBlob(db, pTos);
*pC->pIncrKey = pOp->p3!=0;
assert( pOp->p3==0 || pOp->opcode!=OP_IdxGT );
rc = sqlite3VdbeIdxKeyCompare(pC, pTos->n, (u8*)pTos->z, &res);
rc = sqlite3VdbeIdxKeyCompare(db, pC, pTos->n, (u8*)pTos->z, &res);
*pC->pIncrKey = 0;
if( rc!=SQLITE_OK ){
break;
@ -4202,7 +4208,7 @@ case OP_ParseSchema: { /* no-push */
initData.db = db;
initData.iDb = pOp->p1;
initData.pzErrMsg = &p->zErrMsg;
zSql = sqlite3MPrintf(
zSql = sqlite3MPrintf(db,
"SELECT name, rootpage, sql FROM '%q'.%s WHERE %s",
db->aDb[iDb].zName, zMaster, pOp->p3);
if( zSql==0 ) goto no_mem;
@ -4331,7 +4337,7 @@ case OP_IntegrityCk: {
pTos->xDel = 0;
}
pTos->enc = SQLITE_UTF8;
sqlite3VdbeChangeEncoding(pTos, encoding);
sqlite3VdbeChangeEncoding(db, pTos, encoding);
sqlite3_free(aRoot);
break;
}
@ -4346,7 +4352,7 @@ case OP_FifoWrite: { /* no-push */
assert( pTos>=p->aStack );
sqlite3VdbeMemIntegerify(pTos);
if( sqlite3VdbeFifoPush(&p->sFifo, pTos->u.i)==SQLITE_NOMEM ){
goto nomem;
goto no_mem;
}
assert( (pTos->flags & MEM_Dyn)==0 );
pTos--;
@ -4387,7 +4393,7 @@ case OP_ContextPush: { /* no-push */
/* FIX ME: This should be allocated as part of the vdbe at compile-time */
if( i>=p->contextStackDepth ){
p->contextStackDepth = i+1;
p->contextStack = sqlite3ReallocOrFree(db, p->contextStack,
p->contextStack = sqlite3DbReallocOrFree(db, p->contextStack,
sizeof(Context)*(i+1));
if( p->contextStack==0 ) goto no_mem;
}
@ -4429,7 +4435,7 @@ case OP_ContextPop: { /* no-push */
case OP_MemStore: { /* no-push */
assert( pTos>=p->aStack );
assert( pOp->p1>=0 && pOp->p1<p->nMem );
rc = sqlite3VdbeMemMove(&p->aMem[pOp->p1], pTos);
rc = sqlite3VdbeMemMove(db, &p->aMem[pOp->p1], pTos);
pTos--;
/* If P2 is 0 then fall thru to the next opcode, OP_MemLoad, that will
@ -4583,7 +4589,7 @@ case OP_MemInt: {
case OP_MemMove: {
assert( pOp->p1>=0 && pOp->p1<p->nMem );
assert( pOp->p2>=0 && pOp->p2<p->nMem );
rc = sqlite3VdbeMemMove(&p->aMem[pOp->p1], &p->aMem[pOp->p2]);
rc = sqlite3VdbeMemMove(db, &p->aMem[pOp->p1], &p->aMem[pOp->p2]);
break;
}
@ -4950,10 +4956,10 @@ case OP_VColumn: {
** do this regardless of whether or not an error occured to ensure any
** dynamic allocation in sContext.s (a Mem struct) is released.
*/
sqlite3VdbeChangeEncoding(&sContext.s, encoding);
sqlite3VdbeChangeEncoding(db, &sContext.s, encoding);
pTos++;
pTos->flags = 0;
sqlite3VdbeMemMove(pTos, &sContext.s);
sqlite3VdbeMemMove(db, pTos, &sContext.s);
if( sqlite3SafetyOn(db) ){
goto abort_due_to_misuse;
@ -5022,7 +5028,7 @@ case OP_VRename: { /* no-push */
sqlite3_vtab *pVtab = (sqlite3_vtab *)(pOp->p3);
assert( pVtab->pModule->xRename );
Stringify(pTos, encoding);
Stringify(db, pTos, encoding);
if( sqlite3SafetyOff(db) ) goto abort_due_to_misuse;
sqlite3VtabLock(pVtab);

30
src/vdbeInt.h
View File

@ -376,56 +376,56 @@ int sqlite3VdbeSerialGet(const unsigned char*, u32, Mem*);
void sqlite3VdbeDeleteAuxData(VdbeFunc*, int);
int sqlite2BtreeKeyCompare(BtCursor *, const void *, int, int, int *);
int sqlite3VdbeIdxKeyCompare(Cursor*, int , const unsigned char*, int*);
int sqlite3VdbeIdxRowid(BtCursor *, i64 *);
int sqlite3VdbeIdxKeyCompare(sqlite3*,Cursor*,int,const unsigned char*,int*);
int sqlite3VdbeIdxRowid(sqlite3 *, BtCursor *, i64 *);
int sqlite3MemCompare(const Mem*, const Mem*, const CollSeq*);
int sqlite3VdbeRecordCompare(void*,int,const void*,int, const void*);
int sqlite3VdbeIdxRowidLen(const u8*);
int sqlite3VdbeExec(Vdbe*);
int sqlite3VdbeList(Vdbe*);
int sqlite3VdbeHalt(Vdbe*);
int sqlite3VdbeChangeEncoding(Mem *, int);
int sqlite3VdbeChangeEncoding(sqlite3 *, Mem *, int);
int sqlite3VdbeMemTooBig(Mem*);
int sqlite3VdbeMemCopy(Mem*, const Mem*);
int sqlite3VdbeMemCopy(sqlite3*, Mem*, const Mem*);
void sqlite3VdbeMemShallowCopy(Mem*, const Mem*, int);
int sqlite3VdbeMemMove(Mem*, Mem*);
int sqlite3VdbeMemNulTerminate(Mem*);
int sqlite3VdbeMemSetStr(Mem*, const char*, int, u8, void(*)(void*));
int sqlite3VdbeMemMove(sqlite3*, Mem*, Mem*);
int sqlite3VdbeMemNulTerminate(sqlite3 *, Mem*);
int sqlite3VdbeMemSetStr(sqlite3 *, Mem*, const char*, int, u8, void(*)(void*));
void sqlite3VdbeMemSetInt64(Mem*, i64);
void sqlite3VdbeMemSetDouble(Mem*, double);
void sqlite3VdbeMemSetNull(Mem*);
void sqlite3VdbeMemSetZeroBlob(Mem*,int);
int sqlite3VdbeMemMakeWriteable(Mem*);
int sqlite3VdbeMemDynamicify(Mem*);
int sqlite3VdbeMemStringify(Mem*, int);
int sqlite3VdbeMemMakeWriteable(sqlite3 *, Mem*);
int sqlite3VdbeMemDynamicify(sqlite3 *, Mem*);
int sqlite3VdbeMemStringify(sqlite3*, Mem*, int);
i64 sqlite3VdbeIntValue(Mem*);
int sqlite3VdbeMemIntegerify(Mem*);
double sqlite3VdbeRealValue(Mem*);
void sqlite3VdbeIntegerAffinity(Mem*);
int sqlite3VdbeMemRealify(Mem*);
int sqlite3VdbeMemNumerify(Mem*);
int sqlite3VdbeMemFromBtree(BtCursor*,int,int,int,Mem*);
int sqlite3VdbeMemFromBtree(sqlite3*,BtCursor*,int,int,int,Mem*);
void sqlite3VdbeMemRelease(Mem *p);
int sqlite3VdbeMemFinalize(Mem*, FuncDef*);
#ifndef NDEBUG
void sqlite3VdbeMemSanity(Mem*);
int sqlite3VdbeOpcodeNoPush(u8);
#endif
int sqlite3VdbeMemTranslate(Mem*, u8);
int sqlite3VdbeMemTranslate(sqlite3 *, Mem*, u8);
#ifdef SQLITE_DEBUG
void sqlite3VdbePrintSql(Vdbe*);
void sqlite3VdbeMemPrettyPrint(Mem *pMem, char *zBuf);
#endif
int sqlite3VdbeMemHandleBom(Mem *pMem);
int sqlite3VdbeMemHandleBom(sqlite3 *, Mem *pMem);
void sqlite3VdbeFifoInit(Fifo*);
int sqlite3VdbeFifoPush(Fifo*, i64);
int sqlite3VdbeFifoPop(Fifo*, i64*);
void sqlite3VdbeFifoClear(Fifo*);
#ifndef SQLITE_OMIT_INCRBLOB
int sqlite3VdbeMemExpandBlob(Mem *);
int sqlite3VdbeMemExpandBlob(sqlite3 *, Mem *);
#else
#define sqlite3VdbeMemExpandBlob(x) SQLITE_OK
#define sqlite3VdbeMemExpandBlob(d,x) SQLITE_OK
#endif
#endif /* !defined(_VDBEINT_H_) */

48
src/vdbeapi.c
View File

@ -37,7 +37,7 @@ int sqlite3_expired(sqlite3_stmt *pStmt){
const void *sqlite3_value_blob(sqlite3_value *pVal){
Mem *p = (Mem*)pVal;
if( p->flags & (MEM_Blob|MEM_Str) ){
sqlite3VdbeMemExpandBlob(p);
sqlite3VdbeMemExpandBlob(0, p);
p->flags &= ~MEM_Str;
p->flags |= MEM_Blob;
return p->z;
@ -46,10 +46,10 @@ const void *sqlite3_value_blob(sqlite3_value *pVal){
}
}
int sqlite3_value_bytes(sqlite3_value *pVal){
return sqlite3ValueBytes(pVal, SQLITE_UTF8);
return sqlite3ValueBytes(0, pVal, SQLITE_UTF8);
}
int sqlite3_value_bytes16(sqlite3_value *pVal){
return sqlite3ValueBytes(pVal, SQLITE_UTF16NATIVE);
return sqlite3ValueBytes(0, pVal, SQLITE_UTF16NATIVE);
}
double sqlite3_value_double(sqlite3_value *pVal){
return sqlite3VdbeRealValue((Mem*)pVal);
@ -61,17 +61,17 @@ sqlite_int64 sqlite3_value_int64(sqlite3_value *pVal){
return sqlite3VdbeIntValue((Mem*)pVal);
}
const unsigned char *sqlite3_value_text(sqlite3_value *pVal){
return (const unsigned char *)sqlite3ValueText(pVal, SQLITE_UTF8);
return (const unsigned char *)sqlite3ValueText(0, pVal, SQLITE_UTF8);
}
#ifndef SQLITE_OMIT_UTF16
const void *sqlite3_value_text16(sqlite3_value* pVal){
return sqlite3ValueText(pVal, SQLITE_UTF16NATIVE);
return sqlite3ValueText(0, pVal, SQLITE_UTF16NATIVE);
}
const void *sqlite3_value_text16be(sqlite3_value *pVal){
return sqlite3ValueText(pVal, SQLITE_UTF16BE);
return sqlite3ValueText(0, pVal, SQLITE_UTF16BE);
}
const void *sqlite3_value_text16le(sqlite3_value *pVal){
return sqlite3ValueText(pVal, SQLITE_UTF16LE);
return sqlite3ValueText(0, pVal, SQLITE_UTF16LE);
}
#endif /* SQLITE_OMIT_UTF16 */
int sqlite3_value_type(sqlite3_value* pVal){
@ -90,19 +90,19 @@ void sqlite3_result_blob(
void (*xDel)(void *)
){
assert( n>=0 );
sqlite3VdbeMemSetStr(&pCtx->s, z, n, 0, xDel);
sqlite3VdbeMemSetStr(0, &pCtx->s, z, n, 0, xDel);
}
void sqlite3_result_double(sqlite3_context *pCtx, double rVal){
sqlite3VdbeMemSetDouble(&pCtx->s, rVal);
}
void sqlite3_result_error(sqlite3_context *pCtx, const char *z, int n){
pCtx->isError = 1;
sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF8, SQLITE_TRANSIENT);
sqlite3VdbeMemSetStr(0, &pCtx->s, z, n, SQLITE_UTF8, SQLITE_TRANSIENT);
}
#ifndef SQLITE_OMIT_UTF16
void sqlite3_result_error16(sqlite3_context *pCtx, const void *z, int n){
pCtx->isError = 1;
sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF16NATIVE, SQLITE_TRANSIENT);
sqlite3VdbeMemSetStr(0, &pCtx->s, z, n, SQLITE_UTF16NATIVE, SQLITE_TRANSIENT);
}
#endif
void sqlite3_result_int(sqlite3_context *pCtx, int iVal){
@ -120,7 +120,7 @@ void sqlite3_result_text(
int n,
void (*xDel)(void *)
){
sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF8, xDel);
sqlite3VdbeMemSetStr(0, &pCtx->s, z, n, SQLITE_UTF8, xDel);
}
#ifndef SQLITE_OMIT_UTF16
void sqlite3_result_text16(
@ -129,7 +129,7 @@ void sqlite3_result_text16(
int n,
void (*xDel)(void *)
){
sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF16NATIVE, xDel);
sqlite3VdbeMemSetStr(0, &pCtx->s, z, n, SQLITE_UTF16NATIVE, xDel);
}
void sqlite3_result_text16be(
sqlite3_context *pCtx,
@ -137,7 +137,7 @@ void sqlite3_result_text16be(
int n,
void (*xDel)(void *)
){
sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF16BE, xDel);
sqlite3VdbeMemSetStr(0, &pCtx->s, z, n, SQLITE_UTF16BE, xDel);
}
void sqlite3_result_text16le(
sqlite3_context *pCtx,
@ -145,11 +145,11 @@ void sqlite3_result_text16le(
int n,
void (*xDel)(void *)
){
sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF16LE, xDel);
sqlite3VdbeMemSetStr(0, &pCtx->s, z, n, SQLITE_UTF16LE, xDel);
}
#endif /* SQLITE_OMIT_UTF16 */
void sqlite3_result_value(sqlite3_context *pCtx, sqlite3_value *pValue){
sqlite3VdbeMemCopy(&pCtx->s, pValue);
sqlite3VdbeMemCopy(0, &pCtx->s, pValue);
}
void sqlite3_result_zeroblob(sqlite3_context *pCtx, int n){
sqlite3VdbeMemSetZeroBlob(&pCtx->s, n);
@ -332,10 +332,10 @@ void sqlite3InvalidFunction(
){
const char *zName = context->pFunc->zName;
char *zErr;
zErr = sqlite3MPrintf(
zErr = sqlite3MPrintf(0,
"unable to use function %s in the requested context", zName);
sqlite3_result_error(context, zErr, -1);
sqliteFree(zErr);
sqlite3_free(zErr);
}
/*
@ -352,7 +352,7 @@ void *sqlite3_aggregate_context(sqlite3_context *p, int nByte){
pMem->z = 0;
}else{
pMem->flags = MEM_Agg;
pMem->xDel = sqlite3FreeX;
pMem->xDel = sqlite3_free;
pMem->u.pDef = p->pFunc;
if( nByte<=NBFS ){
pMem->z = pMem->zShort;
@ -736,13 +736,13 @@ static int bindText(
return rc;
}
pVar = &p->aVar[i-1];
rc = sqlite3VdbeMemSetStr(pVar, zData, nData, encoding, xDel);
rc = sqlite3VdbeMemSetStr(0, pVar, zData, nData, encoding, xDel);
if( rc==SQLITE_OK && encoding!=0 ){
rc = sqlite3VdbeChangeEncoding(pVar, ENC(p->db));
rc = sqlite3VdbeChangeEncoding(p->db, pVar, ENC(p->db));
}
sqlite3Error(((Vdbe *)pStmt)->db, rc, 0);
return sqlite3ApiExit(((Vdbe *)pStmt)->db, rc);
sqlite3Error(p->db, rc, 0);
return sqlite3ApiExit(p->db, rc);
}
@ -807,7 +807,7 @@ int sqlite3_bind_value(sqlite3_stmt *pStmt, int i, const sqlite3_value *pValue){
Vdbe *p = (Vdbe *)pStmt;
rc = vdbeUnbind(p, i);
if( rc==SQLITE_OK ){
sqlite3VdbeMemCopy(&p->aVar[i-1], pValue);
rc = sqlite3VdbeMemCopy(0, &p->aVar[i-1], pValue);
}
return rc;
}
@ -905,7 +905,7 @@ int sqlite3_transfer_bindings(sqlite3_stmt *pFromStmt, sqlite3_stmt *pToStmt){
}
for(i=0; rc==SQLITE_OK && i<pFrom->nVar; i++){
sqlite3MallocDisallow();
rc = sqlite3VdbeMemMove(&pTo->aVar[i], &pFrom->aVar[i]);
rc = sqlite3VdbeMemMove(0, &pTo->aVar[i], &pFrom->aVar[i]);
sqlite3MallocAllow();
}
assert( rc==SQLITE_OK || rc==SQLITE_NOMEM );

30
src/vdbeaux.c
View File

@ -122,7 +122,7 @@ static void resizeOpArray(Vdbe *p, int N){
VdbeOp *pNew;
int nNew = N + 100*(!runMode);
int oldSize = p->nOpAlloc;
pNew = sqlite_realloc(p->aOp, nNew*sizeof(Op));
pNew = sqlite3_realloc(p->aOp, nNew*sizeof(Op));
if( pNew ){
p->nOpAlloc = nNew;
p->aOp = pNew;
@ -206,7 +206,7 @@ int sqlite3VdbeMakeLabel(Vdbe *p){
assert( p->magic==VDBE_MAGIC_INIT );
if( i>=p->nLabelAlloc ){
p->nLabelAlloc = p->nLabelAlloc*2 + 10;
p->aLabel = sqlite3ReallocOrFree(p->db, p->aLabel,
p->aLabel = sqlite3DbReallocOrFree(p->db, p->aLabel,
p->nLabelAlloc*sizeof(p->aLabel[0]));
}
if( p->aLabel ){
@ -579,7 +579,7 @@ void sqlite3VdbeComment(Vdbe *p, const char *zFormat, ...){
assert( p->nOp>0 || p->aOp==0 );
assert( p->aOp==0 || p->aOp[p->nOp-1].p3==0 || p->db->mallocFailed );
va_start(ap, zFormat);
sqlite3VdbeChangeP3(p, -1, sqlite3VMPrintf(zFormat, ap), P3_DYNAMIC);
sqlite3VdbeChangeP3(p, -1, sqlite3VMPrintf(p->db, zFormat, ap), P3_DYNAMIC);
va_end(ap);
}
#endif
@ -840,6 +840,7 @@ void sqlite3VdbeMakeReady(
int isExplain /* True if the EXPLAIN keywords is present */
){
int n;
sqlite3 *db = p->db;
assert( p!=0 );
assert( p->magic==VDBE_MAGIC_INIT );
@ -874,7 +875,7 @@ void sqlite3VdbeMakeReady(
if( isExplain ){
nStack = 10;
}
p->aStack = sqlite3DbMallocZer(db,
p->aStack = sqlite3DbMallocZero(db,
nStack*sizeof(p->aStack[0]) /* aStack */
+ nArg*sizeof(Mem*) /* apArg */
+ nVar*sizeof(Mem) /* aVar */
@ -1012,7 +1013,7 @@ void sqlite3VdbeSetNumCols(Vdbe *p, int nResColumn){
sqlite3_free(p->aColName);
n = nResColumn*COLNAME_N;
p->nResColumn = nResColumn;
p->aColName = pColName = (Mem*)sqlite3DbMallocZero(db, sizeof(Mem)*n );
p->aColName = pColName = (Mem*)sqlite3DbMallocZero(p->db, sizeof(Mem)*n );
if( p->aColName==0 ) return;
while( n-- > 0 ){
(pColName++)->flags = MEM_Null;
@ -1039,9 +1040,11 @@ int sqlite3VdbeSetColName(Vdbe *p, int idx, int var, const char *zName, int N){
assert( p->aColName!=0 );
pColName = &(p->aColName[idx+var*p->nResColumn]);
if( N==P3_DYNAMIC || N==P3_STATIC ){
rc = sqlite3VdbeMemSetStr(pColName, zName, -1, SQLITE_UTF8, SQLITE_STATIC);
rc = sqlite3VdbeMemSetStr(p->db,
pColName, zName, -1, SQLITE_UTF8, SQLITE_STATIC);
}else{
rc = sqlite3VdbeMemSetStr(pColName, zName, N, SQLITE_UTF8,SQLITE_TRANSIENT);
rc = sqlite3VdbeMemSetStr(p->db,
pColName, zName, N, SQLITE_UTF8, SQLITE_TRANSIENT);
}
if( rc==SQLITE_OK && N==P3_DYNAMIC ){
pColName->flags = (pColName->flags&(~MEM_Static))|MEM_Dyn;
@ -1147,7 +1150,7 @@ static int vdbeCommit(sqlite3 *db){
u32 random;
sqlite3_free(zMaster);
sqlite3Randomness(sizeof(random), &random);
zMaster = sqlite3MPrintf("%s-mj%08X", zMainFile, random&0x7fffffff);
zMaster = sqlite3MPrintf(db, "%s-mj%08X", zMainFile, random&0x7fffffff);
if( !zMaster ){
return SQLITE_NOMEM;
}
@ -1166,7 +1169,7 @@ static int vdbeCommit(sqlite3 *db){
** still have 'null' as the master journal pointer, so they will roll
** back independently if a failure occurs.
*/
for(i=0; i<db->nDb; i++){
for(i=0; i<db->nDb; i++){
Btree *pBt = db->aDb[i].pBt;
if( i==1 ) continue; /* Ignore the TEMP database */
if( pBt && sqlite3BtreeIsInTrans(pBt) ){
@ -1567,7 +1570,7 @@ int sqlite3VdbeReset(Vdbe *p){
*/
if( p->pc>=0 ){
if( p->zErrMsg ){
sqlite3ValueSetStr(db->pErr, -1, p->zErrMsg, SQLITE_UTF8, sqlite3FreeX);
sqlite3ValueSetStr(db,db->pErr,-1,p->zErrMsg,SQLITE_UTF8,sqlite3_free);
db->errCode = p->rc;
p->zErrMsg = 0;
}else if( p->rc ){
@ -2123,7 +2126,7 @@ int sqlite3VdbeIdxRowidLen(const u8 *aKey){
** Read the rowid (the last field in the record) and store it in *rowid.
** Return SQLITE_OK if everything works, or an error code otherwise.
*/
int sqlite3VdbeIdxRowid(BtCursor *pCur, i64 *rowid){
int sqlite3VdbeIdxRowid(sqlite3 *db, BtCursor *pCur, i64 *rowid){
i64 nCellKey = 0;
int rc;
u32 szHdr; /* Size of the header */
@ -2135,7 +2138,7 @@ int sqlite3VdbeIdxRowid(BtCursor *pCur, i64 *rowid){
if( nCellKey<=0 ){
return SQLITE_CORRUPT_BKPT;
}
rc = sqlite3VdbeMemFromBtree(pCur, 0, nCellKey, 1, &m);
rc = sqlite3VdbeMemFromBtree(db, pCur, 0, nCellKey, 1, &m);
if( rc ){
return rc;
}
@ -2159,6 +2162,7 @@ int sqlite3VdbeIdxRowid(BtCursor *pCur, i64 *rowid){
** is ignored as well.
*/
int sqlite3VdbeIdxKeyCompare(
sqlite3 *db,
Cursor *pC, /* The cursor to compare against */
int nKey, const u8 *pKey, /* The key to compare */
int *res /* Write the comparison result here */
@ -2174,7 +2178,7 @@ int sqlite3VdbeIdxKeyCompare(
*res = 0;
return SQLITE_OK;
}
rc = sqlite3VdbeMemFromBtree(pC->pCursor, 0, nCellKey, 1, &m);
rc = sqlite3VdbeMemFromBtree(db, pC->pCursor, 0, nCellKey, 1, &m);
if( rc ){
return rc;
}

65
src/vdbemem.c
View File

@ -40,7 +40,7 @@
** SQLITE_NOMEM may be returned if a malloc() fails during conversion
** between formats.
*/
int sqlite3VdbeChangeEncoding(Mem *pMem, int desiredEnc){
int sqlite3VdbeChangeEncoding(sqlite3 *db, Mem *pMem, int desiredEnc){
int rc;
if( !(pMem->flags&MEM_Str) || pMem->enc==desiredEnc ){
return SQLITE_OK;
@ -49,11 +49,10 @@ int sqlite3VdbeChangeEncoding(Mem *pMem, int desiredEnc){
return SQLITE_ERROR;
#else
/* MemTranslate() may return SQLITE_OK or SQLITE_NOMEM. If NOMEM is returned,
** then the encoding of the value may not have changed.
*/
rc = sqlite3VdbeMemTranslate(pMem, desiredEnc);
rc = sqlite3VdbeMemTranslate(db, pMem, desiredEnc);
assert(rc==SQLITE_OK || rc==SQLITE_NOMEM);
assert(rc==SQLITE_OK || pMem->enc!=desiredEnc);
assert(rc==SQLITE_NOMEM || pMem->enc==desiredEnc);
@ -165,7 +164,7 @@ int sqlite3VdbeMemNulTerminate(sqlite3 *db, Mem *pMem){
return SQLITE_OK; /* Nothing to do */
}
if( pMem->flags & (MEM_Static|MEM_Ephem) ){
return sqlite3VdbeMemMakeWriteable(pMem);
return sqlite3VdbeMemMakeWriteable(db, pMem);
}else{
char *z;
sqlite3VdbeMemExpandBlob(db, pMem);
@ -202,7 +201,7 @@ int sqlite3VdbeMemNulTerminate(sqlite3 *db, Mem *pMem){
** keys are strings. In the former case a NULL pointer is returned the
** user and the later is an internal programming error.
*/
int sqlite3VdbeMemStringify(Mem *pMem, int enc){
int sqlite3VdbeMemStringify(sqlite3 *db, Mem *pMem, int enc){
int rc = SQLITE_OK;
int fg = pMem->flags;
char *z = pMem->zShort;
@ -227,7 +226,7 @@ int sqlite3VdbeMemStringify(Mem *pMem, int enc){
pMem->z = z;
pMem->enc = SQLITE_UTF8;
pMem->flags |= MEM_Str | MEM_Short | MEM_Term;
sqlite3VdbeChangeEncoding(pMem, enc);
sqlite3VdbeChangeEncoding(db, pMem, enc);
return rc;
}
@ -306,8 +305,8 @@ i64 sqlite3VdbeIntValue(Mem *pMem){
}else if( flags & (MEM_Str|MEM_Blob) ){
i64 value;
pMem->flags |= MEM_Str;
if( sqlite3VdbeChangeEncoding(pMem, SQLITE_UTF8)
|| sqlite3VdbeMemNulTerminate(pMem) ){
if( sqlite3VdbeChangeEncoding(0, pMem, SQLITE_UTF8)
|| sqlite3VdbeMemNulTerminate(0, pMem) ){
return 0;
}
assert( pMem->z );
@ -332,8 +331,8 @@ double sqlite3VdbeRealValue(Mem *pMem){
}else if( pMem->flags & (MEM_Str|MEM_Blob) ){
double val = 0.0;
pMem->flags |= MEM_Str;
if( sqlite3VdbeChangeEncoding(pMem, SQLITE_UTF8)
|| sqlite3VdbeMemNulTerminate(pMem) ){
if( sqlite3VdbeChangeEncoding(0, pMem, SQLITE_UTF8)
|| sqlite3VdbeMemNulTerminate(0, pMem) ){
return 0.0;
}
assert( pMem->z );
@ -485,14 +484,14 @@ void sqlite3VdbeMemShallowCopy(Mem *pTo, const Mem *pFrom, int srcType){
** Make a full copy of pFrom into pTo. Prior contents of pTo are
** freed before the copy is made.
*/
int sqlite3VdbeMemCopy(Mem *pTo, const Mem *pFrom){
int sqlite3VdbeMemCopy(sqlite3 *db, Mem *pTo, const Mem *pFrom){
int rc;
if( pTo->flags & MEM_Dyn ){
sqlite3VdbeMemRelease(pTo);
}
sqlite3VdbeMemShallowCopy(pTo, pFrom, MEM_Ephem);
if( pTo->flags & MEM_Ephem ){
rc = sqlite3VdbeMemMakeWriteable(pTo);
rc = sqlite3VdbeMemMakeWriteable(db, pTo);
}else{
rc = SQLITE_OK;
}
@ -507,7 +506,7 @@ int sqlite3VdbeMemCopy(Mem *pTo, const Mem *pFrom){
** might be returned if pFrom held ephemeral data and we were unable
** to allocate enough space to make a copy.
*/
int sqlite3VdbeMemMove(Mem *pTo, Mem *pFrom){
int sqlite3VdbeMemMove(sqlite3 *db, Mem *pTo, Mem *pFrom){
int rc;
if( pTo->flags & MEM_Dyn ){
sqlite3VdbeMemRelease(pTo);
@ -519,7 +518,7 @@ int sqlite3VdbeMemMove(Mem *pTo, Mem *pFrom){
pFrom->flags = MEM_Null;
pFrom->xDel = 0;
if( pTo->flags & MEM_Ephem ){
rc = sqlite3VdbeMemMakeWriteable(pTo);
rc = sqlite3VdbeMemMakeWriteable(db, pTo);
}else{
rc = SQLITE_OK;
}
@ -530,6 +529,7 @@ int sqlite3VdbeMemMove(Mem *pTo, Mem *pFrom){
** Change the value of a Mem to be a string or a BLOB.
*/
int sqlite3VdbeMemSetStr(
sqlite3 *db,
Mem *pMem, /* Memory cell to set to string value */
const char *z, /* String pointer */
int n, /* Bytes in string, or negative */
@ -581,13 +581,13 @@ int sqlite3VdbeMemSetStr(
pMem->n = sqlite3Utf16ByteLen(pMem->z,-1);
pMem->flags |= MEM_Term;
}
if( sqlite3VdbeMemHandleBom(pMem) ){
if( sqlite3VdbeMemHandleBom(db, pMem) ){
return SQLITE_NOMEM;
}
#endif /* SQLITE_OMIT_UTF16 */
}
if( pMem->flags&MEM_Ephem ){
return sqlite3VdbeMemMakeWriteable(pMem);
return sqlite3VdbeMemMakeWriteable(db, pMem);
}
return SQLITE_OK;
}
@ -687,17 +687,17 @@ int sqlite3MemCompare(const Mem *pMem1, const Mem *pMem2, const CollSeq *pColl){
int n1, n2;
/* Convert the strings into the encoding that the comparison
** function expects */
v1 = sqlite3ValueText((sqlite3_value*)pMem1, pColl->enc);
v1 = sqlite3ValueText(0, (sqlite3_value*)pMem1, pColl->enc);
n1 = v1==0 ? 0 : pMem1->n;
assert( n1==sqlite3ValueBytes((sqlite3_value*)pMem1, pColl->enc) );
v2 = sqlite3ValueText((sqlite3_value*)pMem2, pColl->enc);
assert( n1==sqlite3ValueBytes(0, (sqlite3_value*)pMem1, pColl->enc) );
v2 = sqlite3ValueText(0, (sqlite3_value*)pMem2, pColl->enc);
n2 = v2==0 ? 0 : pMem2->n;
assert( n2==sqlite3ValueBytes((sqlite3_value*)pMem2, pColl->enc) );
assert( n2==sqlite3ValueBytes(0, (sqlite3_value*)pMem2, pColl->enc) );
/* Do the comparison */
rc = pColl->xCmp(pColl->pUser, n1, v1, n2, v2);
/* Convert the strings back into the database encoding */
sqlite3ValueText((sqlite3_value*)pMem1, origEnc);
sqlite3ValueText((sqlite3_value*)pMem2, origEnc);
sqlite3ValueText(0, (sqlite3_value*)pMem1, origEnc);
sqlite3ValueText(0, (sqlite3_value*)pMem2, origEnc);
return rc;
}
}
@ -859,7 +859,7 @@ const void *sqlite3ValueText(sqlite3 *db, sqlite3_value* pVal, u8 enc){
pVal->flags |= (pVal->flags & MEM_Blob)>>3;
expandBlob(db, pVal);
if( pVal->flags&MEM_Str ){
sqlite3VdbeChangeEncoding(pVal, enc & ~SQLITE_UTF16_ALIGNED);
sqlite3VdbeChangeEncoding(db, pVal, enc & ~SQLITE_UTF16_ALIGNED);
if( (enc & SQLITE_UTF16_ALIGNED)!=0 && 1==(1&(int)pVal->z) ){
assert( (pVal->flags & (MEM_Ephem|MEM_Static))!=0 );
if( sqlite3VdbeMemMakeWriteable(db, pVal)!=SQLITE_OK ){
@ -926,14 +926,14 @@ int sqlite3ValueFromExpr(
pVal = sqlite3ValueNew(db);
if( !zVal || !pVal ) goto no_mem;
sqlite3Dequote(zVal);
sqlite3ValueSetStr(db, pVal, -1, zVal, SQLITE_UTF8, sqlite3FreeX);
sqlite3ValueSetStr(db, pVal, -1, zVal, SQLITE_UTF8, sqlite3_free);
if( (op==TK_INTEGER || op==TK_FLOAT ) && affinity==SQLITE_AFF_NONE ){
sqlite3ValueApplyAffinity(pVal, SQLITE_AFF_NUMERIC, enc);
sqlite3ValueApplyAffinity(db, pVal, SQLITE_AFF_NUMERIC, enc);
}else{
sqlite3ValueApplyAffinity(pVal, affinity, enc);
sqlite3ValueApplyAffinity(db, pVal, affinity, enc);
}
}else if( op==TK_UMINUS ) {
if( SQLITE_OK==sqlite3ValueFromExpr(pExpr->pLeft, enc, affinity, &pVal) ){
if( SQLITE_OK==sqlite3ValueFromExpr(db, pExpr->pLeft, enc, affinity, &pVal) ){
pVal->u.i = -1 * pVal->u.i;
pVal->r = -1.0 * pVal->r;
}
@ -941,12 +941,13 @@ int sqlite3ValueFromExpr(
#ifndef SQLITE_OMIT_BLOB_LITERAL
else if( op==TK_BLOB ){
int nVal;
pVal = sqlite3ValueNew();
pVal = sqlite3ValueNew(db);
zVal = sqlite3StrNDup((char*)pExpr->token.z+1, pExpr->token.n-1);
if( !zVal || !pVal ) goto no_mem;
sqlite3Dequote(zVal);
nVal = strlen(zVal)/2;
sqlite3VdbeMemSetStr(pVal, sqlite3HexToBlob(zVal), nVal, 0, sqlite3FreeX);
sqlite3VdbeMemSetStr(
db, pVal, sqlite3HexToBlob(db, zVal), nVal, 0, sqlite3_free);
sqlite3_free(zVal);
}
#endif
@ -981,7 +982,7 @@ void sqlite3ValueSetStr(
*/
void sqlite3ValueFree(sqlite3_value *v){
if( !v ) return;
sqlite3ValueSetStr(v, 0, 0, SQLITE_UTF8, SQLITE_STATIC);
sqlite3ValueSetStr(0, v, 0, 0, SQLITE_UTF8, SQLITE_STATIC);
sqlite3_free(v);
}
@ -989,9 +990,9 @@ void sqlite3ValueFree(sqlite3_value *v){
** Return the number of bytes in the sqlite3_value object assuming
** that it uses the encoding "enc"
*/
int sqlite3ValueBytes(sqlite3_value *pVal, u8 enc){
int sqlite3ValueBytes(sqlite3 *db, sqlite3_value *pVal, u8 enc){
Mem *p = (Mem*)pVal;
if( (p->flags & MEM_Blob)!=0 || sqlite3ValueText(pVal, enc) ){
if( (p->flags & MEM_Blob)!=0 || sqlite3ValueText(db, pVal, enc) ){
if( p->flags & MEM_Zero ){
return p->n+p->u.i;
}else{

16
src/vtab.c
View File

@ -11,7 +11,7 @@
*************************************************************************
** This file contains code used to help implement virtual tables.
**
** $Id: vtab.c,v 1.49 2007/08/16 04:30:41 drh Exp $
** $Id: vtab.c,v 1.50 2007/08/16 10:09:03 danielk1977 Exp $
*/
#ifndef SQLITE_OMIT_VIRTUALTABLE
#include "sqliteInt.h"
@ -250,7 +250,7 @@ void sqlite3VtabFinishParse(Parse *pParse, Token *pEnd){
if( pEnd ){
pParse->sNameToken.n = pEnd->z - pParse->sNameToken.z + pEnd->n;
}
zStmt = sqlite3MPrintf("CREATE VIRTUAL TABLE %T", &pParse->sNameToken);
zStmt = sqlite3MPrintf(db, "CREATE VIRTUAL TABLE %T", &pParse->sNameToken);
/* A slot for the record has already been allocated in the
** SQLITE_MASTER table. We just need to update that slot with all
@ -276,7 +276,7 @@ void sqlite3VtabFinishParse(Parse *pParse, Token *pEnd){
sqlite3ChangeCookie(db, v, iDb);
sqlite3VdbeAddOp(v, OP_Expire, 0, 0);
zWhere = sqlite3MPrintf("name='%q'", pTab->zName);
zWhere = sqlite3MPrintf(db, "name='%q'", pTab->zName);
sqlite3VdbeOp3(v, OP_ParseSchema, iDb, 1, zWhere, P3_DYNAMIC);
sqlite3VdbeOp3(v, OP_VCreate, iDb, 0, pTab->zName, strlen(pTab->zName) + 1);
}
@ -343,7 +343,7 @@ static int vtabCallConstructor(
const char *const*azArg = (const char *const*)pTab->azModuleArg;
int nArg = pTab->nModuleArg;
char *zErr = 0;
char *zModuleName = sqlite3MPrintf("%s", pTab->zName);
char *zModuleName = sqlite3MPrintf(db, "%s", pTab->zName);
if( !zModuleName ){
return SQLITE_NOMEM;
@ -365,14 +365,14 @@ static int vtabCallConstructor(
if( SQLITE_OK!=rc ){
if( zErr==0 ){
*pzErr = sqlite3MPrintf("vtable constructor failed: %s", zModuleName);
*pzErr = sqlite3MPrintf(db, "vtable constructor failed: %s", zModuleName);
}else {
*pzErr = sqlite3MPrintf("%s", zErr);
*pzErr = sqlite3MPrintf(db, "%s", zErr);
sqlite3_free(zErr);
}
}else if( db->pVTab ){
const char *zFormat = "vtable constructor did not declare schema: %s";
*pzErr = sqlite3MPrintf(zFormat, pTab->zName);
*pzErr = sqlite3MPrintf(db, zFormat, pTab->zName);
rc = SQLITE_ERROR;
}
if( rc==SQLITE_OK ){
@ -503,7 +503,7 @@ int sqlite3VtabCallCreate(sqlite3 *db, int iDb, const char *zTab, char **pzErr){
** error. Otherwise, do nothing.
*/
if( !pMod ){
*pzErr = sqlite3MPrintf("no such module: %s", zModule);
*pzErr = sqlite3MPrintf(db, "no such module: %s", zModule);
rc = SQLITE_ERROR;
}else{
rc = vtabCallConstructor(db, pTab, pMod, pMod->pModule->xCreate, pzErr);

17
src/where.c
View File

@ -16,7 +16,7 @@
** so is applicable. Because this module is responsible for selecting
** indices, you might also think of this module as the "query optimizer".
**
** $Id: where.c,v 1.255 2007/08/16 04:30:41 drh Exp $
** $Id: where.c,v 1.256 2007/08/16 10:09:03 danielk1977 Exp $
*/
#include "sqliteInt.h"
@ -716,7 +716,8 @@ static void exprAnalyze(
int nPattern;
int isComplete;
int op;
sqlite3 *db = pWC->pParse->db;
Parse *pParse = pWC->pParse;
sqlite3 *db = pParse->db;
if( db->mallocFailed ) return;
prereqLeft = exprTableUsage(pMaskSet, pExpr->pLeft);
@ -2152,24 +2153,24 @@ WhereInfo *sqlite3WhereBegin(
if( pParse->explain==2 ){
char *zMsg;
struct SrcList_item *pItem = &pTabList->a[pLevel->iFrom];
zMsg = sqlite3MPrintf("TABLE %s", pItem->zName);
zMsg = sqlite3MPrintf(db, "TABLE %s", pItem->zName);
if( pItem->zAlias ){
zMsg = sqlite3MPrintf("%z AS %s", zMsg, pItem->zAlias);
zMsg = sqlite3MPrintf(db, "%z AS %s", zMsg, pItem->zAlias);
}
if( (pIx = pLevel->pIdx)!=0 ){
zMsg = sqlite3MPrintf("%z WITH INDEX %s", zMsg, pIx->zName);
zMsg = sqlite3MPrintf(db, "%z WITH INDEX %s", zMsg, pIx->zName);
}else if( pLevel->flags & (WHERE_ROWID_EQ|WHERE_ROWID_RANGE) ){
zMsg = sqlite3MPrintf("%z USING PRIMARY KEY", zMsg);
zMsg = sqlite3MPrintf(db, "%z USING PRIMARY KEY", zMsg);
}
#ifndef SQLITE_OMIT_VIRTUALTABLE
else if( pLevel->pBestIdx ){
sqlite3_index_info *pBestIdx = pLevel->pBestIdx;
zMsg = sqlite3MPrintf("%z VIRTUAL TABLE INDEX %d:%s", zMsg,
zMsg = sqlite3MPrintf(db, "%z VIRTUAL TABLE INDEX %d:%s", zMsg,
pBestIdx->idxNum, pBestIdx->idxStr);
}
#endif
if( pLevel->flags & WHERE_ORDERBY ){
zMsg = sqlite3MPrintf("%z ORDER BY", zMsg);
zMsg = sqlite3MPrintf(db, "%z ORDER BY", zMsg);
}
sqlite3VdbeOp3(v, OP_Explain, i, pLevel->iFrom, zMsg, P3_DYNAMIC);
}