re
/
go-sqlite3
forked from mirror/go-sqlite3
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Update amalgamation code

This commit is contained in:
Yasuhiro Matsumoto 2022-10-26 10:03:31 +09:00 committed by mattn
parent 4b8633cceb
commit 31c761827c
2 changed files with 205 additions and 108 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

307
sqlite3-binding.c
View File

@ -1,7 +1,7 @@
#ifndef USE_LIBSQLITE3 #ifndef USE_LIBSQLITE3
/****************************************************************************** /******************************************************************************
** This file is an amalgamation of many separate C source files from SQLite ** This file is an amalgamation of many separate C source files from SQLite
** version 3.39.2. By combining all the individual C code files into this ** version 3.39.4. By combining all the individual C code files into this
** single large file, the entire code can be compiled as a single translation ** single large file, the entire code can be compiled as a single translation
** unit. This allows many compilers to do optimizations that would not be ** unit. This allows many compilers to do optimizations that would not be
** possible if the files were compiled separately. Performance improvements ** possible if the files were compiled separately. Performance improvements
@ -453,9 +453,9 @@ extern "C" {
** [sqlite3_libversion_number()], [sqlite3_sourceid()], ** [sqlite3_libversion_number()], [sqlite3_sourceid()],
** [sqlite_version()] and [sqlite_source_id()]. ** [sqlite_version()] and [sqlite_source_id()].
*/ */
#define SQLITE_VERSION "3.39.2" #define SQLITE_VERSION "3.39.4"
#define SQLITE_VERSION_NUMBER 3039002 #define SQLITE_VERSION_NUMBER 3039004
#define SQLITE_SOURCE_ID "2022-07-21 15:24:47 698edb77537b67c41adc68f9b892db56bcf9a55e00371a61420f3ddd668e6603" #define SQLITE_SOURCE_ID "2022-09-29 15:55:41 a29f9949895322123f7c38fbe94c649a9d6e6c9cd0c3b41c96d694552f26b309"
/* /*
** CAPI3REF: Run-Time Library Version Numbers ** CAPI3REF: Run-Time Library Version Numbers
@ -13145,6 +13145,11 @@ struct fts5_api {
/************** End of sqlite3.h *********************************************/ /************** End of sqlite3.h *********************************************/
/************** Continuing where we left off in sqliteInt.h ******************/ /************** Continuing where we left off in sqliteInt.h ******************/
/*
** Reuse the STATIC_LRU for mutex access to sqlite3_temp_directory.
*/
#define SQLITE_MUTEX_STATIC_TEMPDIR SQLITE_MUTEX_STATIC_VFS1
/* /*
** Include the configuration header output by 'configure' if we're using the ** Include the configuration header output by 'configure' if we're using the
** autoconf-based build ** autoconf-based build
@ -29564,8 +29569,13 @@ SQLITE_PRIVATE void *sqlite3OomFault(sqlite3 *db){
} }
DisableLookaside; DisableLookaside;
if( db->pParse ){ if( db->pParse ){
Parse *pParse;
sqlite3ErrorMsg(db->pParse, "out of memory"); sqlite3ErrorMsg(db->pParse, "out of memory");
db->pParse->rc = SQLITE_NOMEM_BKPT; db->pParse->rc = SQLITE_NOMEM_BKPT;
for(pParse=db->pParse->pOuterParse; pParse; pParse = pParse->pOuterParse){
pParse->nErr++;
pParse->rc = SQLITE_NOMEM;
}
} }
} }
return 0; return 0;
@ -33460,7 +33470,7 @@ SQLITE_PRIVATE void sqlite3ErrorMsg(Parse *pParse, const char *zFormat, ...){
va_list ap; va_list ap;
sqlite3 *db = pParse->db; sqlite3 *db = pParse->db;
assert( db!=0 ); assert( db!=0 );
assert( db->pParse==pParse ); assert( db->pParse==pParse || db->pParse->pToplevel==pParse );
db->errByteOffset = -2; db->errByteOffset = -2;
va_start(ap, zFormat); va_start(ap, zFormat);
zMsg = sqlite3VMPrintf(db, zFormat, ap); zMsg = sqlite3VMPrintf(db, zFormat, ap);
@ -41321,6 +41331,7 @@ static const char *unixTempFileDir(void){
static int unixGetTempname(int nBuf, char *zBuf){ static int unixGetTempname(int nBuf, char *zBuf){
const char *zDir; const char *zDir;
int iLimit = 0; int iLimit = 0;
int rc = SQLITE_OK;
/* It's odd to simulate an io-error here, but really this is just /* It's odd to simulate an io-error here, but really this is just
** using the io-error infrastructure to test that SQLite handles this ** using the io-error infrastructure to test that SQLite handles this
@ -41329,18 +41340,26 @@ static int unixGetTempname(int nBuf, char *zBuf){
zBuf[0] = 0; zBuf[0] = 0;
SimulateIOError( return SQLITE_IOERR ); SimulateIOError( return SQLITE_IOERR );
sqlite3_mutex_enter(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_TEMPDIR));
zDir = unixTempFileDir(); zDir = unixTempFileDir();
if( zDir==0 ) return SQLITE_IOERR_GETTEMPPATH; if( zDir==0 ){
do{ rc = SQLITE_IOERR_GETTEMPPATH;
u64 r; }else{
sqlite3_randomness(sizeof(r), &r); do{
assert( nBuf>2 ); u64 r;
zBuf[nBuf-2] = 0; sqlite3_randomness(sizeof(r), &r);
sqlite3_snprintf(nBuf, zBuf, "%s/"SQLITE_TEMP_FILE_PREFIX"%llx%c", assert( nBuf>2 );
zDir, r, 0); zBuf[nBuf-2] = 0;
if( zBuf[nBuf-2]!=0 || (iLimit++)>10 ) return SQLITE_ERROR; sqlite3_snprintf(nBuf, zBuf, "%s/"SQLITE_TEMP_FILE_PREFIX"%llx%c",
}while( osAccess(zBuf,0)==0 ); zDir, r, 0);
return SQLITE_OK; if( zBuf[nBuf-2]!=0 || (iLimit++)>10 ){
rc = SQLITE_ERROR;
break;
}
}while( osAccess(zBuf,0)==0 );
}
sqlite3_mutex_leave(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_TEMPDIR));
return rc;
} }
#if SQLITE_ENABLE_LOCKING_STYLE && defined(__APPLE__) #if SQLITE_ENABLE_LOCKING_STYLE && defined(__APPLE__)
@ -45479,10 +45498,12 @@ SQLITE_API int sqlite3_win32_set_directory8(
const char *zValue /* New value for directory being set or reset */ const char *zValue /* New value for directory being set or reset */
){ ){
char **ppDirectory = 0; char **ppDirectory = 0;
int rc;
#ifndef SQLITE_OMIT_AUTOINIT #ifndef SQLITE_OMIT_AUTOINIT
int rc = sqlite3_initialize(); rc = sqlite3_initialize();
if( rc ) return rc; if( rc ) return rc;
#endif #endif
sqlite3_mutex_enter(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_TEMPDIR));
if( type==SQLITE_WIN32_DATA_DIRECTORY_TYPE ){ if( type==SQLITE_WIN32_DATA_DIRECTORY_TYPE ){
ppDirectory = &sqlite3_data_directory; ppDirectory = &sqlite3_data_directory;
}else if( type==SQLITE_WIN32_TEMP_DIRECTORY_TYPE ){ }else if( type==SQLITE_WIN32_TEMP_DIRECTORY_TYPE ){
@ -45497,14 +45518,19 @@ SQLITE_API int sqlite3_win32_set_directory8(
if( zValue && zValue[0] ){ if( zValue && zValue[0] ){
zCopy = sqlite3_mprintf("%s", zValue); zCopy = sqlite3_mprintf("%s", zValue);
if ( zCopy==0 ){ if ( zCopy==0 ){
return SQLITE_NOMEM_BKPT; rc = SQLITE_NOMEM_BKPT;
goto set_directory8_done;
} }
} }
sqlite3_free(*ppDirectory); sqlite3_free(*ppDirectory);
*ppDirectory = zCopy; *ppDirectory = zCopy;
return SQLITE_OK; rc = SQLITE_OK;
}else{
rc = SQLITE_ERROR;
} }
return SQLITE_ERROR; set_directory8_done:
sqlite3_mutex_leave(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_TEMPDIR));
return rc;
} }
/* /*
@ -48278,6 +48304,18 @@ static int winMakeEndInDirSep(int nBuf, char *zBuf){
return 0; return 0;
} }
/*
** If sqlite3_temp_directory is not, take the mutex and return true.
**
** If sqlite3_temp_directory is NULL, omit the mutex and return false.
*/
static int winTempDirDefined(void){
sqlite3_mutex_enter(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_TEMPDIR));
if( sqlite3_temp_directory!=0 ) return 1;
sqlite3_mutex_leave(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_TEMPDIR));
return 0;
}
/* /*
** Create a temporary file name and store the resulting pointer into pzBuf. ** Create a temporary file name and store the resulting pointer into pzBuf.
** The pointer returned in pzBuf must be freed via sqlite3_free(). ** The pointer returned in pzBuf must be freed via sqlite3_free().
@ -48314,20 +48352,23 @@ static int winGetTempname(sqlite3_vfs *pVfs, char **pzBuf){
*/ */
nDir = nMax - (nPre + 15); nDir = nMax - (nPre + 15);
assert( nDir>0 ); assert( nDir>0 );
if( sqlite3_temp_directory ){ if( winTempDirDefined() ){
int nDirLen = sqlite3Strlen30(sqlite3_temp_directory); int nDirLen = sqlite3Strlen30(sqlite3_temp_directory);
if( nDirLen>0 ){ if( nDirLen>0 ){
if( !winIsDirSep(sqlite3_temp_directory[nDirLen-1]) ){ if( !winIsDirSep(sqlite3_temp_directory[nDirLen-1]) ){
nDirLen++; nDirLen++;
} }
if( nDirLen>nDir ){ if( nDirLen>nDir ){
sqlite3_mutex_leave(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_TEMPDIR));
sqlite3_free(zBuf); sqlite3_free(zBuf);
OSTRACE(("TEMP-FILENAME rc=SQLITE_ERROR\n")); OSTRACE(("TEMP-FILENAME rc=SQLITE_ERROR\n"));
return winLogError(SQLITE_ERROR, 0, "winGetTempname1", 0); return winLogError(SQLITE_ERROR, 0, "winGetTempname1", 0);
} }
sqlite3_snprintf(nMax, zBuf, "%s", sqlite3_temp_directory); sqlite3_snprintf(nMax, zBuf, "%s", sqlite3_temp_directory);
} }
sqlite3_mutex_leave(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_TEMPDIR));
} }
#if defined(__CYGWIN__) #if defined(__CYGWIN__)
else{ else{
static const char *azDirs[] = { static const char *azDirs[] = {
@ -49116,7 +49157,7 @@ static BOOL winIsVerbatimPathname(
** pathname into zOut[]. zOut[] will be at least pVfs->mxPathname ** pathname into zOut[]. zOut[] will be at least pVfs->mxPathname
** bytes in size. ** bytes in size.
*/ */
static int winFullPathname( static int winFullPathnameNoMutex(
sqlite3_vfs *pVfs, /* Pointer to vfs object */ sqlite3_vfs *pVfs, /* Pointer to vfs object */
const char *zRelative, /* Possibly relative input path */ const char *zRelative, /* Possibly relative input path */
int nFull, /* Size of output buffer in bytes */ int nFull, /* Size of output buffer in bytes */
@ -49295,6 +49336,19 @@ static int winFullPathname(
} }
#endif #endif
} }
static int winFullPathname(
sqlite3_vfs *pVfs, /* Pointer to vfs object */
const char *zRelative, /* Possibly relative input path */
int nFull, /* Size of output buffer in bytes */
char *zFull /* Output buffer */
){
int rc;
sqlite3_mutex *pMutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_TEMPDIR);
sqlite3_mutex_enter(pMutex);
rc = winFullPathnameNoMutex(pVfs, zRelative, nFull, zFull);
sqlite3_mutex_leave(pMutex);
return rc;
}
#ifndef SQLITE_OMIT_LOAD_EXTENSION #ifndef SQLITE_OMIT_LOAD_EXTENSION
/* /*
@ -51639,14 +51693,24 @@ SQLITE_PRIVATE void sqlite3PcacheClearSyncFlags(PCache *pCache){
*/ */
SQLITE_PRIVATE void sqlite3PcacheMove(PgHdr *p, Pgno newPgno){ SQLITE_PRIVATE void sqlite3PcacheMove(PgHdr *p, Pgno newPgno){
PCache *pCache = p->pCache; PCache *pCache = p->pCache;
sqlite3_pcache_page *pOther;
assert( p->nRef>0 ); assert( p->nRef>0 );
assert( newPgno>0 ); assert( newPgno>0 );
assert( sqlite3PcachePageSanity(p) ); assert( sqlite3PcachePageSanity(p) );
pcacheTrace(("%p.MOVE %d -> %d\n",pCache,p->pgno,newPgno)); pcacheTrace(("%p.MOVE %d -> %d\n",pCache,p->pgno,newPgno));
pOther = sqlite3GlobalConfig.pcache2.xFetch(pCache->pCache, newPgno, 0);
if( pOther ){
PgHdr *pXPage = (PgHdr*)pOther->pExtra;
assert( pXPage->nRef==0 );
pXPage->nRef++;
pCache->nRefSum++;
sqlite3PcacheDrop(pXPage);
}
sqlite3GlobalConfig.pcache2.xRekey(pCache->pCache, p->pPage, p->pgno,newPgno); sqlite3GlobalConfig.pcache2.xRekey(pCache->pCache, p->pPage, p->pgno,newPgno);
p->pgno = newPgno; p->pgno = newPgno;
if( (p->flags&PGHDR_DIRTY) && (p->flags&PGHDR_NEED_SYNC) ){ if( (p->flags&PGHDR_DIRTY) && (p->flags&PGHDR_NEED_SYNC) ){
pcacheManageDirtyList(p, PCACHE_DIRTYLIST_FRONT); pcacheManageDirtyList(p, PCACHE_DIRTYLIST_FRONT);
assert( sqlite3PcachePageSanity(p) );
} }
} }
@ -53028,23 +53092,26 @@ static void pcache1Rekey(
PCache1 *pCache = (PCache1 *)p; PCache1 *pCache = (PCache1 *)p;
PgHdr1 *pPage = (PgHdr1 *)pPg; PgHdr1 *pPage = (PgHdr1 *)pPg;
PgHdr1 **pp; PgHdr1 **pp;
unsigned int h; unsigned int hOld, hNew;
assert( pPage->iKey==iOld ); assert( pPage->iKey==iOld );
assert( pPage->pCache==pCache ); assert( pPage->pCache==pCache );
assert( iOld!=iNew ); /* The page number really is changing */
pcache1EnterMutex(pCache->pGroup); pcache1EnterMutex(pCache->pGroup);
h = iOld%pCache->nHash; assert( pcache1FetchNoMutex(p, iOld, 0)==pPage ); /* pPg really is iOld */
pp = &pCache->apHash[h]; hOld = iOld%pCache->nHash;
pp = &pCache->apHash[hOld];
while( (*pp)!=pPage ){ while( (*pp)!=pPage ){
pp = &(*pp)->pNext; pp = &(*pp)->pNext;
} }
*pp = pPage->pNext; *pp = pPage->pNext;
h = iNew%pCache->nHash; assert( pcache1FetchNoMutex(p, iNew, 0)==0 ); /* iNew not in cache */
hNew = iNew%pCache->nHash;
pPage->iKey = iNew; pPage->iKey = iNew;
pPage->pNext = pCache->apHash[h]; pPage->pNext = pCache->apHash[hNew];
pCache->apHash[h] = pPage; pCache->apHash[hNew] = pPage;
if( iNew>pCache->iMaxKey ){ if( iNew>pCache->iMaxKey ){
pCache->iMaxKey = iNew; pCache->iMaxKey = iNew;
} }
@ -59677,6 +59744,7 @@ static int pager_open_journal(Pager *pPager){
if( rc!=SQLITE_OK ){ if( rc!=SQLITE_OK ){
sqlite3BitvecDestroy(pPager->pInJournal); sqlite3BitvecDestroy(pPager->pInJournal);
pPager->pInJournal = 0; pPager->pInJournal = 0;
pPager->journalOff = 0;
}else{ }else{
assert( pPager->eState==PAGER_WRITER_LOCKED ); assert( pPager->eState==PAGER_WRITER_LOCKED );
pPager->eState = PAGER_WRITER_CACHEMOD; pPager->eState = PAGER_WRITER_CACHEMOD;
@ -61232,7 +61300,7 @@ SQLITE_PRIVATE int sqlite3PagerGetJournalMode(Pager *pPager){
SQLITE_PRIVATE int sqlite3PagerOkToChangeJournalMode(Pager *pPager){ SQLITE_PRIVATE int sqlite3PagerOkToChangeJournalMode(Pager *pPager){
assert( assert_pager_state(pPager) ); assert( assert_pager_state(pPager) );
if( pPager->eState>=PAGER_WRITER_CACHEMOD ) return 0; if( pPager->eState>=PAGER_WRITER_CACHEMOD ) return 0;
if( NEVER(isOpen(pPager->jfd) && pPager->journalOff>0) ) return 0; if( isOpen(pPager->jfd) && pPager->journalOff>0 ) return 0;
return 1; return 1;
} }
@ -68347,7 +68415,7 @@ static int defragmentPage(MemPage *pPage, int nMaxFrag){
if( iFree2+sz2 > usableSize ) return SQLITE_CORRUPT_PAGE(pPage); if( iFree2+sz2 > usableSize ) return SQLITE_CORRUPT_PAGE(pPage);
memmove(&data[iFree+sz+sz2], &data[iFree+sz], iFree2-(iFree+sz)); memmove(&data[iFree+sz+sz2], &data[iFree+sz], iFree2-(iFree+sz));
sz += sz2; sz += sz2;
}else if( NEVER(iFree+sz>usableSize) ){ }else if( iFree+sz>usableSize ){
return SQLITE_CORRUPT_PAGE(pPage); return SQLITE_CORRUPT_PAGE(pPage);
} }
@ -74703,8 +74771,6 @@ static int balance_nonroot(
Pgno pgno; /* Temp var to store a page number in */ Pgno pgno; /* Temp var to store a page number in */
u8 abDone[NB+2]; /* True after i'th new page is populated */ u8 abDone[NB+2]; /* True after i'th new page is populated */
Pgno aPgno[NB+2]; /* Page numbers of new pages before shuffling */ Pgno aPgno[NB+2]; /* Page numbers of new pages before shuffling */
Pgno aPgOrder[NB+2]; /* Copy of aPgno[] used for sorting pages */
u16 aPgFlags[NB+2]; /* flags field of new pages before shuffling */
CellArray b; /* Parsed information on cells being balanced */ CellArray b; /* Parsed information on cells being balanced */
memset(abDone, 0, sizeof(abDone)); memset(abDone, 0, sizeof(abDone));
@ -75128,42 +75194,39 @@ static int balance_nonroot(
** of the table is closer to a linear scan through the file. That in turn ** of the table is closer to a linear scan through the file. That in turn
** helps the operating system to deliver pages from the disk more rapidly. ** helps the operating system to deliver pages from the disk more rapidly.
** **
** An O(n^2) insertion sort algorithm is used, but since n is never more ** An O(N*N) sort algorithm is used, but since N is never more than NB+2
** than (NB+2) (a small constant), that should not be a problem. ** (5), that is not a performance concern.
** **
** When NB==3, this one optimization makes the database about 25% faster ** When NB==3, this one optimization makes the database about 25% faster
** for large insertions and deletions. ** for large insertions and deletions.
*/ */
for(i=0; i<nNew; i++){ for(i=0; i<nNew; i++){
aPgOrder[i] = aPgno[i] = apNew[i]->pgno; aPgno[i] = apNew[i]->pgno;
aPgFlags[i] = apNew[i]->pDbPage->flags; assert( apNew[i]->pDbPage->flags & PGHDR_WRITEABLE );
for(j=0; j<i; j++){ assert( apNew[i]->pDbPage->flags & PGHDR_DIRTY );
if( NEVER(aPgno[j]==aPgno[i]) ){
/* This branch is taken if the set of sibling pages somehow contains
** duplicate entries. This can happen if the database is corrupt.
** It would be simpler to detect this as part of the loop below, but
** we do the detection here in order to avoid populating the pager
** cache with two separate objects associated with the same
** page number. */
assert( CORRUPT_DB );
rc = SQLITE_CORRUPT_BKPT;
goto balance_cleanup;
}
}
} }
for(i=0; i<nNew; i++){ for(i=0; i<nNew-1; i++){
int iBest = 0; /* aPgno[] index of page number to use */ int iB = i;
for(j=1; j<nNew; j++){ for(j=i+1; j<nNew; j++){
if( aPgOrder[j]<aPgOrder[iBest] ) iBest = j; if( apNew[j]->pgno < apNew[iB]->pgno ) iB = j;
} }
pgno = aPgOrder[iBest];
aPgOrder[iBest] = 0xffffffff; /* If apNew[i] has a page number that is bigger than any of the
if( iBest!=i ){ ** subsequence apNew[i] entries, then swap apNew[i] with the subsequent
if( iBest>i ){ ** entry that has the smallest page number (which we know to be
sqlite3PagerRekey(apNew[iBest]->pDbPage, pBt->nPage+iBest+1, 0); ** entry apNew[iB]).
} */
sqlite3PagerRekey(apNew[i]->pDbPage, pgno, aPgFlags[iBest]); if( iB!=i ){
apNew[i]->pgno = pgno; Pgno pgnoA = apNew[i]->pgno;
Pgno pgnoB = apNew[iB]->pgno;
Pgno pgnoTemp = (PENDING_BYTE/pBt->pageSize)+1;
u16 fgA = apNew[i]->pDbPage->flags;
u16 fgB = apNew[iB]->pDbPage->flags;
sqlite3PagerRekey(apNew[i]->pDbPage, pgnoTemp, fgB);
sqlite3PagerRekey(apNew[iB]->pDbPage, pgnoA, fgA);
sqlite3PagerRekey(apNew[i]->pDbPage, pgnoB, fgB);
apNew[i]->pgno = pgnoB;
apNew[iB]->pgno = pgnoA;
} }
} }
@ -81036,6 +81099,7 @@ SQLITE_PRIVATE int sqlite3VdbeAddFunctionCall(
addr = sqlite3VdbeAddOp4(v, eCallCtx ? OP_PureFunc : OP_Function, addr = sqlite3VdbeAddOp4(v, eCallCtx ? OP_PureFunc : OP_Function,
p1, p2, p3, (char*)pCtx, P4_FUNCCTX); p1, p2, p3, (char*)pCtx, P4_FUNCCTX);
sqlite3VdbeChangeP5(v, eCallCtx & NC_SelfRef); sqlite3VdbeChangeP5(v, eCallCtx & NC_SelfRef);
sqlite3MayAbort(pParse);
return addr; return addr;
} }
@ -81371,6 +81435,7 @@ SQLITE_PRIVATE int sqlite3VdbeAssertMayAbort(Vdbe *v, int mayAbort){
|| opcode==OP_VDestroy || opcode==OP_VDestroy
|| opcode==OP_VCreate || opcode==OP_VCreate
|| opcode==OP_ParseSchema || opcode==OP_ParseSchema
|| opcode==OP_Function || opcode==OP_PureFunc
|| ((opcode==OP_Halt || opcode==OP_HaltIfNull) || ((opcode==OP_Halt || opcode==OP_HaltIfNull)
&& ((pOp->p1)!=SQLITE_OK && pOp->p2==OE_Abort)) && ((pOp->p1)!=SQLITE_OK && pOp->p2==OE_Abort))
){ ){
@ -132705,6 +132770,7 @@ SQLITE_PRIVATE void sqlite3Pragma(
** **
*/ */
case PragTyp_TEMP_STORE_DIRECTORY: { case PragTyp_TEMP_STORE_DIRECTORY: {
sqlite3_mutex_enter(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_TEMPDIR));
if( !zRight ){ if( !zRight ){
returnSingleText(v, sqlite3_temp_directory); returnSingleText(v, sqlite3_temp_directory);
}else{ }else{
@ -132714,6 +132780,7 @@ SQLITE_PRIVATE void sqlite3Pragma(
rc = sqlite3OsAccess(db->pVfs, zRight, SQLITE_ACCESS_READWRITE, &res); rc = sqlite3OsAccess(db->pVfs, zRight, SQLITE_ACCESS_READWRITE, &res);
if( rc!=SQLITE_OK || res==0 ){ if( rc!=SQLITE_OK || res==0 ){
sqlite3ErrorMsg(pParse, "not a writable directory"); sqlite3ErrorMsg(pParse, "not a writable directory");
sqlite3_mutex_leave(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_TEMPDIR));
goto pragma_out; goto pragma_out;
} }
} }
@ -132731,6 +132798,7 @@ SQLITE_PRIVATE void sqlite3Pragma(
} }
#endif /* SQLITE_OMIT_WSD */ #endif /* SQLITE_OMIT_WSD */
} }
sqlite3_mutex_leave(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_TEMPDIR));
break; break;
} }
@ -132749,6 +132817,7 @@ SQLITE_PRIVATE void sqlite3Pragma(
** **
*/ */
case PragTyp_DATA_STORE_DIRECTORY: { case PragTyp_DATA_STORE_DIRECTORY: {
sqlite3_mutex_enter(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_TEMPDIR));
if( !zRight ){ if( !zRight ){
returnSingleText(v, sqlite3_data_directory); returnSingleText(v, sqlite3_data_directory);
}else{ }else{
@ -132758,6 +132827,7 @@ SQLITE_PRIVATE void sqlite3Pragma(
rc = sqlite3OsAccess(db->pVfs, zRight, SQLITE_ACCESS_READWRITE, &res); rc = sqlite3OsAccess(db->pVfs, zRight, SQLITE_ACCESS_READWRITE, &res);
if( rc!=SQLITE_OK || res==0 ){ if( rc!=SQLITE_OK || res==0 ){
sqlite3ErrorMsg(pParse, "not a writable directory"); sqlite3ErrorMsg(pParse, "not a writable directory");
sqlite3_mutex_leave(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_TEMPDIR));
goto pragma_out; goto pragma_out;
} }
} }
@ -132769,6 +132839,7 @@ SQLITE_PRIVATE void sqlite3Pragma(
} }
#endif /* SQLITE_OMIT_WSD */ #endif /* SQLITE_OMIT_WSD */
} }
sqlite3_mutex_leave(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_TEMPDIR));
break; break;
} }
#endif #endif
@ -137214,7 +137285,7 @@ static void generateSortTail(
if( addrOnce ) sqlite3VdbeJumpHere(v, addrOnce); if( addrOnce ) sqlite3VdbeJumpHere(v, addrOnce);
addr = 1 + sqlite3VdbeAddOp2(v, OP_SorterSort, iTab, addrBreak); addr = 1 + sqlite3VdbeAddOp2(v, OP_SorterSort, iTab, addrBreak);
VdbeCoverage(v); VdbeCoverage(v);
codeOffset(v, p->iOffset, addrContinue); assert( p->iLimit==0 && p->iOffset==0 );
sqlite3VdbeAddOp3(v, OP_SorterData, iTab, regSortOut, iSortTab); sqlite3VdbeAddOp3(v, OP_SorterData, iTab, regSortOut, iSortTab);
bSeq = 0; bSeq = 0;
}else{ }else{
@ -137222,6 +137293,9 @@ static void generateSortTail(
codeOffset(v, p->iOffset, addrContinue); codeOffset(v, p->iOffset, addrContinue);
iSortTab = iTab; iSortTab = iTab;
bSeq = 1; bSeq = 1;
if( p->iOffset>0 ){
sqlite3VdbeAddOp2(v, OP_AddImm, p->iLimit, -1);
}
} }
for(i=0, iCol=nKey+bSeq-1; i<nColumn; i++){ for(i=0, iCol=nKey+bSeq-1; i<nColumn; i++){
#ifdef SQLITE_ENABLE_SORTER_REFERENCES #ifdef SQLITE_ENABLE_SORTER_REFERENCES
@ -139214,10 +139288,11 @@ static int multiSelectOrderBy(
*/ */
sqlite3VdbeResolveLabel(v, labelEnd); sqlite3VdbeResolveLabel(v, labelEnd);
/* Reassembly the compound query so that it will be freed correctly /* Reassemble the compound query so that it will be freed correctly
** by the calling function */ ** by the calling function */
if( pSplit->pPrior ){ if( pSplit->pPrior ){
sqlite3SelectDelete(db, pSplit->pPrior); sqlite3ParserAddCleanup(pParse,
(void(*)(sqlite3*,void*))sqlite3SelectDelete, pSplit->pPrior);
} }
pSplit->pPrior = pPrior; pSplit->pPrior = pPrior;
pPrior->pNext = pSplit; pPrior->pNext = pSplit;
@ -140736,6 +140811,7 @@ static Table *isSimpleCount(Select *p, AggInfo *pAggInfo){
|| p->pSrc->nSrc!=1 || p->pSrc->nSrc!=1
|| p->pSrc->a[0].pSelect || p->pSrc->a[0].pSelect
|| pAggInfo->nFunc!=1 || pAggInfo->nFunc!=1
|| p->pHaving
){ ){
return 0; return 0;
} }
@ -143973,6 +144049,23 @@ SQLITE_PRIVATE void sqlite3FinishTrigger(
Vdbe *v; Vdbe *v;
char *z; char *z;
/* If this is a new CREATE TABLE statement, and if shadow tables
** are read-only, and the trigger makes a change to a shadow table,
** then raise an error - do not allow the trigger to be created. */
if( sqlite3ReadOnlyShadowTables(db) ){
TriggerStep *pStep;
for(pStep=pTrig->step_list; pStep; pStep=pStep->pNext){
if( pStep->zTarget!=0
&& sqlite3ShadowTableName(db, pStep->zTarget)
){
sqlite3ErrorMsg(pParse,
"trigger \"%s\" may not write to shadow table \"%s\"",
pTrig->zName, pStep->zTarget);
goto triggerfinish_cleanup;
}
}
}
/* Make an entry in the sqlite_schema table */ /* Make an entry in the sqlite_schema table */
v = sqlite3GetVdbe(pParse); v = sqlite3GetVdbe(pParse);
if( v==0 ) goto triggerfinish_cleanup; if( v==0 ) goto triggerfinish_cleanup;
@ -149784,7 +149877,8 @@ static int codeEqualityTerm(
} }
sqlite3ExprDelete(db, pX); sqlite3ExprDelete(db, pX);
}else{ }else{
aiMap = (int*)sqlite3DbMallocZero(pParse->db, sizeof(int)*nEq); int n = sqlite3ExprVectorSize(pX->pLeft);
aiMap = (int*)sqlite3DbMallocZero(pParse->db, sizeof(int)*MAX(nEq,n));
eType = sqlite3FindInIndex(pParse, pX, IN_INDEX_LOOP, 0, aiMap, &iTab); eType = sqlite3FindInIndex(pParse, pX, IN_INDEX_LOOP, 0, aiMap, &iTab);
} }
pX = pExpr; pX = pExpr;
@ -176937,7 +177031,7 @@ struct Fts3MultiSegReader {
int nAdvance; /* How many seg-readers to advance */ int nAdvance; /* How many seg-readers to advance */
Fts3SegFilter *pFilter; /* Pointer to filter object */ Fts3SegFilter *pFilter; /* Pointer to filter object */
char *aBuffer; /* Buffer to merge doclists in */ char *aBuffer; /* Buffer to merge doclists in */
int nBuffer; /* Allocated size of aBuffer[] in bytes */ i64 nBuffer; /* Allocated size of aBuffer[] in bytes */
int iColFilter; /* If >=0, filter for this column */ int iColFilter; /* If >=0, filter for this column */
int bRestart; int bRestart;
@ -179633,7 +179727,7 @@ static int fts3TermSelectMerge(
** **
** Similar padding is added in the fts3DoclistOrMerge() function. ** Similar padding is added in the fts3DoclistOrMerge() function.
*/ */
pTS->aaOutput[0] = sqlite3_malloc(nDoclist + FTS3_VARINT_MAX + 1); pTS->aaOutput[0] = sqlite3_malloc64((i64)nDoclist + FTS3_VARINT_MAX + 1);
pTS->anOutput[0] = nDoclist; pTS->anOutput[0] = nDoclist;
if( pTS->aaOutput[0] ){ if( pTS->aaOutput[0] ){
memcpy(pTS->aaOutput[0], aDoclist, nDoclist); memcpy(pTS->aaOutput[0], aDoclist, nDoclist);
@ -181121,7 +181215,7 @@ static int fts3EvalDeferredPhrase(Fts3Cursor *pCsr, Fts3Phrase *pPhrase){
nDistance = iPrev - nMaxUndeferred; nDistance = iPrev - nMaxUndeferred;
} }
aOut = (char *)sqlite3_malloc(nPoslist+8); aOut = (char *)sqlite3Fts3MallocZero(nPoslist+FTS3_BUFFER_PADDING);
if( !aOut ){ if( !aOut ){
sqlite3_free(aPoslist); sqlite3_free(aPoslist);
return SQLITE_NOMEM; return SQLITE_NOMEM;
@ -181490,7 +181584,7 @@ static int fts3EvalIncrPhraseNext(
if( bEof==0 ){ if( bEof==0 ){
int nList = 0; int nList = 0;
int nByte = a[p->nToken-1].nList; int nByte = a[p->nToken-1].nList;
char *aDoclist = sqlite3_malloc(nByte+FTS3_BUFFER_PADDING); char *aDoclist = sqlite3_malloc64((i64)nByte+FTS3_BUFFER_PADDING);
if( !aDoclist ) return SQLITE_NOMEM; if( !aDoclist ) return SQLITE_NOMEM;
memcpy(aDoclist, a[p->nToken-1].pList, nByte+1); memcpy(aDoclist, a[p->nToken-1].pList, nByte+1);
memset(&aDoclist[nByte], 0, FTS3_BUFFER_PADDING); memset(&aDoclist[nByte], 0, FTS3_BUFFER_PADDING);
@ -185726,7 +185820,7 @@ static int porterNext(
if( n>c->nAllocated ){ if( n>c->nAllocated ){
char *pNew; char *pNew;
c->nAllocated = n+20; c->nAllocated = n+20;
pNew = sqlite3_realloc(c->zToken, c->nAllocated); pNew = sqlite3_realloc64(c->zToken, c->nAllocated);
if( !pNew ) return SQLITE_NOMEM; if( !pNew ) return SQLITE_NOMEM;
c->zToken = pNew; c->zToken = pNew;
} }
@ -186478,7 +186572,7 @@ static int simpleNext(
if( n>c->nTokenAllocated ){ if( n>c->nTokenAllocated ){
char *pNew; char *pNew;
c->nTokenAllocated = n+20; c->nTokenAllocated = n+20;
pNew = sqlite3_realloc(c->pToken, c->nTokenAllocated); pNew = sqlite3_realloc64(c->pToken, c->nTokenAllocated);
if( !pNew ) return SQLITE_NOMEM; if( !pNew ) return SQLITE_NOMEM;
c->pToken = pNew; c->pToken = pNew;
} }
@ -187640,7 +187734,7 @@ static int fts3PendingListAppendVarint(
/* Allocate or grow the PendingList as required. */ /* Allocate or grow the PendingList as required. */
if( !p ){ if( !p ){
p = sqlite3_malloc(sizeof(*p) + 100); p = sqlite3_malloc64(sizeof(*p) + 100);
if( !p ){ if( !p ){
return SQLITE_NOMEM; return SQLITE_NOMEM;
} }
@ -187649,14 +187743,14 @@ static int fts3PendingListAppendVarint(
p->nData = 0; p->nData = 0;
} }
else if( p->nData+FTS3_VARINT_MAX+1>p->nSpace ){ else if( p->nData+FTS3_VARINT_MAX+1>p->nSpace ){
int nNew = p->nSpace * 2; i64 nNew = p->nSpace * 2;
p = sqlite3_realloc(p, sizeof(*p) + nNew); p = sqlite3_realloc64(p, sizeof(*p) + nNew);
if( !p ){ if( !p ){
sqlite3_free(*pp); sqlite3_free(*pp);
*pp = 0; *pp = 0;
return SQLITE_NOMEM; return SQLITE_NOMEM;
} }
p->nSpace = nNew; p->nSpace = (int)nNew;
p->aData = (char *)&p[1]; p->aData = (char *)&p[1];
} }
@ -188213,7 +188307,7 @@ SQLITE_PRIVATE int sqlite3Fts3ReadBlock(
int nByte = sqlite3_blob_bytes(p->pSegments); int nByte = sqlite3_blob_bytes(p->pSegments);
*pnBlob = nByte; *pnBlob = nByte;
if( paBlob ){ if( paBlob ){
char *aByte = sqlite3_malloc(nByte + FTS3_NODE_PADDING); char *aByte = sqlite3_malloc64((i64)nByte + FTS3_NODE_PADDING);
if( !aByte ){ if( !aByte ){
rc = SQLITE_NOMEM; rc = SQLITE_NOMEM;
}else{ }else{
@ -188330,7 +188424,7 @@ static int fts3SegReaderNext(
int nTerm = fts3HashKeysize(pElem); int nTerm = fts3HashKeysize(pElem);
if( (nTerm+1)>pReader->nTermAlloc ){ if( (nTerm+1)>pReader->nTermAlloc ){
sqlite3_free(pReader->zTerm); sqlite3_free(pReader->zTerm);
pReader->zTerm = (char*)sqlite3_malloc((nTerm+1)*2); pReader->zTerm = (char*)sqlite3_malloc64(((i64)nTerm+1)*2);
if( !pReader->zTerm ) return SQLITE_NOMEM; if( !pReader->zTerm ) return SQLITE_NOMEM;
pReader->nTermAlloc = (nTerm+1)*2; pReader->nTermAlloc = (nTerm+1)*2;
} }
@ -188338,7 +188432,7 @@ static int fts3SegReaderNext(
pReader->zTerm[nTerm] = '\0'; pReader->zTerm[nTerm] = '\0';
pReader->nTerm = nTerm; pReader->nTerm = nTerm;
aCopy = (char*)sqlite3_malloc(nCopy); aCopy = (char*)sqlite3_malloc64(nCopy);
if( !aCopy ) return SQLITE_NOMEM; if( !aCopy ) return SQLITE_NOMEM;
memcpy(aCopy, pList->aData, nCopy); memcpy(aCopy, pList->aData, nCopy);
pReader->nNode = pReader->nDoclist = nCopy; pReader->nNode = pReader->nDoclist = nCopy;
@ -188625,7 +188719,7 @@ SQLITE_PRIVATE int sqlite3Fts3SegReaderNew(
nExtra = nRoot + FTS3_NODE_PADDING; nExtra = nRoot + FTS3_NODE_PADDING;
} }
pReader = (Fts3SegReader *)sqlite3_malloc(sizeof(Fts3SegReader) + nExtra); pReader = (Fts3SegReader *)sqlite3_malloc64(sizeof(Fts3SegReader) + nExtra);
if( !pReader ){ if( !pReader ){
return SQLITE_NOMEM; return SQLITE_NOMEM;
} }
@ -188717,7 +188811,7 @@ SQLITE_PRIVATE int sqlite3Fts3SegReaderPending(
if( nElem==nAlloc ){ if( nElem==nAlloc ){
Fts3HashElem **aElem2; Fts3HashElem **aElem2;
nAlloc += 16; nAlloc += 16;
aElem2 = (Fts3HashElem **)sqlite3_realloc( aElem2 = (Fts3HashElem **)sqlite3_realloc64(
aElem, nAlloc*sizeof(Fts3HashElem *) aElem, nAlloc*sizeof(Fts3HashElem *)
); );
if( !aElem2 ){ if( !aElem2 ){
@ -189051,7 +189145,7 @@ static int fts3NodeAddTerm(
** this is not expected to be a serious problem. ** this is not expected to be a serious problem.
*/ */
assert( pTree->aData==(char *)&pTree[1] ); assert( pTree->aData==(char *)&pTree[1] );
pTree->aData = (char *)sqlite3_malloc(nReq); pTree->aData = (char *)sqlite3_malloc64(nReq);
if( !pTree->aData ){ if( !pTree->aData ){
return SQLITE_NOMEM; return SQLITE_NOMEM;
} }
@ -189069,7 +189163,7 @@ static int fts3NodeAddTerm(
if( isCopyTerm ){ if( isCopyTerm ){
if( pTree->nMalloc<nTerm ){ if( pTree->nMalloc<nTerm ){
char *zNew = sqlite3_realloc(pTree->zMalloc, nTerm*2); char *zNew = sqlite3_realloc64(pTree->zMalloc, (i64)nTerm*2);
if( !zNew ){ if( !zNew ){
return SQLITE_NOMEM; return SQLITE_NOMEM;
} }
@ -189095,7 +189189,7 @@ static int fts3NodeAddTerm(
** now. Instead, the term is inserted into the parent of pTree. If pTree ** now. Instead, the term is inserted into the parent of pTree. If pTree
** has no parent, one is created here. ** has no parent, one is created here.
*/ */
pNew = (SegmentNode *)sqlite3_malloc(sizeof(SegmentNode) + p->nNodeSize); pNew = (SegmentNode *)sqlite3_malloc64(sizeof(SegmentNode) + p->nNodeSize);
if( !pNew ){ if( !pNew ){
return SQLITE_NOMEM; return SQLITE_NOMEM;
} }
@ -189233,7 +189327,7 @@ static int fts3SegWriterAdd(
){ ){
int nPrefix; /* Size of term prefix in bytes */ int nPrefix; /* Size of term prefix in bytes */
int nSuffix; /* Size of term suffix in bytes */ int nSuffix; /* Size of term suffix in bytes */
int nReq; /* Number of bytes required on leaf page */ i64 nReq; /* Number of bytes required on leaf page */
int nData; int nData;
SegmentWriter *pWriter = *ppWriter; SegmentWriter *pWriter = *ppWriter;
@ -189242,13 +189336,13 @@ static int fts3SegWriterAdd(
sqlite3_stmt *pStmt; sqlite3_stmt *pStmt;
/* Allocate the SegmentWriter structure */ /* Allocate the SegmentWriter structure */
pWriter = (SegmentWriter *)sqlite3_malloc(sizeof(SegmentWriter)); pWriter = (SegmentWriter *)sqlite3_malloc64(sizeof(SegmentWriter));
if( !pWriter ) return SQLITE_NOMEM; if( !pWriter ) return SQLITE_NOMEM;
memset(pWriter, 0, sizeof(SegmentWriter)); memset(pWriter, 0, sizeof(SegmentWriter));
*ppWriter = pWriter; *ppWriter = pWriter;
/* Allocate a buffer in which to accumulate data */ /* Allocate a buffer in which to accumulate data */
pWriter->aData = (char *)sqlite3_malloc(p->nNodeSize); pWriter->aData = (char *)sqlite3_malloc64(p->nNodeSize);
if( !pWriter->aData ) return SQLITE_NOMEM; if( !pWriter->aData ) return SQLITE_NOMEM;
pWriter->nSize = p->nNodeSize; pWriter->nSize = p->nNodeSize;
@ -189323,7 +189417,7 @@ static int fts3SegWriterAdd(
** the buffer to make it large enough. ** the buffer to make it large enough.
*/ */
if( nReq>pWriter->nSize ){ if( nReq>pWriter->nSize ){
char *aNew = sqlite3_realloc(pWriter->aData, nReq); char *aNew = sqlite3_realloc64(pWriter->aData, nReq);
if( !aNew ) return SQLITE_NOMEM; if( !aNew ) return SQLITE_NOMEM;
pWriter->aData = aNew; pWriter->aData = aNew;
pWriter->nSize = nReq; pWriter->nSize = nReq;
@ -189348,7 +189442,7 @@ static int fts3SegWriterAdd(
*/ */
if( isCopyTerm ){ if( isCopyTerm ){
if( nTerm>pWriter->nMalloc ){ if( nTerm>pWriter->nMalloc ){
char *zNew = sqlite3_realloc(pWriter->zMalloc, nTerm*2); char *zNew = sqlite3_realloc64(pWriter->zMalloc, (i64)nTerm*2);
if( !zNew ){ if( !zNew ){
return SQLITE_NOMEM; return SQLITE_NOMEM;
} }
@ -189656,12 +189750,12 @@ static void fts3ColumnFilter(
static int fts3MsrBufferData( static int fts3MsrBufferData(
Fts3MultiSegReader *pMsr, /* Multi-segment-reader handle */ Fts3MultiSegReader *pMsr, /* Multi-segment-reader handle */
char *pList, char *pList,
int nList i64 nList
){ ){
if( nList>pMsr->nBuffer ){ if( nList>pMsr->nBuffer ){
char *pNew; char *pNew;
pMsr->nBuffer = nList*2; pMsr->nBuffer = nList*2;
pNew = (char *)sqlite3_realloc(pMsr->aBuffer, pMsr->nBuffer); pNew = (char *)sqlite3_realloc64(pMsr->aBuffer, pMsr->nBuffer);
if( !pNew ) return SQLITE_NOMEM; if( !pNew ) return SQLITE_NOMEM;
pMsr->aBuffer = pNew; pMsr->aBuffer = pNew;
} }
@ -189717,7 +189811,7 @@ SQLITE_PRIVATE int sqlite3Fts3MsrIncrNext(
fts3SegReaderSort(pMsr->apSegment, nMerge, j, xCmp); fts3SegReaderSort(pMsr->apSegment, nMerge, j, xCmp);
if( nList>0 && fts3SegReaderIsPending(apSegment[0]) ){ if( nList>0 && fts3SegReaderIsPending(apSegment[0]) ){
rc = fts3MsrBufferData(pMsr, pList, nList+1); rc = fts3MsrBufferData(pMsr, pList, (i64)nList+1);
if( rc!=SQLITE_OK ) return rc; if( rc!=SQLITE_OK ) return rc;
assert( (pMsr->aBuffer[nList] & 0xFE)==0x00 ); assert( (pMsr->aBuffer[nList] & 0xFE)==0x00 );
pList = pMsr->aBuffer; pList = pMsr->aBuffer;
@ -189854,11 +189948,11 @@ SQLITE_PRIVATE int sqlite3Fts3MsrIncrRestart(Fts3MultiSegReader *pCsr){
return SQLITE_OK; return SQLITE_OK;
} }
static int fts3GrowSegReaderBuffer(Fts3MultiSegReader *pCsr, int nReq){ static int fts3GrowSegReaderBuffer(Fts3MultiSegReader *pCsr, i64 nReq){
if( nReq>pCsr->nBuffer ){ if( nReq>pCsr->nBuffer ){
char *aNew; char *aNew;
pCsr->nBuffer = nReq*2; pCsr->nBuffer = nReq*2;
aNew = sqlite3_realloc(pCsr->aBuffer, pCsr->nBuffer); aNew = sqlite3_realloc64(pCsr->aBuffer, pCsr->nBuffer);
if( !aNew ){ if( !aNew ){
return SQLITE_NOMEM; return SQLITE_NOMEM;
} }
@ -189949,7 +190043,8 @@ SQLITE_PRIVATE int sqlite3Fts3SegReaderStep(
){ ){
pCsr->nDoclist = apSegment[0]->nDoclist; pCsr->nDoclist = apSegment[0]->nDoclist;
if( fts3SegReaderIsPending(apSegment[0]) ){ if( fts3SegReaderIsPending(apSegment[0]) ){
rc = fts3MsrBufferData(pCsr, apSegment[0]->aDoclist, pCsr->nDoclist); rc = fts3MsrBufferData(pCsr, apSegment[0]->aDoclist,
(i64)pCsr->nDoclist);
pCsr->aDoclist = pCsr->aBuffer; pCsr->aDoclist = pCsr->aBuffer;
}else{ }else{
pCsr->aDoclist = apSegment[0]->aDoclist; pCsr->aDoclist = apSegment[0]->aDoclist;
@ -190002,7 +190097,8 @@ SQLITE_PRIVATE int sqlite3Fts3SegReaderStep(
nByte = sqlite3Fts3VarintLen(iDelta) + (isRequirePos?nList+1:0); nByte = sqlite3Fts3VarintLen(iDelta) + (isRequirePos?nList+1:0);
rc = fts3GrowSegReaderBuffer(pCsr, nByte+nDoclist+FTS3_NODE_PADDING); rc = fts3GrowSegReaderBuffer(pCsr,
(i64)nByte+nDoclist+FTS3_NODE_PADDING);
if( rc ) return rc; if( rc ) return rc;
if( isFirst ){ if( isFirst ){
@ -190028,7 +190124,7 @@ SQLITE_PRIVATE int sqlite3Fts3SegReaderStep(
fts3SegReaderSort(apSegment, nMerge, j, xCmp); fts3SegReaderSort(apSegment, nMerge, j, xCmp);
} }
if( nDoclist>0 ){ if( nDoclist>0 ){
rc = fts3GrowSegReaderBuffer(pCsr, nDoclist+FTS3_NODE_PADDING); rc = fts3GrowSegReaderBuffer(pCsr, (i64)nDoclist+FTS3_NODE_PADDING);
if( rc ) return rc; if( rc ) return rc;
memset(&pCsr->aBuffer[nDoclist], 0, FTS3_NODE_PADDING); memset(&pCsr->aBuffer[nDoclist], 0, FTS3_NODE_PADDING);
pCsr->aDoclist = pCsr->aBuffer; pCsr->aDoclist = pCsr->aBuffer;
@ -190741,7 +190837,7 @@ struct NodeReader {
static void blobGrowBuffer(Blob *pBlob, int nMin, int *pRc){ static void blobGrowBuffer(Blob *pBlob, int nMin, int *pRc){
if( *pRc==SQLITE_OK && nMin>pBlob->nAlloc ){ if( *pRc==SQLITE_OK && nMin>pBlob->nAlloc ){
int nAlloc = nMin; int nAlloc = nMin;
char *a = (char *)sqlite3_realloc(pBlob->a, nAlloc); char *a = (char *)sqlite3_realloc64(pBlob->a, nAlloc);
if( a ){ if( a ){
pBlob->nAlloc = nAlloc; pBlob->nAlloc = nAlloc;
pBlob->a = a; pBlob->a = a;
@ -191538,7 +191634,7 @@ static int fts3RepackSegdirLevel(
if( nIdx>=nAlloc ){ if( nIdx>=nAlloc ){
int *aNew; int *aNew;
nAlloc += 16; nAlloc += 16;
aNew = sqlite3_realloc(aIdx, nAlloc*sizeof(int)); aNew = sqlite3_realloc64(aIdx, nAlloc*sizeof(int));
if( !aNew ){ if( !aNew ){
rc = SQLITE_NOMEM; rc = SQLITE_NOMEM;
break; break;
@ -191912,7 +192008,7 @@ SQLITE_PRIVATE int sqlite3Fts3Incrmerge(Fts3Table *p, int nMerge, int nMin){
/* Allocate space for the cursor, filter and writer objects */ /* Allocate space for the cursor, filter and writer objects */
const int nAlloc = sizeof(*pCsr) + sizeof(*pFilter) + sizeof(*pWriter); const int nAlloc = sizeof(*pCsr) + sizeof(*pFilter) + sizeof(*pWriter);
pWriter = (IncrmergeWriter *)sqlite3_malloc(nAlloc); pWriter = (IncrmergeWriter *)sqlite3_malloc64(nAlloc);
if( !pWriter ) return SQLITE_NOMEM; if( !pWriter ) return SQLITE_NOMEM;
pFilter = (Fts3SegFilter *)&pWriter[1]; pFilter = (Fts3SegFilter *)&pWriter[1];
pCsr = (Fts3MultiSegReader *)&pFilter[1]; pCsr = (Fts3MultiSegReader *)&pFilter[1];
@ -192548,7 +192644,7 @@ SQLITE_PRIVATE int sqlite3Fts3DeferredTokenList(
return SQLITE_OK; return SQLITE_OK;
} }
pRet = (char *)sqlite3_malloc(p->pList->nData); pRet = (char *)sqlite3_malloc64(p->pList->nData);
if( !pRet ) return SQLITE_NOMEM; if( !pRet ) return SQLITE_NOMEM;
nSkip = sqlite3Fts3GetVarint(p->pList->aData, &dummy); nSkip = sqlite3Fts3GetVarint(p->pList->aData, &dummy);
@ -192568,7 +192664,7 @@ SQLITE_PRIVATE int sqlite3Fts3DeferToken(
int iCol /* Column that token must appear in (or -1) */ int iCol /* Column that token must appear in (or -1) */
){ ){
Fts3DeferredToken *pDeferred; Fts3DeferredToken *pDeferred;
pDeferred = sqlite3_malloc(sizeof(*pDeferred)); pDeferred = sqlite3_malloc64(sizeof(*pDeferred));
if( !pDeferred ){ if( !pDeferred ){
return SQLITE_NOMEM; return SQLITE_NOMEM;
} }
@ -204147,7 +204243,7 @@ static int geopolyUpdate(
sqlite3_free(p); sqlite3_free(p);
nChange = 1; nChange = 1;
} }
for(jj=1; jj<pRtree->nAux; jj++){ for(jj=1; jj<nData-2; jj++){
nChange++; nChange++;
sqlite3_bind_value(pUp, jj+2, aData[jj+2]); sqlite3_bind_value(pUp, jj+2, aData[jj+2]);
} }
@ -204750,8 +204846,9 @@ static void icuRegexpFunc(sqlite3_context *p, int nArg, sqlite3_value **apArg){
if( U_SUCCESS(status) ){ if( U_SUCCESS(status) ){
sqlite3_set_auxdata(p, 0, pExpr, icuRegexpDelete); sqlite3_set_auxdata(p, 0, pExpr, icuRegexpDelete);
}else{ pExpr = sqlite3_get_auxdata(p, 0);
assert(!pExpr); }
if( !pExpr ){
icuFunctionError(p, "uregex_open", status); icuFunctionError(p, "uregex_open", status);
return; return;
} }
@ -236637,7 +236734,7 @@ static void fts5SourceIdFunc(
){ ){
assert( nArg==0 ); assert( nArg==0 );
UNUSED_PARAM2(nArg, apUnused); UNUSED_PARAM2(nArg, apUnused);
sqlite3_result_text(pCtx, "fts5: 2022-07-21 15:24:47 698edb77537b67c41adc68f9b892db56bcf9a55e00371a61420f3ddd668e6603", -1, SQLITE_TRANSIENT); sqlite3_result_text(pCtx, "fts5: 2022-09-29 15:55:41 a29f9949895322123f7c38fbe94c649a9d6e6c9cd0c3b41c96d694552f26b309", -1, SQLITE_TRANSIENT);
} }
/* /*

6
sqlite3-binding.h
View File

@ -147,9 +147,9 @@ extern "C" {
** [sqlite3_libversion_number()], [sqlite3_sourceid()], ** [sqlite3_libversion_number()], [sqlite3_sourceid()],
** [sqlite_version()] and [sqlite_source_id()]. ** [sqlite_version()] and [sqlite_source_id()].
*/ */
#define SQLITE_VERSION "3.39.2" #define SQLITE_VERSION "3.39.4"
#define SQLITE_VERSION_NUMBER 3039002 #define SQLITE_VERSION_NUMBER 3039004
#define SQLITE_SOURCE_ID "2022-07-21 15:24:47 698edb77537b67c41adc68f9b892db56bcf9a55e00371a61420f3ddd668e6603" #define SQLITE_SOURCE_ID "2022-09-29 15:55:41 a29f9949895322123f7c38fbe94c649a9d6e6c9cd0c3b41c96d694552f26b309"
/* /*
** CAPI3REF: Run-Time Library Version Numbers ** CAPI3REF: Run-Time Library Version Numbers