-C When\smaterializing\sa\sview\sfor\san\sUPDATE\sor\sDELETE\smake\suse\sof\sthe\sWHERE\nclause\sto\slimit\sthe\snumber\sof\srows\smaterialized.\s\sTicket\s#2938.\s(CVS\s4782)
-D 2008-02-12T16:52:14
+C Where\spossible,\savoid\sfreeing\sbuffers\sallocated\sfor\svdbe\smemory\scells\sin\scase\sthey\scan\sbe\sreused.\s(CVS\s4783)
+D 2008-02-13T18:25:27
F Makefile.arm-wince-mingw32ce-gcc ac5f7b2cef0cd850d6f755ba6ee4ab961b1fadf7
F Makefile.in bc2b5df3e3d0d4b801b824b7ef6dec43812b049b
F Makefile.linux-gcc d53183f4aa6a9192d249731c90dbdffbd2c68654
F sqlite3.pc.in abed4664817e1cd500f2276142c71958087c16bc
F src/alter.c b494a50f239a760565ce6220ee316e96956ec054
F src/analyze.c a78ac494668581fe7f54ee63700815bb0ea34261
-F src/attach.c 90665c7ef5145e066570f66d7f0f15cdd0a4d14b
+F src/attach.c e13d62597e8725075b27186817f7e745122af24e
F src/auth.c c8b2ab5c8bad4bd90ed7c294694f48269162c627
F src/btmutex.c 483ced3c52205b04b97df69161fadbf87f4f1ea2
F src/btree.c 29ea577155f39be65bdec1c7782301ff2ee9eb3f
F src/func.c 8e3d0c59961dc403716767308ee764504179054b
F src/hash.c 2dc6afe7478a0b739499af360c8863c900ea11a8
F src/hash.h 031cd9f915aff27e12262cb9eb570ac1b8326b53
-F src/insert.c d422fda2d1f02219871cb7e3e4b49c680632450e
+F src/insert.c b313f5ecadf82dda15b1aa6780b0310eceb9e776
F src/journal.c 807bed7a158979ac8d63953e1774e8d85bff65e2
-F src/legacy.c 4ac53191fad2e3c4d59bde1228879b2dc5a96d66
+F src/legacy.c cb1939fdeb91ea88fb44fbd2768a10e14bc44650
F src/limits.h 71ab25f17e35e0a9f3f6f234b8ed49cc56731d35
F src/loadext.c d17a0f760d6866aacf5262f97d8efaaad379cdd7
F src/main.c b4014b71979a58d6aa79549fdf87175ab7bdf1cc
F src/malloc.c 60e392a4c12c839517f9b0db7b995f825444fb35
F src/md5.c c5fdfa5c2593eaee2e32a5ce6c6927c986eaf217
-F src/mem1.c 6d1a11864963d249c67e72ad5f6533b040333880
-F src/mem2.c 607af52ad7593f34934e7e4fa53a364556853d30
-F src/mem3.c 9d80034bb004c1bddc28d6befe1ddb044d18deab
+F src/mem1.c b15e107d51bdd4bcf410c18798ee48bee4768d4e
+F src/mem2.c ed0cb11ae43a3cc92bfb07172c2801956e94eaba
+F src/mem3.c cf1bf5b2f9d4d76e465c84c0607f6882d3b1b522
F src/mem4.c 36ecd536a8b7acfe4cbf011353dae6ea68121e40
F src/mutex.c 3259f62c2429967aee6dc112117a6d2f499ef061
F src/mutex.h 079fa6fe9da18ceb89e79012c010594c6672addb
F src/mutex_os2.c 19ab15764736f13b94b4f70e53f77547cbddd47a
F src/mutex_unix.c a6e111947a3cdaa2cda394ed060d7f496fcb4af8
F src/mutex_w32.c 6e197765f283815496193e78e9548b5d0e53b68e
-F src/os.c 50c0c1706c35f872db312815aaecc4b5ebcd6a4c
+F src/os.c 2f2753b8d33f79d169c43d6bb0b25b3c58fd33de
F src/os.h d04706d54a072c7a30ab9e346ad916ef28c842d5
F src/os_common.h 98862f120ca6bf7a48ce8b16f158b77d00bc9d2f
F src/os_os2.c bf1cd3d4f42c1b1ab059c12732cd9f7be4e718a6
F src/pager.c 2ed81808091ce42ceb1cf209e4ce87922a0065c8
F src/pager.h 8174615ffd14ccc2cad2b081b919a398fa95e3f9
F src/parse.y 00f2698c8ae84f315be5e3f10b63c94f531fdd6d
-F src/pragma.c 2bb8d6882b9a330e041acd05fb6aff5a01bf0a08
+F src/pragma.c e3f39f8576234887ecd0c1de43dc51af5855930c
F src/prepare.c 1b0601ca3f97a9d253cc08697484e3045a1678e9
F src/printf.c eb27822ba2eec669161409ca31279a24c26ac910
F src/random.c 02ef38b469237482f1ea14a78b2087cfbaec48bd
-F src/select.c 394aa3542e8df599dcca77b0e75f7875760a13ad
+F src/select.c 1d780691071af7d58b83a6b38517c2687dd83c5b
F src/server.c 087b92a39d883e3fa113cae259d64e4c7438bc96
F src/shell.c ca06cb687c40a8bff6307b5fad41a0e86a0f8558
F src/sqlite.h.in 690736613958e0f462e08ae2a9136fa335214edc
F src/sqlite3ext.h a93f59cdee3638dc0c9c086f80df743a4e68c3cb
-F src/sqliteInt.h e4ca11fff0cdac38551b75a2a278edb8ad9e1f00
+F src/sqliteInt.h 822045362bdddd303a0b17aa09679ba735ffbaa1
F src/sqliteLimit.h ee4430f88f69bf63527967bb35ca52af7b0ccb1e
F src/table.c 46ccf9b7892a86f57420ae7bac69ecd5e72d26b5
-F src/tclsqlite.c 9923abeffc9b3d7dad58e92b319661521f60debf
-F src/test1.c 5363a117741f26e84b85e30757f0f4414331c46f
+F src/tclsqlite.c 0d4483e37c6a1e87f80565e50d977df6dd2bf732
+F src/test1.c 28b135491b436b1df6390a8b53834da2f94efca4
F src/test2.c 77b34303883b9d722c65a6879bb0163a400e3789
F src/test3.c 4557ee13c6e5921eb28979ff77cdbd913bfde6be
F src/test4.c c2c0f5dc907f1346f5d4b65eb5799f11eb9e4071
F src/test5.c 3a6a5717a149d7ca2e6d14f5be72cf7555d54dc4
F src/test6.c f8b34a6ff04937092327798ddf0ab46863535bc5
F src/test7.c acec2256c7c2d279db5a8b5fa1a2a68fcc942c67
-F src/test8.c cab3f576353dfef4877c7cc3b0d0e48acc65c37c
+F src/test8.c 25e127f0e21f59da24fa33cdbc645851cfb933f1
F src/test9.c 4615ef08750245a2d96aaa7cbe2fb4aff2b57acc
F src/test_async.c 5f21392d66869a4c87dc9153e40d0dc0e085261f
F src/test_autoext.c 855157d97aa28cf84233847548bfacda21807436
F src/test_devsym.c fd8884c2269fb7e0db2c52d21ec59d31a33790ba
F src/test_hexio.c 1a1cd8324d57585ea86b922f609fa1fbaaf9662d
F src/test_loadext.c 22065d601a18878e5542191001f0eaa5d77c0ed8
-F src/test_malloc.c 0bc9d27c09efe0be63d0de5fb6e38a4253cd5551
+F src/test_malloc.c f57e6327a9c32dc71fb2c15941f64d4e91461d3b
F src/test_md5.c c107c96637123239c3518b5fbe97a79130f4d32e
F src/test_onefile.c 54282b6796d55d7acc489be83b89b8715e7d3756
F src/test_schema.c 12c9de7661d6294eec2d57afbb52e2af1128084f
F src/tokenize.c c4b79fd48ddb709b2b8522b7d93a5a3d98168ca4
F src/trigger.c 9bd3b6fa0beff4a02d262c96466f752ec15a7fc3
F src/update.c 9b3be169cd2a0b065717164aa0f90aa48f34aed1
-F src/utf.c ef4b7d83bae533b76c3e1bf635b113fdad86a736
+F src/utf.c 32b00d6e19010025e58f2ecb2f921d5e126771b4
F src/util.c c56e41ed4769c1f2b8af9ffde4757a7b4fb08ed1
F src/vacuum.c 3f34f278809bf3eb0b62ec46ff779e9c385b28f0
-F src/vdbe.c 1049375248b494e626598abffeeb31052c660c78
+F src/vdbe.c a172f5134d19ae910134e28987bf7906523c9b6f
F src/vdbe.h 58a7d931ffb704e034b2a725981cfa5bd406fad9
-F src/vdbeInt.h 969d360acc85f7b2069a8169b4f8a3e1fbaccd44
-F src/vdbeapi.c 61b37dbe11baa221baea7f93c01780705d2419ed
-F src/vdbeaux.c 771b9ffd7b42cbb4bd029d7a9414a7cb03f924a7
+F src/vdbeInt.h 76c81d057a39813de0fda3cad1498655d53ec69d
+F src/vdbeapi.c cf9fc963efae3cdf5de08e2a9718b487059c7fc5
+F src/vdbeaux.c 36d4db24659146606a1c755650f2a70cf88eec25
F src/vdbeblob.c 63c750acc7b5012479f508c0e9627372a82cb65d
F src/vdbefifo.c 334c838c8f42d61a94813d136019ee566b5dc2f6
-F src/vdbemem.c cee169fb5542cccfd1e8d832ae4538cb69b8917a
+F src/vdbemem.c e060d04bc6f8cf32c638fddada266b01cad8ee9a
F src/vtab.c dc8947c9c79780b19ee6d6bae4ea624a2a303353
F src/where.c 7ff0ca021cc77086e367ed3b6308fbc6bc9e1a31
F tclinstaller.tcl 4356d9d94d2b5ed5e68f9f0c80c4df3048dd7617
F test/malloc9.test 95d7069ad4fa262bf33bc4c5ca0a46f2bb2391cb
F test/mallocA.test 5ee8d42ff90e5b1aeee6fb645e73ffcb35bffd21
F test/mallocAll.test 2a2222a5e447be6c6579055a9a26e507e4586f4e
-F test/mallocB.test 82ecf4d3fa6c389cabc747daa2deddfe94af2a74
+F test/mallocB.test d4a91e7d9cc916d009e0fec08537b3be299ee514
F test/mallocC.test 9daac0aa8e5b0afa7b0a3fb0cd792f02fe0cc838
F test/mallocD.test 24c1d07a00e605831d0d627b036bd690b2952416
F test/mallocE.test e15333c394d7c330c8372a7cdf7b0f7c16573082
F test/pragma2.test 5364893491b9231dd170e3459bfc2e2342658b47
F test/printf.test c3405535b418d454e8a52196a0fc592ec9eec58d
F test/progress.test 5b075c3c790c7b2a61419bc199db87aaf48b8301 x
-F test/ptrchng.test 38ae1806833d72d9a81a6121322e274f24937e18
+F test/ptrchng.test 1f7bb92398163f1c18d69727c3ab31d90e94b458
F test/quick.test 771a6b3a88fdd0e7e813ce013ceda29037bc9462
F test/quote.test 215897dbe8de1a6f701265836d6601cc6ed103e6
F test/rdonly.test b34db316525440d3b42c32e83942c02c37d28ef0
F test/tableapi.test 4546eb710d979db023bfcc16b0c108b1557fcb43
F test/tclsqlite.test 3fac87cb1059c46b8fa8a60b553f4f1adb0fb6d9
F test/temptable.test 19b851b9e3e64d91e9867619b2a3f5fffee6e125
-F test/tester.tcl bfad4d2acf0659c6afbf48a98556b0433d2906dc
+F test/tester.tcl 70ed4c0dda3e2277bac9e0bf38e60df9dc360d08
F test/thread001.test 8fbd9559da0bbdc273e00318c7fd66c162020af7
F test/thread002.test 2c4ad2c386f60f6fe268cd91c769ee35b3c1fd0b
F test/thread1.test 776c9e459b75ba905193b351926ac4019b049f35
F www/vdbe.tcl 87a31ace769f20d3627a64fa1fade7fed47b90d0
F www/version3.tcl 890248cf7b70e60c383b0e84d77d5132b3ead42b
F www/whentouse.tcl fc46eae081251c3c181bd79c5faef8195d7991a5
-P 607247c27b80520b8c25c489757288b8ea186f9e
-R 6e7459c99c887be282a1c6ce2d461da7
-U drh
-Z 584629669827c756e74626290b2a5564
+P 5ab71c3a79cac04cb2c576f83a62218d05571006
+R c1dd02f73a73bb7e12988703f2d12663
+U danielk1977
+Z 2dff5d02e45b3ba8d57e28cad43b1b4e
-5ab71c3a79cac04cb2c576f83a62218d05571006
\ No newline at end of file
+990237e27e417aff3dbf05784b716c21f3761a3a
\ No newline at end of file
*************************************************************************
** This file contains code used to implement the ATTACH and DETACH commands.
**
-** $Id: attach.c,v 1.71 2008/02/06 14:11:35 drh Exp $
+** $Id: attach.c,v 1.72 2008/02/13 18:25:27 danielk1977 Exp $
*/
#include "sqliteInt.h"
}
v = sqlite3GetVdbe(pParse);
- regArgs = sqlite3GetTempRange(pParse, 3);
+ regArgs = sqlite3GetTempRange(pParse, 4);
sqlite3ExprCode(pParse, pFilename, regArgs);
sqlite3ExprCode(pParse, pDbname, regArgs+1);
sqlite3ExprCode(pParse, pKey, regArgs+2);
assert( v || db->mallocFailed );
if( v ){
- sqlite3VdbeAddOp3(v, OP_Function, 0, regArgs+3-nFunc, regArgs);
+ sqlite3VdbeAddOp3(v, OP_Function, 0, regArgs+3-nFunc, regArgs+3);
sqlite3VdbeChangeP5(v, nFunc);
pFunc = sqlite3FindFunction(db, zFunc, strlen(zFunc), nFunc, SQLITE_UTF8,0);
sqlite3VdbeChangeP4(v, -1, (char *)pFunc, P4_FUNCDEF);
** This file contains C code routines that are called by the parser
** to handle INSERT statements in SQLite.
**
-** $Id: insert.c,v 1.228 2008/01/25 15:04:50 drh Exp $
+** $Id: insert.c,v 1.229 2008/02/13 18:25:27 danielk1977 Exp $
*/
#include "sqliteInt.h"
Vdbe *v = pParse->pVdbe;
Db *pDb = &pParse->db->aDb[iDb];
int j1;
+ int iRec = ++pParse->nMem; /* Memory cell used for record */
assert( v );
sqlite3OpenTable(pParse, iCur, iDb, pDb->pSchema->pSeqTab, OP_OpenWrite);
j1 = sqlite3VdbeAddOp1(v, OP_NotNull, memId+1);
sqlite3VdbeAddOp2(v, OP_NewRowid, iCur, memId+1);
sqlite3VdbeJumpHere(v, j1);
- sqlite3VdbeAddOp3(v, OP_MakeRecord, memId-1, 2, memId-1);
- sqlite3VdbeAddOp3(v, OP_Insert, iCur, memId-1, memId+1);
+ sqlite3VdbeAddOp3(v, OP_MakeRecord, memId-1, 2, iRec);
+ sqlite3VdbeAddOp3(v, OP_Insert, iCur, iRec, memId+1);
sqlite3VdbeChangeP5(v, OPFLAG_APPEND);
sqlite3VdbeAddOp1(v, OP_Close, iCur);
}
** other files are for internal use by SQLite and should not be
** accessed by users of the library.
**
-** $Id: legacy.c,v 1.22 2007/08/29 12:31:26 danielk1977 Exp $
+** $Id: legacy.c,v 1.23 2008/02/13 18:25:27 danielk1977 Exp $
*/
#include "sqliteInt.h"
if( 0==nCallback ){
for(i=0; i<nCol; i++){
azCols[i] = (char *)sqlite3_column_name(pStmt, i);
+ if( !azCols[i] ){
+ db->mallocFailed = 1;
+ goto exec_out;
+ }
}
nCallback++;
}
azVals = &azCols[nCol];
for(i=0; i<nCol; i++){
azVals[i] = (char *)sqlite3_column_text(pStmt, i);
+ if( !azVals[i] && sqlite3_column_type(pStmt, i)!=SQLITE_NULL ){
+ db->mallocFailed = 1;
+ goto exec_out;
+ }
}
}
if( xCallback(pArg, nCol, azVals, azCols) ){
** This file contains the C functions that implement a memory
** allocation subsystem for use by SQLite.
**
-** $Id: mem1.c,v 1.14 2007/11/29 18:36:49 drh Exp $
+** $Id: mem1.c,v 1.15 2008/02/13 18:25:27 danielk1977 Exp $
*/
/*
sqlite3_mutex_leave(mem.mutex);
}
+/*
+** Return the number of bytes allocated at p.
+*/
+int sqlite3MallocSize(void *p){
+ sqlite3_int64 *pInt;
+ if( !p ) return 0;
+ pInt = p;
+ return pInt[-1];
+}
+
/*
** Change the size of an existing memory allocation
*/
** This file contains the C functions that implement a memory
** allocation subsystem for use by SQLite.
**
-** $Id: mem2.c,v 1.19 2008/01/22 21:30:53 drh Exp $
+** $Id: mem2.c,v 1.20 2008/02/13 18:25:27 danielk1977 Exp $
*/
/*
return p;
}
+/*
+** Return the number of bytes currently allocated at address p.
+*/
+int sqlite3MallocSize(void *p){
+ struct MemBlockHdr *pHdr;
+ if( !p ){
+ return 0;
+ }
+ pHdr = sqlite3MemsysGetHeader(p);
+ return pHdr->iSize;
+}
+
/*
** Allocate nByte bytes of memory.
*/
fclose(out);
}
+/*
+** Return the number of times sqlite3_malloc() has been called.
+*/
+int sqlite3_memdebug_malloc_count(){
+ int i;
+ int nTotal = 0;
+ for(i=0; i<NCSIZE; i++){
+ nTotal += mem.sizeCnt[i];
+ }
+ return nTotal;
+}
+
#endif /* SQLITE_MEMDEBUG && !SQLITE_OMIT_MEMORY_ALLOCATION */
** This version of the memory allocation subsystem is used if
** and only if SQLITE_MEMORY_SIZE is defined.
**
-** $Id: mem3.c,v 1.8 2007/12/29 13:18:22 drh Exp $
+** $Id: mem3.c,v 1.9 2008/02/13 18:25:27 danielk1977 Exp $
*/
/*
** size returned omits the 8-byte header overhead. This only
** works for chunks that are currently checked out.
*/
-static int memsys3Size(void *p){
+int sqlite3MallocSize(void *p){
Mem3Block *pBlock = (Mem3Block*)p;
assert( (pBlock[-1].u.hdr.size4x&1)!=0 );
return (pBlock[-1].u.hdr.size4x&~3)*2 - 4;
return 0;
}
assert( mem.mutex!=0 );
- nOld = memsys3Size(pPrior);
+ nOld = sqlite3MallocSize(pPrior);
if( nBytes<=nOld && nBytes>=nOld-128 ){
return pPrior;
}
- /*
+/*
** 2005 November 29
**
** The author disclaims copyright to this source code. In place of
*************************************************************************
** This file contains code used to implement the PRAGMA command.
**
-** $Id: pragma.c,v 1.169 2008/01/22 01:48:09 drh Exp $
+** $Id: pragma.c,v 1.170 2008/02/13 18:25:27 danielk1977 Exp $
*/
#include "sqliteInt.h"
#include <ctype.h>
if( cnt==0 ) continue;
/* Make sure sufficient number of registers have been allocated */
- if( pParse->nMem < cnt+3 ){
- pParse->nMem = cnt+3;
+ if( pParse->nMem < cnt+4 ){
+ pParse->nMem = cnt+4;
}
/* Do the b-tree integrity checks */
sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0,
sqlite3MPrintf(db, "*** in database %s ***\n", db->aDb[i].zName),
P4_DYNAMIC);
- sqlite3VdbeAddOp3(v, OP_Concat, 2, 3, 2);
+ sqlite3VdbeAddOp2(v, OP_Move, 2, 4);
+ sqlite3VdbeAddOp3(v, OP_Concat, 4, 3, 2);
sqlite3VdbeAddOp2(v, OP_ResultRow, 2, 1);
sqlite3VdbeJumpHere(v, addr);
** This file contains C code routines that are called by the parser
** to handle SELECT statements in SQLite.
**
-** $Id: select.c,v 1.412 2008/02/06 23:52:37 drh Exp $
+** $Id: select.c,v 1.413 2008/02/13 18:25:27 danielk1977 Exp $
*/
#include "sqliteInt.h"
int j1;
assert( nColumn==1 );
j1 = sqlite3VdbeAddOp1(v, OP_IsNull, regRow);
- sqlite3VdbeAddOp4(v, OP_MakeRecord, regRow, 1, regRow, &p->affinity, 1);
- sqlite3VdbeAddOp2(v, OP_IdxInsert, iParm, regRow);
+ sqlite3VdbeAddOp4(v, OP_MakeRecord, regRow, 1, regRowid, &p->affinity, 1);
+ sqlite3VdbeAddOp2(v, OP_IdxInsert, iParm, regRowid);
sqlite3VdbeJumpHere(v, j1);
break;
}
*************************************************************************
** Internal interface definitions for SQLite.
**
-** @(#) $Id: sqliteInt.h,v 1.660 2008/02/12 16:52:14 drh Exp $
+** @(#) $Id: sqliteInt.h,v 1.661 2008/02/13 18:25:27 danielk1977 Exp $
*/
#ifndef _SQLITEINT_H_
#define _SQLITEINT_H_
char *sqlite3DbStrNDup(sqlite3*,const char*, int);
void *sqlite3DbReallocOrFree(sqlite3 *, void *, int);
void *sqlite3DbRealloc(sqlite3 *, void *, int);
+int sqlite3MallocSize(void *);
char *sqlite3MPrintf(sqlite3*,const char*, ...);
char *sqlite3VMPrintf(sqlite3*,const char*, va_list);
** A TCL Interface to SQLite. Append this file to sqlite3.c and
** compile the whole thing to build a TCL-enabled version of SQLite.
**
-** $Id: tclsqlite.c,v 1.207 2007/11/14 06:48:48 danielk1977 Exp $
+** $Id: tclsqlite.c,v 1.208 2008/02/13 18:25:27 danielk1977 Exp $
*/
#include "tcl.h"
#include <errno.h>
switch( sqlite3_column_type(pStmt, i) ){
case SQLITE_BLOB: {
int bytes = sqlite3_column_bytes(pStmt, i);
- pVal = Tcl_NewByteArrayObj(sqlite3_column_blob(pStmt, i), bytes);
+ char *zBlob = sqlite3_column_blob(pStmt, i);
+ if( !zBlob ) bytes = 0;
+ pVal = Tcl_NewByteArrayObj(zBlob, bytes);
break;
}
case SQLITE_INTEGER: {
** is not included in the SQLite library. It is used for automated
** testing of the SQLite library.
**
-** $Id: test1.c,v 1.287 2008/01/23 14:51:50 drh Exp $
+** $Id: test1.c,v 1.288 2008/02/13 18:25:27 danielk1977 Exp $
*/
#include "sqliteInt.h"
#include "tcl.h"
/* Use the sqlite3_create_function16() API here. Mainly for fun, but also
** because it is not tested anywhere else. */
if( rc==SQLITE_OK ){
+ void *zUtf16;
sqlite3_value *pVal;
sqlite3_mutex_enter(db->mutex);
pVal = sqlite3ValueNew(db);
sqlite3ValueSetStr(pVal, -1, "x_sqlite_exec", SQLITE_UTF8, SQLITE_STATIC);
+ zUtf16 = sqlite3ValueText(pVal, SQLITE_UTF16NATIVE);
if( db->mallocFailed ){
rc = SQLITE_NOMEM;
}else{
- rc = sqlite3_create_function16(db,
- sqlite3ValueText(pVal, SQLITE_UTF16NATIVE),
- 1, SQLITE_UTF16, db, sqlite3ExecFunc, 0, 0);
+ rc = sqlite3_create_function16(db, zUtf16,
+ 1, SQLITE_UTF16, db, sqlite3ExecFunc, 0, 0);
}
sqlite3ValueFree(pVal);
sqlite3_mutex_leave(db->mutex);
rc = sqlite3_create_collation(db, "test_collate", SQLITE_UTF8,
(void *)SQLITE_UTF8, val?test_collate_func:0);
if( rc==SQLITE_OK ){
+ void *zUtf16;
if( TCL_OK!=Tcl_GetBooleanFromObj(interp, objv[3], &val) ) return TCL_ERROR;
rc = sqlite3_create_collation(db, "test_collate", SQLITE_UTF16LE,
(void *)SQLITE_UTF16LE, val?test_collate_func:0);
sqlite3_mutex_enter(db->mutex);
pVal = sqlite3ValueNew(db);
sqlite3ValueSetStr(pVal, -1, "test_collate", SQLITE_UTF8, SQLITE_STATIC);
+ zUtf16 = sqlite3ValueText(pVal, SQLITE_UTF16NATIVE);
if( db->mallocFailed ){
rc = SQLITE_NOMEM;
}else{
- rc = sqlite3_create_collation16(db,
- sqlite3ValueText(pVal, SQLITE_UTF16NATIVE), SQLITE_UTF16BE,
+ rc = sqlite3_create_collation16(db, zUtf16, SQLITE_UTF16BE,
(void *)SQLITE_UTF16BE, val?test_collate_func:0);
}
sqlite3ValueFree(pVal);
** is not included in the SQLite library. It is used for automated
** testing of the SQLite library.
**
-** $Id: test8.c,v 1.59 2008/01/22 21:30:53 drh Exp $
+** $Id: test8.c,v 1.60 2008/02/13 18:25:27 danielk1977 Exp $
*/
#include "sqliteInt.h"
#include "tcl.h"
*/
nBytes = sizeof(char *) * nCol;
for(ii=0; ii<nCol; ii++){
- nBytes += (strlen(sqlite3_column_name(pStmt, ii)) + 1);
+ const char *zName = sqlite3_column_name(pStmt, ii);
+ if( !zName ){
+ rc = SQLITE_NOMEM;
+ goto out;
+ }
+ nBytes += strlen(zName)+1;
}
aCol = (char **)sqlite3MallocZero(nBytes);
if( !aCol ){
if( bindArgOne ){
sqlite3_bind_value(pStmt, 1, apData[1]);
}
- for(i=2; i<nData; i++){
- if( apData[i] ) sqlite3_bind_value(pStmt, i, apData[i]);
+ for(i=2; i<nData && rc==SQLITE_OK; i++){
+ if( apData[i] ) rc = sqlite3_bind_value(pStmt, i, apData[i]);
+ }
+ if( rc==SQLITE_OK ){
+ sqlite3_step(pStmt);
+ rc = sqlite3_finalize(pStmt);
+ }else{
+ sqlite3_finalize(pStmt);
}
- sqlite3_step(pStmt);
- rc = sqlite3_finalize(pStmt);
}
if( pRowid && rc==SQLITE_OK ){
** This file contains code used to implement test interfaces to the
** memory allocation subsystem.
**
-** $Id: test_malloc.c,v 1.11 2008/01/31 14:43:24 drh Exp $
+** $Id: test_malloc.c,v 1.12 2008/02/13 18:25:27 danielk1977 Exp $
*/
#include "sqliteInt.h"
#include "tcl.h"
return TCL_OK;
}
+/*
+** Usage: sqlite3_memdebug_malloc_count
+**
+** Return the total number of times malloc() has been called.
+*/
+static int test_memdebug_malloc_count(
+ void * clientData,
+ Tcl_Interp *interp,
+ int objc,
+ Tcl_Obj *CONST objv[]
+){
+ int nMalloc = -1;
+ if( objc!=1 ){
+ Tcl_WrongNumArgs(interp, 1, objv, "");
+ return TCL_ERROR;
+ }
+#if defined(SQLITE_MEMDEBUG)
+ {
+ extern int sqlite3_memdebug_malloc_count();
+ nMalloc = sqlite3_memdebug_malloc_count();
+ }
+#endif
+ Tcl_SetObjResult(interp, Tcl_NewIntObj(nMalloc));
+ return TCL_OK;
+}
+
/*
** Usage: sqlite3_memdebug_fail COUNTER ?OPTIONS?
{ "sqlite3_memdebug_fail", test_memdebug_fail },
{ "sqlite3_memdebug_pending", test_memdebug_pending },
{ "sqlite3_memdebug_settitle", test_memdebug_settitle },
+ { "sqlite3_memdebug_malloc_count", test_memdebug_malloc_count },
};
int i;
for(i=0; i<sizeof(aObjCmd)/sizeof(aObjCmd[0]); i++){
** This file contains routines used to translate between UTF-8,
** UTF-16, UTF-16BE, and UTF-16LE.
**
-** $Id: utf.c,v 1.59 2007/10/03 08:46:45 danielk1977 Exp $
+** $Id: utf.c,v 1.60 2008/02/13 18:25:27 danielk1977 Exp $
**
** Notes on UTF-8:
**
** encoding, or if *pMem does not contain a string value.
*/
int sqlite3VdbeMemTranslate(Mem *pMem, u8 desiredEnc){
- unsigned char zShort[NBFS]; /* Temporary short output buffer */
int len; /* Maximum length of output string in bytes */
unsigned char *zOut; /* Output buffer */
unsigned char *zIn; /* Input iterator */
/* Set zIn to point at the start of the input buffer and zTerm to point 1
** byte past the end.
**
- ** Variable zOut is set to point at the output buffer. This may be space
- ** obtained from sqlite3_malloc(), or Mem.zShort, if it large enough and
- ** not in use, or the zShort array on the stack (see above).
+ ** Variable zOut is set to point at the output buffer, space obtained
+ ** from sqlite3_malloc().
*/
zIn = (u8*)pMem->z;
zTerm = &zIn[pMem->n];
- if( len>NBFS ){
- zOut = sqlite3DbMallocRaw(pMem->db, len);
- if( !zOut ){
- return SQLITE_NOMEM;
- }
- }else{
- zOut = zShort;
+ zOut = sqlite3DbMallocRaw(pMem->db, len);
+ if( !zOut ){
+ return SQLITE_NOMEM;
}
z = zOut;
assert( (pMem->n+(desiredEnc==SQLITE_UTF8?1:2))<=len );
sqlite3VdbeMemRelease(pMem);
- pMem->flags &= ~(MEM_Static|MEM_Dyn|MEM_Ephem|MEM_Short);
+ pMem->flags &= ~(MEM_Static|MEM_Dyn|MEM_Ephem);
pMem->enc = desiredEnc;
- if( zOut==zShort ){
- memcpy(pMem->zShort, zOut, len);
- zOut = (u8*)pMem->zShort;
- pMem->flags |= (MEM_Term|MEM_Short);
- }else{
- pMem->flags |= (MEM_Term|MEM_Dyn);
- }
+ pMem->flags |= (MEM_Term|MEM_Dyn);
pMem->z = (char*)zOut;
translate_out:
}
if( bom ){
- /* This function is called as soon as a string is stored in a Mem*,
- ** from within sqlite3VdbeMemSetStr(). At that point it is not possible
- ** for the string to be stored in Mem.zShort, or for it to be stored
- ** in dynamic memory with no destructor.
- */
- assert( !(pMem->flags&MEM_Short) );
- assert( !(pMem->flags&MEM_Dyn) || pMem->xDel );
- if( pMem->flags & MEM_Dyn ){
- void (*xDel)(void*) = pMem->xDel;
- char *z = pMem->z;
- pMem->z = 0;
- pMem->xDel = 0;
- rc = sqlite3VdbeMemSetStr(pMem, &z[2], pMem->n-2, bom,
- SQLITE_TRANSIENT);
- xDel(z);
- }else{
- rc = sqlite3VdbeMemSetStr(pMem, &pMem->z[2], pMem->n-2, bom,
- SQLITE_TRANSIENT);
+ rc = sqlite3VdbeMemMakeWriteable(pMem);
+ if( rc==SQLITE_OK ){
+ pMem->n -= 2;
+ memmove(pMem->z, &pMem->z[2], pMem->n);
+ pMem->z[pMem->n] = '\0';
+ pMem->z[pMem->n+1] = '\0';
+ pMem->flags |= MEM_Term;
+ pMem->enc = bom;
}
}
return rc;
** in this file for details. If in doubt, do not deviate from existing
** commenting and indentation practices when changing or adding code.
**
-** $Id: vdbe.c,v 1.708 2008/02/06 14:11:35 drh Exp $
+** $Id: vdbe.c,v 1.709 2008/02/13 18:25:27 danielk1977 Exp $
*/
#include "sqliteInt.h"
#include <ctype.h>
i64 value;
sqlite3VdbeChangeEncoding(pRec, SQLITE_UTF8);
if( !realnum && sqlite3Atoi64(pRec->z, &value) ){
- sqlite3VdbeMemRelease(pRec);
pRec->u.i = value;
- pRec->flags = MEM_Int;
+ MemSetTypeFlag(pRec, MEM_Int);
}else{
sqlite3VdbeMemRealify(pRec);
}
** Add the text in register P1 onto the end of the text in
** register P2 and store the result in register P3.
** If either the P1 or P2 text are NULL then store NULL in P3.
+**
+** P3 = P2 || P1
+**
+** It is illegal for P1 and P3 to be the same register. Sometimes,
+** if P3 is the same register as P2, the implementation is able
+** to avoid a memcpy().
*/
case OP_Concat: { /* same as TK_CONCAT, in1, in2, out3 */
- char *zNew;
i64 nByte;
+ assert( pIn1!=pOut );
if( (pIn1->flags | pIn2->flags) & MEM_Null ){
- Release(pOut);
- pOut->flags = MEM_Null;
+ sqlite3VdbeMemSetNull(pOut);
break;
}
ExpandBlob(pIn1);
if( nByte>SQLITE_MAX_LENGTH ){
goto too_big;
}
- zNew = sqlite3DbMallocRaw(db, nByte+2);
- if( zNew==0 ){
+ MemSetTypeFlag(pOut, MEM_Str);
+ if( sqlite3VdbeMemGrow(pOut, nByte+2, pOut==pIn2) ){
goto no_mem;
}
- memcpy(zNew, pIn2->z, pIn2->n);
- memcpy(&zNew[pIn2->n], pIn1->z, pIn1->n);
- zNew[nByte] = 0;
- zNew[nByte+1] = 0;
- Release(pOut);
+ if( pOut!=pIn2 ){
+ memcpy(pOut->z, pIn2->z, pIn2->n);
+ }
+ memcpy(&pOut->z[pIn2->n], pIn1->z, pIn1->n);
+ pOut->z[nByte] = 0;
+ pOut->z[nByte+1] = 0;
+ pOut->flags |= MEM_Term;
pOut->n = nByte;
- pOut->flags = MEM_Str|MEM_Dyn|MEM_Term;
- pOut->xDel = 0;
pOut->enc = encoding;
- pOut->z = zNew;
UPDATE_MAX_BLOBSIZE(pOut);
break;
}
break;
}
}
- Release(pOut);
pOut->u.i = b;
- pOut->flags = MEM_Int;
+ MemSetTypeFlag(pOut, MEM_Int);
}else{
double a, b;
a = sqlite3VdbeRealValue(pIn1);
if( sqlite3_isnan(b) ){
goto arithmetic_result_is_null;
}
- Release(pOut);
pOut->r = b;
- pOut->flags = MEM_Real;
+ MemSetTypeFlag(pOut, MEM_Real);
if( (flags & MEM_Real)==0 ){
sqlite3VdbeIntegerAffinity(pOut);
}
** Invoke a user function (P4 is a pointer to a Function structure that
** defines the function) with P5 arguments taken from register P2 and
** successors. The result of the function is stored in register P3.
+** Register P3 must not be one of the function inputs.
**
** P1 is a 32-bit bitmask indicating whether or not each argument to the
** function was determined to be constant at compile time. If the first
assert( apVal || n==0 );
assert( n==0 || (pOp->p2>0 && pOp->p2+n<=p->nMem) );
+ assert( pOp->p3<pOp->p2 || pOp->p3>=pOp->p2+n );
pArg = &p->aMem[pOp->p2];
for(i=0; i<n; i++, pArg++){
apVal[i] = pArg;
ctx.pFunc = ctx.pVdbeFunc->pFunc;
}
+ assert( pOp->p3>0 && pOp->p3<=p->nMem );
+ pOut = &p->aMem[pOp->p3];
ctx.s.flags = MEM_Null;
- ctx.s.z = 0;
- ctx.s.xDel = 0;
- ctx.s.db = db;
+ ctx.s.db = 0;
+
+ /* The output cell may already have a buffer allocated. Move
+ ** the pointer to ctx.s so in case the user-function can use
+ ** the already allocated buffer instead of allocating a new one.
+ */
+ sqlite3VdbeMemMove(&ctx.s, pOut);
+ MemSetTypeFlag(&ctx.s, MEM_Null);
+
ctx.isError = 0;
if( ctx.pFunc->needCollSeq ){
assert( pOp>p->aOp );
/* Copy the result of the function into register P3 */
sqlite3VdbeChangeEncoding(&ctx.s, encoding);
- assert( pOp->p3>0 && pOp->p3<=p->nMem );
- pOut = &p->aMem[pOp->p3];
sqlite3VdbeMemMove(pOut, &ctx.s);
if( sqlite3VdbeMemTooBig(pOut) ){
goto too_big;
default: assert( pOp->opcode==OP_ShiftRight );
a >>= b; break;
}
- Release(pOut);
pOut->u.i = a;
- pOut->flags = MEM_Int;
+ MemSetTypeFlag(pOut, MEM_Int);
break;
}
if( pIn1->r>(double)v ) v++;
if( pOp->p3 && pIn1->r==(double)v ) v++;
}
- Release(pIn1);
pIn1->u.i = v;
- pIn1->flags = MEM_Int;
+ MemSetTypeFlag(pIn1, MEM_Int);
break;
}
pc = pOp->p2 - 1;
}
}else{
- Release(pIn1);
- pIn1->flags = MEM_Int;
+ MemSetTypeFlag(pIn1, MEM_Int);
}
break;
}
pIn1->flags |= (pIn1->flags&MEM_Blob)>>3;
applyAffinity(pIn1, SQLITE_AFF_TEXT, encoding);
rc = ExpandBlob(pIn1);
- assert( pIn1->flags & MEM_Str );
+ assert( pIn1->flags & MEM_Str || db->mallocFailed );
pIn1->flags &= ~(MEM_Int|MEM_Real|MEM_Blob);
UPDATE_MAX_BLOBSIZE(pIn1);
break;
if( pIn1->flags & MEM_Null ) break;
if( (pIn1->flags & MEM_Blob)==0 ){
applyAffinity(pIn1, SQLITE_AFF_TEXT, encoding);
- assert( pIn1->flags & MEM_Str );
- pIn1->flags |= MEM_Blob;
+ assert( pIn1->flags & MEM_Str || db->mallocFailed );
}
- pIn1->flags &= ~(MEM_Int|MEM_Real|MEM_Str);
+ MemSetTypeFlag(pIn1, MEM_Blob);
UPDATE_MAX_BLOBSIZE(pIn1);
break;
}
*/
if( pOp->p5 & SQLITE_STOREP2 ){
pOut = &p->aMem[pOp->p2];
- Release(pOut);
- pOut->flags = MEM_Null;
+ MemSetTypeFlag(pOut, MEM_Null);
REGISTER_TRACE(pOp->p2, pOut);
}else if( pOp->p5 & SQLITE_JUMPIFNULL ){
pc = pOp->p2-1;
if( pOp->p5 & SQLITE_STOREP2 ){
pOut = &p->aMem[pOp->p2];
- Release(pOut);
- pOut->flags = MEM_Int;
+ MemSetTypeFlag(pOut, MEM_Int);
pOut->u.i = res;
REGISTER_TRACE(pOp->p2, pOut);
}else if( res ){
static const unsigned char or_logic[] = { 0, 1, 2, 1, 1, 1, 2, 1, 2 };
v1 = or_logic[v1*3+v2];
}
- Release(pOut);
if( v1==2 ){
- pOut->flags = MEM_Null;
+ MemSetTypeFlag(pOut, MEM_Null);
}else{
pOut->u.i = v1;
- pOut->flags = MEM_Int;
+ MemSetTypeFlag(pOut, MEM_Int);
}
break;
}
if( pIn1->flags & MEM_Null ) break; /* Do nothing to NULLs */
sqlite3VdbeMemIntegerify(pIn1);
pIn1->u.i = !pIn1->u.i;
- assert( pIn1->flags==MEM_Int );
+ assert( pIn1->flags&MEM_Int );
break;
}
if( pIn1->flags & MEM_Null ) break; /* Do nothing to NULLs */
sqlite3VdbeMemIntegerify(pIn1);
pIn1->u.i = ~pIn1->u.i;
- assert( pIn1->flags==MEM_Int );
+ assert( pIn1->flags&MEM_Int );
break;
}
Mem sMem; /* For storing the record being decoded */
sMem.flags = 0;
+ sMem.db = 0;
assert( p1<p->nCursor );
assert( pOp->p3>0 && pOp->p3<=p->nMem );
pDest = &p->aMem[pOp->p3];
- sqlite3VdbeMemSetNull(pDest);
+ MemSetTypeFlag(pDest, MEM_Null);
/* This block sets the variable payloadSize to be the total number of
** bytes in the record.
/* If payloadSize is 0, then just store a NULL */
if( payloadSize==0 ){
- assert( pDest->flags==MEM_Null );
+ assert( pDest->flags&MEM_Null );
goto op_column_out;
}
if( payloadSize>SQLITE_MAX_LENGTH ){
** acquire the complete header text.
*/
if( !zRec && avail<offset ){
+ sMem.flags = 0;
+ sMem.db = 0;
rc = sqlite3VdbeMemFromBtree(pCrsr, 0, offset, pC->isIndex, &sMem);
if( rc!=SQLITE_OK ){
goto op_column_out;
if( aOffset[p2] ){
assert( rc==SQLITE_OK );
if( zRec ){
- zData = &zRec[aOffset[p2]];
+ if( pDest->flags&MEM_Dyn ){
+ sqlite3VdbeSerialGet((u8 *)&zRec[aOffset[p2]], aType[p2], &sMem);
+ sMem.db = db;
+ sqlite3VdbeMemCopy(pDest, &sMem);
+ assert( !(sMem.flags&MEM_Dyn) );
+ }else{
+ sqlite3VdbeSerialGet((u8 *)&zRec[aOffset[p2]], aType[p2], pDest);
+ }
}else{
len = sqlite3VdbeSerialTypeLen(aType[p2]);
+ sqlite3VdbeMemMove(&sMem, pDest);
rc = sqlite3VdbeMemFromBtree(pCrsr, aOffset[p2], len, pC->isIndex, &sMem);
if( rc!=SQLITE_OK ){
goto op_column_out;
}
zData = sMem.z;
+ sqlite3VdbeSerialGet((u8*)zData, aType[p2], pDest);
}
- sqlite3VdbeSerialGet((u8*)zData, aType[p2], pDest);
pDest->enc = encoding;
}else{
if( pOp->p4type==P4_MEM ){
sqlite3VdbeMemShallowCopy(pDest, pOp->p4.pMem, MEM_Static);
}else{
- assert( pDest->flags==MEM_Null );
+ assert( pDest->flags&MEM_Null );
}
}
** This prevents a memory copy.
*/
if( (sMem.flags & MEM_Dyn)!=0 ){
- assert( pDest->flags & MEM_Ephem );
- assert( pDest->flags & (MEM_Str|MEM_Blob) );
- assert( pDest->z==sMem.z );
- assert( sMem.flags & MEM_Term );
- pDest->flags &= ~MEM_Ephem;
+ assert( !sMem.xDel );
+ assert( !(pDest->flags & MEM_Dyn) );
+ assert( !(pDest->flags & (MEM_Blob|MEM_Str)) || pDest->z==sMem.z );
+ pDest->flags &= ~(MEM_Ephem|MEM_Static);
pDest->flags |= MEM_Dyn|MEM_Term;
+ pDest->z = sMem.z;
}
- /* pDest->z might be pointing to sMem.zShort[]. Fix that so that we
- ** can abandon sMem */
rc = sqlite3VdbeMemMakeWriteable(pDest);
op_column_out:
char *zAffinity; /* The affinity string for the record */
int file_format; /* File format to use for encoding */
int i; /* Space used in zNewRecord[] */
- char zTemp[NBFS]; /* Space to hold small records */
nField = pOp->p1;
zAffinity = pOp->p4.z;
goto too_big;
}
- /* Allocate space for the new record. */
- if( nByte>sizeof(zTemp) ){
- zNewRecord = sqlite3DbMallocRaw(db, nByte);
- if( !zNewRecord ){
- goto no_mem;
- }
- }else{
- zNewRecord = (u8*)zTemp;
+ /* Make sure the output register has a buffer large enough to store
+ ** the new record. The output register (pOp->p3) is not allowed to
+ ** be one of the input registers (because the following call to
+ ** sqlite3VdbeMemGrow() could clobber the value before it is used).
+ */
+ assert( pOp->p3<pOp->p1 || pOp->p3>=pOp->p1+pOp->p2 );
+ pOut = &p->aMem[pOp->p3];
+ if( sqlite3VdbeMemGrow(pOut, nByte, 0) ){
+ goto no_mem;
}
+ zNewRecord = (u8 *)pOut->z;
/* Write the record */
i = sqlite3PutVarint(zNewRecord, nHdr);
assert( i==nByte );
assert( pOp->p3>0 && pOp->p3<=p->nMem );
- pOut = &p->aMem[pOp->p3];
- Release(pOut);
pOut->n = nByte;
- if( nByte<=sizeof(zTemp) ){
- assert( zNewRecord==(unsigned char *)zTemp );
- pOut->z = pOut->zShort;
- memcpy(pOut->zShort, zTemp, nByte);
- pOut->flags = MEM_Blob | MEM_Short;
- }else{
- assert( zNewRecord!=(unsigned char *)zTemp );
- pOut->z = (char*)zNewRecord;
- pOut->flags = MEM_Blob | MEM_Dyn;
- pOut->xDel = 0;
- }
+ pOut->flags = MEM_Blob | MEM_Dyn;
+ pOut->xDel = 0;
if( nZero ){
pOut->u.i = nZero;
pOut->flags |= MEM_Zero;
*/
rc = sqlite3BtreeGetMeta(db->aDb[iDb].pBt, 1 + iCookie, (u32 *)&iMeta);
pOut->u.i = iMeta;
- pOut->flags = MEM_Int;
+ MemSetTypeFlag(pOut, MEM_Int);
break;
}
pK = &p->aMem[pOp->p4.i];
sqlite3VdbeMemIntegerify(pIn3);
R = pIn3->u.i;
- assert( (pIn3->flags & MEM_Dyn)==0 );
assert( i>=0 && i<p->nCursor );
pCx = p->apCsr[i];
assert( pCx!=0 );
** a UNIQUE constraint.)
*/
pIn3->u.i = v;
- assert( pIn3->flags==MEM_Int );
+ assert( pIn3->flags&MEM_Int );
}
break;
}
assert( i>=0 && i<p->nCursor );
assert( p->apCsr[i]!=0 );
pOut->u.i = p->apCsr[i]->seqCount++;
- pOut->flags = MEM_Int;
+ MemSetTypeFlag(pOut, MEM_Int);
break;
}
pC->deferredMoveto = 0;
pC->cacheStatus = CACHE_STALE;
}
- pOut->flags = MEM_Int;
+ MemSetTypeFlag(pOut, MEM_Int);
pOut->u.i = v;
break;
}
** If the P1 cursor must be pointing to a valid row (not a NULL row)
** of a real table, not a pseudo-table.
*/
-case OP_RowKey: /* out2-prerelease */
-case OP_RowData: { /* out2-prerelease */
+case OP_RowKey:
+case OP_RowData: {
int i = pOp->p1;
Cursor *pC;
BtCursor *pCrsr;
u32 n;
+ pOut = &p->aMem[pOp->p2];
+
/* Note that RowKey and RowData are really exactly the same instruction */
assert( i>=0 && i<p->nCursor );
pC = p->apCsr[i];
goto too_big;
}
}
- pOut->n = n;
- if( n<=NBFS ){
- pOut->flags = MEM_Blob | MEM_Short;
- pOut->z = pOut->zShort;
- }else{
- char *z = sqlite3_malloc( n );
- if( z==0 ) goto no_mem;
- pOut->flags = MEM_Blob | MEM_Dyn;
- pOut->xDel = 0;
- pOut->z = z;
+ if( sqlite3VdbeMemGrow(pOut, n, 0) ){
+ goto no_mem;
}
+ pOut->n = n;
+ MemSetTypeFlag(pOut, MEM_Blob);
if( pC->isIndex ){
rc = sqlite3BtreeKey(pCrsr, 0, n, pOut->z);
}else{
v = keyToInt(v);
}
pOut->u.i = v;
- pOut->flags = MEM_Int;
+ MemSetTypeFlag(pOut, MEM_Int);
break;
}
/* Opcode: IdxDelete P1 P2 * * *
**
-** The content of register P2 is an index key built using the either the
-** MakeIdxRec opcode. Removes that entry from the index.
+** The content of register P2 is an index key built using the
+** MakeIdxRec opcode. This opcode removes that entry from the
+** index opened by cursor P1.
*/
case OP_IdxDelete: { /* in2 */
int i = pOp->p1;
if( rc!=SQLITE_OK ){
goto abort_due_to_error;
}
- pOut->flags = MEM_Int;
+ MemSetTypeFlag(pOut, MEM_Int);
pOut->u.i = rowid;
}
}
assert( iCnt==1 );
assert( (p->btreeMask & (1<<iDb))!=0 );
rc = sqlite3BtreeDropTable(db->aDb[iDb].pBt, pOp->p1, &iMoved);
- pOut->flags = MEM_Int;
+ MemSetTypeFlag(pOut, MEM_Int);
pOut->u.i = iMoved;
#ifndef SQLITE_OMIT_AUTOVACUUM
if( rc==SQLITE_OK && iMoved!=0 ){
rc = sqlite3BtreeCreateTable(pDb->pBt, &pgno, flags);
if( rc==SQLITE_OK ){
pOut->u.i = pgno;
- pOut->flags = MEM_Int;
+ MemSetTypeFlag(pOut, MEM_Int);
}
break;
}
if( nErr==0 ){
assert( z==0 );
}else{
- pIn1->z = z;
- pIn1->n = strlen(z);
- pIn1->flags = MEM_Str | MEM_Dyn | MEM_Term;
- pIn1->xDel = 0;
+ sqlite3VdbeMemSetStr(pIn1, z, -1, SQLITE_UTF8, sqlite3_free);
}
- pIn1->enc = SQLITE_UTF8;
UPDATE_MAX_BLOBSIZE(pIn1);
sqlite3VdbeChangeEncoding(pIn1, encoding);
sqlite3_free(aRoot);
CHECK_FOR_INTERRUPT;
assert( pOp->p1>0 && pOp->p1<=p->nMem );
pOut = &p->aMem[pOp->p1];
- Release(pOut);
- pOut->flags = MEM_Int;
+ MemSetTypeFlag(pOut, MEM_Int);
if( sqlite3VdbeFifoPop(&p->sFifo, &pOut->u.i)==SQLITE_DONE ){
pc = pOp->p2 - 1;
}
** not contain an integer. An assertion fault will result if you try.
*/
case OP_IfPos: { /* jump, in1 */
- assert( pIn1->flags==MEM_Int );
+ assert( pIn1->flags&MEM_Int );
if( pIn1->u.i>0 ){
pc = pOp->p2 - 1;
}
** not contain an integer. An assertion fault will result if you try.
*/
case OP_IfNeg: { /* jump, in1 */
- assert( pIn1->flags==MEM_Int );
+ assert( pIn1->flags&MEM_Int );
if( pIn1->u.i<0 ){
pc = pOp->p2 - 1;
}
** not contain an integer. An assertion fault will result if you try.
*/
case OP_IfZero: { /* jump, in1 */
- assert( pIn1->flags==MEM_Int );
+ assert( pIn1->flags&MEM_Int );
if( pIn1->u.i==0 ){
pc = pOp->p2 - 1;
}
if( sqlite3SafetyOff(db) ) goto abort_due_to_misuse;
rc = pModule->xRowid(pCur->pVtabCursor, &iRow);
if( sqlite3SafetyOn(db) ) goto abort_due_to_misuse;
- pOut->flags = MEM_Int;
+ MemSetTypeFlag(pOut, MEM_Int);
pOut->u.i = iRow;
break;
}
pModule = pCur->pVtabCursor->pVtab->pModule;
assert( pModule->xColumn );
memset(&sContext, 0, sizeof(sContext));
- sContext.s.flags = MEM_Null;
- sContext.s.db = db;
+
+ /* The output cell may already have a buffer allocated. Move
+ ** the current contents to sContext.s so in case the user-function
+ ** can use the already allocated buffer instead of allocating a
+ ** new one.
+ */
+ sqlite3VdbeMemMove(&sContext.s, pDest);
+ MemSetTypeFlag(&sContext.s, MEM_Null);
+
if( sqlite3SafetyOff(db) ) goto abort_due_to_misuse;
rc = pModule->xColumn(pCur->pVtabCursor, &sContext, pOp->p2);
};
typedef struct Cursor Cursor;
-/*
-** Number of bytes of string storage space available to each stack
-** layer without having to malloc. NBFS is short for Number of Bytes
-** For Strings.
-*/
-#define NBFS 32
-
/*
** A value for Cursor.cacheValid that means the cache is always invalid.
*/
u8 type; /* One of SQLITE_NULL, SQLITE_TEXT, SQLITE_INTEGER, etc */
u8 enc; /* SQLITE_UTF8, SQLITE_UTF16BE, SQLITE_UTF16LE */
void (*xDel)(void *); /* If not null, call this function to delete Mem.z */
- char zShort[NBFS]; /* Space for short strings */
};
/* One or more of the following flags are set to indicate the validOK
#define MEM_Real 0x0008 /* Value is a real number */
#define MEM_Blob 0x0010 /* Value is a BLOB */
+#define MemSetTypeFlag(p, f) \
+ ((p)->flags = ((p)->flags&~(MEM_Int|MEM_Real|MEM_Null|MEM_Blob|MEM_Str))|f)
+
/* Whenever Mem contains a valid string or blob representation, one of
** the following flags must be set to determine the memory management
** policy for Mem.z. The MEM_Term flag tells us whether or not the
#define MEM_Dyn 0x0040 /* Need to call sqliteFree() on Mem.z */
#define MEM_Static 0x0080 /* Mem.z points to a static string */
#define MEM_Ephem 0x0100 /* Mem.z points to an ephemeral string */
-#define MEM_Short 0x0200 /* Mem.z points to Mem.zShort */
#define MEM_Agg 0x0400 /* Mem.z points to an agg function context */
#define MEM_Zero 0x0800 /* Mem.i contains count of 0s appended to blob */
int sqlite3VdbeMemFinalize(Mem*, FuncDef*);
const char *sqlite3OpcodeName(int);
int sqlite3VdbeOpcodeHasProperty(int, int);
+int sqlite3VdbeMemGrow(Mem *pMem, int n, int preserve);
#ifndef NDEBUG
void sqlite3VdbeMemSanity(Mem*);
if( rc==SQLITE_OK ){
rc = sqlite3VdbeMemCopy(&p->aVar[i-1], pValue);
}
+ rc = sqlite3ApiExit(p->db, rc);
sqlite3_mutex_leave(p->db->mutex);
return rc;
}
** Release an array of N Mem elements
*/
static void releaseMemArray(Mem *p, int N){
- if( p ){
+ if( p && N ){
+ sqlite3 *db = p->db;
+ int malloc_failed = db->mallocFailed;
while( N-->0 ){
assert( N<2 || p[0].db==p[1].db );
- sqlite3VdbeMemSetNull(p++);
+ sqlite3VdbeMemRelease(p);
+ p++->flags = MEM_Null;
}
+ db->mallocFailed = malloc_failed;
}
}
rc = SQLITE_ERROR;
sqlite3SetString(&p->zErrMsg, sqlite3ErrStr(p->rc), (char*)0);
}else{
+ char *z;
Op *pOp = &p->aOp[i];
if( p->explain==1 ){
pMem->flags = MEM_Int;
pMem++;
}
- pMem->flags = MEM_Ephem|MEM_Str|MEM_Term; /* P4 */
- pMem->z = displayP4(pOp, pMem->zShort, sizeof(pMem->zShort));
- assert( pMem->z!=0 );
- pMem->n = strlen(pMem->z);
+ if( sqlite3VdbeMemGrow(pMem, 32, 0) ){ /* P4 */
+ p->db->mallocFailed = 1;
+ return SQLITE_NOMEM;
+ }
+ pMem->flags = MEM_Dyn|MEM_Str|MEM_Term;
+ z = displayP4(pOp, pMem->z, 32);
+ if( z!=pMem->z ){
+ sqlite3VdbeMemSetStr(pMem, z, -1, SQLITE_UTF8, 0);
+ }else{
+ assert( pMem->z!=0 );
+ pMem->n = strlen(pMem->z);
+ pMem->enc = SQLITE_UTF8;
+ }
pMem->type = SQLITE_TEXT;
- pMem->enc = SQLITE_UTF8;
pMem++;
if( p->explain==1 ){
- pMem->flags = MEM_Str|MEM_Term|MEM_Short;
- pMem->n = sprintf(pMem->zShort, "%.2x", pOp->p5); /* P5 */
- pMem->z = pMem->zShort;
+ if( sqlite3VdbeMemGrow(pMem, 32, 0) ){
+ p->db->mallocFailed = 1;
+ return SQLITE_NOMEM;
+ }
+ pMem->flags = MEM_Dyn|MEM_Str|MEM_Term;
+ pMem->n = sprintf(pMem->z, "%.2x", pOp->p5); /* P5 */
pMem->type = SQLITE_TEXT;
pMem->enc = SQLITE_UTF8;
pMem++;
static void Cleanup(Vdbe *p){
int i;
closeAllCursorsExceptActiveVtabs(p);
+ for(i=1; i<=p->nMem; i++){
+ MemSetTypeFlag(&p->aMem[i], MEM_Null);
+ }
releaseMemArray(&p->aMem[1], p->nMem);
sqlite3VdbeFifoClear(&p->sFifo);
if( p->contextStack ){
Mem mem2;
mem1.enc = pKeyInfo->enc;
mem1.db = pKeyInfo->db;
+ mem1.flags = 0;
mem2.enc = pKeyInfo->enc;
mem2.db = pKeyInfo->db;
+ mem2.flags = 0;
idx1 = GetVarint(aKey1, szHdr1);
d1 = szHdr1;
/* Do the comparison
*/
rc = sqlite3MemCompare(&mem1, &mem2, i<nField ? pKeyInfo->aColl[i] : 0);
- if( mem1.flags & MEM_Dyn ) sqlite3VdbeMemRelease(&mem1);
- if( mem2.flags & MEM_Dyn ) sqlite3VdbeMemRelease(&mem2);
+ if( mem1.flags&MEM_Dyn ) sqlite3VdbeMemRelease(&mem1);
+ if( mem2.flags&MEM_Dyn ) sqlite3VdbeMemRelease(&mem2);
if( rc!=0 ){
break;
}
if( nCellKey<=0 ){
return SQLITE_CORRUPT_BKPT;
}
+ m.flags = 0;
+ m.db = 0;
rc = sqlite3VdbeMemFromBtree(pCur, 0, nCellKey, 1, &m);
if( rc ){
return rc;
*res = 0;
return SQLITE_OK;
}
+ m.db = 0;
+ m.flags = 0;
rc = sqlite3VdbeMemFromBtree(pC->pCursor, 0, nCellKey, 1, &m);
if( rc ){
return rc;
#endif
}
+/*
+** Make sure pMem->z points to a writable allocation of at least
+** n bytes.
+**
+** If the memory cell currently contains string or blob data
+** and the third argument passed to this function is true, the
+** current content of the cell is preserved. Otherwise, it may
+** be discarded.
+**
+** This function sets the MEM_Dyn flag and clears any xDel callback.
+** It also clears MEM_Ephem and MEM_Static. If the preserve flag is
+** not set, Mem.n is zeroed.
+*/
+int sqlite3VdbeMemGrow(Mem *pMem, int n, int preserve){
+ int f = pMem->flags;
+
+ assert( (f & (MEM_Dyn|MEM_Static|MEM_Ephem))==0
+ || (f & (MEM_Dyn|MEM_Static|MEM_Ephem))==MEM_Dyn
+ || (f & (MEM_Dyn|MEM_Static|MEM_Ephem))==MEM_Ephem
+ || (f & (MEM_Dyn|MEM_Static|MEM_Ephem))==MEM_Static
+ );
+
+ if( ((f&MEM_Dyn)==0 || pMem->xDel || sqlite3MallocSize(pMem->z)<n) ){
+
+ /* Allocate the new buffer. The minimum allocation size is 32 bytes. */
+ char *z = 0;
+ if( n>0 ){
+ if( preserve && (f&MEM_Dyn) && !pMem->xDel ){
+ z = sqlite3DbReallocOrFree(pMem->db, pMem->z, n);
+ pMem->z = 0;
+ preserve = 0;
+ }else{
+ z = sqlite3DbMallocRaw(pMem->db, (n>32?n:32));
+ }
+ if( !z ){
+ return SQLITE_NOMEM;
+ }
+ }
+
+ /* If the value is currently a string or blob and the preserve flag
+ ** is true, copy the content to the new buffer.
+ */
+ if( pMem->flags&(MEM_Blob|MEM_Str) && preserve ){
+ int nCopy = (pMem->n>n?n:pMem->n);
+ memcpy(z, pMem->z, nCopy);
+ }
+
+ /* Release the old buffer. */
+ sqlite3VdbeMemRelease(pMem);
+
+ pMem->z = z;
+ pMem->flags |= MEM_Dyn;
+ pMem->flags &= ~(MEM_Ephem|MEM_Static);
+ pMem->xDel = 0;
+ }
+ return SQLITE_OK;
+}
+
/*
** Make the given Mem object MEM_Dyn.
**
** Return SQLITE_OK on success or SQLITE_NOMEM if malloc fails.
*/
int sqlite3VdbeMemDynamicify(Mem *pMem){
- int n;
- u8 *z;
+ int f;
assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
expandBlob(pMem);
- if( (pMem->flags & (MEM_Ephem|MEM_Static|MEM_Short))==0 ){
- return SQLITE_OK;
- }
- assert( (pMem->flags & MEM_Dyn)==0 );
- n = pMem->n;
- assert( pMem->flags & (MEM_Str|MEM_Blob) );
- z = sqlite3DbMallocRaw(pMem->db, n+2 );
- if( z==0 ){
- return SQLITE_NOMEM;
+ f = pMem->flags;
+ if( (f&(MEM_Str|MEM_Blob)) && ((f&MEM_Dyn)==0 || pMem->xDel) ){
+ if( sqlite3VdbeMemGrow(pMem, pMem->n + 2, 1) ){
+ return SQLITE_NOMEM;
+ }
+ pMem->z[pMem->n] = 0;
+ pMem->z[pMem->n+1] = 0;
+ pMem->flags |= MEM_Term;
}
- pMem->flags |= MEM_Dyn|MEM_Term;
- pMem->xDel = 0;
- memcpy(z, pMem->z, n );
- z[n] = 0;
- z[n+1] = 0;
- pMem->z = (char*)z;
- pMem->flags &= ~(MEM_Ephem|MEM_Static|MEM_Short);
+
return SQLITE_OK;
}
#ifndef SQLITE_OMIT_INCRBLOB
int sqlite3VdbeMemExpandBlob(Mem *pMem){
if( pMem->flags & MEM_Zero ){
- char *pNew;
int nByte;
- assert( (pMem->flags & MEM_Blob)!=0 );
- nByte = pMem->n + pMem->u.i;
- if( nByte<=0 ) nByte = 1;
+ assert( pMem->flags&MEM_Blob );
assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
- pNew = sqlite3DbMallocRaw(pMem->db, nByte);
- if( pNew==0 ){
+
+ /* Set nByte to the number of bytes required to store the expanded blob. */
+ nByte = pMem->n + pMem->u.i;
+ if( nByte<=0 ){
+ nByte = 1;
+ }
+ if( sqlite3VdbeMemGrow(pMem, nByte, 1) ){
return SQLITE_NOMEM;
}
- memcpy(pNew, pMem->z, pMem->n);
- memset(&pNew[pMem->n], 0, pMem->u.i);
- sqlite3VdbeMemRelease(pMem);
- pMem->z = pNew;
+
+ memset(&pMem->z[pMem->n], 0, pMem->u.i);
pMem->n += pMem->u.i;
- pMem->u.i = 0;
- pMem->flags &= ~(MEM_Zero|MEM_Static|MEM_Ephem|MEM_Short|MEM_Term);
- pMem->flags |= MEM_Dyn;
+ pMem->flags &= ~(MEM_Zero|MEM_Term);
}
return SQLITE_OK;
}
** Return SQLITE_OK on success or SQLITE_NOMEM if malloc fails.
*/
int sqlite3VdbeMemMakeWriteable(Mem *pMem){
- int n;
- u8 *z;
- assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
- expandBlob(pMem);
- if( (pMem->flags & (MEM_Ephem|MEM_Static))==0 ){
- return SQLITE_OK;
- }
- assert( (pMem->flags & MEM_Dyn)==0 );
- assert( pMem->flags & (MEM_Str|MEM_Blob) );
- if( (n = pMem->n)+2<sizeof(pMem->zShort) ){
- z = (u8*)pMem->zShort;
- pMem->flags |= MEM_Short|MEM_Term;
- }else{
- z = sqlite3DbMallocRaw(pMem->db, n+2 );
- if( z==0 ){
- return SQLITE_NOMEM;
- }
- pMem->flags |= MEM_Dyn|MEM_Term;
- pMem->xDel = 0;
- }
- memcpy(z, pMem->z, n );
- z[n] = 0;
- z[n+1] = 0;
- pMem->z = (char*)z;
- pMem->flags &= ~(MEM_Ephem|MEM_Static);
- assert(0==(1&(int)pMem->z));
- return SQLITE_OK;
+ return sqlite3VdbeMemDynamicify(pMem);
}
/*
if( (pMem->flags & MEM_Term)!=0 || (pMem->flags & MEM_Str)==0 ){
return SQLITE_OK; /* Nothing to do */
}
- if( pMem->flags & (MEM_Static|MEM_Ephem) ){
- return sqlite3VdbeMemMakeWriteable(pMem);
- }else{
- char *z;
- sqlite3VdbeMemExpandBlob(pMem);
- z = sqlite3DbMallocRaw(pMem->db, pMem->n+2);
- if( !z ){
- return SQLITE_NOMEM;
- }
- memcpy(z, pMem->z, pMem->n);
- z[pMem->n] = 0;
- z[pMem->n+1] = 0;
- if( pMem->xDel ){
- pMem->xDel(pMem->z);
- }else{
- sqlite3_free(pMem->z);
- }
- pMem->xDel = 0;
- pMem->z = z;
- pMem->flags |= MEM_Term;
+ if( sqlite3VdbeMemGrow(pMem, pMem->n+2, 1) ){
+ return SQLITE_NOMEM;
}
+ pMem->z[pMem->n] = 0;
+ pMem->z[pMem->n+1] = 0;
+ pMem->flags |= MEM_Term;
return SQLITE_OK;
}
int sqlite3VdbeMemStringify(Mem *pMem, int enc){
int rc = SQLITE_OK;
int fg = pMem->flags;
- char *z = pMem->zShort;
+ const int nByte = 32;
assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
assert( !(fg&MEM_Zero) );
assert( !(fg&(MEM_Str|MEM_Blob)) );
assert( fg&(MEM_Int|MEM_Real) );
- /* For a Real or Integer, use sqlite3_snprintf() to produce the UTF-8
+ if( sqlite3VdbeMemGrow(pMem, nByte, 0) ){
+ return SQLITE_NOMEM;
+ }
+
+ /* For a Real or Integer, use sqlite3_mprintf() to produce the UTF-8
** string representation of the value. Then, if the required encoding
** is UTF-16le or UTF-16be do a translation.
**
** FIX ME: It would be better if sqlite3_snprintf() could do UTF-16.
*/
if( fg & MEM_Int ){
- sqlite3_snprintf(NBFS, z, "%lld", pMem->u.i);
+ sqlite3_snprintf(nByte, pMem->z, "%lld", pMem->u.i);
}else{
assert( fg & MEM_Real );
- sqlite3_snprintf(NBFS, z, "%!.15g", pMem->r);
+ sqlite3_snprintf(nByte, pMem->z, "%!.15g", pMem->r);
}
- pMem->n = strlen(z);
- pMem->z = z;
+ pMem->n = strlen(pMem->z);
pMem->enc = SQLITE_UTF8;
- pMem->flags |= MEM_Str | MEM_Short | MEM_Term;
+ pMem->flags |= MEM_Str|MEM_Term;
sqlite3VdbeChangeEncoding(pMem, enc);
return rc;
}
assert( (pMem->flags & MEM_Null)!=0 || pFunc==pMem->u.pDef );
assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
ctx.s.flags = MEM_Null;
- ctx.s.z = pMem->zShort;
ctx.s.db = pMem->db;
ctx.pMem = pMem;
ctx.pFunc = pFunc;
ctx.isError = 0;
pFunc->xFinalize(&ctx);
- if( pMem->z && pMem->z!=pMem->zShort ){
+ if( pMem->z ){
sqlite3_free( pMem->z );
}
*pMem = ctx.s;
- if( pMem->flags & MEM_Short ){
- pMem->z = pMem->zShort;
- }
rc = (ctx.isError?SQLITE_ERROR:SQLITE_OK);
}
return rc;
}
}
+static void setTypeFlag(Mem *pMem, int f){
+ MemSetTypeFlag(pMem, f);
+}
+
/*
** Convert pMem to type integer. Invalidate any prior representations.
*/
int sqlite3VdbeMemIntegerify(Mem *pMem){
assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
pMem->u.i = sqlite3VdbeIntValue(pMem);
- sqlite3VdbeMemRelease(pMem);
- pMem->flags = MEM_Int;
+ setTypeFlag(pMem, MEM_Int);
return SQLITE_OK;
}
int sqlite3VdbeMemRealify(Mem *pMem){
assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
pMem->r = sqlite3VdbeRealValue(pMem);
- sqlite3VdbeMemRelease(pMem);
- pMem->flags = MEM_Real;
+ setTypeFlag(pMem, MEM_Real);
return SQLITE_OK;
}
sqlite3VdbeMemIntegerify(pMem);
}else{
pMem->r = r1;
- pMem->flags = MEM_Real;
- sqlite3VdbeMemRelease(pMem);
+ setTypeFlag(pMem, MEM_Real);
}
return SQLITE_OK;
}
** Delete any previous value and set the value stored in *pMem to NULL.
*/
void sqlite3VdbeMemSetNull(Mem *pMem){
- sqlite3VdbeMemRelease(pMem);
- pMem->flags = MEM_Null;
+ setTypeFlag(pMem, MEM_Null);
pMem->type = SQLITE_NULL;
- pMem->n = 0;
}
/*
*/
void sqlite3VdbeMemSetZeroBlob(Mem *pMem, int n){
sqlite3VdbeMemRelease(pMem);
- pMem->flags = MEM_Blob|MEM_Zero|MEM_Short;
+ setTypeFlag(pMem, MEM_Blob);
+ pMem->flags = MEM_Blob|MEM_Zero;
pMem->type = SQLITE_BLOB;
pMem->n = 0;
if( n<0 ) n = 0;
pMem->u.i = n;
- pMem->z = pMem->zShort;
pMem->enc = SQLITE_UTF8;
}
*/
void sqlite3VdbeMemShallowCopy(Mem *pTo, const Mem *pFrom, int srcType){
sqlite3VdbeMemRelease(pTo);
- memcpy(pTo, pFrom, sizeof(*pFrom)-sizeof(pFrom->zShort));
+ memcpy(pTo, pFrom, sizeof(*pFrom));
pTo->xDel = 0;
- if( pTo->flags & (MEM_Str|MEM_Blob) ){
- pTo->flags &= ~(MEM_Dyn|MEM_Static|MEM_Short|MEM_Ephem);
+ if( pTo->flags&MEM_Dyn ){
+ pTo->flags &= ~(MEM_Dyn|MEM_Static|MEM_Ephem);
assert( srcType==MEM_Ephem || srcType==MEM_Static );
pTo->flags |= srcType;
}
** freed before the copy is made.
*/
int sqlite3VdbeMemCopy(Mem *pTo, const Mem *pFrom){
- int rc;
- sqlite3VdbeMemShallowCopy(pTo, pFrom, MEM_Ephem);
- if( pTo->flags & MEM_Ephem ){
- rc = sqlite3VdbeMemMakeWriteable(pTo);
+ int rc = SQLITE_OK;
+ char *zBuf = 0;
+
+ /* If cell pTo currently has a reusable buffer, save a pointer to it
+ ** in local variable zBuf. This function attempts to avoid freeing
+ ** this buffer.
+ */
+ if( pTo->xDel ){
+ sqlite3VdbeMemRelease(pTo);
+ }else if( pTo->flags&MEM_Dyn ){
+ zBuf = pTo->z;
+ }
+
+ /* Copy the contents of *pFrom to *pTo */
+ memcpy(pTo, pFrom, sizeof(*pFrom));
+
+ if( pTo->flags&(MEM_Str|MEM_Blob) && pTo->flags&MEM_Static ){
+ /* pFrom contained a pointer to a static string. In this case,
+ ** free any dynamically allocated buffer associated with pTo.
+ */
+ sqlite3_free(zBuf);
}else{
- rc = SQLITE_OK;
+ char *zData = pTo->z;
+
+ pTo->z = zBuf;
+ pTo->flags &= ~(MEM_Static|MEM_Ephem);
+ pTo->flags |= MEM_Dyn;
+ pTo->xDel = 0;
+
+ if( pTo->flags&(MEM_Str|MEM_Blob) ){
+ if( sqlite3VdbeMemGrow(pTo, pTo->n+2, 0) ){
+ pTo->n = 0;
+ rc = SQLITE_NOMEM;
+ }else{
+ memcpy(pTo->z, zData, pTo->n);
+ pTo->z[pTo->n] = '\0';
+ pTo->z[pTo->n+1] = '\0';
+ pTo->flags |= MEM_Term;
+ }
+ }
}
return rc;
}
sqlite3VdbeMemRelease(pTo);
}
memcpy(pTo, pFrom, sizeof(Mem));
- if( pFrom->flags & MEM_Short ){
- pTo->z = pTo->zShort;
- }
pFrom->flags = MEM_Null;
pFrom->xDel = 0;
}
/*
** Change the value of a Mem to be a string or a BLOB.
+**
+** The memory management strategy depends on the value of the xDel
+** parameter. If the value passed is SQLITE_TRANSIENT, then the
+** string is copied into a (possibly existing) buffer managed by the
+** Mem structure. Otherwise, any existing buffer is freed and the
+** pointer copied.
*/
int sqlite3VdbeMemSetStr(
Mem *pMem, /* Memory cell to set to string value */
u8 enc, /* Encoding of z. 0 for BLOBs */
void (*xDel)(void*) /* Destructor function */
){
+ int nByte = n; /* New value for pMem->n */
+ int flags = 0; /* New value for pMem->flags */
+
assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
- sqlite3VdbeMemRelease(pMem);
+
+ /* If z is a NULL pointer, set pMem to contain an SQL NULL. */
if( !z ){
- pMem->flags = MEM_Null;
- pMem->type = SQLITE_NULL;
+ sqlite3VdbeMemSetNull(pMem);
return SQLITE_OK;
}
- pMem->z = (char *)z;
- if( xDel==SQLITE_STATIC ){
- pMem->flags = MEM_Static;
- }else if( xDel==SQLITE_TRANSIENT ){
- pMem->flags = MEM_Ephem;
+
+ flags = (enc==0?MEM_Blob:MEM_Str);
+ if( nByte<0 ){
+ assert( enc!=0 );
+ nByte = ((enc==SQLITE_UTF8)?strlen(z):sqlite3Utf16ByteLen(z, -1));
+ flags |= MEM_Term;
+ }
+
+ /* The following block sets the new values of Mem.z and Mem.xDel. It
+ ** also sets a flag in local variable "flags" to indicate the memory
+ ** management (one of MEM_Dyn or MEM_Static).
+ */
+ if( xDel==SQLITE_TRANSIENT ){
+ int nAlloc = nByte;
+ if( flags&MEM_Term ){
+ nAlloc += (enc==SQLITE_UTF8?1:2);
+ }
+ if( sqlite3VdbeMemGrow(pMem, nAlloc, 0) ){
+ return SQLITE_NOMEM;
+ }
+ memcpy(pMem->z, z, nAlloc);
+ flags |= MEM_Dyn;
}else{
- pMem->flags = MEM_Dyn;
+ sqlite3VdbeMemRelease(pMem);
+ pMem->z = (char *)z;
pMem->xDel = xDel;
+ flags |= ((xDel==SQLITE_STATIC)?MEM_Static:MEM_Dyn);
}
- pMem->enc = enc;
- pMem->type = enc==0 ? SQLITE_BLOB : SQLITE_TEXT;
- pMem->n = n;
-
- assert( enc==0 || enc==SQLITE_UTF8 || enc==SQLITE_UTF16LE
- || enc==SQLITE_UTF16BE );
- switch( enc ){
- case 0:
- pMem->flags |= MEM_Blob;
- pMem->enc = SQLITE_UTF8;
- break;
-
- case SQLITE_UTF8:
- pMem->flags |= MEM_Str;
- if( n<0 ){
- pMem->n = strlen(z);
- pMem->flags |= MEM_Term;
- }
- break;
+ pMem->n = nByte;
+ pMem->flags = flags;
+ pMem->enc = (enc==0 ? SQLITE_UTF8 : enc);
+ pMem->type = (enc==0 ? SQLITE_BLOB : SQLITE_TEXT);
#ifndef SQLITE_OMIT_UTF16
- case SQLITE_UTF16LE:
- case SQLITE_UTF16BE:
- pMem->flags |= MEM_Str;
- if( pMem->n<0 ){
- pMem->n = sqlite3Utf16ByteLen(pMem->z,-1);
- pMem->flags |= MEM_Term;
- }
- if( sqlite3VdbeMemHandleBom(pMem) ){
- return SQLITE_NOMEM;
- }
-#endif /* SQLITE_OMIT_UTF16 */
- }
- if( pMem->flags&MEM_Ephem ){
- return sqlite3VdbeMemMakeWriteable(pMem);
+ if( pMem->enc!=SQLITE_UTF8 && sqlite3VdbeMemHandleBom(pMem) ){
+ return SQLITE_NOMEM;
}
+#endif
+
return SQLITE_OK;
}
char *zData; /* Data from the btree layer */
int available = 0; /* Number of bytes available on the local btree page */
sqlite3 *db; /* Database connection */
+ int rc = SQLITE_OK;
db = sqlite3BtreeCursorDb(pCur);
assert( sqlite3_mutex_held(db->mutex) );
}
assert( zData!=0 );
- pMem->db = db;
- pMem->n = amt;
- if( offset+amt<=available ){
+ if( offset+amt<=available && ((pMem->flags&MEM_Dyn)==0 || pMem->xDel) ){
+ sqlite3VdbeMemRelease(pMem);
pMem->z = &zData[offset];
pMem->flags = MEM_Blob|MEM_Ephem;
- }else{
- int rc;
- if( amt>NBFS-2 ){
- zData = (char *)sqlite3DbMallocRaw(db, amt+2);
- if( !zData ){
- return SQLITE_NOMEM;
- }
- pMem->flags = MEM_Blob|MEM_Dyn|MEM_Term;
- pMem->xDel = 0;
- }else{
- zData = &(pMem->zShort[0]);
- pMem->flags = MEM_Blob|MEM_Short|MEM_Term;
- }
- pMem->z = zData;
+ }else if( SQLITE_OK==(rc = sqlite3VdbeMemGrow(pMem, amt+2, 0)) ){
+ pMem->flags = MEM_Blob|MEM_Dyn|MEM_Term;
pMem->enc = 0;
pMem->type = SQLITE_BLOB;
-
if( key ){
- rc = sqlite3BtreeKey(pCur, offset, amt, zData);
+ rc = sqlite3BtreeKey(pCur, offset, amt, pMem->z);
}else{
- rc = sqlite3BtreeData(pCur, offset, amt, zData);
+ rc = sqlite3BtreeData(pCur, offset, amt, pMem->z);
}
- zData[amt] = 0;
- zData[amt+1] = 0;
+ pMem->z[amt] = 0;
+ pMem->z[amt+1] = 0;
if( rc!=SQLITE_OK ){
- if( amt>NBFS-2 ){
- assert( zData!=pMem->zShort );
- assert( pMem->flags & MEM_Dyn );
- sqlite3_free(zData);
- } else {
- assert( zData==pMem->zShort );
- assert( pMem->flags & MEM_Short );
- }
- return rc;
+ sqlite3VdbeMemRelease(pMem);
}
}
+ pMem->n = amt;
- return SQLITE_OK;
+ return rc;
}
#if 0
*/
void sqlite3ValueFree(sqlite3_value *v){
if( !v ) return;
- sqlite3ValueSetStr(v, 0, 0, SQLITE_UTF8, SQLITE_STATIC);
+ sqlite3VdbeMemRelease((Mem *)v);
sqlite3_free(v);
}
# that they have little in common.
#
#
-# $Id: mallocB.test,v 1.7 2008/01/17 20:26:47 drh Exp $
+# $Id: mallocB.test,v 1.8 2008/02/13 18:25:27 danielk1977 Exp $
set testdir [file dirname $argv0]
source $testdir/tester.tcl
do_malloc_test mallocB-1 -sqlbody {SELECT - 456}
do_malloc_test mallocB-2 -sqlbody {SELECT - 456.1}
do_malloc_test mallocB-3 -sqlbody {SELECT random()}
-do_malloc_test mallocB-4 -sqlbody {SELECT zeroblob(1000)}
+do_malloc_test mallocB-4 -sqlbody {SELECT length(zeroblob(1000))}
ifcapable subquery {
do_malloc_test mallocB-5 -sqlbody {SELECT * FROM (SELECT 1) GROUP BY 1;}
}
# sqlite3_value_bytes()
# sqlite3_value_bytes16()
#
-# $Id: ptrchng.test,v 1.2 2007/09/12 17:01:45 danielk1977 Exp $
+# $Id: ptrchng.test,v 1.3 2008/02/13 18:25:27 danielk1977 Exp $
set testdir [file dirname $argv0]
source $testdir/tester.tcl
# For the short entries that fit in the Mem.zBuf[], the pointer should
# never change regardless of what type conversions occur.
#
+# UPDATE: No longer true, as Mem.zBuf[] has been removed.
+#
do_test ptrchng-2.1 {
execsql {
SELECT pointer_change(y, 'text', 'noop', 'blob') FROM t1 WHERE x=1
execsql {
SELECT pointer_change(y, 'blob', 'noop', 'text') FROM t1 WHERE x=1
}
-} {0}
+} {1}
ifcapable utf16 {
do_test ptrchng-2.3 {
execsql {
SELECT pointer_change(y, 'text', 'noop', 'text16') FROM t1 WHERE x=1
}
- } {0}
+ } {1}
do_test ptrchng-2.4 {
execsql {
SELECT pointer_change(y, 'blob', 'noop', 'text16') FROM t1 WHERE x=1
}
- } {0}
+ } {1}
do_test ptrchng-2.5 {
execsql {
SELECT pointer_change(y, 'text16', 'noop', 'blob') FROM t1 WHERE x=1
execsql {
SELECT pointer_change(y, 'text16', 'noop', 'text') FROM t1 WHERE x=1
}
- } {0}
+ } {1}
}
do_test ptrchng-2.11 {
execsql {
execsql {
SELECT pointer_change(y, 'blob', 'noop', 'text') FROM t1 WHERE x=3
}
-} {0}
+} {1}
ifcapable utf16 {
do_test ptrchng-2.13 {
execsql {
SELECT pointer_change(y, 'text', 'noop', 'text16') FROM t1 WHERE x=3
}
- } {0}
+ } {1}
do_test ptrchng-2.14 {
execsql {
SELECT pointer_change(y, 'blob', 'noop', 'text16') FROM t1 WHERE x=3
}
- } {0}
+ } {1}
do_test ptrchng-2.15 {
execsql {
SELECT pointer_change(y, 'text16', 'noop', 'blob') FROM t1 WHERE x=3
execsql {
SELECT pointer_change(y, 'text16', 'noop', 'text') FROM t1 WHERE x=3
}
- } {0}
+ } {1}
}
# For the long entries that do not fit in the Mem.zBuf[], the pointer
execsql {
SELECT pointer_change(y, 'blob', 'noop', 'text') FROM t1 WHERE x=2
}
-} {0}
+} {1}
ifcapable utf16 {
do_test ptrchng-3.3 {
execsql {
execsql {
SELECT pointer_change(y, 'blob', 'noop', 'text') FROM t1 WHERE x=4
}
-} {0}
+} {1}
ifcapable utf16 {
do_test ptrchng-3.13 {
execsql {
# This file implements some common TCL routines used for regression
# testing the SQLite library
#
-# $Id: tester.tcl,v 1.103 2008/02/08 18:25:30 danielk1977 Exp $
+# $Id: tester.tcl,v 1.104 2008/02/13 18:25:27 danielk1977 Exp $
set tcl_precision 15
}
puts "Maximum memory usage: [sqlite3_memory_highwater 1] bytes"
puts "Current memory usage: [sqlite3_memory_highwater] bytes"
+ if {[info commands sqlite3_memdebug_malloc_count] ne ""} {
+ puts "Number of malloc() : [sqlite3_memdebug_malloc_count] calls"
+ }
foreach f [glob -nocomplain test.db-*-journal] {
file delete -force $f
}
projects / thirdparty / sqlite.git / commitdiff
