database/sqlite
1
0
Fork 0
mirror of https://github.com/sqlite/sqlite.git synced 2025-08-07 02:42:48 +03:00
Code 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
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/date.c \
$(TOP)/src/func.c \ $(TOP)/src/func.c \
$(TOP)/src/insert.c \ $(TOP)/src/insert.c \
$(TOP)/src/main.c \
$(TOP)/src/malloc.c \ $(TOP)/src/malloc.c \
$(TOP)/src/os.c \ $(TOP)/src/os.c \
$(TOP)/src/os_os2.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) C More\swork\son\srefactoring\sof\smalloc()\sinterfaces.\sThere\sare\sstill\smany\serrors.\s(CVS\s4233)
D 2007-08-16T04:39:01 D 2007-08-16T10:09:02
F Makefile.in 0c0e53720f658c7a551046442dd7afba0b72bfbe F Makefile.in 0c0e53720f658c7a551046442dd7afba0b72bfbe
F Makefile.linux-gcc 65241babba6faf1152bf86574477baab19190499 F Makefile.linux-gcc 65241babba6faf1152bf86574477baab19190499
F README 9c4e2d6706bdcc3efdd773ce752a8cdab4f90028 F README 9c4e2d6706bdcc3efdd773ce752a8cdab4f90028
@@ -51,7 +51,7 @@ F ext/icu/README.txt 3b130aa66e7a681136f6add198b076a2f90d1e33
F ext/icu/icu.c 61a345d8126686aa3487aa8d2d0f68abd655f7a4 F ext/icu/icu.c 61a345d8126686aa3487aa8d2d0f68abd655f7a4
F install-sh 9d4de14ab9fb0facae2f48780b874848cbf2f895 F install-sh 9d4de14ab9fb0facae2f48780b874848cbf2f895
F ltmain.sh 56abb507100ed2d4261f6dd1653dec3cf4066387 F ltmain.sh 56abb507100ed2d4261f6dd1653dec3cf4066387
F main.mk dad2269dd2a097892536482c12acaab001e930c2 F main.mk 659cad1c400ab92948087d46c499e0330215db7b
F mkdll.sh 37fa8a7412e51b5ab2bc6d4276135f022a0feffb F mkdll.sh 37fa8a7412e51b5ab2bc6d4276135f022a0feffb
F mkextu.sh 416f9b7089d80e5590a29692c9d9280a10dbad9f F mkextu.sh 416f9b7089d80e5590a29692c9d9280a10dbad9f
F mkextw.sh 1a866b53637dab137191341cc875575a5ca110fb F mkextw.sh 1a866b53637dab137191341cc875575a5ca110fb
@@ -64,33 +64,33 @@ F sqlite.pc.in 30552343140c53304c2a658c080fbe810cd09ca2
F sqlite3.1 6be1ad09113570e1fc8dcaff84c9b0b337db5ffc F sqlite3.1 6be1ad09113570e1fc8dcaff84c9b0b337db5ffc
F sqlite3.def a96c1d0d39362b763d2ddba220a32da41a15c4b4 F sqlite3.def a96c1d0d39362b763d2ddba220a32da41a15c4b4
F sqlite3.pc.in 985b9bf34192a549d7d370e0f0b6b34a4f61369a F sqlite3.pc.in 985b9bf34192a549d7d370e0f0b6b34a4f61369a
F src/alter.c 27b0c0d371a825f9a8b7198a3f3f94c2e027f25e F src/alter.c f0aac0060ae8102e58f210b44d35b53438d53173
F src/analyze.c e2bbd2510b4009bc9839e32ceac21ac1bd711f37 F src/analyze.c a14237d869c6bea0846493b59317e4097e81a0b6
F src/attach.c a52225c75b107be8c5bc144a2b6d20201be3f8f8 F src/attach.c a52225c75b107be8c5bc144a2b6d20201be3f8f8
F src/auth.c 5ea90bc93dfea46e9fe4bf531e14c7cd98219ecb F src/auth.c 5ea90bc93dfea46e9fe4bf531e14c7cd98219ecb
F src/btree.c 1f7c009817a03a3cbf4f78d4d373543d89ebc890 F src/btree.c f371e9d7a24ba330c108bf1bb795280051f696ac
F src/btree.h 1d527bf61ed176f980c34999d5793a0fd45dcf8c F src/btree.h 1d527bf61ed176f980c34999d5793a0fd45dcf8c
F src/btreeInt.h ac1ab1fb624ffbe571786cd2bd9559f9ae336355 F src/btreeInt.h ac1ab1fb624ffbe571786cd2bd9559f9ae336355
F src/build.c a25bf9d25623c7730bc58922e0e84204ad98c968 F src/build.c 923d6643c8f59fbcd10cd9e2f2690e82f48db69e
F src/callback.c 5680c2b84177e52c54b42e94291d30b4b6ed2126 F src/callback.c 143436453bb93e831c9574fea0b9b9eb90e40ff3
F src/complete.c 7d1a44be8f37de125fcafd3d3a018690b3799675 F src/complete.c ea63834e798a0ab14159bdc6e6cabc3df21aa346
F src/date.c 6c6ae019e78fec543988c8d907fa9524dc2c2934 F src/date.c c44aa498ee9a289ba2b2c62e8269b74b1b81351f
F src/delete.c 849846d06d29851dde0d9f424a5de5817eb140d1 F src/delete.c 849846d06d29851dde0d9f424a5de5817eb140d1
F src/experimental.c 1b2d1a6cd62ecc39610e97670332ca073c50792b F src/experimental.c 1b2d1a6cd62ecc39610e97670332ca073c50792b
F src/expr.c 002266066377f542e776448e04816d2a887d7dc3 F src/expr.c beb6b40974ddb22d683b8239d635c37f28b16f95
F src/func.c bd94a8aabeecc741df71afba856133738f1c1638 F src/func.c 4195c626d09662a2cc040a35057f2b3828dd7465
F src/hash.c 05ebefb85d77caed0454408ee1e069702d289bff F src/hash.c 2f322979071dd2bdba7503b5276d66f028744382
F src/hash.h 3ad3da76bfb954978d227bf495568b0e6da2c19e F src/hash.h 3ad3da76bfb954978d227bf495568b0e6da2c19e
F src/insert.c bca11ad7b7ab4a1ba4808b6e0a6fd842923f88bb F src/insert.c bca11ad7b7ab4a1ba4808b6e0a6fd842923f88bb
F src/legacy.c 6013a7cb7da1b72550b3d35d4fc598b3c3e5b8c1 F src/legacy.c 6013a7cb7da1b72550b3d35d4fc598b3c3e5b8c1
F src/limits.h 71ab25f17e35e0a9f3f6f234b8ed49cc56731d35 F src/limits.h 71ab25f17e35e0a9f3f6f234b8ed49cc56731d35
F src/loadext.c aa1c6e584d39cc241226ec9390387bc2d4a23e8f F src/loadext.c aa1c6e584d39cc241226ec9390387bc2d4a23e8f
F src/main.c 7850774e64fc1f804a3f91a8a66ba4215e9fa05b F src/main.c 47c6d4918394cf86e38502527ca652ac0602fac1
F src/malloc.c bec719bda3db0ea797b03c5e6536b125d0e618ff F src/malloc.c 613c65f12ff0ee4edd017aa458209ab7a23cd7b1
F src/md5.c c5fdfa5c2593eaee2e32a5ce6c6927c986eaf217 F src/md5.c c5fdfa5c2593eaee2e32a5ce6c6927c986eaf217
F src/mem1.c 6d4b9efe51242fcc63d410fb326824f1208b3d4e F src/mem1.c 6d4b9efe51242fcc63d410fb326824f1208b3d4e
F src/mem2.c d0ba3b23da2e95bced1818ade8a8a2dc9526111c F src/mem2.c d0ba3b23da2e95bced1818ade8a8a2dc9526111c
F src/mutex.c 667dae0de95f8fb92a3ffc8c3f20c0d26115a1a6 F src/mutex.c b4f963ebdcb0622b3026937826afefd8a05884e1
F src/os.c e2faefbe0f5a8ca5e3b1c49ee1b5c6cfa0f0e279 F src/os.c e2faefbe0f5a8ca5e3b1c49ee1b5c6cfa0f0e279
F src/os.h 8eff07babf74e5bc3f895f8a6c7c294dad5ff997 F src/os.h 8eff07babf74e5bc3f895f8a6c7c294dad5ff997
F src/os_common.h a5c446d3b93f09f369d13bf217de4bed3437dd1c 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_os2.h e5f17dd69333632bbc3112881ea407c37d245eb3
F src/os_test.c 49833426101f99aee4bb5f6a44b7c4b2029fda1c F src/os_test.c 49833426101f99aee4bb5f6a44b7c4b2029fda1c
F src/os_test.h 903c93554c23d88f34f667f1979e4a1cee792af3 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_unix.h 5768d56d28240d3fe4537fac08cc85e4fb52279e
F src/os_win.c d868d5f9e95ec9c1b9e2a30c54c996053db6dddd F src/os_win.c d868d5f9e95ec9c1b9e2a30c54c996053db6dddd
F src/os_win.h 41a946bea10f61c158ce8645e7646b29d44f122b F src/os_win.h 41a946bea10f61c158ce8645e7646b29d44f122b
F src/pager.c ddb0279c4030128b2f06cdd02b68ae266a8f4fe7 F src/pager.c 812a3f78ea398764991d668d2d3d81a951e58fa3
F src/pager.h 94110a5570dca30d54a883e880a3633b2e4c05ae F src/pager.h 94110a5570dca30d54a883e880a3633b2e4c05ae
F src/parse.y 4934dc7e7a679f71359420de11aae7c281a73151 F src/parse.y c03529c3b82702ada98ce405b390e3a9409708cf
F src/pragma.c 9ecc2bcd790fc1723a5f78ff46493ce4d2b77ced F src/pragma.c 873b0b2ab56248ef76d0387193b8f7a87782b73c
F src/prepare.c 237ed8ce0509da9e28a4773b96ec4c44015b970e F src/prepare.c 03292beeffce2d65debab12508a8ec1f5aec7241
F src/printf.c 326386450a8fa31853503b3a8cc758d72d41fc7e F src/printf.c a8f46e0ed360c18d40e89aa636533be300b406c2
F src/random.c 6119474a6f6917f708c1dee25b9a8e519a620e88 F src/random.c 6119474a6f6917f708c1dee25b9a8e519a620e88
F src/select.c 4df152ea0cd13b37cc4e41c56cad7c8ed2d9718c F src/select.c 98c367bce3f38c5adfcc97de9ab5c79b0e5dc2b2
F src/server.c 087b92a39d883e3fa113cae259d64e4c7438bc96 F src/server.c 087b92a39d883e3fa113cae259d64e4c7438bc96
F src/shell.c ac29402b538515fa4697282387be9c1205e6e9eb F src/shell.c ac29402b538515fa4697282387be9c1205e6e9eb
F src/sqlite.h.in 165913eb3426fbaa8a2a51d87f84593bfe5bee15 F src/sqlite.h.in 165913eb3426fbaa8a2a51d87f84593bfe5bee15
F src/sqlite3ext.h a27bedc222df5e5f0f458ac99726d0483b953a91 F src/sqlite3ext.h 647a6b8a8f76ff6c9611e4a071531d8e63ff2d6b
F src/sqliteInt.h acdc2d5b997504c3b1d1cc7ac31ec064f23c26b5 F src/sqliteInt.h 2649e0cbf0073e0d5c88080c642de4a3bac58c09
F src/sqliteLimit.h f14609c27636ebc217c9603ade26dbdd7d0f6afa F src/sqliteLimit.h f14609c27636ebc217c9603ade26dbdd7d0f6afa
F src/table.c a8de75bcedf84d4060d804264b067ab3b1a3561d F src/table.c c725e47f6f3092b9a7b569fc58e408e2173ee008
F src/tclsqlite.c 0606c4f31711492eb4d7480a981eebb80914f3d9 F src/tclsqlite.c 0606c4f31711492eb4d7480a981eebb80914f3d9
F src/test1.c b5b36bdf40a78e351cb0def7bc900991adcc4c4f F src/test1.c f2969f28574433743f7439da62f0cfd9063fc26b
F src/test2.c 5c3edc610852a8f67990cd08c5d5dbb79e3f8db9 F src/test2.c 4db48e4a487d4d18c2926d9600875613ad286ba8
F src/test3.c 497ed07038ea79ab683b0beba6a39c89540ce632 F src/test3.c c337cff70c3bf9c30f77e953106ef7ddf655dd51
F src/test4.c d22cb3ab4f9fdfd0a595b70d5328cee923b7322c F src/test4.c d22cb3ab4f9fdfd0a595b70d5328cee923b7322c
F src/test5.c 27f3aa4eebfec94769d199f85212708ec77536c7 F src/test5.c 7bc8a87c2b6fd076ec2ca9972946e71a367883ad
F src/test6.c b0aea6299100bee055ff9d8f30d87e393384e607 F src/test6.c 14919eef8504da6814db7ab19608c786d836fcb2
F src/test7.c 91d914c2c2b2806157213f41f4185ad3a4970c07 F src/test7.c 91d914c2c2b2806157213f41f4185ad3a4970c07
F src/test8.c 95c9e0639e555768e15f88c87ae805c10340d8c2 F src/test8.c 0dc64e1a676df556cbcc3f7fcbaa583d7f234826
F src/test9.c c0f38f7795cc51d37db6c63874d90f40f10d0f0e F src/test9.c c0f38f7795cc51d37db6c63874d90f40f10d0f0e
F src/test_async.c 871ffbe4a520be74b403aca87aa622ebdb690232 F src/test_async.c 871ffbe4a520be74b403aca87aa622ebdb690232
F src/test_autoext.c 855157d97aa28cf84233847548bfacda21807436 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_schema.c 12c9de7661d6294eec2d57afbb52e2af1128084f
F src/test_server.c 76c0baf509abe65ca6e5c7974ab0097cfdd8b833 F src/test_server.c 76c0baf509abe65ca6e5c7974ab0097cfdd8b833
F src/test_tclvar.c 51f69f526ed4a044dc7c13c7badccd33cb41132b F src/test_tclvar.c 51f69f526ed4a044dc7c13c7badccd33cb41132b
F src/tokenize.c 418842048447c6d0889fd2e0b414288615d28aaa F src/tokenize.c 3a3fd71cfb2abb8e11ed6ab6b764b790c534defc
F src/trigger.c f29b1d40a329f33dd683b500cc5d493f2acb9558 F src/trigger.c dccc6fbf37d12193c90ede5b026bbd195d505ff4
F src/update.c b20d7730bfe46367a8d3f540a0b0632840c82fec F src/update.c e89b980b443d44b68bfc0b1746cdb6308e049ac9
F src/utf.c e2212080d74559a1a351ab4d235b97f522132995 F src/utf.c 853f97ce0d3cff8dbaef517a6dc475f7001a67c5
F src/util.c c831d17623ffb0e09a3710f8f679eeeb42a423c2 F src/util.c 0273ba16dbf9bab423b1b84c6d548d8f14c25f64
F src/vacuum.c f45bd9d3aad8d68bb3b85cf89d7a797be5075fde F src/vacuum.c f45bd9d3aad8d68bb3b85cf89d7a797be5075fde
F src/vdbe.c dd6f17be86fde2ca07d4b065ed79815a617615cd F src/vdbe.c 10052a4f1e42e629aee0466b40983e2b61e0295a
F src/vdbe.h 001c5b257567c1d3de7feb2203aac71d0d7b16a3 F src/vdbe.h 001c5b257567c1d3de7feb2203aac71d0d7b16a3
F src/vdbeInt.h 0629275fd265cf1ba039c08e1d41c91258f02f64 F src/vdbeInt.h e0bd068cf607dcb10021aefa9390b96f56fc3e03
F src/vdbeapi.c fce4ee6ab2cb8fd209f53b8a9261603c82993b8c F src/vdbeapi.c ca82e14ac4ef0c15d7ed8851b0bf9377d7eb0058
F src/vdbeaux.c e59e50659a5e19298e6b3e21e7ae309d43607305 F src/vdbeaux.c aa079bb65d3ebe81eab4765c26c3e69deabc6825
F src/vdbeblob.c cf9ee3c7d9977cbd896f8b118da4fb4268637f4f F src/vdbeblob.c cf9ee3c7d9977cbd896f8b118da4fb4268637f4f
F src/vdbefifo.c 334c838c8f42d61a94813d136019ee566b5dc2f6 F src/vdbefifo.c 334c838c8f42d61a94813d136019ee566b5dc2f6
F src/vdbemem.c 59fde3ec6178bee1e6200a524c2cf5937cfe33ab F src/vdbemem.c 52ec18736ff0203cd34a1b55043027a312f23646
F src/vtab.c ea2557202d0e6d01dc810be9007a63e1ef357820 F src/vtab.c 8d65679ab4ef3efce5d946d7f2d2dac5a33313b4
F src/where.c 366bfb2b03b1b1fa63dc6a1b14f86509fe0d12ed F src/where.c b5af62312d2ac6b22897cd0f06fb0eca477d8589
F tclinstaller.tcl 4356d9d94d2b5ed5e68f9f0c80c4df3048dd7617 F tclinstaller.tcl 4356d9d94d2b5ed5e68f9f0c80c4df3048dd7617
F test/aggerror.test a867e273ef9e3d7919f03ef4f0e8c0d2767944f2 F test/aggerror.test a867e273ef9e3d7919f03ef4f0e8c0d2767944f2
F test/all.test 56bc526a6cbb262c5b678dd606de8c92ae39705e F test/all.test 56bc526a6cbb262c5b678dd606de8c92ae39705e
@@ -529,7 +529,7 @@ F www/tclsqlite.tcl 8be95ee6dba05eabcd27a9d91331c803f2ce2130
F www/vdbe.tcl 87a31ace769f20d3627a64fa1fade7fed47b90d0 F www/vdbe.tcl 87a31ace769f20d3627a64fa1fade7fed47b90d0
F www/version3.tcl 890248cf7b70e60c383b0e84d77d5132b3ead42b F www/version3.tcl 890248cf7b70e60c383b0e84d77d5132b3ead42b
F www/whentouse.tcl fc46eae081251c3c181bd79c5faef8195d7991a5 F www/whentouse.tcl fc46eae081251c3c181bd79c5faef8195d7991a5
P deb7ecd65f7b83eaf0ba610eeef3b0ede61db1c3 P 161643a694458e76849cd663f277892ae7c6b729
R cf90298b3b3d07ca81013abb6b566a4c R 78bb61c2e514dbedee0545c75b0d9447
U danielk1977 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 ** This file contains C code routines that used to generate VDBE code
** that implements the ALTER TABLE command. ** 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 "sqliteInt.h"
#include <ctype.h> #include <ctype.h>
@@ -51,6 +51,8 @@ static void renameTableFunc(
int len = 0; int len = 0;
char *zRet; char *zRet;
sqlite3 *db = sqlite3_user_data(context);
/* The principle used to locate the table name in the CREATE TABLE /* 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 ** statement is that the table name is the first token that is immediatedly
** followed by a left parenthesis - TK_LP - or "USING" TK_USING. ** followed by a left parenthesis - TK_LP - or "USING" TK_USING.
@@ -76,9 +78,9 @@ static void renameTableFunc(
assert( len>0 ); assert( len>0 );
} while( token!=TK_LP && token!=TK_USING ); } 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); 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; int len = 0;
char *zRet; char *zRet;
sqlite3 *db = sqlite3_user_data(context);
/* The principle used to locate the table name in the CREATE TRIGGER /* 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 ** 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 ** 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 /* Variable tname now contains the token that is the old table-name
** in the CREATE TRIGGER statement. ** 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); zTableName, tname.z+tname.n);
sqlite3_result_text(context, zRet, -1, sqlite3FreeX); sqlite3_result_text(context, zRet, -1, sqlite3_free);
} }
} }
#endif /* !SQLITE_OMIT_TRIGGER */ #endif /* !SQLITE_OMIT_TRIGGER */
@@ -174,7 +178,7 @@ void sqlite3AlterFunctions(sqlite3 *db){
for(i=0; i<sizeof(aFuncs)/sizeof(aFuncs[0]); i++){ for(i=0; i<sizeof(aFuncs)/sizeof(aFuncs[0]); i++){
sqlite3CreateFunc(db, aFuncs[i].zName, aFuncs[i].nArg, 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. ** expression being built up in zWhere.
*/ */
if( pTab->pSchema!=pTempSchema ){ if( pTab->pSchema!=pTempSchema ){
sqlite3 *db = pParse->db;
for( pTrig=pTab->pTrigger; pTrig; pTrig=pTrig->pNext ){ for( pTrig=pTab->pTrigger; pTrig; pTrig=pTrig->pNext ){
if( pTrig->pSchema==pTempSchema ){ if( pTrig->pSchema==pTempSchema ){
if( !zWhere ){ if( !zWhere ){
zWhere = sqlite3MPrintf("name=%Q", pTrig->name); zWhere = sqlite3MPrintf(db, "name=%Q", pTrig->name);
}else{ }else{
tmp = zWhere; tmp = zWhere;
zWhere = sqlite3MPrintf("%s OR name=%Q", zWhere, pTrig->name); zWhere = sqlite3MPrintf(db, "%s OR name=%Q", zWhere, pTrig->name);
sqlite3_free(tmp); 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); sqlite3VdbeOp3(v, OP_DropTable, iDb, 0, pTab->zName, 0);
/* Reload the table, index and permanent trigger schemas. */ /* 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; if( !zWhere ) return;
sqlite3VdbeOp3(v, OP_ParseSchema, iDb, 0, zWhere, P3_DYNAMIC); sqlite3VdbeOp3(v, OP_ParseSchema, iDb, 0, zWhere, P3_DYNAMIC);
@@ -487,7 +492,7 @@ void sqlite3AlterFinishAddColumn(Parse *pParse, Token *pColDef){
*/ */
if( pDflt ){ if( pDflt ){
sqlite3_value *pVal; 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; db->mallocFailed = 1;
return; return;
} }

4
src/analyze.c
View File

@@ -11,7 +11,7 @@
************************************************************************* *************************************************************************
** This file contains code associated with the ANALYZE command. ** 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 #ifndef SQLITE_OMIT_ANALYZE
#include "sqliteInt.h" #include "sqliteInt.h"
@@ -397,7 +397,7 @@ int sqlite3AnalysisLoad(sqlite3 *db, int iDb){
/* Load new statistics out of the sqlite_stat1 table */ /* 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); sInfo.zDatabase);
sqlite3SafetyOff(db); sqlite3SafetyOff(db);
rc = sqlite3_exec(db, zSql, analysisLoader, &sInfo, 0); 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. ** 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. ** This file implements a external (disk-based) database using BTrees.
** See the header comment on "btreeInt.h" for additional information. ** See the header comment on "btreeInt.h" for additional information.
@@ -5741,7 +5741,7 @@ static void checkAppendMsg(
pCheck->mxErr--; pCheck->mxErr--;
pCheck->nErr++; pCheck->nErr++;
va_start(ap, zFormat); va_start(ap, zFormat);
zMsg2 = sqlite3VMPrintf(zFormat, ap); zMsg2 = sqlite3VMPrintf(0, zFormat, ap);
va_end(ap); va_end(ap);
if( zMsg1==0 ) zMsg1 = ""; if( zMsg1==0 ) zMsg1 = "";
if( pCheck->zErrMsg ){ if( pCheck->zErrMsg ){
@@ -6091,7 +6091,7 @@ char *sqlite3BtreeIntegrityCheck(
if( !sCheck.anRef ){ if( !sCheck.anRef ){
unlockBtreeIfUnused(pBt); unlockBtreeIfUnused(pBt);
*pnErr = 1; *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])); (sCheck.nPage+1)*sizeof(sCheck.anRef[0]));
} }
for(i=0; i<=sCheck.nPage; i++){ sCheck.anRef[i] = 0; } for(i=0; i<=sCheck.nPage; i++){ sCheck.anRef[i] = 0; }

21
src/build.c
View File

@@ -22,7 +22,7 @@
** COMMIT ** COMMIT
** ROLLBACK ** 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 "sqliteInt.h"
#include <ctype.h> #include <ctype.h>
@@ -235,10 +235,9 @@ void sqlite3NestedParse(Parse *pParse, const char *zFormat, ...){
if( pParse->nErr ) return; if( pParse->nErr ) return;
assert( pParse->nested<10 ); /* Nesting should only be of limited depth */ assert( pParse->nested<10 ); /* Nesting should only be of limited depth */
va_start(ap, zFormat); va_start(ap, zFormat);
zSql = sqlite3VMPrintf(zFormat, ap); zSql = sqlite3VMPrintf(pParse->db, zFormat, ap);
va_end(ap); va_end(ap);
if( zSql==0 ){ if( zSql==0 ){
pParse->db->mallocFailed = 1;
return; /* A malloc must have failed */ return; /* A malloc must have failed */
} }
pParse->nested++; pParse->nested++;
@@ -1498,10 +1497,12 @@ void sqlite3EndTable(
/* Compute the complete text of the CREATE statement */ /* Compute the complete text of the CREATE statement */
if( pSelect ){ if( pSelect ){
zStmt = createTableStmt(p, p->pSchema==pParse->db->aDb[1].pSchema); zStmt = createTableStmt(p, p->pSchema==db->aDb[1].pSchema);
}else{ }else{
n = pEnd->z - pParse->sNameToken.z + 1; 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 /* 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 */ /* Reparse everything to update our internal data structures */
sqlite3VdbeOp3(v, OP_ParseSchema, iDb, 0, 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 ){ if( pList==0 ){
nullId.z = (u8*)pTab->aCol[pTab->nCol-1].zName; nullId.z = (u8*)pTab->aCol[pTab->nCol-1].zName;
nullId.n = strlen((char*)nullId.z); nullId.n = strlen((char*)nullId.z);
pList = sqlite3ExprListAppend(0, 0, &nullId); pList = sqlite3ExprListAppend(pParse, 0, 0, &nullId);
if( pList==0 ) goto exit_create_index; if( pList==0 ) goto exit_create_index;
pList->a[0].sortOrder = sortOrder; pList->a[0].sortOrder = sortOrder;
} }
@@ -2607,7 +2608,7 @@ void sqlite3CreateIndex(
*/ */
if( pStart && pEnd ){ if( pStart && pEnd ){
/* A named index with an explicit CREATE INDEX statement */ /* 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", onError==OE_None ? "" : " UNIQUE",
pEnd->z - pName->z + 1, pEnd->z - pName->z + 1,
pName->z); pName->z);
@@ -2636,7 +2637,7 @@ void sqlite3CreateIndex(
sqlite3RefillIndex(pParse, pIndex, iMem); sqlite3RefillIndex(pParse, pIndex, iMem);
sqlite3ChangeCookie(db, v, iDb); sqlite3ChangeCookie(db, v, iDb);
sqlite3VdbeOp3(v, OP_ParseSchema, iDb, 0, 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); sqlite3VdbeAddOp(v, OP_Expire, 0, 0);
} }
} }
@@ -3366,7 +3367,7 @@ KeyInfo *sqlite3IndexKeyinfo(Parse *pParse, Index *pIdx){
int i; int i;
int nCol = pIdx->nColumn; int nCol = pIdx->nColumn;
int nBytes = sizeof(KeyInfo) + (nCol-1)*sizeof(CollSeq*) + nCol; 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 ){ if( pKey ){
pKey->aSortOrder = (u8 *)&(pKey->aColl[nCol]); 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 ** This file contains functions used to access the internal hash tables
** of user defined functions and collation sequences. ** 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" #include "sqliteInt.h"
@@ -35,9 +35,9 @@ static void callCollNeeded(sqlite3 *db, const char *zName, int nName){
#ifndef SQLITE_OMIT_UTF16 #ifndef SQLITE_OMIT_UTF16
if( db->xCollNeeded16 ){ if( db->xCollNeeded16 ){
char const *zExternal; char const *zExternal;
sqlite3_value *pTmp = sqlite3ValueNew(); sqlite3_value *pTmp = sqlite3ValueNew(db);
sqlite3ValueSetStr(pTmp, nName, zName, SQLITE_UTF8, SQLITE_STATIC); sqlite3ValueSetStr(db, pTmp, nName, zName, SQLITE_UTF8, SQLITE_STATIC);
zExternal = sqlite3ValueText(pTmp, SQLITE_UTF16NATIVE); zExternal = sqlite3ValueText(db, pTmp, SQLITE_UTF16NATIVE);
if( zExternal ){ if( zExternal ){
db->xCollNeeded16(db->pCollNeededArg, db, (int)ENC(db), 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 ** separating it out, the code will be automatically omitted from
** static links that do not use it. ** 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" #include "sqliteInt.h"
#ifndef SQLITE_OMIT_COMPLETE #ifndef SQLITE_OMIT_COMPLETE
@@ -248,11 +248,11 @@ int sqlite3_complete(const char *zSql){
int sqlite3_complete16(const void *zSql){ int sqlite3_complete16(const void *zSql){
sqlite3_value *pVal; sqlite3_value *pVal;
char const *zSql8; char const *zSql8;
int rc = 0; int rc = SQLITE_NOMEM;
pVal = sqlite3ValueNew(); pVal = sqlite3ValueNew(0);
sqlite3ValueSetStr(pVal, -1, zSql, SQLITE_UTF16NATIVE, SQLITE_STATIC); sqlite3ValueSetStr(0, pVal, -1, zSql, SQLITE_UTF16NATIVE, SQLITE_STATIC);
zSql8 = sqlite3ValueText(pVal, SQLITE_UTF8); zSql8 = sqlite3ValueText(0, pVal, SQLITE_UTF8);
if( zSql8 ){ if( zSql8 ){
rc = sqlite3_complete(zSql8); rc = sqlite3_complete(zSql8);
} }

14
src/date.c
View File

@@ -16,7 +16,7 @@
** sqlite3RegisterDateTimeFunctions() found at the bottom of the file. ** sqlite3RegisterDateTimeFunctions() found at the bottom of the file.
** All other code has file scope. ** 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 ** SQLite processes all times and dates as Julian Day numbers. The
** dates and times are stored as the number of days since noon ** dates and times are stored as the number of days since noon
@@ -894,9 +894,9 @@ static void ctimeFunc(
int argc, int argc,
sqlite3_value **argv sqlite3_value **argv
){ ){
sqlite3_value *pVal = sqlite3ValueNew(); sqlite3_value *pVal = sqlite3ValueNew(0);
if( pVal ){ if( pVal ){
sqlite3ValueSetStr(pVal, -1, "now", SQLITE_UTF8, SQLITE_STATIC); sqlite3ValueSetStr(0, pVal, -1, "now", SQLITE_UTF8, SQLITE_STATIC);
timeFunc(context, 1, &pVal); timeFunc(context, 1, &pVal);
sqlite3ValueFree(pVal); sqlite3ValueFree(pVal);
} }
@@ -912,9 +912,9 @@ static void cdateFunc(
int argc, int argc,
sqlite3_value **argv sqlite3_value **argv
){ ){
sqlite3_value *pVal = sqlite3ValueNew(); sqlite3_value *pVal = sqlite3ValueNew(0);
if( pVal ){ if( pVal ){
sqlite3ValueSetStr(pVal, -1, "now", SQLITE_UTF8, SQLITE_STATIC); sqlite3ValueSetStr(0, pVal, -1, "now", SQLITE_UTF8, SQLITE_STATIC);
dateFunc(context, 1, &pVal); dateFunc(context, 1, &pVal);
sqlite3ValueFree(pVal); sqlite3ValueFree(pVal);
} }
@@ -930,9 +930,9 @@ static void ctimestampFunc(
int argc, int argc,
sqlite3_value **argv sqlite3_value **argv
){ ){
sqlite3_value *pVal = sqlite3ValueNew(); sqlite3_value *pVal = sqlite3ValueNew(0);
if( pVal ){ if( pVal ){
sqlite3ValueSetStr(pVal, -1, "now", SQLITE_UTF8, SQLITE_STATIC); sqlite3ValueSetStr(0, pVal, -1, "now", SQLITE_UTF8, SQLITE_STATIC);
datetimeFunc(context, 1, &pVal); datetimeFunc(context, 1, &pVal);
sqlite3ValueFree(pVal); sqlite3ValueFree(pVal);
} }

22
src/expr.c
View File

@@ -12,7 +12,7 @@
** This file contains routines used for analyzing expressions and ** This file contains routines used for analyzing expressions and
** for generating VDBE code that evaluates expressions in SQLite. ** 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 "sqliteInt.h"
#include <ctype.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 ** Join two expressions using an AND operator. If either expression is
** NULL, then just return the other expression. ** 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 ){ if( pLeft==0 ){
return pRight; return pRight;
}else if( pRight==0 ){ }else if( pRight==0 ){
@@ -328,6 +328,7 @@ Expr *sqlite3ExprAnd(sqlite *db, Expr *pLeft, Expr *pRight){
if( p==0 ){ if( p==0 ){
db->mallocFailed = 1; 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. ** 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; Expr *pNew;
if( p==0 ) return 0; if( p==0 ) return 0;
pNew = sqlite3DbMallocRaw(db, sizeof(*p) ); pNew = sqlite3DbMallocRaw(db, sizeof(*p) );
@@ -1179,7 +1180,7 @@ static int lookupName(
sqlite3_free(zCol); sqlite3_free(zCol);
return 2; return 2;
} }
pDup = sqlite3ExprDup(pOrig); pDup = sqlite3ExprDup(db, pOrig);
if( pExpr->flags & EP_ExpCollate ){ if( pExpr->flags & EP_ExpCollate ){
pDup->pColl = pExpr->pColl; pDup->pColl = pExpr->pColl;
pDup->flags |= EP_ExpCollate; pDup->flags |= EP_ExpCollate;
@@ -1780,7 +1781,7 @@ void sqlite3ExprCode(Parse *pParse, Expr *pExpr){
case TK_STRING: { case TK_STRING: {
assert( TK_FLOAT==OP_Real ); assert( TK_FLOAT==OP_Real );
assert( TK_STRING==OP_String8 ); assert( TK_STRING==OP_String8 );
sqlite3DequoteExpr(pExpr); sqlite3DequoteExpr(pParse->db, pExpr);
sqlite3VdbeOp3(v, op, 0, 0, (char*)pExpr->token.z, pExpr->token.n); sqlite3VdbeOp3(v, op, 0, 0, (char*)pExpr->token.z, pExpr->token.n);
break; break;
} }
@@ -1883,7 +1884,7 @@ void sqlite3ExprCode(Parse *pParse, Expr *pExpr){
assert( pLeft ); assert( pLeft );
if( pLeft->op==TK_FLOAT || pLeft->op==TK_INTEGER ){ if( pLeft->op==TK_FLOAT || pLeft->op==TK_INTEGER ){
Token *p = &pLeft->token; 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 ){ if( pLeft->op==TK_FLOAT ){
sqlite3VdbeOp3(v, OP_Real, 0, 0, z, p->n+1); sqlite3VdbeOp3(v, OP_Real, 0, 0, z, p->n+1);
}else{ }else{
@@ -2095,7 +2096,7 @@ void sqlite3ExprCode(Parse *pParse, Expr *pExpr){
assert( pExpr->iColumn==OE_Rollback || assert( pExpr->iColumn==OE_Rollback ||
pExpr->iColumn == OE_Abort || pExpr->iColumn == OE_Abort ||
pExpr->iColumn == OE_Fail ); pExpr->iColumn == OE_Fail );
sqlite3DequoteExpr(pExpr); sqlite3DequoteExpr(pParse->db, pExpr);
sqlite3VdbeOp3(v, OP_Halt, SQLITE_CONSTRAINT, pExpr->iColumn, sqlite3VdbeOp3(v, OP_Halt, SQLITE_CONSTRAINT, pExpr->iColumn,
(char*)pExpr->token.z, pExpr->token.n); (char*)pExpr->token.z, pExpr->token.n);
} else { } else {
@@ -2465,7 +2466,6 @@ static int analyzeAggregate(void *pArg, Expr *pExpr){
Parse *pParse = pNC->pParse; Parse *pParse = pNC->pParse;
SrcList *pSrcList = pNC->pSrcList; SrcList *pSrcList = pNC->pSrcList;
AggInfo *pAggInfo = pNC->pAggInfo; AggInfo *pAggInfo = pNC->pAggInfo;
switch( pExpr->op ){ switch( pExpr->op ){
case TK_AGG_COLUMN: case TK_AGG_COLUMN:
@@ -2491,7 +2491,9 @@ static int analyzeAggregate(void *pArg, Expr *pExpr){
break; break;
} }
} }
if( k>=pAggInfo->nColumn && (k = addAggInfoColumn(pAggInfo))>=0 ){ if( (k>=pAggInfo->nColumn)
&& (k = addAggInfoColumn(pParse->db, pAggInfo))>=0
){
pCol = &pAggInfo->aCol[k]; pCol = &pAggInfo->aCol[k];
pCol->pTab = pExpr->pTab; pCol->pTab = pExpr->pTab;
pCol->iTable = pExpr->iTable; 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[] /* pExpr is original. Make a new entry in pAggInfo->aFunc[]
*/ */
u8 enc = ENC(pParse->db); u8 enc = ENC(pParse->db);
i = addAggInfoFunc(pAggInfo); i = addAggInfoFunc(pParse->db, pAggInfo);
if( i>=0 ){ if( i>=0 ){
pItem = &pAggInfo->aFunc[i]; pItem = &pAggInfo->aFunc[i];
pItem->pExpr = pExpr; pItem->pExpr = pExpr;

18
src/func.c
View File

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

4
src/hash.c
View File

@@ -12,7 +12,7 @@
** This is the implementation of generic hash-tables ** This is the implementation of generic hash-tables
** used in SQLite. ** 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 "sqliteInt.h"
#include <assert.h> #include <assert.h>
@@ -222,7 +222,7 @@ static void rehash(Hash *pH, int new_size){
int (*xHash)(const void*,int); /* The hash function */ int (*xHash)(const void*,int); /* The hash function */
assert( (new_size & (new_size-1))==0 ); 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( new_ht==0 ) return;
if( pH->ht ) sqlite3_free(pH->ht); if( pH->ht ) sqlite3_free(pH->ht);
pH->ht = new_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 ** other files are for internal use by SQLite and should not be
** accessed by users of the library. ** 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 "sqliteInt.h"
#include "os.h" #include "os.h"
@@ -219,7 +219,7 @@ int sqlite3_close(sqlite3 *db){
*/ */
sqlite3_free(db->aDb[1].pSchema); sqlite3_free(db->aDb[1].pSchema);
sqlite3_free(db); sqlite3_free(db);
sqlite3ReleaseThreadData(); /* sqlite3ReleaseThreadData(); */
return SQLITE_OK; return SQLITE_OK;
} }
@@ -542,7 +542,7 @@ int sqlite3_create_function16(
char *zFunc8; char *zFunc8;
assert( !db->mallocFailed ); assert( !db->mallocFailed );
zFunc8 = sqlite3Utf16to8(zFunctionName, -1); zFunc8 = sqlite3Utf16to8(db, zFunctionName, -1);
rc = sqlite3CreateFunc(db, zFunc8, nArg, eTextRep, p, xFunc, xStep, xFinal); rc = sqlite3CreateFunc(db, zFunc8, nArg, eTextRep, p, xFunc, xStep, xFinal);
sqlite3_free(zFunc8); sqlite3_free(zFunc8);
@@ -780,7 +780,7 @@ const void *sqlite3_errmsg16(sqlite3 *db){
} }
z = sqlite3_value_text16(db->pErr); z = sqlite3_value_text16(db->pErr);
if( z==0 ){ if( z==0 ){
sqlite3ValueSetStr(db->pErr, -1, sqlite3ErrStr(db->errCode), sqlite3ValueSetStr(db, db->pErr, -1, sqlite3ErrStr(db->errCode),
SQLITE_UTF8, SQLITE_STATIC); SQLITE_UTF8, SQLITE_STATIC);
z = sqlite3_value_text16(db->pErr); z = sqlite3_value_text16(db->pErr);
} }
@@ -1044,15 +1044,15 @@ int sqlite3_open16(
sqlite3 **ppDb sqlite3 **ppDb
){ ){
char const *zFilename8; /* zFilename encoded in UTF-8 instead of UTF-16 */ char const *zFilename8; /* zFilename encoded in UTF-8 instead of UTF-16 */
int rc = SQLITE_OK;
sqlite3_value *pVal; sqlite3_value *pVal;
int rc = SQLITE_NOMEM;
assert( zFilename ); assert( zFilename );
assert( ppDb ); assert( ppDb );
*ppDb = 0; *ppDb = 0;
pVal = sqlite3ValueNew(); pVal = sqlite3ValueNew(0);
sqlite3ValueSetStr(pVal, -1, zFilename, SQLITE_UTF16NATIVE, SQLITE_STATIC); sqlite3ValueSetStr(0, pVal, -1, zFilename, SQLITE_UTF16NATIVE, SQLITE_STATIC);
zFilename8 = sqlite3ValueText(pVal, SQLITE_UTF8); zFilename8 = sqlite3ValueText(0, pVal, SQLITE_UTF8);
if( zFilename8 ){ if( zFilename8 ){
rc = openDatabase(zFilename8, ppDb); rc = openDatabase(zFilename8, ppDb);
if( rc==SQLITE_OK && *ppDb ){ if( rc==SQLITE_OK && *ppDb ){
@@ -1155,7 +1155,7 @@ int sqlite3_create_collation16(
int rc = SQLITE_OK; int rc = SQLITE_OK;
char *zName8; char *zName8;
assert( !db->mallocFailed ); assert( !db->mallocFailed );
zName8 = sqlite3Utf16to8(zName, -1); zName8 = sqlite3Utf16to8(db, zName, -1);
if( zName8 ){ if( zName8 ){
rc = createCollation(db, zName8, enc, pCtx, xCompare, 0); rc = createCollation(db, zName8, enc, pCtx, xCompare, 0);
sqlite3_free(zName8); sqlite3_free(zName8);
@@ -1258,7 +1258,7 @@ int sqlite3_enable_shared_cache(int enable){
} }
pTd->useSharedData = enable; pTd->useSharedData = enable;
sqlite3ReleaseThreadData(); /* sqlite3ReleaseThreadData(); */
} }
return sqlite3ApiExit(0, SQLITE_OK); return sqlite3ApiExit(0, SQLITE_OK);
} }

37
src/malloc.c
View File

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

3
src/mutex.c
View File

@@ -12,7 +12,7 @@
** This file contains the C functions that implement mutexes for ** This file contains the C functions that implement mutexes for
** use by the SQLite core. ** 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){ int sqlite3_mutex_serialize(void (*xCallback)(void*), void *pArg){
xCallback(pArg); xCallback(pArg);
return SQLITE_OK;
} }
#if 0 #if 0

4
src/os_unix.c
View File

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

12
src/pager.c
View File

@@ -18,7 +18,7 @@
** file simultaneously, or one process from reading the database while ** file simultaneously, or one process from reading the database while
** another is writing. ** 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 #ifndef SQLITE_OMIT_DISKIO
#include "sqliteInt.h" #include "sqliteInt.h"
@@ -2745,7 +2745,15 @@ int sqlite3PagerReleaseMemory(int nReq){
for( pTmp=pPager->pAll; pTmp->pNextAll!=pPg; pTmp=pTmp->pNextAll ){} for( pTmp=pPager->pAll; pTmp->pNextAll!=pPg; pTmp=pTmp->pNextAll ){}
pTmp->pNextAll = pPg->pNextAll; pTmp->pNextAll = pPg->pNextAll;
} }
#if 0
nReleased += sqliteAllocSize(pPg); 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)); IOTRACE(("PGFREE %p %d *\n", pPager, pPg->pgno));
PAGER_INCR(sqlite3_pager_pgfree_count); PAGER_INCR(sqlite3_pager_pgfree_count);
sqlite3_free(pPg); sqlite3_free(pPg);
@@ -3121,7 +3129,9 @@ int sqlite3PagerAcquire(
pPg->pgno = pgno; pPg->pgno = pgno;
assert( !MEMDB || pgno>pPager->stmtSize ); assert( !MEMDB || pgno>pPager->stmtSize );
if( pPager->aInJournal && (int)pgno<=pPager->origDbSize ){ if( pPager->aInJournal && (int)pgno<=pPager->origDbSize ){
#if 0
sqlite3CheckMemory(pPager->aInJournal, pgno/8); sqlite3CheckMemory(pPager->aInJournal, pgno/8);
#endif
assert( pPager->journalOpen ); assert( pPager->journalOpen );
pPg->inJournal = (pPager->aInJournal[pgno/8] & (1<<(pgno&7)))!=0; pPg->inJournal = (pPager->aInJournal[pgno/8] & (1<<(pgno&7)))!=0;
pPg->needSync = 0; pPg->needSync = 0;

6
src/parse.y
View File

@@ -14,7 +14,7 @@
** the parser. Lemon will also generate a header file containing ** the parser. Lemon will also generate a header file containing
** numeric codes for all of the tokens. ** 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_" // 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); A = sqlite3ExprListAppend(pParse,P,X,Y.n?&Y:0);
} }
selcollist(A) ::= sclp(P) STAR. { 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); A = sqlite3ExprListAppend(pParse, P, p, 0);
} }
selcollist(A) ::= sclp(P) nm(X) DOT STAR. { 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); SrcList *pSrc = sqlite3SrcListAppend(pParse->db, 0,&Y,&Z);
A = sqlite3PExpr(pParse, TK_IN, X, 0, 0); A = sqlite3PExpr(pParse, TK_IN, X, 0, 0);
if( A ){ 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); sqlite3ExprSetHeight(A);
}else{ }else{
sqlite3SrcListDelete(pSrc); sqlite3SrcListDelete(pSrc);

4
src/pragma.c
View File

@@ -11,7 +11,7 @@
************************************************************************* *************************************************************************
** This file contains code used to implement the PRAGMA command. ** 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 "sqliteInt.h"
#include "os.h" #include "os.h"
@@ -864,7 +864,7 @@ void sqlite3Pragma(
sqlite3VdbeAddOp(v, OP_IntegrityCk, 0, i); sqlite3VdbeAddOp(v, OP_IntegrityCk, 0, i);
addr = sqlite3VdbeAddOp(v, OP_IsNull, -1, 0); addr = sqlite3VdbeAddOp(v, OP_IsNull, -1, 0);
sqlite3VdbeOp3(v, OP_String8, 0, 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); P3_DYNAMIC);
sqlite3VdbeAddOp(v, OP_Pull, 1, 0); sqlite3VdbeAddOp(v, OP_Pull, 1, 0);
sqlite3VdbeAddOp(v, OP_Concat, 0, 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 ** interface, and routines that contribute to loading the database schema
** from disk. ** 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 "sqliteInt.h"
#include "os.h" #include "os.h"
@@ -290,7 +290,7 @@ static int sqlite3InitOne(sqlite3 *db, int iDb, char **pzErrMsg){
rc = SQLITE_OK; rc = SQLITE_OK;
}else{ }else{
char *zSql; char *zSql;
zSql = sqlite3MPrintf( zSql = sqlite3MPrintf(db,
"SELECT name, rootpage, sql FROM '%q'.%s", "SELECT name, rootpage, sql FROM '%q'.%s",
db->aDb[iDb].zName, zMasterName); db->aDb[iDb].zName, zMasterName);
sqlite3SafetyOff(db); sqlite3SafetyOff(db);
@@ -560,7 +560,7 @@ int sqlite3Prepare(
} }
rc = sqlite3ApiExit(db, rc); rc = sqlite3ApiExit(db, rc);
sqlite3ReleaseThreadData(); /* sqlite3ReleaseThreadData(); */
assert( (rc&db->errMask)==rc ); assert( (rc&db->errMask)==rc );
return rc; return rc;
} }
@@ -647,7 +647,7 @@ static int sqlite3Prepare16(
if( sqlite3SafetyCheck(db) ){ if( sqlite3SafetyCheck(db) ){
return SQLITE_MISUSE; return SQLITE_MISUSE;
} }
zSql8 = sqlite3Utf16to8(zSql, nBytes); zSql8 = sqlite3Utf16to8(db, zSql, nBytes);
if( zSql8 ){ if( zSql8 ){
rc = sqlite3Prepare(db, zSql8, -1, saveSqlFlag, ppStmt, &zTail8); rc = sqlite3Prepare(db, zSql8, -1, saveSqlFlag, ppStmt, &zTail8);
} }

10
src/printf.c
View File

@@ -701,7 +701,7 @@ static int vxprintf(
} }
} }
if( zExtra ){ if( zExtra ){
sqliteFree(zExtra); sqlite3_free(zExtra);
} }
}/* End for loop over the format string */ }/* End for loop over the format string */
return errorflag ? -1 : count; return errorflag ? -1 : count;
@@ -717,7 +717,7 @@ struct sgMprintf {
int nChar; /* Length of the string so far */ int nChar; /* Length of the string so far */
int nTotal; /* Output size if unconstrained */ int nTotal; /* Output size if unconstrained */
int nAlloc; /* Amount of space allocated in zText */ 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. ** the consumer.
*/ */
static char *base_vprintf( 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 */ int useInternal, /* Use internal %-conversions if true */
char *zInitBuf, /* Initially write here, before mallocing */ char *zInitBuf, /* Initially write here, before mallocing */
int nInitBuf, /* Size of zInitBuf[] */ int nInitBuf, /* Size of zInitBuf[] */
@@ -801,8 +801,8 @@ static char *base_vprintf(
/* /*
** Realloc that is a real function, not a macro. ** Realloc that is a real function, not a macro.
*/ */
static void *printf_realloc(void *old, int size){ static void *printf_realloc(void *old, unsigned int size){
return sqlite3_realloc(old,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 ** This file contains C code routines that are called by the parser
** to handle SELECT statements in SQLite. ** 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" #include "sqliteInt.h"
@@ -193,11 +193,13 @@ static void setToken(Token *p, const char *z){
** **
** {a"bc} -> {"a""bc"} ** {a"bc} -> {"a""bc"}
*/ */
static void setQuotedToken(Token *p, const char *z){ static void setQuotedToken(Parse *pParse, Token *p, const char *z){
p->z = (u8 *)sqlite3MPrintf("\"%w\"", z); p->z = (u8 *)sqlite3MPrintf(0, "\"%w\"", z);
p->dyn = 1; p->dyn = 1;
if( p->z ){ if( p->z ){
p->n = strlen((char *)p->z); p->n = strlen((char *)p->z);
}else{
pParse->db->mallocFailed = 1;
} }
} }
@@ -241,7 +243,7 @@ static void addWhereTerm(
pE2b = sqlite3CreateIdExpr(pParse, zAlias2); pE2b = sqlite3CreateIdExpr(pParse, zAlias2);
pE1c = sqlite3PExpr(pParse, TK_DOT, pE1b, pE1a, 0); pE1c = sqlite3PExpr(pParse, TK_DOT, pE1b, pE1a, 0);
pE2c = sqlite3PExpr(pParse, TK_DOT, pE2b, pE2a, 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 ){ if( pE ){
ExprSetProperty(pE, EP_FromJoin); ExprSetProperty(pE, EP_FromJoin);
pE->iRightJoinTable = iRightJoinTable; pE->iRightJoinTable = iRightJoinTable;
@@ -328,7 +330,7 @@ static int sqliteProcessJoin(Parse *pParse, Select *p){
for(j=0; j<pLeftTab->nCol; j++){ for(j=0; j<pLeftTab->nCol; j++){
char *zName = pLeftTab->aCol[j].zName; char *zName = pLeftTab->aCol[j].zName;
if( columnIndex(pRightTab, zName)>=0 ){ if( columnIndex(pRightTab, zName)>=0 ){
addWhereTerm(zName, pLeftTab, pLeft->zAlias, addWhereTerm(pParse, zName, pLeftTab, pLeft->zAlias,
pRightTab, pRight->zAlias, pRightTab, pRight->zAlias,
pRight->iCursor, &p->pWhere); pRight->iCursor, &p->pWhere);
@@ -369,7 +371,7 @@ static int sqliteProcessJoin(Parse *pParse, Select *p){
"not present in both tables", zName); "not present in both tables", zName);
return 1; return 1;
} }
addWhereTerm(zName, pLeftTab, pLeft->zAlias, addWhereTerm(pParse, zName, pLeftTab, pLeft->zAlias,
pRightTab, pRight->zAlias, pRightTab, pRight->zAlias,
pRight->iCursor, &p->pWhere); pRight->iCursor, &p->pWhere);
} }
@@ -1139,7 +1141,7 @@ Table *sqlite3ResultSetOfSelect(Parse *pParse, char *zTabName, Select *pSelect){
for(j=cnt=0; j<i; j++){ for(j=cnt=0; j<i; j++){
if( sqlite3StrICmp(aCol[j].zName, zName)==0 ){ if( sqlite3StrICmp(aCol[j].zName, zName)==0 ){
zName[nName] = 0; zName[nName] = 0;
zName = sqlite3MPrintf("%z:%d", zName, ++cnt); zName = sqlite3MPrintf(db, "%z:%d", zName, ++cnt);
j = -1; j = -1;
if( zName==0 ) break; if( zName==0 ) break;
} }
@@ -1225,7 +1227,7 @@ static int prepSelectStmt(Parse *pParse, Select *p){
assert( pFrom->pSelect!=0 ); assert( pFrom->pSelect!=0 );
if( pFrom->zAlias==0 ){ if( pFrom->zAlias==0 ){
pFrom->zAlias = pFrom->zAlias =
sqlite3MPrintf("sqlite_subquery_%p_", (void*)pFrom->pSelect); sqlite3MPrintf(db, "sqlite_subquery_%p_", (void*)pFrom->pSelect);
} }
assert( pFrom->pTab==0 ); assert( pFrom->pTab==0 );
pFrom->pTab = pTab = pFrom->pTab = pTab =
@@ -1364,13 +1366,14 @@ static int prepSelectStmt(Parse *pParse, Select *p){
} }
pRight = sqlite3Expr(TK_ID, 0, 0, 0); pRight = sqlite3Expr(TK_ID, 0, 0, 0);
if( pRight==0 ) break; if( pRight==0 ) break;
setQuotedToken(&pRight->token, zName); setQuotedToken(pParse, &pRight->token, zName);
if( zTabName && (longNames || pTabList->nSrc>1) ){ if( zTabName && (longNames || pTabList->nSrc>1) ){
Expr *pLeft = sqlite3Expr(TK_ID, 0, 0, 0); Expr *pLeft = sqlite3Expr(TK_ID, 0, 0, 0);
pExpr = sqlite3Expr(TK_DOT, pLeft, pRight, 0); pExpr = sqlite3Expr(TK_DOT, pLeft, pRight, 0);
if( pExpr==0 ) break; if( pExpr==0 ) break;
setQuotedToken(&pLeft->token, zTabName); setQuotedToken(pParse, &pLeft->token, zTabName);
setToken(&pExpr->span, sqlite3MPrintf("%s.%s", zTabName, zName)); setToken(&pExpr->span,
sqlite3MPrintf(db, "%s.%s", zTabName, zName));
pExpr->span.dyn = 1; pExpr->span.dyn = 1;
pExpr->token.z = 0; pExpr->token.z = 0;
pExpr->token.n = 0; pExpr->token.n = 0;
@@ -2354,17 +2357,17 @@ static int flattenSubquery(
sqlite3DbStrNDup(db, (char*)pExpr->span.z, pExpr->span.n); sqlite3DbStrNDup(db, (char*)pExpr->span.z, pExpr->span.n);
} }
} }
substExprList(p->pEList, iParent, pSub->pEList); substExprList(db, p->pEList, iParent, pSub->pEList);
if( isAgg ){ if( isAgg ){
substExprList(p->pGroupBy, iParent, pSub->pEList); substExprList(db, p->pGroupBy, iParent, pSub->pEList);
substExpr(p->pHaving, iParent, pSub->pEList); substExpr(db, p->pHaving, iParent, pSub->pEList);
} }
if( pSub->pOrderBy ){ if( pSub->pOrderBy ){
assert( p->pOrderBy==0 ); assert( p->pOrderBy==0 );
p->pOrderBy = pSub->pOrderBy; p->pOrderBy = pSub->pOrderBy;
pSub->pOrderBy = 0; pSub->pOrderBy = 0;
}else if( p->pOrderBy ){ }else if( p->pOrderBy ){
substExprList(p->pOrderBy, iParent, pSub->pEList); substExprList(db, p->pOrderBy, iParent, pSub->pEList);
} }
if( pSub->pWhere ){ if( pSub->pWhere ){
pWhere = sqlite3ExprDup(db, pSub->pWhere); pWhere = sqlite3ExprDup(db, pSub->pWhere);
@@ -2375,13 +2378,13 @@ static int flattenSubquery(
assert( p->pHaving==0 ); assert( p->pHaving==0 );
p->pHaving = p->pWhere; p->pHaving = p->pWhere;
p->pWhere = pWhere; p->pWhere = pWhere;
substExpr(p->pHaving, iParent, pSub->pEList); substExpr(db, p->pHaving, iParent, pSub->pEList);
p->pHaving = sqlite3ExprAnd(db, p->pHaving, p->pHaving = sqlite3ExprAnd(db, p->pHaving,
sqlite3ExprDup(db, pSub->pHaving)); sqlite3ExprDup(db, pSub->pHaving));
assert( p->pGroupBy==0 ); assert( p->pGroupBy==0 );
p->pGroupBy = sqlite3ExprListDup(db, pSub->pGroupBy); p->pGroupBy = sqlite3ExprListDup(db, pSub->pGroupBy);
}else{ }else{
substExpr(p->pWhere, iParent, pSub->pEList); substExpr(db, p->pWhere, iParent, pSub->pEList);
p->pWhere = sqlite3ExprAnd(db, p->pWhere, pWhere); p->pWhere = sqlite3ExprAnd(db, p->pWhere, pWhere);
} }
@@ -2718,7 +2721,7 @@ int sqlite3SelectResolve(
} }
} }
if( db->mallocFailed ){ if( pParse->db->mallocFailed ){
return SQLITE_NOMEM; return SQLITE_NOMEM;
} }

6
src/sqlite3ext.h
View File

@@ -15,7 +15,7 @@
** as extensions by SQLite should #include this file instead of ** as extensions by SQLite should #include this file instead of
** sqlite3.h. ** 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_ #ifndef _SQLITE3EXT_H_
#define _SQLITE3EXT_H_ #define _SQLITE3EXT_H_
@@ -102,7 +102,7 @@ struct sqlite3_api_routines {
sqlite_int64 (*last_insert_rowid)(sqlite3*); sqlite_int64 (*last_insert_rowid)(sqlite3*);
const char * (*libversion)(void); const char * (*libversion)(void);
int (*libversion_number)(void); int (*libversion_number)(void);
void *(*malloc)(int); void *(*malloc)(unsigned int);
char * (*mprintf)(const char*,...); char * (*mprintf)(const char*,...);
int (*open)(const char*,sqlite3**); int (*open)(const char*,sqlite3**);
int (*open16)(const void*,sqlite3**); int (*open16)(const void*,sqlite3**);
@@ -110,7 +110,7 @@ struct sqlite3_api_routines {
int (*prepare16)(sqlite3*,const void*,int,sqlite3_stmt**,const void**); int (*prepare16)(sqlite3*,const void*,int,sqlite3_stmt**,const void**);
void * (*profile)(sqlite3*,void(*)(void*,const char*,sqlite_uint64),void*); void * (*profile)(sqlite3*,void(*)(void*,const char*,sqlite_uint64),void*);
void (*progress_handler)(sqlite3*,int,int(*)(void*),void*); void (*progress_handler)(sqlite3*,int,int(*)(void*),void*);
void *(*realloc)(void*,int); void *(*realloc)(void*,unsigned int);
int (*reset)(sqlite3_stmt*pStmt); int (*reset)(sqlite3_stmt*pStmt);
void (*result_blob)(sqlite3_context*,const void*,int,void(*)(void*)); void (*result_blob)(sqlite3_context*,const void*,int,void(*)(void*));
void (*result_double)(sqlite3_context*,double); void (*result_double)(sqlite3_context*,double);

30
src/sqliteInt.h
View File

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

4
src/table.c
View File

@@ -154,12 +154,12 @@ int sqlite3_get_table(
sqlite3_free(*pzErrMsg); sqlite3_free(*pzErrMsg);
*pzErrMsg = sqlite3_mprintf("%s",res.zErrMsg); *pzErrMsg = sqlite3_mprintf("%s",res.zErrMsg);
} }
sqliteFree(res.zErrMsg); sqlite3_free(res.zErrMsg);
} }
db->errCode = res.rc; db->errCode = res.rc;
return res.rc & db->errMask; return res.rc & db->errMask;
} }
sqliteFree(res.zErrMsg); sqlite3_free(res.zErrMsg);
if( rc!=SQLITE_OK ){ if( rc!=SQLITE_OK ){
sqlite3_free_table(&res.azResult[1]); sqlite3_free_table(&res.azResult[1]);
return rc & db->errMask; 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 ** is not included in the SQLite library. It is used for automated
** testing of the SQLite library. ** 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 "sqliteInt.h"
#include "tcl.h" #include "tcl.h"
@@ -192,9 +192,9 @@ static int getStmtPointer(
static int getFilePointer( static int getFilePointer(
Tcl_Interp *interp, Tcl_Interp *interp,
const char *zArg, const char *zArg,
OsFile **ppFile sqlite3_file **ppFile
){ ){
*ppFile = (OsFile*)sqlite3TextToPtr(zArg); *ppFile = (sqlite3_file*)sqlite3TextToPtr(zArg);
return TCL_OK; return TCL_OK;
} }
@@ -412,7 +412,7 @@ static int test_mprintf_z(
int i; int i;
for(i=2; i<argc; 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); Tcl_AppendResult(interp, zResult, 0);
sqlite3_free(zResult); sqlite3_free(zResult);
@@ -433,7 +433,7 @@ static int test_mprintf_n(
){ ){
char *zStr; char *zStr;
int n = 0; int n = 0;
zStr = sqlite3MPrintf("%s%n", argv[1], &n); zStr = sqlite3MPrintf(0, "%s%n", argv[1], &n);
sqlite3_free(zStr); sqlite3_free(zStr);
Tcl_SetObjResult(interp, Tcl_NewIntObj(n)); Tcl_SetObjResult(interp, Tcl_NewIntObj(n));
return TCL_OK; return TCL_OK;
@@ -917,15 +917,15 @@ static int test_create_function(
** because it is not tested anywhere else. */ ** because it is not tested anywhere else. */
if( rc==SQLITE_OK ){ if( rc==SQLITE_OK ){
sqlite3_value *pVal; sqlite3_value *pVal;
#ifdef 0 #if 0
if( sqlite3_iMallocFail>0 ){ if( sqlite3_iMallocFail>0 ){
sqlite3_iMallocFail++; sqlite3_iMallocFail++;
} }
#endif #endif
pVal = sqlite3ValueNew(); pVal = sqlite3ValueNew(0);
sqlite3ValueSetStr(pVal, -1, "x_sqlite_exec", SQLITE_UTF8, SQLITE_STATIC); sqlite3ValueSetStr(0,pVal, -1, "x_sqlite_exec", SQLITE_UTF8, SQLITE_STATIC);
rc = sqlite3_create_function16(db, rc = sqlite3_create_function16(db,
sqlite3ValueText(pVal, SQLITE_UTF16NATIVE), sqlite3ValueText(0, pVal, SQLITE_UTF16NATIVE),
1, SQLITE_UTF16, db, sqlite3ExecFunc, 0, 0); 1, SQLITE_UTF16, db, sqlite3ExecFunc, 0, 0);
sqlite3ValueFree(pVal); sqlite3ValueFree(pVal);
} }
@@ -2055,12 +2055,12 @@ static int test_collate_func(
assert(0); assert(0);
} }
pVal = sqlite3ValueNew(); pVal = sqlite3ValueNew(0);
sqlite3ValueSetStr(pVal, nA, zA, encin, SQLITE_STATIC); sqlite3ValueSetStr(0, pVal, nA, zA, encin, SQLITE_STATIC);
n = sqlite3_value_bytes(pVal); n = sqlite3_value_bytes(pVal);
Tcl_ListObjAppendElement(i,pX, Tcl_ListObjAppendElement(i,pX,
Tcl_NewStringObj((char*)sqlite3_value_text(pVal),n)); 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); n = sqlite3_value_bytes(pVal);
Tcl_ListObjAppendElement(i,pX, Tcl_ListObjAppendElement(i,pX,
Tcl_NewStringObj((char*)sqlite3_value_text(pVal),n)); Tcl_NewStringObj((char*)sqlite3_value_text(pVal),n));
@@ -2100,10 +2100,10 @@ static int test_collate(
sqlite3_iMallocFail++; sqlite3_iMallocFail++;
} }
#endif #endif
pVal = sqlite3ValueNew(); pVal = sqlite3ValueNew(0);
sqlite3ValueSetStr(pVal, -1, "test_collate", SQLITE_UTF8, SQLITE_STATIC); sqlite3ValueSetStr(0, pVal, -1, "test_collate", SQLITE_UTF8, SQLITE_STATIC);
rc = sqlite3_create_collation16(db, 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); (void *)SQLITE_UTF16BE, val?test_collate_func:0);
sqlite3ValueFree(pVal); sqlite3ValueFree(pVal);
} }
@@ -2269,8 +2269,8 @@ static void test_function_utf8(
Tcl_EvalObjEx(interp, pX, 0); Tcl_EvalObjEx(interp, pX, 0);
Tcl_DecrRefCount(pX); Tcl_DecrRefCount(pX);
sqlite3_result_text(pCtx, Tcl_GetStringResult(interp), -1, SQLITE_TRANSIENT); sqlite3_result_text(pCtx, Tcl_GetStringResult(interp), -1, SQLITE_TRANSIENT);
pVal = sqlite3ValueNew(); pVal = sqlite3ValueNew(0);
sqlite3ValueSetStr(pVal, -1, Tcl_GetStringResult(interp), sqlite3ValueSetStr(0, pVal, -1, Tcl_GetStringResult(interp),
SQLITE_UTF8, SQLITE_STATIC); SQLITE_UTF8, SQLITE_STATIC);
sqlite3_result_text16be(pCtx, sqlite3_value_text16be(pVal), sqlite3_result_text16be(pCtx, sqlite3_value_text16be(pVal),
-1, SQLITE_TRANSIENT); -1, SQLITE_TRANSIENT);
@@ -2292,8 +2292,8 @@ static void test_function_utf16le(
Tcl_NewStringObj((char*)sqlite3_value_text(argv[0]), -1)); Tcl_NewStringObj((char*)sqlite3_value_text(argv[0]), -1));
Tcl_EvalObjEx(interp, pX, 0); Tcl_EvalObjEx(interp, pX, 0);
Tcl_DecrRefCount(pX); Tcl_DecrRefCount(pX);
pVal = sqlite3ValueNew(); pVal = sqlite3ValueNew(0);
sqlite3ValueSetStr(pVal, -1, Tcl_GetStringResult(interp), sqlite3ValueSetStr(0, pVal, -1, Tcl_GetStringResult(interp),
SQLITE_UTF8, SQLITE_STATIC); SQLITE_UTF8, SQLITE_STATIC);
sqlite3_result_text(pCtx,(char*)sqlite3_value_text(pVal),-1,SQLITE_TRANSIENT); sqlite3_result_text(pCtx,(char*)sqlite3_value_text(pVal),-1,SQLITE_TRANSIENT);
sqlite3ValueFree(pVal); sqlite3ValueFree(pVal);
@@ -2314,8 +2314,8 @@ static void test_function_utf16be(
Tcl_NewStringObj((char*)sqlite3_value_text(argv[0]), -1)); Tcl_NewStringObj((char*)sqlite3_value_text(argv[0]), -1));
Tcl_EvalObjEx(interp, pX, 0); Tcl_EvalObjEx(interp, pX, 0);
Tcl_DecrRefCount(pX); Tcl_DecrRefCount(pX);
pVal = sqlite3ValueNew(); pVal = sqlite3ValueNew(0);
sqlite3ValueSetStr(pVal, -1, Tcl_GetStringResult(interp), sqlite3ValueSetStr(0, pVal, -1, Tcl_GetStringResult(interp),
SQLITE_UTF8, SQLITE_STATIC); SQLITE_UTF8, SQLITE_STATIC);
sqlite3_result_text16le(pCtx, sqlite3_value_text16le(pVal), sqlite3_result_text16le(pCtx, sqlite3_value_text16le(pVal),
-1, SQLITE_TRANSIENT); -1, SQLITE_TRANSIENT);
@@ -3595,7 +3595,7 @@ static int test_sqlite3OsOpenReadWrite(
int objc, int objc,
Tcl_Obj *CONST objv[] Tcl_Obj *CONST objv[]
){ ){
OsFile *pFile; sqlite3_file *pFile;
int rc; int rc;
int dummy; int dummy;
char zBuf[100]; char zBuf[100];
@@ -3625,7 +3625,7 @@ static int test_sqlite3OsClose(
int objc, int objc,
Tcl_Obj *CONST objv[] Tcl_Obj *CONST objv[]
){ ){
OsFile *pFile; sqlite3_file *pFile;
int rc; int rc;
if( objc!=2 ){ if( objc!=2 ){
@@ -3654,7 +3654,7 @@ static int test_sqlite3OsLock(
int objc, int objc,
Tcl_Obj *CONST objv[] Tcl_Obj *CONST objv[]
){ ){
OsFile * pFile; sqlite3_file * pFile;
int rc; int rc;
if( objc!=3 ){ if( objc!=3 ){
@@ -3702,7 +3702,7 @@ static int test_sqlite3OsUnlock(
int objc, int objc,
Tcl_Obj *CONST objv[] Tcl_Obj *CONST objv[]
){ ){
OsFile * pFile; sqlite3_file * pFile;
int rc; int rc;
if( objc!=2 ){ 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 ** is not included in the SQLite library. It is used for automated
** testing of the SQLite library. ** 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 "sqliteInt.h"
#include "os.h" #include "os.h"
@@ -531,7 +531,7 @@ static int fake_big_file(
int rc; int rc;
int n; int n;
i64 offset; i64 offset;
OsFile *fd = 0; sqlite3_file *fd = 0;
int readOnly = 0; int readOnly = 0;
if( argc!=3 ){ if( argc!=3 ){
Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0], 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 ** is not included in the SQLite library. It is used for automated
** testing of the SQLite library. ** 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 "sqliteInt.h"
#include "pager.h" #include "pager.h"
@@ -589,7 +589,7 @@ static int btree_integrity_check(
sqlite3_free((void*)aRoot); sqlite3_free((void*)aRoot);
if( zResult ){ if( zResult ){
Tcl_AppendResult(interp, zResult, 0); Tcl_AppendResult(interp, zResult, 0);
sqliteFree(zResult); sqlite3_free(zResult);
} }
return TCL_OK; return TCL_OK;
} }

14
src/test5.c
View File

@@ -15,7 +15,7 @@
** is used for testing the SQLite routines for converting between ** is used for testing the SQLite routines for converting between
** the various supported unicode encodings. ** 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 "sqliteInt.h"
#include "vdbeInt.h" #include "vdbeInt.h"
@@ -142,7 +142,7 @@ static int test_translate(
return TCL_ERROR; return TCL_ERROR;
} }
if( objc==5 ){ if( objc==5 ){
xDel = sqlite3FreeX; xDel = sqlite3_free;
} }
enc_from = name_to_enc(interp, objv[2]); enc_from = name_to_enc(interp, objv[2]);
@@ -150,14 +150,14 @@ static int test_translate(
enc_to = name_to_enc(interp, objv[3]); enc_to = name_to_enc(interp, objv[3]);
if( !enc_to ) return TCL_ERROR; if( !enc_to ) return TCL_ERROR;
pVal = sqlite3ValueNew(); pVal = sqlite3ValueNew(0);
if( enc_from==SQLITE_UTF8 ){ if( enc_from==SQLITE_UTF8 ){
z = Tcl_GetString(objv[1]); z = Tcl_GetString(objv[1]);
if( objc==5 ){ if( objc==5 ){
z = sqlite3StrDup(z); z = sqlite3StrDup(z);
} }
sqlite3ValueSetStr(pVal, -1, z, enc_from, xDel); sqlite3ValueSetStr(0, pVal, -1, z, enc_from, xDel);
}else{ }else{
z = (char*)Tcl_GetByteArrayFromObj(objv[1], &len); z = (char*)Tcl_GetByteArrayFromObj(objv[1], &len);
if( objc==5 ){ if( objc==5 ){
@@ -165,11 +165,11 @@ static int test_translate(
z = sqlite3_malloc(len); z = sqlite3_malloc(len);
memcpy(z, zTmp, 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); z = (char *)sqlite3ValueText(0, pVal, enc_to);
len = sqlite3ValueBytes(pVal, enc_to) + (enc_to==SQLITE_UTF8?1:2); len = sqlite3ValueBytes(0, pVal, enc_to) + (enc_to==SQLITE_UTF8?1:2);
Tcl_SetObjResult(interp, Tcl_NewByteArrayObj((u8*)z, len)); Tcl_SetObjResult(interp, Tcl_NewByteArrayObj((u8*)z, len));
sqlite3ValueFree(pVal); sqlite3ValueFree(pVal);

42
src/test6.c
View File

@@ -125,7 +125,7 @@ struct WriteBuffer {
struct CrashFile { struct CrashFile {
const sqlite3_io_methods *pMethod; /* Must be first */ const sqlite3_io_methods *pMethod; /* Must be first */
sqlite3_file *pRealFile; /* Underlying "real" file handle */ sqlite3_file *pRealFile; /* Underlying "real" file handle */
const char *zName; char *zName;
}; };
struct CrashGlobal { struct CrashGlobal {
@@ -224,7 +224,7 @@ static int writeListSync(CrashFile *pFile, int isCrash){
for(i=iFirst; rc==SQLITE_OK && i<=iLast; i++){ for(i=iFirst; rc==SQLITE_OK && i<=iLast; i++){
sqlite3Randomness(g.iSectorSize, zGarbage); sqlite3Randomness(g.iSectorSize, zGarbage);
rc = sqlite3OsWrite( rc = sqlite3OsWrite(
pFile->pRealFile, i*g.iSectorSize, zGarbage, g.iSectorSize pFile->pRealFile, zGarbage, g.iSectorSize, i*g.iSectorSize
); );
} }
sqlite3_free(zGarbage); sqlite3_free(zGarbage);
@@ -286,7 +286,7 @@ static int writeListAppend(
/* /*
** Close a crash-file. ** Close a crash-file.
*/ */
int cfClose(sqlite3_file *pFile){ static int cfClose(sqlite3_file *pFile){
CrashFile *pCrash = (CrashFile *)pFile; CrashFile *pCrash = (CrashFile *)pFile;
writeListSync(pCrash, 0); writeListSync(pCrash, 0);
sqlite3OsClose(&pCrash->pRealFile); sqlite3OsClose(&pCrash->pRealFile);
@@ -296,7 +296,12 @@ int cfClose(sqlite3_file *pFile){
/* /*
** Read data from a crash-file. ** 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; CrashFile *pCrash = (CrashFile *)pFile;
sqlite3_int64 iSize; sqlite3_int64 iSize;
int rc; int rc;
@@ -361,21 +366,26 @@ int cfRead(sqlite3_file *pFile, void *zBuf, int iAmt, sqlite_int64 iOfst){
/* /*
** Write data to a crash-file. ** 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); return writeListAppend(pFile, iOfst, zBuf, iAmt);
} }
/* /*
** Truncate a crash-file. ** 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); return writeListAppend(pFile, size, 0, 0);
} }
/* /*
** Sync a crash-file. ** Sync a crash-file.
*/ */
int cfSync(sqlite3_file *pFile, int flags){ static int cfSync(sqlite3_file *pFile, int flags){
CrashFile *pCrash = (CrashFile *)pFile; CrashFile *pCrash = (CrashFile *)pFile;
int isCrash = 0; int isCrash = 0;
@@ -391,7 +401,7 @@ int cfSync(sqlite3_file *pFile, int flags){
/* /*
** Return the current file-size of the crash-file. ** 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; CrashFile *pCrash = (CrashFile *)pFile;
WriteBuffer *pWrite; WriteBuffer *pWrite;
int rc; 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. ** 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); 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); return sqlite3OsUnlock(((CrashFile *)pFile)->pRealFile, eLock);
} }
int cfCheckReservedLock(sqlite3_file *pFile){ static int cfCheckReservedLock(sqlite3_file *pFile){
return sqlite3OsCheckReservedLock(((CrashFile *)pFile)->pRealFile); return sqlite3OsCheckReservedLock(((CrashFile *)pFile)->pRealFile);
} }
int cfBreakLock(sqlite3_file *pFile){ static int cfBreakLock(sqlite3_file *pFile){
return sqlite3OsBreakLock(((CrashFile *)pFile)->pRealFile); return sqlite3OsBreakLock(((CrashFile *)pFile)->pRealFile);
} }
@@ -434,10 +444,10 @@ int cfBreakLock(sqlite3_file *pFile){
** the global values configured by the [sqlite_crashparams] tcl ** the global values configured by the [sqlite_crashparams] tcl
* interface. * interface.
*/ */
int cfSectorSize(sqlite3_file *pFile){ static int cfSectorSize(sqlite3_file *pFile){
return g.iSectorSize; return g.iSectorSize;
} }
int cfDeviceCharacteristics(sqlite3_file *pFile){ static int cfDeviceCharacteristics(sqlite3_file *pFile){
return g.iDeviceCharacteristics; return g.iDeviceCharacteristics;
} }
@@ -474,7 +484,7 @@ int sqlite3CrashFileOpen(
pReal = (sqlite3_file *)sqlite3_malloc(pVfs->szOsFile); pReal = (sqlite3_file *)sqlite3_malloc(pVfs->szOsFile);
if( pReal ){ if( pReal ){
pWrapper->pMethod = &CrashFileVtab; pWrapper->pMethod = &CrashFileVtab;
pWrapper->zName = zName; pWrapper->zName = (char *)zName;
rc = pVfs->xOpen(pVfs->pAppData, zName, pReal, flags, pOutFlags); rc = pVfs->xOpen(pVfs->pAppData, zName, pReal, flags, pOutFlags);
if( rc==SQLITE_OK ){ if( rc==SQLITE_OK ){
pWrapper->pRealFile = pFile; pWrapper->pRealFile = pFile;
@@ -498,7 +508,7 @@ int sqlite3CrashFileWrap(
pWrapper->pMethod = &CrashFileVtab; pWrapper->pMethod = &CrashFileVtab;
pWrapper->pRealFile = pFile; pWrapper->pRealFile = pFile;
pWrapper->zName = &pWrapper[1]; pWrapper->zName = (char *)&pWrapper[1];
memcpy(pWrapper->zName, zName, strlen(zName)+1); memcpy(pWrapper->zName, zName, strlen(zName)+1);
*ppWrapper = (sqlite3_file *)pWrapper; *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 ** is not included in the SQLite library. It is used for automated
** testing of the SQLite library. ** 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 "sqliteInt.h"
#include "tcl.h" #include "tcl.h"
@@ -220,7 +220,7 @@ static int getIndexArray(
} }
/* Compile an sqlite pragma to loop through all indices on table zTab */ /* 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 ){ if( !zSql ){
rc = SQLITE_NOMEM; rc = SQLITE_NOMEM;
goto get_index_array_out; goto get_index_array_out;
@@ -234,7 +234,7 @@ static int getIndexArray(
while( pStmt && sqlite3_step(pStmt)==SQLITE_ROW ){ while( pStmt && sqlite3_step(pStmt)==SQLITE_ROW ){
const char *zIdx = (const char *)sqlite3_column_text(pStmt, 1); const char *zIdx = (const char *)sqlite3_column_text(pStmt, 1);
sqlite3_stmt *pStmt2 = 0; sqlite3_stmt *pStmt2 = 0;
zSql = sqlite3MPrintf("PRAGMA index_info(%s)", zIdx); zSql = sqlite3MPrintf(0, "PRAGMA index_info(%s)", zIdx);
if( !zSql ){ if( !zSql ){
rc = SQLITE_NOMEM; rc = SQLITE_NOMEM;
goto get_index_array_out; goto get_index_array_out;
@@ -372,7 +372,7 @@ static int echoConstructor(
pVtab->db = db; pVtab->db = db;
/* Allocate echo_vtab.zThis */ /* Allocate echo_vtab.zThis */
pVtab->zThis = sqlite3MPrintf("%s", argv[2]); pVtab->zThis = sqlite3MPrintf(0, "%s", argv[2]);
if( !pVtab->zThis ){ if( !pVtab->zThis ){
echoDestructor((sqlite3_vtab *)pVtab); echoDestructor((sqlite3_vtab *)pVtab);
return SQLITE_NOMEM; return SQLITE_NOMEM;
@@ -380,10 +380,10 @@ static int echoConstructor(
/* Allocate echo_vtab.zTableName */ /* Allocate echo_vtab.zTableName */
if( argc>3 ){ if( argc>3 ){
pVtab->zTableName = sqlite3MPrintf("%s", argv[3]); pVtab->zTableName = sqlite3MPrintf(0, "%s", argv[3]);
dequoteString(pVtab->zTableName); dequoteString(pVtab->zTableName);
if( pVtab->zTableName && pVtab->zTableName[0]=='*' ){ 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); sqlite3_free(pVtab->zTableName);
pVtab->zTableName = z; pVtab->zTableName = z;
pVtab->isPattern = 1; pVtab->isPattern = 1;
@@ -440,8 +440,8 @@ static int echoCreate(
if( rc==SQLITE_OK && argc==5 ){ if( rc==SQLITE_OK && argc==5 ){
char *zSql; char *zSql;
echo_vtab *pVtab = *(echo_vtab **)ppVtab; echo_vtab *pVtab = *(echo_vtab **)ppVtab;
pVtab->zLogName = sqlite3MPrintf("%s", argv[4]); pVtab->zLogName = sqlite3MPrintf(0, "%s", argv[4]);
zSql = sqlite3MPrintf("CREATE TABLE %Q(logmsg)", pVtab->zLogName); zSql = sqlite3MPrintf(0, "CREATE TABLE %Q(logmsg)", pVtab->zLogName);
rc = sqlite3_exec(db, zSql, 0, 0, 0); rc = sqlite3_exec(db, zSql, 0, 0, 0);
sqlite3_free(zSql); sqlite3_free(zSql);
} }
@@ -482,7 +482,7 @@ static int echoDestroy(sqlite3_vtab *pVtab){
/* Drop the "log" table, if one exists (see echoCreate() for details) */ /* Drop the "log" table, if one exists (see echoCreate() for details) */
if( p && p->zLogName ){ if( p && p->zLogName ){
char *zSql; 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); rc = sqlite3_exec(p->db, zSql, 0, 0, 0);
sqlite3_free(zSql); sqlite3_free(zSql);
} }
@@ -1037,7 +1037,7 @@ static int echoRename(sqlite3_vtab *vtab, const char *zNewName){
if( p->isPattern ){ if( p->isPattern ){
int nThis = strlen(p->zThis); 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] p->zTableName, zNewName, &p->zTableName[nThis]
); );
rc = sqlite3_exec(p->db, zSql, 0, 0, 0); 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 ** individual tokens and sends those tokens one-by-one over to the
** parser for analysis. ** 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 "sqliteInt.h"
#include "os.h" #include "os.h"
@@ -435,7 +435,7 @@ int sqlite3RunParser(Parse *pParse, const char *zSql, char **pzErrMsg){
case TK_ILLEGAL: { case TK_ILLEGAL: {
if( pzErrMsg ){ if( pzErrMsg ){
sqlite3_free(*pzErrMsg); sqlite3_free(*pzErrMsg);
*pzErrMsg = sqlite3MPrintf("unrecognized token: \"%T\"", *pzErrMsg = sqlite3MPrintf(db, "unrecognized token: \"%T\"",
&pParse->sLastToken); &pParse->sLastToken);
} }
nErr++; nErr++;

5
src/trigger.c
View File

@@ -253,8 +253,9 @@ void sqlite3FinishTrigger(
sqlite3VdbeChangeP3(v, addr+6, (char*)pAll->z, pAll->n); sqlite3VdbeChangeP3(v, addr+6, (char*)pAll->z, pAll->n);
sqlite3ChangeCookie(db, v, iDb); sqlite3ChangeCookie(db, v, iDb);
sqlite3VdbeAddOp(v, OP_Close, 0, 0); sqlite3VdbeAddOp(v, OP_Close, 0, 0);
sqlite3VdbeOp3(v, OP_ParseSchema, iDb, 0, sqlite3VdbeOp3(v, OP_ParseSchema, iDb, 0, sqlite3MPrintf(
sqlite3MPrintf("type='trigger' AND name='%q'", pTrig->name), P3_DYNAMIC); db, "type='trigger' AND name='%q'", pTrig->name), P3_DYNAMIC
);
} }
if( db->init.busy ){ 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 ** This file contains C code routines that are called by the parser
** to handle UPDATE statements. ** 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" #include "sqliteInt.h"
@@ -60,7 +60,7 @@ void sqlite3ColumnDefault(Vdbe *v, Table *pTab, int i){
u8 enc = ENC(sqlite3VdbeDb(v)); u8 enc = ENC(sqlite3VdbeDb(v));
Column *pCol = &pTab->aCol[i]; Column *pCol = &pTab->aCol[i];
assert( i<pTab->nCol ); assert( i<pTab->nCol );
sqlite3ValueFromExpr(pCol->pDflt, enc, pCol->affinity, &pValue); sqlite3ValueFromExpr(sqlite3VdbeDb(v), pCol->pDflt, enc, pCol->affinity, &pValue);
if( pValue ){ if( pValue ){
sqlite3VdbeChangeP3(v, -1, (const char *)pValue, P3_MEM); sqlite3VdbeChangeP3(v, -1, (const char *)pValue, P3_MEM);
}else{ }else{

11
src/utf.c
View File

@@ -12,7 +12,7 @@
** This file contains routines used to translate between UTF-8, ** This file contains routines used to translate between UTF-8,
** UTF-16, UTF-16BE, and UTF-16LE. ** 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: ** Notes on UTF-8:
** **
@@ -216,7 +216,7 @@ int sqlite3VdbeMemTranslate(sqlite3 *db, Mem *pMem, u8 desiredEnc){
if( pMem->enc!=SQLITE_UTF8 && desiredEnc!=SQLITE_UTF8 ){ if( pMem->enc!=SQLITE_UTF8 && desiredEnc!=SQLITE_UTF8 ){
u8 temp; u8 temp;
int rc; int rc;
rc = sqlite3VdbeMemMakeWriteable(pMem); rc = sqlite3VdbeMemMakeWriteable(db, pMem);
if( rc!=SQLITE_OK ){ if( rc!=SQLITE_OK ){
assert( rc==SQLITE_NOMEM ); assert( rc==SQLITE_NOMEM );
return SQLITE_NOMEM; return SQLITE_NOMEM;
@@ -336,7 +336,7 @@ translate_out:
** The allocation (static, dynamic etc.) and encoding of the Mem may be ** The allocation (static, dynamic etc.) and encoding of the Mem may be
** changed by this function. ** changed by this function.
*/ */
int sqlite3VdbeMemHandleBom(Mem *pMem){ int sqlite3VdbeMemHandleBom(sqlite3 *db, Mem *pMem){
int rc = SQLITE_OK; int rc = SQLITE_OK;
u8 bom = 0; u8 bom = 0;
@@ -364,10 +364,11 @@ int sqlite3VdbeMemHandleBom(Mem *pMem){
char *z = pMem->z; char *z = pMem->z;
pMem->z = 0; pMem->z = 0;
pMem->xDel = 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); xDel(z);
}else{ }else{
rc = sqlite3VdbeMemSetStr(pMem, &pMem->z[2], pMem->n-2, bom, rc = sqlite3VdbeMemSetStr(db, pMem, &pMem->z[2], pMem->n-2, bom,
SQLITE_TRANSIENT); SQLITE_TRANSIENT);
} }
} }

16
src/util.c
View File

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

30
src/vdbeInt.h
View File

@@ -376,56 +376,56 @@ int sqlite3VdbeSerialGet(const unsigned char*, u32, Mem*);
void sqlite3VdbeDeleteAuxData(VdbeFunc*, int); void sqlite3VdbeDeleteAuxData(VdbeFunc*, int);
int sqlite2BtreeKeyCompare(BtCursor *, const void *, int, int, int *); int sqlite2BtreeKeyCompare(BtCursor *, const void *, int, int, int *);
int sqlite3VdbeIdxKeyCompare(Cursor*, int , const unsigned char*, int*); int sqlite3VdbeIdxKeyCompare(sqlite3*,Cursor*,int,const unsigned char*,int*);
int sqlite3VdbeIdxRowid(BtCursor *, i64 *); int sqlite3VdbeIdxRowid(sqlite3 *, BtCursor *, i64 *);
int sqlite3MemCompare(const Mem*, const Mem*, const CollSeq*); int sqlite3MemCompare(const Mem*, const Mem*, const CollSeq*);
int sqlite3VdbeRecordCompare(void*,int,const void*,int, const void*); int sqlite3VdbeRecordCompare(void*,int,const void*,int, const void*);
int sqlite3VdbeIdxRowidLen(const u8*); int sqlite3VdbeIdxRowidLen(const u8*);
int sqlite3VdbeExec(Vdbe*); int sqlite3VdbeExec(Vdbe*);
int sqlite3VdbeList(Vdbe*); int sqlite3VdbeList(Vdbe*);
int sqlite3VdbeHalt(Vdbe*); int sqlite3VdbeHalt(Vdbe*);
int sqlite3VdbeChangeEncoding(Mem *, int); int sqlite3VdbeChangeEncoding(sqlite3 *, Mem *, int);
int sqlite3VdbeMemTooBig(Mem*); int sqlite3VdbeMemTooBig(Mem*);
int sqlite3VdbeMemCopy(Mem*, const Mem*); int sqlite3VdbeMemCopy(sqlite3*, Mem*, const Mem*);
void sqlite3VdbeMemShallowCopy(Mem*, const Mem*, int); void sqlite3VdbeMemShallowCopy(Mem*, const Mem*, int);
int sqlite3VdbeMemMove(Mem*, Mem*); int sqlite3VdbeMemMove(sqlite3*, Mem*, Mem*);
int sqlite3VdbeMemNulTerminate(Mem*); int sqlite3VdbeMemNulTerminate(sqlite3 *, Mem*);
int sqlite3VdbeMemSetStr(Mem*, const char*, int, u8, void(*)(void*)); int sqlite3VdbeMemSetStr(sqlite3 *, Mem*, const char*, int, u8, void(*)(void*));
void sqlite3VdbeMemSetInt64(Mem*, i64); void sqlite3VdbeMemSetInt64(Mem*, i64);
void sqlite3VdbeMemSetDouble(Mem*, double); void sqlite3VdbeMemSetDouble(Mem*, double);
void sqlite3VdbeMemSetNull(Mem*); void sqlite3VdbeMemSetNull(Mem*);
void sqlite3VdbeMemSetZeroBlob(Mem*,int); void sqlite3VdbeMemSetZeroBlob(Mem*,int);
int sqlite3VdbeMemMakeWriteable(Mem*); int sqlite3VdbeMemMakeWriteable(sqlite3 *, Mem*);
int sqlite3VdbeMemDynamicify(Mem*); int sqlite3VdbeMemDynamicify(sqlite3 *, Mem*);
int sqlite3VdbeMemStringify(Mem*, int); int sqlite3VdbeMemStringify(sqlite3*, Mem*, int);
i64 sqlite3VdbeIntValue(Mem*); i64 sqlite3VdbeIntValue(Mem*);
int sqlite3VdbeMemIntegerify(Mem*); int sqlite3VdbeMemIntegerify(Mem*);
double sqlite3VdbeRealValue(Mem*); double sqlite3VdbeRealValue(Mem*);
void sqlite3VdbeIntegerAffinity(Mem*); void sqlite3VdbeIntegerAffinity(Mem*);
int sqlite3VdbeMemRealify(Mem*); int sqlite3VdbeMemRealify(Mem*);
int sqlite3VdbeMemNumerify(Mem*); int sqlite3VdbeMemNumerify(Mem*);
int sqlite3VdbeMemFromBtree(BtCursor*,int,int,int,Mem*); int sqlite3VdbeMemFromBtree(sqlite3*,BtCursor*,int,int,int,Mem*);
void sqlite3VdbeMemRelease(Mem *p); void sqlite3VdbeMemRelease(Mem *p);
int sqlite3VdbeMemFinalize(Mem*, FuncDef*); int sqlite3VdbeMemFinalize(Mem*, FuncDef*);
#ifndef NDEBUG #ifndef NDEBUG
void sqlite3VdbeMemSanity(Mem*); void sqlite3VdbeMemSanity(Mem*);
int sqlite3VdbeOpcodeNoPush(u8); int sqlite3VdbeOpcodeNoPush(u8);
#endif #endif
int sqlite3VdbeMemTranslate(Mem*, u8); int sqlite3VdbeMemTranslate(sqlite3 *, Mem*, u8);
#ifdef SQLITE_DEBUG #ifdef SQLITE_DEBUG
void sqlite3VdbePrintSql(Vdbe*); void sqlite3VdbePrintSql(Vdbe*);
void sqlite3VdbeMemPrettyPrint(Mem *pMem, char *zBuf); void sqlite3VdbeMemPrettyPrint(Mem *pMem, char *zBuf);
#endif #endif
int sqlite3VdbeMemHandleBom(Mem *pMem); int sqlite3VdbeMemHandleBom(sqlite3 *, Mem *pMem);
void sqlite3VdbeFifoInit(Fifo*); void sqlite3VdbeFifoInit(Fifo*);
int sqlite3VdbeFifoPush(Fifo*, i64); int sqlite3VdbeFifoPush(Fifo*, i64);
int sqlite3VdbeFifoPop(Fifo*, i64*); int sqlite3VdbeFifoPop(Fifo*, i64*);
void sqlite3VdbeFifoClear(Fifo*); void sqlite3VdbeFifoClear(Fifo*);
#ifndef SQLITE_OMIT_INCRBLOB #ifndef SQLITE_OMIT_INCRBLOB
int sqlite3VdbeMemExpandBlob(Mem *); int sqlite3VdbeMemExpandBlob(sqlite3 *, Mem *);
#else #else
#define sqlite3VdbeMemExpandBlob(x) SQLITE_OK #define sqlite3VdbeMemExpandBlob(d,x) SQLITE_OK
#endif #endif
#endif /* !defined(_VDBEINT_H_) */ #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){ const void *sqlite3_value_blob(sqlite3_value *pVal){
Mem *p = (Mem*)pVal; Mem *p = (Mem*)pVal;
if( p->flags & (MEM_Blob|MEM_Str) ){ if( p->flags & (MEM_Blob|MEM_Str) ){
sqlite3VdbeMemExpandBlob(p); sqlite3VdbeMemExpandBlob(0, p);
p->flags &= ~MEM_Str; p->flags &= ~MEM_Str;
p->flags |= MEM_Blob; p->flags |= MEM_Blob;
return p->z; return p->z;
@@ -46,10 +46,10 @@ const void *sqlite3_value_blob(sqlite3_value *pVal){
} }
} }
int sqlite3_value_bytes(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){ 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){ double sqlite3_value_double(sqlite3_value *pVal){
return sqlite3VdbeRealValue((Mem*)pVal); return sqlite3VdbeRealValue((Mem*)pVal);
@@ -61,17 +61,17 @@ sqlite_int64 sqlite3_value_int64(sqlite3_value *pVal){
return sqlite3VdbeIntValue((Mem*)pVal); return sqlite3VdbeIntValue((Mem*)pVal);
} }
const unsigned char *sqlite3_value_text(sqlite3_value *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 #ifndef SQLITE_OMIT_UTF16
const void *sqlite3_value_text16(sqlite3_value* pVal){ 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){ 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){ const void *sqlite3_value_text16le(sqlite3_value *pVal){
return sqlite3ValueText(pVal, SQLITE_UTF16LE); return sqlite3ValueText(0, pVal, SQLITE_UTF16LE);
} }
#endif /* SQLITE_OMIT_UTF16 */ #endif /* SQLITE_OMIT_UTF16 */
int sqlite3_value_type(sqlite3_value* pVal){ int sqlite3_value_type(sqlite3_value* pVal){
@@ -90,19 +90,19 @@ void sqlite3_result_blob(
void (*xDel)(void *) void (*xDel)(void *)
){ ){
assert( n>=0 ); 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){ void sqlite3_result_double(sqlite3_context *pCtx, double rVal){
sqlite3VdbeMemSetDouble(&pCtx->s, rVal); sqlite3VdbeMemSetDouble(&pCtx->s, rVal);
} }
void sqlite3_result_error(sqlite3_context *pCtx, const char *z, int n){ void sqlite3_result_error(sqlite3_context *pCtx, const char *z, int n){
pCtx->isError = 1; 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 #ifndef SQLITE_OMIT_UTF16
void sqlite3_result_error16(sqlite3_context *pCtx, const void *z, int n){ void sqlite3_result_error16(sqlite3_context *pCtx, const void *z, int n){
pCtx->isError = 1; pCtx->isError = 1;
sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF16NATIVE, SQLITE_TRANSIENT); sqlite3VdbeMemSetStr(0, &pCtx->s, z, n, SQLITE_UTF16NATIVE, SQLITE_TRANSIENT);
} }
#endif #endif
void sqlite3_result_int(sqlite3_context *pCtx, int iVal){ void sqlite3_result_int(sqlite3_context *pCtx, int iVal){
@@ -120,7 +120,7 @@ void sqlite3_result_text(
int n, int n,
void (*xDel)(void *) void (*xDel)(void *)
){ ){
sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF8, xDel); sqlite3VdbeMemSetStr(0, &pCtx->s, z, n, SQLITE_UTF8, xDel);
} }
#ifndef SQLITE_OMIT_UTF16 #ifndef SQLITE_OMIT_UTF16
void sqlite3_result_text16( void sqlite3_result_text16(
@@ -129,7 +129,7 @@ void sqlite3_result_text16(
int n, int n,
void (*xDel)(void *) void (*xDel)(void *)
){ ){
sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF16NATIVE, xDel); sqlite3VdbeMemSetStr(0, &pCtx->s, z, n, SQLITE_UTF16NATIVE, xDel);
} }
void sqlite3_result_text16be( void sqlite3_result_text16be(
sqlite3_context *pCtx, sqlite3_context *pCtx,
@@ -137,7 +137,7 @@ void sqlite3_result_text16be(
int n, int n,
void (*xDel)(void *) void (*xDel)(void *)
){ ){
sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF16BE, xDel); sqlite3VdbeMemSetStr(0, &pCtx->s, z, n, SQLITE_UTF16BE, xDel);
} }
void sqlite3_result_text16le( void sqlite3_result_text16le(
sqlite3_context *pCtx, sqlite3_context *pCtx,
@@ -145,11 +145,11 @@ void sqlite3_result_text16le(
int n, int n,
void (*xDel)(void *) void (*xDel)(void *)
){ ){
sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF16LE, xDel); sqlite3VdbeMemSetStr(0, &pCtx->s, z, n, SQLITE_UTF16LE, xDel);
} }
#endif /* SQLITE_OMIT_UTF16 */ #endif /* SQLITE_OMIT_UTF16 */
void sqlite3_result_value(sqlite3_context *pCtx, sqlite3_value *pValue){ 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){ void sqlite3_result_zeroblob(sqlite3_context *pCtx, int n){
sqlite3VdbeMemSetZeroBlob(&pCtx->s, n); sqlite3VdbeMemSetZeroBlob(&pCtx->s, n);
@@ -332,10 +332,10 @@ void sqlite3InvalidFunction(
){ ){
const char *zName = context->pFunc->zName; const char *zName = context->pFunc->zName;
char *zErr; char *zErr;
zErr = sqlite3MPrintf( zErr = sqlite3MPrintf(0,
"unable to use function %s in the requested context", zName); "unable to use function %s in the requested context", zName);
sqlite3_result_error(context, zErr, -1); 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; pMem->z = 0;
}else{ }else{
pMem->flags = MEM_Agg; pMem->flags = MEM_Agg;
pMem->xDel = sqlite3FreeX; pMem->xDel = sqlite3_free;
pMem->u.pDef = p->pFunc; pMem->u.pDef = p->pFunc;
if( nByte<=NBFS ){ if( nByte<=NBFS ){
pMem->z = pMem->zShort; pMem->z = pMem->zShort;
@@ -736,13 +736,13 @@ static int bindText(
return rc; return rc;
} }
pVar = &p->aVar[i-1]; 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 ){ 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); sqlite3Error(p->db, rc, 0);
return sqlite3ApiExit(((Vdbe *)pStmt)->db, rc); 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; Vdbe *p = (Vdbe *)pStmt;
rc = vdbeUnbind(p, i); rc = vdbeUnbind(p, i);
if( rc==SQLITE_OK ){ if( rc==SQLITE_OK ){
sqlite3VdbeMemCopy(&p->aVar[i-1], pValue); rc = sqlite3VdbeMemCopy(0, &p->aVar[i-1], pValue);
} }
return rc; 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++){ for(i=0; rc==SQLITE_OK && i<pFrom->nVar; i++){
sqlite3MallocDisallow(); sqlite3MallocDisallow();
rc = sqlite3VdbeMemMove(&pTo->aVar[i], &pFrom->aVar[i]); rc = sqlite3VdbeMemMove(0, &pTo->aVar[i], &pFrom->aVar[i]);
sqlite3MallocAllow(); sqlite3MallocAllow();
} }
assert( rc==SQLITE_OK || rc==SQLITE_NOMEM ); 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; VdbeOp *pNew;
int nNew = N + 100*(!runMode); int nNew = N + 100*(!runMode);
int oldSize = p->nOpAlloc; int oldSize = p->nOpAlloc;
pNew = sqlite_realloc(p->aOp, nNew*sizeof(Op)); pNew = sqlite3_realloc(p->aOp, nNew*sizeof(Op));
if( pNew ){ if( pNew ){
p->nOpAlloc = nNew; p->nOpAlloc = nNew;
p->aOp = pNew; p->aOp = pNew;
@@ -206,7 +206,7 @@ int sqlite3VdbeMakeLabel(Vdbe *p){
assert( p->magic==VDBE_MAGIC_INIT ); assert( p->magic==VDBE_MAGIC_INIT );
if( i>=p->nLabelAlloc ){ if( i>=p->nLabelAlloc ){
p->nLabelAlloc = p->nLabelAlloc*2 + 10; 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])); p->nLabelAlloc*sizeof(p->aLabel[0]));
} }
if( p->aLabel ){ if( p->aLabel ){
@@ -579,7 +579,7 @@ void sqlite3VdbeComment(Vdbe *p, const char *zFormat, ...){
assert( p->nOp>0 || p->aOp==0 ); assert( p->nOp>0 || p->aOp==0 );
assert( p->aOp==0 || p->aOp[p->nOp-1].p3==0 || p->db->mallocFailed ); assert( p->aOp==0 || p->aOp[p->nOp-1].p3==0 || p->db->mallocFailed );
va_start(ap, zFormat); 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); va_end(ap);
} }
#endif #endif
@@ -840,6 +840,7 @@ void sqlite3VdbeMakeReady(
int isExplain /* True if the EXPLAIN keywords is present */ int isExplain /* True if the EXPLAIN keywords is present */
){ ){
int n; int n;
sqlite3 *db = p->db;
assert( p!=0 ); assert( p!=0 );
assert( p->magic==VDBE_MAGIC_INIT ); assert( p->magic==VDBE_MAGIC_INIT );
@@ -874,7 +875,7 @@ void sqlite3VdbeMakeReady(
if( isExplain ){ if( isExplain ){
nStack = 10; nStack = 10;
} }
p->aStack = sqlite3DbMallocZer(db, p->aStack = sqlite3DbMallocZero(db,
nStack*sizeof(p->aStack[0]) /* aStack */ nStack*sizeof(p->aStack[0]) /* aStack */
+ nArg*sizeof(Mem*) /* apArg */ + nArg*sizeof(Mem*) /* apArg */
+ nVar*sizeof(Mem) /* aVar */ + nVar*sizeof(Mem) /* aVar */
@@ -1012,7 +1013,7 @@ void sqlite3VdbeSetNumCols(Vdbe *p, int nResColumn){
sqlite3_free(p->aColName); sqlite3_free(p->aColName);
n = nResColumn*COLNAME_N; n = nResColumn*COLNAME_N;
p->nResColumn = nResColumn; 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; if( p->aColName==0 ) return;
while( n-- > 0 ){ while( n-- > 0 ){
(pColName++)->flags = MEM_Null; (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 ); assert( p->aColName!=0 );
pColName = &(p->aColName[idx+var*p->nResColumn]); pColName = &(p->aColName[idx+var*p->nResColumn]);
if( N==P3_DYNAMIC || N==P3_STATIC ){ 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{ }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 ){ if( rc==SQLITE_OK && N==P3_DYNAMIC ){
pColName->flags = (pColName->flags&(~MEM_Static))|MEM_Dyn; pColName->flags = (pColName->flags&(~MEM_Static))|MEM_Dyn;
@@ -1147,7 +1150,7 @@ static int vdbeCommit(sqlite3 *db){
u32 random; u32 random;
sqlite3_free(zMaster); sqlite3_free(zMaster);
sqlite3Randomness(sizeof(random), &random); sqlite3Randomness(sizeof(random), &random);
zMaster = sqlite3MPrintf("%s-mj%08X", zMainFile, random&0x7fffffff); zMaster = sqlite3MPrintf(db, "%s-mj%08X", zMainFile, random&0x7fffffff);
if( !zMaster ){ if( !zMaster ){
return SQLITE_NOMEM; return SQLITE_NOMEM;
} }
@@ -1166,7 +1169,7 @@ static int vdbeCommit(sqlite3 *db){
** still have 'null' as the master journal pointer, so they will roll ** still have 'null' as the master journal pointer, so they will roll
** back independently if a failure occurs. ** 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; Btree *pBt = db->aDb[i].pBt;
if( i==1 ) continue; /* Ignore the TEMP database */ if( i==1 ) continue; /* Ignore the TEMP database */
if( pBt && sqlite3BtreeIsInTrans(pBt) ){ if( pBt && sqlite3BtreeIsInTrans(pBt) ){
@@ -1567,7 +1570,7 @@ int sqlite3VdbeReset(Vdbe *p){
*/ */
if( p->pc>=0 ){ if( p->pc>=0 ){
if( p->zErrMsg ){ 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; db->errCode = p->rc;
p->zErrMsg = 0; p->zErrMsg = 0;
}else if( p->rc ){ }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. ** 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. ** 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; i64 nCellKey = 0;
int rc; int rc;
u32 szHdr; /* Size of the header */ u32 szHdr; /* Size of the header */
@@ -2135,7 +2138,7 @@ int sqlite3VdbeIdxRowid(BtCursor *pCur, i64 *rowid){
if( nCellKey<=0 ){ if( nCellKey<=0 ){
return SQLITE_CORRUPT_BKPT; return SQLITE_CORRUPT_BKPT;
} }
rc = sqlite3VdbeMemFromBtree(pCur, 0, nCellKey, 1, &m); rc = sqlite3VdbeMemFromBtree(db, pCur, 0, nCellKey, 1, &m);
if( rc ){ if( rc ){
return rc; return rc;
} }
@@ -2159,6 +2162,7 @@ int sqlite3VdbeIdxRowid(BtCursor *pCur, i64 *rowid){
** is ignored as well. ** is ignored as well.
*/ */
int sqlite3VdbeIdxKeyCompare( int sqlite3VdbeIdxKeyCompare(
sqlite3 *db,
Cursor *pC, /* The cursor to compare against */ Cursor *pC, /* The cursor to compare against */
int nKey, const u8 *pKey, /* The key to compare */ int nKey, const u8 *pKey, /* The key to compare */
int *res /* Write the comparison result here */ int *res /* Write the comparison result here */
@@ -2174,7 +2178,7 @@ int sqlite3VdbeIdxKeyCompare(
*res = 0; *res = 0;
return SQLITE_OK; return SQLITE_OK;
} }
rc = sqlite3VdbeMemFromBtree(pC->pCursor, 0, nCellKey, 1, &m); rc = sqlite3VdbeMemFromBtree(db, pC->pCursor, 0, nCellKey, 1, &m);
if( rc ){ if( rc ){
return rc; return rc;
} }

65
src/vdbemem.c
View File

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

16
src/vtab.c
View File

@@ -11,7 +11,7 @@
************************************************************************* *************************************************************************
** This file contains code used to help implement virtual tables. ** 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 #ifndef SQLITE_OMIT_VIRTUALTABLE
#include "sqliteInt.h" #include "sqliteInt.h"
@@ -250,7 +250,7 @@ void sqlite3VtabFinishParse(Parse *pParse, Token *pEnd){
if( pEnd ){ if( pEnd ){
pParse->sNameToken.n = pEnd->z - pParse->sNameToken.z + pEnd->n; 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 /* A slot for the record has already been allocated in the
** SQLITE_MASTER table. We just need to update that slot with all ** 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); sqlite3ChangeCookie(db, v, iDb);
sqlite3VdbeAddOp(v, OP_Expire, 0, 0); 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_ParseSchema, iDb, 1, zWhere, P3_DYNAMIC);
sqlite3VdbeOp3(v, OP_VCreate, iDb, 0, pTab->zName, strlen(pTab->zName) + 1); 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; const char *const*azArg = (const char *const*)pTab->azModuleArg;
int nArg = pTab->nModuleArg; int nArg = pTab->nModuleArg;
char *zErr = 0; char *zErr = 0;
char *zModuleName = sqlite3MPrintf("%s", pTab->zName); char *zModuleName = sqlite3MPrintf(db, "%s", pTab->zName);
if( !zModuleName ){ if( !zModuleName ){
return SQLITE_NOMEM; return SQLITE_NOMEM;
@@ -365,14 +365,14 @@ static int vtabCallConstructor(
if( SQLITE_OK!=rc ){ if( SQLITE_OK!=rc ){
if( zErr==0 ){ if( zErr==0 ){
*pzErr = sqlite3MPrintf("vtable constructor failed: %s", zModuleName); *pzErr = sqlite3MPrintf(db, "vtable constructor failed: %s", zModuleName);
}else { }else {
*pzErr = sqlite3MPrintf("%s", zErr); *pzErr = sqlite3MPrintf(db, "%s", zErr);
sqlite3_free(zErr); sqlite3_free(zErr);
} }
}else if( db->pVTab ){ }else if( db->pVTab ){
const char *zFormat = "vtable constructor did not declare schema: %s"; const char *zFormat = "vtable constructor did not declare schema: %s";
*pzErr = sqlite3MPrintf(zFormat, pTab->zName); *pzErr = sqlite3MPrintf(db, zFormat, pTab->zName);
rc = SQLITE_ERROR; rc = SQLITE_ERROR;
} }
if( rc==SQLITE_OK ){ if( rc==SQLITE_OK ){
@@ -503,7 +503,7 @@ int sqlite3VtabCallCreate(sqlite3 *db, int iDb, const char *zTab, char **pzErr){
** error. Otherwise, do nothing. ** error. Otherwise, do nothing.
*/ */
if( !pMod ){ if( !pMod ){
*pzErr = sqlite3MPrintf("no such module: %s", zModule); *pzErr = sqlite3MPrintf(db, "no such module: %s", zModule);
rc = SQLITE_ERROR; rc = SQLITE_ERROR;
}else{ }else{
rc = vtabCallConstructor(db, pTab, pMod, pMod->pModule->xCreate, pzErr); 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 ** so is applicable. Because this module is responsible for selecting
** indices, you might also think of this module as the "query optimizer". ** 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" #include "sqliteInt.h"
@@ -716,7 +716,8 @@ static void exprAnalyze(
int nPattern; int nPattern;
int isComplete; int isComplete;
int op; int op;
sqlite3 *db = pWC->pParse->db; Parse *pParse = pWC->pParse;
sqlite3 *db = pParse->db;
if( db->mallocFailed ) return; if( db->mallocFailed ) return;
prereqLeft = exprTableUsage(pMaskSet, pExpr->pLeft); prereqLeft = exprTableUsage(pMaskSet, pExpr->pLeft);
@@ -2152,24 +2153,24 @@ WhereInfo *sqlite3WhereBegin(
if( pParse->explain==2 ){ if( pParse->explain==2 ){
char *zMsg; char *zMsg;
struct SrcList_item *pItem = &pTabList->a[pLevel->iFrom]; struct SrcList_item *pItem = &pTabList->a[pLevel->iFrom];
zMsg = sqlite3MPrintf("TABLE %s", pItem->zName); zMsg = sqlite3MPrintf(db, "TABLE %s", pItem->zName);
if( pItem->zAlias ){ 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 ){ 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) ){ }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 #ifndef SQLITE_OMIT_VIRTUALTABLE
else if( pLevel->pBestIdx ){ else if( pLevel->pBestIdx ){
sqlite3_index_info *pBestIdx = 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); pBestIdx->idxNum, pBestIdx->idxStr);
} }
#endif #endif
if( pLevel->flags & WHERE_ORDERBY ){ 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); sqlite3VdbeOp3(v, OP_Explain, i, pLevel->iFrom, zMsg, P3_DYNAMIC);
} }