Make sure all memory from sqlite3DbMalloc() is freed by sqlite3DbFree()
and all memory from sqlite3_malloc() is freed by sqlite3_free().
FossilOrigin-Name: 629e38a8c9e31111e351fe4625a5835576d23584
diff --git a/src/analyze.c b/src/analyze.c
index d96deb3..42705ca 100644
--- a/src/analyze.c
+++ b/src/analyze.c
@@ -591,7 +591,7 @@
if( pIdx->aSample==0 ){
static const int sz = sizeof(IndexSample)*SQLITE_INDEX_SAMPLES;
- pIdx->aSample = (IndexSample *)sqlite3Malloc(sz);
+ pIdx->aSample = (IndexSample *)sqlite3DbMallocRaw(0, sz);
if( pIdx->aSample==0 ){
db->mallocFailed = 1;
break;
@@ -619,10 +619,8 @@
if( n < 1){
pSample->u.z = 0;
}else{
- pSample->u.z = sqlite3Malloc(n);
- if( pSample->u.z ){
- memcpy(pSample->u.z, z, n);
- }else{
+ pSample->u.z = sqlite3DbStrNDup(0, z, n);
+ if( pSample->u.z==0 ){
db->mallocFailed = 1;
break;
}
diff --git a/src/btree.c b/src/btree.c
index f47614a..d07e4c3 100644
--- a/src/btree.c
+++ b/src/btree.c
@@ -2004,7 +2004,7 @@
if( pBt->xFreeSchema && pBt->pSchema ){
pBt->xFreeSchema(pBt->pSchema);
}
- sqlite3_free(pBt->pSchema);
+ sqlite3DbFree(0, pBt->pSchema);
freeTempSpace(pBt);
sqlite3_free(pBt);
}
@@ -7749,6 +7749,7 @@
sCheck.anRef[i] = 1;
}
sqlite3StrAccumInit(&sCheck.errMsg, zErr, sizeof(zErr), 20000);
+ sCheck.errMsg.useMalloc = 2;
/* Check the integrity of the freelist
*/
@@ -7886,7 +7887,7 @@
BtShared *pBt = p->pBt;
sqlite3BtreeEnter(p);
if( !pBt->pSchema && nBytes ){
- pBt->pSchema = sqlite3MallocZero(nBytes);
+ pBt->pSchema = sqlite3DbMallocZero(0, nBytes);
pBt->xFreeSchema = xFree;
}
sqlite3BtreeLeave(p);
diff --git a/src/build.c b/src/build.c
index 989489f..1281af6 100644
--- a/src/build.c
+++ b/src/build.c
@@ -1351,7 +1351,7 @@
zEnd = "\n)";
}
n += 35 + 6*p->nCol;
- zStmt = sqlite3Malloc( n );
+ zStmt = sqlite3DbMallocRaw(0, n);
if( zStmt==0 ){
db->mallocFailed = 1;
return 0;
@@ -2800,7 +2800,7 @@
/* Clean up before exiting */
exit_create_index:
if( pIndex ){
- sqlite3_free(pIndex->zColAff);
+ sqlite3DbFree(db, pIndex->zColAff);
sqlite3DbFree(db, pIndex);
}
sqlite3ExprListDelete(db, pList);
diff --git a/src/callback.c b/src/callback.c
index f8918bc..fdcc9f9 100644
--- a/src/callback.c
+++ b/src/callback.c
@@ -439,7 +439,7 @@
if( pBt ){
p = (Schema *)sqlite3BtreeSchema(pBt, sizeof(Schema), sqlite3SchemaFree);
}else{
- p = (Schema *)sqlite3MallocZero(sizeof(Schema));
+ p = (Schema *)sqlite3DbMallocZero(0, sizeof(Schema));
}
if( !p ){
db->mallocFailed = 1;
diff --git a/src/func.c b/src/func.c
index 8b1b2f7..15d7a5b 100644
--- a/src/func.c
+++ b/src/func.c
@@ -1010,14 +1010,14 @@
testcase( nOut-2==db->aLimit[SQLITE_LIMIT_LENGTH] );
if( nOut-1>db->aLimit[SQLITE_LIMIT_LENGTH] ){
sqlite3_result_error_toobig(context);
- sqlite3DbFree(db, zOut);
+ sqlite3_free(zOut);
return;
}
zOld = zOut;
zOut = sqlite3_realloc(zOut, (int)nOut);
if( zOut==0 ){
sqlite3_result_error_nomem(context);
- sqlite3DbFree(db, zOld);
+ sqlite3_free(zOld);
return;
}
memcpy(&zOut[j], zRep, nRep);
@@ -1378,7 +1378,7 @@
if( pAccum ){
sqlite3 *db = sqlite3_context_db_handle(context);
int firstTerm = pAccum->useMalloc==0;
- pAccum->useMalloc = 1;
+ pAccum->useMalloc = 2;
pAccum->mxAlloc = db->aLimit[SQLITE_LIMIT_LENGTH];
if( !firstTerm ){
if( argc==2 ){
diff --git a/src/insert.c b/src/insert.c
index f6ad5ab..b8aa91b 100644
--- a/src/insert.c
+++ b/src/insert.c
@@ -67,7 +67,7 @@
int n;
Table *pTab = pIdx->pTable;
sqlite3 *db = sqlite3VdbeDb(v);
- pIdx->zColAff = (char *)sqlite3Malloc(pIdx->nColumn+2);
+ pIdx->zColAff = (char *)sqlite3DbMallocRaw(0, pIdx->nColumn+2);
if( !pIdx->zColAff ){
db->mallocFailed = 1;
return 0;
@@ -109,7 +109,7 @@
int i;
sqlite3 *db = sqlite3VdbeDb(v);
- zColAff = (char *)sqlite3Malloc(pTab->nCol+1);
+ zColAff = (char *)sqlite3DbMallocRaw(0, pTab->nCol+1);
if( !zColAff ){
db->mallocFailed = 1;
return;
diff --git a/src/loadext.c b/src/loadext.c
index 8fe35d9..835b8a8 100644
--- a/src/loadext.c
+++ b/src/loadext.c
@@ -376,13 +376,11 @@
handle = sqlite3OsDlOpen(pVfs, zFile);
if( handle==0 ){
if( pzErrMsg ){
- zErrmsg = sqlite3StackAllocZero(db, nMsg);
+ *pzErrMsg = zErrmsg = sqlite3_malloc(nMsg);
if( zErrmsg ){
sqlite3_snprintf(nMsg, zErrmsg,
"unable to open shared library [%s]", zFile);
sqlite3OsDlError(pVfs, nMsg-1, zErrmsg);
- *pzErrMsg = sqlite3DbStrDup(0, zErrmsg);
- sqlite3StackFree(db, zErrmsg);
}
}
return SQLITE_ERROR;
@@ -391,13 +389,11 @@
sqlite3OsDlSym(pVfs, handle, zProc);
if( xInit==0 ){
if( pzErrMsg ){
- zErrmsg = sqlite3StackAllocZero(db, nMsg);
+ *pzErrMsg = zErrmsg = sqlite3_malloc(nMsg);
if( zErrmsg ){
sqlite3_snprintf(nMsg, zErrmsg,
"no entry point [%s] in shared library [%s]", zProc,zFile);
sqlite3OsDlError(pVfs, nMsg-1, zErrmsg);
- *pzErrMsg = sqlite3DbStrDup(0, zErrmsg);
- sqlite3StackFree(db, zErrmsg);
}
sqlite3OsDlClose(pVfs, handle);
}
diff --git a/src/malloc.c b/src/malloc.c
index 05ea510..73508bd 100644
--- a/src/malloc.c
+++ b/src/malloc.c
@@ -368,6 +368,7 @@
|| p<sqlite3GlobalConfig.pScratch
|| p>=(void*)mem0.aScratchFree ){
assert( sqlite3MemdebugHasType(p, MEMTYPE_SCRATCH) );
+ assert( sqlite3MemdebugNoType(p, ~MEMTYPE_SCRATCH) );
sqlite3MemdebugSetType(p, MEMTYPE_HEAP);
if( sqlite3GlobalConfig.bMemstat ){
int iSize = sqlite3MallocSize(p);
@@ -408,7 +409,7 @@
*/
#ifndef SQLITE_OMIT_LOOKASIDE
static int isLookaside(sqlite3 *db, void *p){
- return db && p && p>=db->lookaside.pStart && p<db->lookaside.pEnd;
+ return p && p>=db->lookaside.pStart && p<db->lookaside.pEnd;
}
#else
#define isLookaside(A,B) 0
@@ -420,15 +421,17 @@
*/
int sqlite3MallocSize(void *p){
assert( sqlite3MemdebugHasType(p, MEMTYPE_HEAP) );
+ assert( sqlite3MemdebugNoType(p, MEMTYPE_DB) );
return sqlite3GlobalConfig.m.xSize(p);
}
int sqlite3DbMallocSize(sqlite3 *db, void *p){
assert( db==0 || sqlite3_mutex_held(db->mutex) );
- if( isLookaside(db, p) ){
+ if( db && isLookaside(db, p) ){
return db->lookaside.sz;
}else{
- assert( sqlite3MemdebugHasType(p,
- db ? (MEMTYPE_DB|MEMTYPE_HEAP) : MEMTYPE_HEAP) );
+ assert( sqlite3MemdebugHasType(p, MEMTYPE_DB) );
+ assert( sqlite3MemdebugHasType(p, MEMTYPE_LOOKASIDE|MEMTYPE_HEAP) );
+ assert( db!=0 || sqlite3MemdebugNoType(p, MEMTYPE_LOOKASIDE) );
return sqlite3GlobalConfig.m.xSize(p);
}
}
@@ -438,6 +441,7 @@
*/
void sqlite3_free(void *p){
if( p==0 ) return;
+ assert( sqlite3MemdebugNoType(p, MEMTYPE_DB) );
assert( sqlite3MemdebugHasType(p, MEMTYPE_HEAP) );
if( sqlite3GlobalConfig.bMemstat ){
sqlite3_mutex_enter(mem0.mutex);
@@ -455,23 +459,24 @@
*/
void sqlite3DbFree(sqlite3 *db, void *p){
assert( db==0 || sqlite3_mutex_held(db->mutex) );
- if( db && db->pnBytesFreed ){
- if( isLookaside(db, p) ){
- *db->pnBytesFreed += db->lookaside.sz;
- }else{
- *db->pnBytesFreed += sqlite3MallocSize(p);
+ if( db ){
+ if( db->pnBytesFreed ){
+ *db->pnBytesFreed += sqlite3DbMallocSize(db, p);
+ return;
}
- }else if( isLookaside(db, p) ){
- LookasideSlot *pBuf = (LookasideSlot*)p;
- pBuf->pNext = db->lookaside.pFree;
- db->lookaside.pFree = pBuf;
- db->lookaside.nOut--;
- }else{
- assert( sqlite3MemdebugHasType(p,
- db ? (MEMTYPE_DB|MEMTYPE_HEAP) : MEMTYPE_HEAP) );
- sqlite3MemdebugSetType(p, MEMTYPE_HEAP);
- sqlite3_free(p);
+ if( isLookaside(db, p) ){
+ LookasideSlot *pBuf = (LookasideSlot*)p;
+ pBuf->pNext = db->lookaside.pFree;
+ db->lookaside.pFree = pBuf;
+ db->lookaside.nOut--;
+ return;
+ }
}
+ assert( sqlite3MemdebugHasType(p, MEMTYPE_DB) );
+ assert( sqlite3MemdebugHasType(p, MEMTYPE_LOOKASIDE|MEMTYPE_HEAP) );
+ assert( db!=0 || sqlite3MemdebugNoType(p, MEMTYPE_LOOKASIDE) );
+ sqlite3MemdebugSetType(p, MEMTYPE_HEAP);
+ sqlite3_free(p);
}
/*
@@ -503,6 +508,7 @@
sqlite3MallocAlarm(nNew-nOld);
}
assert( sqlite3MemdebugHasType(pOld, MEMTYPE_HEAP) );
+ assert( sqlite3MemdebugNoType(pOld, ~MEMTYPE_HEAP) );
pNew = sqlite3GlobalConfig.m.xRealloc(pOld, nNew);
if( pNew==0 && mem0.alarmCallback ){
sqlite3MallocAlarm(nBytes);
@@ -600,8 +606,8 @@
if( !p && db ){
db->mallocFailed = 1;
}
- sqlite3MemdebugSetType(p,
- (db && db->lookaside.bEnabled) ? MEMTYPE_DB : MEMTYPE_HEAP);
+ sqlite3MemdebugSetType(p, MEMTYPE_DB |
+ ((db && db->lookaside.bEnabled) ? MEMTYPE_LOOKASIDE : MEMTYPE_HEAP));
return p;
}
@@ -627,14 +633,16 @@
sqlite3DbFree(db, p);
}
}else{
- assert( sqlite3MemdebugHasType(p, MEMTYPE_DB|MEMTYPE_HEAP) );
+ assert( sqlite3MemdebugHasType(p, MEMTYPE_DB) );
+ assert( sqlite3MemdebugHasType(p, MEMTYPE_LOOKASIDE|MEMTYPE_HEAP) );
sqlite3MemdebugSetType(p, MEMTYPE_HEAP);
pNew = sqlite3_realloc(p, n);
if( !pNew ){
+ sqlite3MemdebugSetType(p, MEMTYPE_DB|MEMTYPE_HEAP);
db->mallocFailed = 1;
}
- sqlite3MemdebugSetType(pNew,
- db->lookaside.bEnabled ? MEMTYPE_DB : MEMTYPE_HEAP);
+ sqlite3MemdebugSetType(pNew, MEMTYPE_DB |
+ (db->lookaside.bEnabled ? MEMTYPE_LOOKASIDE : MEMTYPE_HEAP));
}
}
return pNew;
diff --git a/src/mem2.c b/src/mem2.c
index a82fee8..528a020 100644
--- a/src/mem2.c
+++ b/src/mem2.c
@@ -401,19 +401,34 @@
struct MemBlockHdr *pHdr;
pHdr = sqlite3MemsysGetHeader(p);
assert( pHdr->iForeGuard==FOREGUARD ); /* Allocation is valid */
- assert( (pHdr->eType & (pHdr->eType-1))==0 ); /* Only one type bit set */
if( (pHdr->eType&eType)==0 ){
- void **pBt;
- pBt = (void**)pHdr;
- pBt -= pHdr->nBacktraceSlots;
- backtrace_symbols_fd(pBt, pHdr->nBacktrace, fileno(stderr));
- fprintf(stderr, "\n");
rc = 0;
}
}
return rc;
}
-
+
+/*
+** Return TRUE if the mask of type in eType matches no bits of the type of the
+** allocation p. Also return true if p==NULL.
+**
+** This routine is designed for use within an assert() statement, to
+** verify the type of an allocation. For example:
+**
+** assert( sqlite3MemdebugNoType(p, MEMTYPE_DB) );
+*/
+int sqlite3MemdebugNoType(void *p, u8 eType){
+ int rc = 1;
+ if( p ){
+ struct MemBlockHdr *pHdr;
+ pHdr = sqlite3MemsysGetHeader(p);
+ assert( pHdr->iForeGuard==FOREGUARD ); /* Allocation is valid */
+ if( (pHdr->eType&eType)!=0 ){
+ rc = 0;
+ }
+ }
+ return rc;
+}
/*
** Set the number of backtrace levels kept for each allocation.
diff --git a/src/notify.c b/src/notify.c
index 4c8ab00..fcab5bf 100644
--- a/src/notify.c
+++ b/src/notify.c
@@ -255,7 +255,7 @@
assert( aArg==aDyn || (aDyn==0 && aArg==aStatic) );
assert( nArg<=(int)ArraySize(aStatic) || aArg==aDyn );
if( (!aDyn && nArg==(int)ArraySize(aStatic))
- || (aDyn && nArg==(int)(sqlite3DbMallocSize(db, aDyn)/sizeof(void*)))
+ || (aDyn && nArg==(int)(sqlite3MallocSize(aDyn)/sizeof(void*)))
){
/* The aArg[] array needs to grow. */
void **pNew = (void **)sqlite3Malloc(nArg*sizeof(void *)*2);
diff --git a/src/pragma.c b/src/pragma.c
index 2428965..0f3ce3c 100644
--- a/src/pragma.c
+++ b/src/pragma.c
@@ -765,7 +765,7 @@
}
sqlite3_free(sqlite3_temp_directory);
if( zRight[0] ){
- sqlite3_temp_directory = sqlite3DbStrDup(0, zRight);
+ sqlite3_temp_directory = sqlite3_mprintf("%s", zRight);
}else{
sqlite3_temp_directory = 0;
}
diff --git a/src/printf.c b/src/printf.c
index 6ab230b..da2fdf6 100644
--- a/src/printf.c
+++ b/src/printf.c
@@ -772,7 +772,11 @@
}else{
p->nAlloc = (int)szNew;
}
- zNew = sqlite3DbMallocRaw(p->db, p->nAlloc );
+ if( p->useMalloc==1 ){
+ zNew = sqlite3DbMallocRaw(p->db, p->nAlloc );
+ }else{
+ zNew = sqlite3_malloc(p->nAlloc);
+ }
if( zNew ){
memcpy(zNew, p->zText, p->nChar);
sqlite3StrAccumReset(p);
@@ -797,7 +801,11 @@
if( p->zText ){
p->zText[p->nChar] = 0;
if( p->useMalloc && p->zText==p->zBase ){
- p->zText = sqlite3DbMallocRaw(p->db, p->nChar+1 );
+ if( p->useMalloc==1 ){
+ p->zText = sqlite3DbMallocRaw(p->db, p->nChar+1 );
+ }else{
+ p->zText = sqlite3_malloc(p->nChar+1);
+ }
if( p->zText ){
memcpy(p->zText, p->zBase, p->nChar+1);
}else{
@@ -813,7 +821,11 @@
*/
void sqlite3StrAccumReset(StrAccum *p){
if( p->zText!=p->zBase ){
- sqlite3DbFree(p->db, p->zText);
+ if( p->useMalloc==1 ){
+ sqlite3DbFree(p->db, p->zText);
+ }else{
+ sqlite3_free(p->zText);
+ }
}
p->zText = 0;
}
@@ -895,6 +907,7 @@
if( sqlite3_initialize() ) return 0;
#endif
sqlite3StrAccumInit(&acc, zBase, sizeof(zBase), SQLITE_MAX_LENGTH);
+ acc.useMalloc = 2;
sqlite3VXPrintf(&acc, 0, zFormat, ap);
z = sqlite3StrAccumFinish(&acc);
return z;
diff --git a/src/sqliteInt.h b/src/sqliteInt.h
index 66f1cff..0270576 100644
--- a/src/sqliteInt.h
+++ b/src/sqliteInt.h
@@ -2327,7 +2327,7 @@
int nAlloc; /* Amount of space allocated in zText */
int mxAlloc; /* Maximum allowed string length */
u8 mallocFailed; /* Becomes true if any memory allocation fails */
- u8 useMalloc; /* True if zText is enlargeable using realloc */
+ u8 useMalloc; /* 0: none, 1: sqlite3DbMalloc, 2: sqlite3_malloc */
u8 tooBig; /* Becomes true if string size exceeds limits */
};
@@ -3120,17 +3120,18 @@
** sqlite3MemdebugHasType() returns true if any of the bits in its second
** argument match the type set by the previous sqlite3MemdebugSetType().
** sqlite3MemdebugHasType() is intended for use inside assert() statements.
-** For example:
**
-** assert( sqlite3MemdebugHasType(p, MEMTYPE_HEAP) );
+** sqlite3MemdebugNoType() returns true if none of the bits in its second
+** argument match the type set by the previous sqlite3MemdebugSetType().
**
** Perhaps the most important point is the difference between MEMTYPE_HEAP
-** and MEMTYPE_DB. If an allocation is MEMTYPE_DB, that means it might have
-** been allocated by lookaside, except the allocation was too large or
-** lookaside was already full. It is important to verify that allocations
-** that might have been satisfied by lookaside are not passed back to
-** non-lookaside free() routines. Asserts such as the example above are
-** placed on the non-lookaside free() routines to verify this constraint.
+** and MEMTYPE_LOOKASIDE. If an allocation is MEMTYPE_LOOKASIDE, that means
+** it might have been allocated by lookaside, except the allocation was
+** too large or lookaside was already full. It is important to verify
+** that allocations that might have been satisfied by lookaside are not
+** passed back to non-lookaside free() routines. Asserts such as the
+** example above are placed on the non-lookaside free() routines to verify
+** this constraint.
**
** All of this is no-op for a production build. It only comes into
** play when the SQLITE_MEMDEBUG compile-time option is used.
@@ -3138,13 +3139,16 @@
#ifdef SQLITE_MEMDEBUG
void sqlite3MemdebugSetType(void*,u8);
int sqlite3MemdebugHasType(void*,u8);
+ int sqlite3MemdebugNoType(void*,u8);
#else
# define sqlite3MemdebugSetType(X,Y) /* no-op */
# define sqlite3MemdebugHasType(X,Y) 1
+# define sqlite3MemdebugNoType(X,Y) 1
#endif
-#define MEMTYPE_HEAP 0x01 /* General heap allocations */
-#define MEMTYPE_DB 0x02 /* Associated with a database connection */
-#define MEMTYPE_SCRATCH 0x04 /* Scratch allocations */
-#define MEMTYPE_PCACHE 0x08 /* Page cache allocations */
+#define MEMTYPE_HEAP 0x01 /* General heap allocations */
+#define MEMTYPE_LOOKASIDE 0x02 /* Might have been lookaside memory */
+#define MEMTYPE_SCRATCH 0x04 /* Scratch allocations */
+#define MEMTYPE_PCACHE 0x08 /* Page cache allocations */
+#define MEMTYPE_DB 0x10 /* Uses sqlite3DbMalloc, not sqlite_malloc */
#endif /* _SQLITEINT_H_ */
diff --git a/src/test4.c b/src/test4.c
index cb5087b..49447d3 100644
--- a/src/test4.c
+++ b/src/test4.c
@@ -142,7 +142,7 @@
}
threadset[i].busy = 1;
sqlite3_free(threadset[i].zFilename);
- threadset[i].zFilename = sqlite3DbStrDup(0, argv[2]);
+ threadset[i].zFilename = sqlite3_mprintf("%s", argv[2]);
threadset[i].opnum = 1;
threadset[i].completed = 0;
rc = pthread_create(&x, 0, thread_main, &threadset[i]);
@@ -476,7 +476,7 @@
thread_wait(&threadset[i]);
threadset[i].xOp = do_compile;
sqlite3_free(threadset[i].zArg);
- threadset[i].zArg = sqlite3DbStrDup(0, argv[2]);
+ threadset[i].zArg = sqlite3_mprintf("%s", argv[2]);
threadset[i].opnum++;
return TCL_OK;
}
diff --git a/src/test5.c b/src/test5.c
index dc7dafe..504fdb8 100644
--- a/src/test5.c
+++ b/src/test5.c
@@ -155,7 +155,7 @@
if( enc_from==SQLITE_UTF8 ){
z = Tcl_GetString(objv[1]);
if( objc==5 ){
- z = sqlite3DbStrDup(0, z);
+ z = sqlite3_mprintf("%s", z);
}
sqlite3ValueSetStr(pVal, -1, z, enc_from, xDel);
}else{
diff --git a/src/test7.c b/src/test7.c
index 77b3661..3383d86 100644
--- a/src/test7.c
+++ b/src/test7.c
@@ -164,7 +164,7 @@
}
threadset[i].busy = 1;
sqlite3_free(threadset[i].zFilename);
- threadset[i].zFilename = sqlite3DbStrDup(0, argv[2]);
+ threadset[i].zFilename = sqlite3_mprintf("%s", argv[2]);
threadset[i].opnum = 1;
threadset[i].completed = 0;
rc = pthread_create(&x, 0, client_main, &threadset[i]);
@@ -507,7 +507,7 @@
client_wait(&threadset[i]);
threadset[i].xOp = do_compile;
sqlite3_free(threadset[i].zArg);
- threadset[i].zArg = sqlite3DbStrDup(0, argv[2]);
+ threadset[i].zArg = sqlite3_mprintf("%s", argv[2]);
threadset[i].opnum++;
return TCL_OK;
}
diff --git a/src/test8.c b/src/test8.c
index 110aa65..b3e6058 100644
--- a/src/test8.c
+++ b/src/test8.c
@@ -485,7 +485,7 @@
rc = sqlite3_exec(db, zSql, 0, 0, 0);
sqlite3_free(zSql);
if( rc!=SQLITE_OK ){
- *pzErr = sqlite3DbStrDup(0, sqlite3_errmsg(db));
+ *pzErr = sqlite3_mprintf("%s", sqlite3_errmsg(db));
}
}
diff --git a/src/tokenize.c b/src/tokenize.c
index e8778e6..c624efd 100644
--- a/src/tokenize.c
+++ b/src/tokenize.c
@@ -496,7 +496,7 @@
}
#endif
#ifndef SQLITE_OMIT_VIRTUALTABLE
- sqlite3DbFree(db, pParse->apVtabLock);
+ sqlite3_free(pParse->apVtabLock);
#endif
if( !IN_DECLARE_VTAB ){
diff --git a/src/vdbe.c b/src/vdbe.c
index 6813837..29c2d49 100644
--- a/src/vdbe.c
+++ b/src/vdbe.c
@@ -502,6 +502,20 @@
#endif
/*
+** Transfer error message text from an sqlite3_vtab.zErrMsg (text stored
+** in memory obtained from sqlite3_malloc) into a Vdbe.zErrMsg (text stored
+** in memory obtained from sqlite3DbMalloc).
+*/
+static void importVtabErrMsg(Vdbe *p, sqlite3_vtab *pVtab){
+ sqlite3 *db = p->db;
+ sqlite3DbFree(db, p->zErrMsg);
+ p->zErrMsg = sqlite3DbStrDup(db, pVtab->zErrMsg);
+ sqlite3_free(pVtab->zErrMsg);
+ pVtab->zErrMsg = 0;
+}
+
+
+/*
** Execute as much of a VDBE program as we can then return.
**
** sqlite3VdbeMakeReady() must be called before this routine in order to
@@ -4030,9 +4044,7 @@
pModule = pVtab->pModule;
assert( pModule->xRowid );
rc = pModule->xRowid(pC->pVtabCursor, &v);
- sqlite3DbFree(db, p->zErrMsg);
- p->zErrMsg = pVtab->zErrMsg;
- pVtab->zErrMsg = 0;
+ importVtabErrMsg(p, pVtab);
#endif /* SQLITE_OMIT_VIRTUALTABLE */
}else{
assert( pC->pCursor!=0 );
@@ -5375,11 +5387,7 @@
VTable *pVTab;
pVTab = pOp->p4.pVtab;
rc = sqlite3VtabBegin(db, pVTab);
- if( pVTab ){
- sqlite3DbFree(db, p->zErrMsg);
- p->zErrMsg = pVTab->pVtab->zErrMsg;
- pVTab->pVtab->zErrMsg = 0;
- }
+ if( pVTab ) importVtabErrMsg(p, pVTab->pVtab);
break;
}
#endif /* SQLITE_OMIT_VIRTUALTABLE */
@@ -5429,9 +5437,7 @@
pModule = (sqlite3_module *)pVtab->pModule;
assert(pVtab && pModule);
rc = pModule->xOpen(pVtab, &pVtabCursor);
- sqlite3DbFree(db, p->zErrMsg);
- p->zErrMsg = pVtab->zErrMsg;
- pVtab->zErrMsg = 0;
+ importVtabErrMsg(p, pVtab);
if( SQLITE_OK==rc ){
/* Initialize sqlite3_vtab_cursor base class */
pVtabCursor->pVtab = pVtab;
@@ -5508,9 +5514,7 @@
p->inVtabMethod = 1;
rc = pModule->xFilter(pVtabCursor, iQuery, pOp->p4.z, nArg, apArg);
p->inVtabMethod = 0;
- sqlite3DbFree(db, p->zErrMsg);
- p->zErrMsg = pVtab->zErrMsg;
- pVtab->zErrMsg = 0;
+ importVtabErrMsg(p, pVtab);
if( rc==SQLITE_OK ){
res = pModule->xEof(pVtabCursor);
}
@@ -5560,9 +5564,7 @@
MemSetTypeFlag(&sContext.s, MEM_Null);
rc = pModule->xColumn(pCur->pVtabCursor, &sContext, pOp->p2);
- sqlite3DbFree(db, p->zErrMsg);
- p->zErrMsg = pVtab->zErrMsg;
- pVtab->zErrMsg = 0;
+ importVtabErrMsg(p, pVtab);
if( sContext.isError ){
rc = sContext.isError;
}
@@ -5615,9 +5617,7 @@
p->inVtabMethod = 1;
rc = pModule->xNext(pCur->pVtabCursor);
p->inVtabMethod = 0;
- sqlite3DbFree(db, p->zErrMsg);
- p->zErrMsg = pVtab->zErrMsg;
- pVtab->zErrMsg = 0;
+ importVtabErrMsg(p, pVtab);
if( rc==SQLITE_OK ){
res = pModule->xEof(pCur->pVtabCursor);
}
@@ -5647,9 +5647,7 @@
REGISTER_TRACE(pOp->p1, pName);
assert( pName->flags & MEM_Str );
rc = pVtab->pModule->xRename(pVtab, pName->z);
- sqlite3DbFree(db, p->zErrMsg);
- p->zErrMsg = pVtab->zErrMsg;
- pVtab->zErrMsg = 0;
+ importVtabErrMsg(p, pVtab);
break;
}
@@ -5701,9 +5699,7 @@
pX++;
}
rc = pModule->xUpdate(pVtab, nArg, apArg, &rowid);
- sqlite3DbFree(db, p->zErrMsg);
- p->zErrMsg = pVtab->zErrMsg;
- pVtab->zErrMsg = 0;
+ importVtabErrMsg(p, pVtab);
if( rc==SQLITE_OK && pOp->p1 ){
assert( nArg>1 && apArg[0] && (apArg[0]->flags&MEM_Null) );
db->lastRowid = rowid;
diff --git a/src/vdbeaux.c b/src/vdbeaux.c
index a297ddd..7359d18 100644
--- a/src/vdbeaux.c
+++ b/src/vdbeaux.c
@@ -584,7 +584,6 @@
switch( p4type ){
case P4_REAL:
case P4_INT64:
- case P4_MPRINTF:
case P4_DYNAMIC:
case P4_KEYINFO:
case P4_INTARRAY:
@@ -592,6 +591,10 @@
sqlite3DbFree(db, p4);
break;
}
+ case P4_MPRINTF: {
+ sqlite3_free(p4);
+ break;
+ }
case P4_VDBEFUNC: {
VdbeFunc *pVdbeFunc = (VdbeFunc *)p4;
freeEphemeralFunction(db, pVdbeFunc->pFunc);
@@ -756,7 +759,7 @@
nField = ((KeyInfo*)zP4)->nField;
nByte = sizeof(*pKeyInfo) + (nField-1)*sizeof(pKeyInfo->aColl[0]) + nField;
- pKeyInfo = sqlite3Malloc( nByte );
+ pKeyInfo = sqlite3DbMallocRaw(0, nByte);
pOp->p4.pKeyInfo = pKeyInfo;
if( pKeyInfo ){
u8 *aSortOrder;
diff --git a/src/vtab.c b/src/vtab.c
index e57f4e4..bd4cf44 100644
--- a/src/vtab.c
+++ b/src/vtab.c
@@ -466,7 +466,7 @@
*pzErr = sqlite3MPrintf(db, "vtable constructor failed: %s", zModuleName);
}else {
*pzErr = sqlite3MPrintf(db, "%s", zErr);
- sqlite3DbFree(db, zErr);
+ sqlite3_free(zErr);
}
sqlite3DbFree(db, pVTable);
}else if( ALWAYS(pVTable->pVtab) ){
@@ -673,7 +673,7 @@
db->pVTab = 0;
}else{
sqlite3Error(db, SQLITE_ERROR, zErr);
- sqlite3DbFree(db, zErr);
+ sqlite3_free(zErr);
rc = SQLITE_ERROR;
}
pParse->declareVtab = 0;
@@ -768,8 +768,8 @@
if( pVtab && (x = pVtab->pModule->xSync)!=0 ){
rc = x(pVtab);
sqlite3DbFree(db, *pzErrmsg);
- *pzErrmsg = pVtab->zErrMsg;
- pVtab->zErrMsg = 0;
+ *pzErrmsg = sqlite3DbStrDup(db, pVtab->zErrMsg);
+ sqlite3_free(pVtab->zErrMsg);
}
}
db->aVTrans = aVTrans;
diff --git a/src/where.c b/src/where.c
index 3e6189c..e527fbd 100644
--- a/src/where.c
+++ b/src/where.c
@@ -2025,7 +2025,7 @@
sqlite3ErrorMsg(pParse, "%s", pVtab->zErrMsg);
}
}
- sqlite3DbFree(pParse->db, pVtab->zErrMsg);
+ sqlite3_free(pVtab->zErrMsg);
pVtab->zErrMsg = 0;
for(i=0; i<p->nConstraint; i++){