$(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 \
-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
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
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
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
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
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
-161643a694458e76849cd663f277892ae7c6b729
\ No newline at end of file
+77b1671351fe94b0ebc126a63140643deae2aa64
\ No newline at end of file
** 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>
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.
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);
}
}
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
/* 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 */
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);
}
}
** 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);
}
}
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);
*/
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;
}
*************************************************************************
** 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"
/* 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);
** 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.
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 ){
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; }
** 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>
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++;
/* 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
/* 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);
}
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;
}
*/
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);
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);
}
}
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]);
** 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"
#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);
}
** 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
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);
}
** 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
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);
}
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);
}
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);
}
** 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>
** 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 ){
if( p==0 ){
db->mallocFailed = 1;
}
+ return 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) );
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;
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;
}
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{
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 {
Parse *pParse = pNC->pParse;
SrcList *pSrcList = pNC->pSrcList;
AggInfo *pAggInfo = pNC->pAggInfo;
-
switch( pExpr->op ){
case TK_AGG_COLUMN:
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;
/* 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;
** 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>
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
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]);
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){
}
}
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
** 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>
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;
** 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"
*/
sqlite3_free(db->aDb[1].pSchema);
sqlite3_free(db);
- sqlite3ReleaseThreadData();
+ /* sqlite3ReleaseThreadData(); */
return SQLITE_OK;
}
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);
}
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);
}
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 ){
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);
}
pTd->useSharedData = enable;
- sqlite3ReleaseThreadData();
+ /* sqlite3ReleaseThreadData(); */
}
return sqlite3ApiExit(0, SQLITE_OK);
}
** 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"
** 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
}
void *pNew;
pNew = sqlite3_realloc(p, n);
if( !pNew ){
- sqlite3FreeX(p);
+ sqlite3_free(p);
db->mallocFailed = 1;
}
return pNew;
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;
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
nByte += strlen(z);
}
va_end(ap);
- sqliteFree(*pz);
- *pz = zResult = sqliteMallocRaw( nByte );
+ sqlite3_free(*pz);
+ *pz = zResult = sqlite3_malloc(nByte);
if( zResult==0 ){
return;
}
** 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;
** 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 );
#endif
}
#endif
+#endif
** 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 $
*/
/*
*/
int sqlite3_mutex_serialize(void (*xCallback)(void*), void *pArg){
xCallback(pArg);
+ return SQLITE_OK;
}
#if 0
zBuf[0] = 0;
sqlite3SetString(&zFull, getcwd(zBuf, 5000), "/", zRelative,
(char*)0);
- sqliteFree(zBuf);
+ sqlite3_free(zBuf);
}
#if 0
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;
** 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"
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);
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;
** 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_"
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. {
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);
*************************************************************************
** 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"
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);
** 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"
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);
}
rc = sqlite3ApiExit(db, rc);
- sqlite3ReleaseThreadData();
+ /* sqlite3ReleaseThreadData(); */
assert( (rc&db->errMask)==rc );
return rc;
}
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);
}
}
}
if( zExtra ){
- sqliteFree(zExtra);
+ sqlite3_free(zExtra);
}
}/* End for loop over the format string */
return errorflag ? -1 : count;
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 */
};
/*
** 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[] */
/*
** 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);
}
/*
** 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"
**
** {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;
}
}
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;
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);
"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);
}
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;
}
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 =
}
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;
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);
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);
}
}
}
- if( db->mallocFailed ){
+ if( pParse->db->mallocFailed ){
return SQLITE_NOMEM;
}
** 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_
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**);
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);
*************************************************************************
** 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_
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*);
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);
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);
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*);
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 *,
void sqlite3AbortOtherActiveVdbes(sqlite3 *, Vdbe *);
int sqlite3OpenTempDatabase(Parse *);
+void *sqlite3DbReallocOrFree(sqlite3 *, void *, int);
+sqlite3 *sqlite3DbOfVdbe(Vdbe *);
+
/*
** The interface to the LEMON-generated parser
*/
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*);
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;
** 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"
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;
}
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);
){
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;
** 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);
}
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));
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);
}
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);
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);
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);
int objc,
Tcl_Obj *CONST objv[]
){
- OsFile *pFile;
+ sqlite3_file *pFile;
int rc;
int dummy;
char zBuf[100];
int objc,
Tcl_Obj *CONST objv[]
){
- OsFile *pFile;
+ sqlite3_file *pFile;
int rc;
if( objc!=2 ){
int objc,
Tcl_Obj *CONST objv[]
){
- OsFile * pFile;
+ sqlite3_file * pFile;
int rc;
if( objc!=3 ){
int objc,
Tcl_Obj *CONST objv[]
){
- OsFile * pFile;
+ sqlite3_file * pFile;
int rc;
if( objc!=2 ){
** 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"
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],
** 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"
sqlite3_free((void*)aRoot);
if( zResult ){
Tcl_AppendResult(interp, zResult, 0);
- sqliteFree(zResult);
+ sqlite3_free(zResult);
}
return TCL_OK;
}
** 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"
return TCL_ERROR;
}
if( objc==5 ){
- xDel = sqlite3FreeX;
+ xDel = sqlite3_free;
}
enc_from = name_to_enc(interp, objv[2]);
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 ){
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);
struct CrashFile {
const sqlite3_io_methods *pMethod; /* Must be first */
sqlite3_file *pRealFile; /* Underlying "real" file handle */
- const char *zName;
+ char *zName;
};
struct CrashGlobal {
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);
/*
** 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);
/*
** 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;
/*
** 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;
/*
** 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;
/*
** 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);
}
** 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;
}
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;
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;
** 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"
}
/* 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;
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;
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;
/* 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;
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);
}
/* 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);
}
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);
** 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"
case TK_ILLEGAL: {
if( pzErrMsg ){
sqlite3_free(*pzErrMsg);
- *pzErrMsg = sqlite3MPrintf("unrecognized token: \"%T\"",
+ *pzErrMsg = sqlite3MPrintf(db, "unrecognized token: \"%T\"",
&pParse->sLastToken);
}
nErr++;
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 ){
** 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"
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{
** 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:
**
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;
** 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;
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);
}
}
** 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"
** 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);
}
}
}
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;
** 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;
}
** 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"
** 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; }
/*
** 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
*/
int sqlite3_value_numeric_type(sqlite3_value *pVal){
Mem *pMem = (Mem*)pVal;
- applyNumericAffinity(pMem);
+ applyNumericAffinity(0, pMem);
storeTypeInfo(pMem, 0);
return pMem->type;
}
** 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
pTos->enc = SQLITE_UTF8;
pTos->r = sqlite3VdbeRealValue(pTos);
pTos->flags |= MEM_Real;
- sqlite3VdbeChangeEncoding(pTos, encoding);
+ sqlite3VdbeChangeEncoding(db, pTos, encoding);
break;
}
#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;
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);
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;
}
pTos++;
sqlite3VdbeMemShallowCopy(pTos, pFrom, MEM_Ephem);
if( pOp->p2 ){
- Deephemeralize(pTos);
+ Deephemeralize(db, pTos);
}
break;
}
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 ){
Mem *pTo = &pTos[-pOp->p1];
assert( pTo>=p->aStack );
- sqlite3VdbeMemMove(pTo, pTos);
+ sqlite3VdbeMemMove(db, pTo, pTos);
pTos--;
break;
}
*/
pFirstColumn = &pTos[0-pOp->p1];
for(pMem = p->aStack; pMem<pFirstColumn; pMem++){
- Deephemeralize(pMem);
+ Deephemeralize(db, pMem);
}
/* Invalidate all ephemeral cursor row caches */
** as side effect.
*/
for(; pMem<=pTos; pMem++ ){
- sqlite3VdbeMemNulTerminate(pMem);
+ sqlite3VdbeMemNulTerminate(db, pMem);
storeTypeInfo(pMem, encoding);
}
nByte = -1;
break;
}
- ExpandBlob(pTerm);
- Stringify(pTerm, encoding);
+ ExpandBlob(db, pTerm);
+ Stringify(db, pTerm, encoding);
nByte += pTerm->n;
}
}
/* 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;
}
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--;
*/
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;
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;
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;
}
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;
** 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;
}
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;
}
/* 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;
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);
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;
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;
/* 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;
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;
** 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;
}
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;
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;
}
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;
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;
pTos->xDel = 0;
}
pTos->enc = SQLITE_UTF8;
- sqlite3VdbeChangeEncoding(pTos, encoding);
+ sqlite3VdbeChangeEncoding(db, pTos, encoding);
sqlite3_free(aRoot);
break;
}
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--;
/* 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;
}
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
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;
}
** 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;
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);
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_) */
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;
}
}
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);
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){
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){
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(
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,
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,
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);
){
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);
}
/*
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;
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);
}
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;
}
}
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 );
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;
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 ){
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
int isExplain /* True if the EXPLAIN keywords is present */
){
int n;
+ sqlite3 *db = p->db;
assert( p!=0 );
assert( p->magic==VDBE_MAGIC_INIT );
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 */
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;
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;
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;
}
** 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) ){
*/
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 ){
** 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 */
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;
}
** 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 */
*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;
}
** 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;
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);
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);
** 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;
pMem->z = z;
pMem->enc = SQLITE_UTF8;
pMem->flags |= MEM_Str | MEM_Short | MEM_Term;
- sqlite3VdbeChangeEncoding(pMem, enc);
+ sqlite3VdbeChangeEncoding(db, pMem, enc);
return rc;
}
}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 );
}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 );
** 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;
}
** 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);
pFrom->flags = MEM_Null;
pFrom->xDel = 0;
if( pTo->flags & MEM_Ephem ){
- rc = sqlite3VdbeMemMakeWriteable(pTo);
+ rc = sqlite3VdbeMemMakeWriteable(db, pTo);
}else{
rc = SQLITE_OK;
}
** 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 */
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;
}
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;
}
}
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 ){
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;
}
#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
*/
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);
}
** 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{
*************************************************************************
** 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"
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
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);
}
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;
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 ){
** 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);
** 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"
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);
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);
}
projects / thirdparty / sqlite.git / commitdiff
