Do not let the multi-core sorter use lookaside memory, which is not
thread-safe.
FossilOrigin-Name: acdc7d1270b6aacf4612296a8d4dd596042b058c
diff --git a/manifest b/manifest
index 38f1409..8a00a3e 100644
--- a/manifest
+++ b/manifest
@@ -1,5 +1,5 @@
-C Merge\sin\sall\sthe\slatest\strunk\schanges.
-D 2012-08-21T17:46:18.408
+C Do\snot\slet\sthe\smulti-core\ssorter\suse\slookaside\smemory,\swhich\sis\snot\nthread-safe.
+D 2012-08-22T15:16:36.722
F Makefile.arm-wince-mingw32ce-gcc d6df77f1f48d690bd73162294bbba7f59507c72f
F Makefile.in adec39f15a9c7000f634b87a535b95279b0cbd09
F Makefile.linux-gcc 91d710bdc4998cb015f39edf3cb314ec4f4d7e23
@@ -231,21 +231,21 @@
F src/test_vfstrace.c 6b28adb2a0e8ecd0f2e3581482e1f658b11b4067
F src/test_wholenumber.c 3d2b9ed1505c40ad5c5ca2ad16ae7a289d6cc251
F src/test_wsd.c 41cadfd9d97fe8e3e4e44f61a4a8ccd6f7ca8fe9
-F src/threads.c 2b918d1f4f0b0831e8f41c49bcaa097f01490120
+F src/threads.c cde9d885fd562b5427f89a42a8829085f88b17df
F src/tokenize.c 1e86210d3976717a19238ea7b047fac481fe8c12
F src/trigger.c ee7e178fb9188f44b532cebd449a7c1df90fb684
F src/update.c d3076782c887c10e882996550345da9c4c9f9dea
F src/utf.c 890c67dcfcc7a74623c95baac7535aadfe265e84
F src/util.c 0af2e515dc0dabacec931bca39525f6c3f1c5455
F src/vacuum.c 587a52bb8833d7ac15af8916f25437e2575028bd
-F src/vdbe.c 75da79cdcd58481825a06f045bc2f5ea3966eeae
+F src/vdbe.c 1a451790e5abd4df1c0ad0c39d5d6398888b473f
F src/vdbe.h 18f581cac1f4339ec3299f3e0cc6e11aec654cdb
-F src/vdbeInt.h 986b6b11a13c517337355009e5438703ba5b0a40
+F src/vdbeInt.h 3c238336fc5b186b193553dbac4e1979d91e0c0d
F src/vdbeapi.c 88ea823bbcb4320f5a6607f39cd7c2d3cc4c26b1
-F src/vdbeaux.c dce80038c3c41f2680e5ab4dd0f7e0d8b7ff9071
+F src/vdbeaux.c 84bd15358329f4005a7bceefafc1e798592e987d
F src/vdbeblob.c 32f2a4899d67f69634ea4dd93e3f651936d732cb
F src/vdbemem.c cb55e84b8e2c15704968ee05f0fae25883299b74
-F src/vdbesort.c 3945ae71fe43e52727ec52103a07492e9df1776f
+F src/vdbesort.c acaefad52f6345a06fcfe2ec7da0c7d7d2569c39
F src/vdbetrace.c 8bd5da325fc90f28464335e4cc4ad1407fe30835
F src/vtab.c bb8ea3a26608bb1357538a5d2fc72beba6638998
F src/wal.c 9294df6f96aae5909ae1a9b733fd1e1b4736978b
@@ -1012,7 +1012,7 @@
F tool/warnings-clang.sh f6aa929dc20ef1f856af04a730772f59283631d4
F tool/warnings.sh fbc018d67fd7395f440c28f33ef0f94420226381
F tool/win/sqlite.vsix 67d8a99aceb56384a81b3f30d6c71743146d2cc9
-P 555fc07efd1a1bc597804dcacbbcd95e88e75e90 573770f5a66fa4d708931b30350149eb739da607
-R 6a248acc2b1ad3eddb9f82f26a87ebb7
+P 45cdc32f1e4d33959108dac94f551a4b8030424d
+R fe69bbfbdf0f9035e48cc3502476a4c4
U drh
-Z eefdd7d4c689b509af3b4731cefe3c98
+Z cf3f449e5e4dc5f0a36f059aada3751c
diff --git a/manifest.uuid b/manifest.uuid
index c3f2313..571cd82 100644
--- a/manifest.uuid
+++ b/manifest.uuid
@@ -1 +1 @@
-45cdc32f1e4d33959108dac94f551a4b8030424d
\ No newline at end of file
+acdc7d1270b6aacf4612296a8d4dd596042b058c
\ No newline at end of file
diff --git a/src/threads.c b/src/threads.c
index 33781a7..7cc9642 100644
--- a/src/threads.c
+++ b/src/threads.c
@@ -47,7 +47,6 @@
void *pIn /* Argument passed into xTask() */
){
SQLiteThread *p;
- int rc;
assert( ppThread!=0 );
assert( xTask!=0 );
diff --git a/src/vdbe.c b/src/vdbe.c
index 12e7325..8d512ed 100644
--- a/src/vdbe.c
+++ b/src/vdbe.c
@@ -4405,7 +4405,7 @@
assert( pC->isSorter==(pOp->opcode==OP_SorterSort) );
res = 1;
if( isSorter(pC) ){
- rc = sqlite3VdbeSorterRewind(db, pC, &res);
+ rc = sqlite3VdbeSorterRewind(pC, &res);
}else{
pCrsr = pC->pCursor;
assert( pCrsr );
@@ -4474,7 +4474,7 @@
assert( pC->isSorter==(pOp->opcode==OP_SorterNext) );
if( isSorter(pC) ){
assert( pOp->opcode==OP_SorterNext );
- rc = sqlite3VdbeSorterNext(db, pC, &res);
+ rc = sqlite3VdbeSorterNext(pC, &res);
}else{
res = 1;
assert( pC->deferredMoveto==0 );
@@ -4530,7 +4530,7 @@
rc = ExpandBlob(pIn2);
if( rc==SQLITE_OK ){
if( isSorter(pC) ){
- rc = sqlite3VdbeSorterWrite(db, pC, pIn2);
+ rc = sqlite3VdbeSorterWrite(pC, pIn2);
}else{
nKey = pIn2->n;
zKey = pIn2->z;
diff --git a/src/vdbeInt.h b/src/vdbeInt.h
index 1f5694a..88a2eef 100644
--- a/src/vdbeInt.h
+++ b/src/vdbeInt.h
@@ -422,19 +422,19 @@
#ifdef SQLITE_OMIT_MERGE_SORT
# define sqlite3VdbeSorterInit(Y,Z) SQLITE_OK
-# define sqlite3VdbeSorterWrite(X,Y,Z) SQLITE_OK
-# define sqlite3VdbeSorterClose(Y,Z)
+# define sqlite3VdbeSorterWrite(Y,Z) SQLITE_OK
+# define sqlite3VdbeSorterClose(Z)
# define sqlite3VdbeSorterRowkey(Y,Z) SQLITE_OK
-# define sqlite3VdbeSorterRewind(X,Y,Z) SQLITE_OK
-# define sqlite3VdbeSorterNext(X,Y,Z) SQLITE_OK
-# define sqlite3VdbeSorterCompare(X,Y,Z) SQLITE_OK
+# define sqlite3VdbeSorterRewind(Y,Z) SQLITE_OK
+# define sqlite3VdbeSorterNext(Y,Z) SQLITE_OK
+# define sqlite3VdbeSorterCompare(Y,Z) SQLITE_OK
#else
int sqlite3VdbeSorterInit(sqlite3 *, VdbeCursor *);
-void sqlite3VdbeSorterClose(sqlite3 *, VdbeCursor *);
+void sqlite3VdbeSorterClose(VdbeCursor *);
int sqlite3VdbeSorterRowkey(const VdbeCursor *, Mem *);
-int sqlite3VdbeSorterNext(sqlite3 *, const VdbeCursor *, int *);
-int sqlite3VdbeSorterRewind(sqlite3 *, const VdbeCursor *, int *);
-int sqlite3VdbeSorterWrite(sqlite3 *, const VdbeCursor *, Mem *);
+int sqlite3VdbeSorterNext(const VdbeCursor *, int *);
+int sqlite3VdbeSorterRewind(const VdbeCursor *, int *);
+int sqlite3VdbeSorterWrite(const VdbeCursor *, Mem *);
int sqlite3VdbeSorterCompare(const VdbeCursor *, Mem *, int *);
#endif
diff --git a/src/vdbeaux.c b/src/vdbeaux.c
index 3ccf711..2551b9f 100644
--- a/src/vdbeaux.c
+++ b/src/vdbeaux.c
@@ -1575,7 +1575,7 @@
if( pCx==0 ){
return;
}
- sqlite3VdbeSorterClose(p->db, pCx);
+ sqlite3VdbeSorterClose(pCx);
if( pCx->pBt ){
sqlite3BtreeClose(pCx->pBt);
/* The pCx->pCursor will be close automatically, if it exists, by
diff --git a/src/vdbesort.c b/src/vdbesort.c
index 4b546e7..0fd17ab 100644
--- a/src/vdbesort.c
+++ b/src/vdbesort.c
@@ -107,6 +107,8 @@
SorterRecord *pRecord; /* Head of in-memory record list */
int nRecord; /* Number of elements on the pRecord list */
UnpackedRecord *pUnpacked; /* Used to unpack keys */
+ KeyInfo *pKeyInfo; /* Copy of cursor KeyInfo without db ptr */
+ sqlite3 *db; /* Database connection */
};
/*
@@ -116,6 +118,7 @@
struct VdbeSorterIter {
i64 iReadOff; /* Current read offset */
i64 iEof; /* 1 byte past EOF for this iterator */
+ sqlite3 *db; /* Corresponding database connection */
int nAlloc; /* Bytes of space at aAlloc */
int nKey; /* Number of bytes in key */
sqlite3_file *pFile; /* File iterator is reading from */
@@ -178,7 +181,6 @@
** next call to this function.
*/
static int vdbeSorterIterRead(
- sqlite3 *db, /* Database handle (for malloc) */
VdbeSorterIter *p, /* Iterator */
int nByte, /* Bytes of data to read */
u8 **ppOut /* OUT: Pointer to buffer containing data */
@@ -223,7 +225,7 @@
if( p->nAlloc<nByte ){
int nNew = p->nAlloc*2;
while( nByte>nNew ) nNew = nNew*2;
- p->aAlloc = sqlite3DbReallocOrFree(db, p->aAlloc, nNew);
+ p->aAlloc = sqlite3DbReallocOrFree(p->db, p->aAlloc, nNew);
if( !p->aAlloc ) return SQLITE_NOMEM;
p->nAlloc = nNew;
}
@@ -243,7 +245,7 @@
nCopy = nRem;
if( nRem>p->nBuffer ) nCopy = p->nBuffer;
- rc = vdbeSorterIterRead(db, p, nCopy, &aNext);
+ rc = vdbeSorterIterRead(p, nCopy, &aNext);
if( rc!=SQLITE_OK ) return rc;
assert( aNext!=p->aAlloc );
memcpy(&p->aAlloc[nByte - nRem], aNext, nCopy);
@@ -260,7 +262,7 @@
** Read a varint from the stream of data accessed by p. Set *pnOut to
** the value read.
*/
-static int vdbeSorterIterVarint(sqlite3 *db, VdbeSorterIter *p, u64 *pnOut){
+static int vdbeSorterIterVarint(VdbeSorterIter *p, u64 *pnOut){
int iBuf;
iBuf = p->iReadOff % p->nBuffer;
@@ -270,7 +272,7 @@
u8 aVarint[16], *a;
int i = 0, rc;
do{
- rc = vdbeSorterIterRead(db, p, 1, &a);
+ rc = vdbeSorterIterRead(p, 1, &a);
if( rc ) return rc;
aVarint[(i++)&0xf] = a[0];
}while( (a[0]&0x80)!=0 );
@@ -286,11 +288,11 @@
** no error occurs, or an SQLite error code if one does.
*/
static int vdbeSorterIterNext(
- sqlite3 *db, /* Database handle (for sqlite3DbMalloc() ) */
VdbeSorterIter *pIter /* Iterator to advance */
){
int rc; /* Return Code */
u64 nRec = 0; /* Size of record in bytes */
+ sqlite3 *db = pIter->db; /* Database connection */
if( pIter->iReadOff>=pIter->iEof ){
/* This is an EOF condition */
@@ -298,10 +300,10 @@
return SQLITE_OK;
}
- rc = vdbeSorterIterVarint(db, pIter, &nRec);
+ rc = vdbeSorterIterVarint(pIter, &nRec);
if( rc==SQLITE_OK ){
pIter->nKey = (int)nRec;
- rc = vdbeSorterIterRead(db, pIter, (int)nRec, &pIter->aKey);
+ rc = vdbeSorterIterRead(pIter, (int)nRec, &pIter->aKey);
}
return rc;
@@ -314,7 +316,6 @@
** PMA is empty).
*/
static int vdbeSorterIterInit(
- sqlite3 *db, /* Database handle */
const VdbeSorter *pSorter, /* Sorter object */
i64 iStart, /* Start offset in pFile */
VdbeSorterIter *pIter, /* Iterator to populate */
@@ -322,6 +323,7 @@
){
int rc = SQLITE_OK;
int nBuf;
+ sqlite3 *db = pSorter->db;
nBuf = sqlite3BtreeGetPageSize(db->aDb[0].pBt);
@@ -330,6 +332,7 @@
assert( pIter->aBuffer==0 );
pIter->pFile = pSorter->pTemp1;
pIter->iReadOff = iStart;
+ pIter->db = db;
pIter->nAlloc = 128;
pIter->aAlloc = (u8 *)sqlite3DbMallocRaw(db, pIter->nAlloc);
pIter->nBuffer = nBuf;
@@ -355,14 +358,14 @@
if( rc==SQLITE_OK ){
u64 nByte; /* Size of PMA in bytes */
pIter->iEof = pSorter->iWriteOff;
- rc = vdbeSorterIterVarint(db, pIter, &nByte);
+ rc = vdbeSorterIterVarint(pIter, &nByte);
pIter->iEof = pIter->iReadOff + nByte;
*pnByte += nByte;
}
}
if( rc==SQLITE_OK ){
- rc = vdbeSorterIterNext(db, pIter);
+ rc = vdbeSorterIterNext(pIter);
}
return rc;
}
@@ -384,14 +387,14 @@
** has been allocated and contains an unpacked record that is used as key2.
*/
static void vdbeSorterCompare(
- const VdbeCursor *pCsr, /* Cursor object (for pKeyInfo) */
+ VdbeSorter *pSorter, /* The sorter */
int bOmitRowid, /* Ignore rowid field at end of keys */
const void *pKey1, int nKey1, /* Left side of comparison */
const void *pKey2, int nKey2, /* Right side of comparison */
int *pRes, /* OUT: Result of comparison */
UnpackedRecord *r2 /* Space to hold the unpacked Key2 record */
){
- KeyInfo *pKeyInfo = pCsr->pKeyInfo;
+ KeyInfo *pKeyInfo = pSorter->pKeyInfo;
int i;
if( pKey2 ){
@@ -419,8 +422,7 @@
** multiple b-tree segments. Parameter iOut is the index of the aTree[]
** value to recalculate.
*/
-static int vdbeSorterDoCompare(const VdbeCursor *pCsr, int iOut){
- VdbeSorter *pSorter = pCsr->pSorter;
+static int vdbeSorterDoCompare(VdbeSorter *pSorter, int iOut){
int i1;
int i2;
int iRes;
@@ -447,7 +449,7 @@
}else{
int res;
vdbeSorterCompare(
- pCsr, 0, p1->aKey, p1->nKey, p2->aKey, p2->nKey, &res,
+ pSorter, 0, p1->aKey, p1->nKey, p2->aKey, p2->nKey, &res,
pSorter->pUnpacked
);
if( res<=0 ){
@@ -469,17 +471,32 @@
int mxCache; /* Cache size */
VdbeSorter *pSorter; /* The new sorter */
char *d; /* Dummy */
+ int nByte; /* Bytes in pKeyInfo */
assert( pCsr->pKeyInfo && pCsr->pBt==0 );
pCsr->pSorter = pSorter = sqlite3DbMallocZero(db, sizeof(VdbeSorter));
if( pSorter==0 ){
return SQLITE_NOMEM;
}
+ pSorter->db = db;
pSorter->pUnpacked = sqlite3VdbeAllocUnpackedRecord(pCsr->pKeyInfo, 0, 0, &d);
if( pSorter->pUnpacked==0 ) return SQLITE_NOMEM;
assert( pSorter->pUnpacked==(UnpackedRecord *)d );
+ /* pSorter->pKeyInfo is a copy of pCsr->pKeyInfo with the db field set to
+ ** zero. We use this modified pKeyInfo for sorting so that no lookaside
+ ** memory will be used, so that sorting can proceed in parallel in multiple
+ ** threads.
+ */
+ nByte = sizeof(KeyInfo) + (pCsr->pKeyInfo->nField - 1)*sizeof(CollSeq*);
+ pSorter->pKeyInfo = sqlite3DbMallocRaw(db, nByte);
+ if( pSorter->pKeyInfo==0 ){
+ return SQLITE_NOMEM;
+ }
+ memcpy(pSorter->pKeyInfo, pCsr->pKeyInfo, nByte);
+ pSorter->pKeyInfo->db = 0;
+
if( !sqlite3TempInMemory(db) ){
pgsz = sqlite3BtreeGetPageSize(db->aDb[0].pBt);
pSorter->mnPmaSize = SORTER_MIN_WORKING * pgsz;
@@ -506,9 +523,10 @@
/*
** Free any cursor components allocated by sqlite3VdbeSorterXXX routines.
*/
-void sqlite3VdbeSorterClose(sqlite3 *db, VdbeCursor *pCsr){
+void sqlite3VdbeSorterClose(VdbeCursor *pCsr){
VdbeSorter *pSorter = pCsr->pSorter;
if( pSorter ){
+ sqlite3 *db = pSorter->db;
if( pSorter->aIter ){
int i;
for(i=0; i<pSorter->nTree; i++){
@@ -521,6 +539,7 @@
}
vdbeSorterRecordFree(db, pSorter->pRecord);
sqlite3DbFree(db, pSorter->pUnpacked);
+ sqlite3DbFree(db, pSorter->pKeyInfo);
sqlite3DbFree(db, pSorter);
pCsr->pSorter = 0;
}
@@ -545,7 +564,7 @@
** Set *ppOut to the head of the new list.
*/
static void vdbeSorterMerge(
- const VdbeCursor *pCsr, /* For pKeyInfo */
+ VdbeSorter *pSorter, /* The sorter object */
SorterRecord *p1, /* First list to merge */
SorterRecord *p2, /* Second list to merge */
SorterRecord **ppOut, /* OUT: Head of merged list */
@@ -557,7 +576,7 @@
while( p1 && p2 ){
int res;
- vdbeSorterCompare(pCsr, 0, p1->pVal, p1->nVal, pVal2, p2->nVal, &res,
+ vdbeSorterCompare(pSorter, 0, p1->pVal, p1->nVal, pVal2, p2->nVal, &res,
pUnpacked);
if( res<=0 ){
*pp = p1;
@@ -580,9 +599,9 @@
** Background sorting task
*/
typedef struct SortTask {
- SorterRecord *pList; /* List of elements to be sorted */
- const VdbeCursor *pCsr; /* Cursor. Needed for pCur->pKeyInfo */
+ VdbeSorter *pSorter; /* The sorter for which this task works */
UnpackedRecord *pUnpacked; /* Space to hold an unpacked key */
+ SorterRecord *pList; /* List of elements to be sorted */
SorterRecord **apSlot; /* Temp memory for the merge sort */
} SortTask;
@@ -599,7 +618,7 @@
p->pNext = 0;
for(i=0; a[i]; i++){
if( a[i]==0 ) break;
- vdbeSorterMerge(pTask->pCsr, a[i], p, &p, pTask->pUnpacked);
+ vdbeSorterMerge(pTask->pSorter, a[i], p, &p, pTask->pUnpacked);
a[i] = 0;
}
a[i] = p;
@@ -607,7 +626,7 @@
}
p = 0;
for(i=0; i<64; i++){
- vdbeSorterMerge(pTask->pCsr, a[i], p, &p, pTask->pUnpacked);
+ vdbeSorterMerge(pTask->pSorter, a[i], p, &p, pTask->pUnpacked);
}
pTask->pList = p;
return p;
@@ -644,10 +663,8 @@
** if successful, or an SQLite error code (i.e. SQLITE_NOMEM) if an error
** occurs.
*/
-static int vdbeSorterSort(const VdbeCursor *pCsr){
+static int vdbeSorterSort(VdbeSorter *pSorter){
int rc;
- SorterRecord *p;
- VdbeSorter *pSorter = pCsr->pSorter;
char *pDummy = 0;
int nByteA, nByteB;
SortTask aTask[2];
@@ -655,19 +672,19 @@
nByteA = 64*sizeof(SorterRecord*);
nByteB = ROUND8(sizeof(UnpackedRecord));
- nByteB += sizeof(Mem)*(pCsr->pKeyInfo->nField+1);
+ nByteB += sizeof(Mem)*(pSorter->pKeyInfo->nField+1);
aTask[0].apSlot = (SorterRecord **)sqlite3MallocZero(2*(nByteA + nByteB));
if( !aTask[0].apSlot ){
return SQLITE_NOMEM;
}
- aTask[0].pCsr = pCsr;
- aTask[0].pUnpacked = sqlite3VdbeAllocUnpackedRecord(pCsr->pKeyInfo,
+ aTask[0].pSorter = pSorter;
+ aTask[0].pUnpacked = sqlite3VdbeAllocUnpackedRecord(pSorter->pKeyInfo,
(char*)&aTask[0].apSlot[64], nByteB, &pDummy);
assert( pDummy==0 );
- aTask[1].apSlot = (nByteA+nByteB)+(char*)aTask[0].apSlot;
- aTask[1].pCsr = pCsr;
- aTask[1].pUnpacked = sqlite3VdbeAllocUnpackedRecord(pCsr->pKeyInfo,
+ aTask[1].apSlot = (SorterRecord**)((nByteA+nByteB)+(char*)aTask[0].apSlot);
+ aTask[1].pSorter = pSorter;
+ aTask[1].pUnpacked = sqlite3VdbeAllocUnpackedRecord(pSorter->pKeyInfo,
(char*)&aTask[1].apSlot[64], nByteB, &pDummy);
assert( pDummy==0 );
@@ -678,10 +695,10 @@
if( rc==SQLITE_NOMEM ){
vdbeSorterBackgroundSort(&aTask[0]);
}else{
- rc = sqlite3ThreadJoin(pThread, &pDummy);
+ rc = sqlite3ThreadJoin(pThread, (void**)&pDummy);
}
- vdbeSorterMerge(pCsr, aTask[0].pList, aTask[1].pList, &pSorter->pRecord,
- aTask[0].pUnpacked);
+ vdbeSorterMerge(pSorter, aTask[0].pList, aTask[1].pList, &pSorter->pRecord,
+ pSorter->pUnpacked);
sqlite3_free(aTask[0].apSlot);
return rc;
}
@@ -785,10 +802,10 @@
** Each record consists of a varint followed by a blob of data (the
** key). The varint is the number of bytes in the blob of data.
*/
-static int vdbeSorterListToPMA(sqlite3 *db, const VdbeCursor *pCsr){
+static int vdbeSorterListToPMA(VdbeSorter *pSorter){
int rc = SQLITE_OK; /* Return code */
- VdbeSorter *pSorter = pCsr->pSorter;
FileWriter writer;
+ sqlite3 *db = pSorter->db;
memset(&writer, 0, sizeof(FileWriter));
@@ -798,7 +815,7 @@
return rc;
}
- rc = vdbeSorterSort(pCsr);
+ rc = vdbeSorterSort(pSorter);
/* If the first temporary PMA file has not been opened, open it now. */
if( rc==SQLITE_OK && pSorter->pTemp1==0 ){
@@ -833,11 +850,11 @@
** Add a record to the sorter.
*/
int sqlite3VdbeSorterWrite(
- sqlite3 *db, /* Database handle */
- const VdbeCursor *pCsr, /* Sorter cursor */
+ const VdbeCursor *pCsr, /* Sorter cursor */
Mem *pVal /* Memory cell containing record */
){
VdbeSorter *pSorter = pCsr->pSorter;
+ sqlite3 *db = pSorter->db;
int rc = SQLITE_OK; /* Return Code */
SorterRecord *pNew; /* New list element */
@@ -874,7 +891,7 @@
+ sqlite3VarintLen(pSorter->nInMemory)
+ pSorter->nInMemory;
#endif
- rc = vdbeSorterListToPMA(db, pCsr);
+ rc = vdbeSorterListToPMA(pSorter);
pSorter->nInMemory = 0;
assert( rc!=SQLITE_OK || (nExpect==pSorter->iWriteOff) );
}
@@ -886,11 +903,9 @@
** Helper function for sqlite3VdbeSorterRewind().
*/
static int vdbeSorterInitMerge(
- sqlite3 *db, /* Database handle */
- const VdbeCursor *pCsr, /* Cursor handle for this sorter */
+ VdbeSorter *pSorter, /* The sorter */
i64 *pnByte /* Sum of bytes in all opened PMAs */
){
- VdbeSorter *pSorter = pCsr->pSorter;
int rc = SQLITE_OK; /* Return code */
int i; /* Used to iterator through aIter[] */
i64 nByte = 0; /* Total bytes in all opened PMAs */
@@ -898,7 +913,7 @@
/* Initialize the iterators. */
for(i=0; i<SORTER_MAX_MERGE_COUNT; i++){
VdbeSorterIter *pIter = &pSorter->aIter[i];
- rc = vdbeSorterIterInit(db, pSorter, pSorter->iReadOff, pIter, &nByte);
+ rc = vdbeSorterIterInit(pSorter, pSorter->iReadOff, pIter, &nByte);
pSorter->iReadOff = pIter->iEof;
assert( rc!=SQLITE_OK || pSorter->iReadOff<=pSorter->iWriteOff );
if( rc!=SQLITE_OK || pSorter->iReadOff>=pSorter->iWriteOff ) break;
@@ -906,7 +921,7 @@
/* Initialize the aTree[] array. */
for(i=pSorter->nTree-1; rc==SQLITE_OK && i>0; i--){
- rc = vdbeSorterDoCompare(pCsr, i);
+ rc = vdbeSorterDoCompare(pSorter, i);
}
*pnByte = nByte;
@@ -917,8 +932,9 @@
** Once the sorter has been populated, this function is called to prepare
** for iterating through its contents in sorted order.
*/
-int sqlite3VdbeSorterRewind(sqlite3 *db, const VdbeCursor *pCsr, int *pbEof){
+int sqlite3VdbeSorterRewind(const VdbeCursor *pCsr, int *pbEof){
VdbeSorter *pSorter = pCsr->pSorter;
+ sqlite3 *db = pSorter->db;
int rc; /* Return code */
sqlite3_file *pTemp2 = 0; /* Second temp file to use */
i64 iWrite2 = 0; /* Write offset for pTemp2 */
@@ -934,11 +950,11 @@
if( pSorter->nPMA==0 ){
*pbEof = !pSorter->pRecord;
assert( pSorter->aTree==0 );
- return vdbeSorterSort(pCsr);
+ return vdbeSorterSort(pSorter);
}
/* Write the current in-memory list to a PMA. */
- rc = vdbeSorterListToPMA(db, pCsr);
+ rc = vdbeSorterListToPMA(pSorter);
if( rc!=SQLITE_OK ) return rc;
/* Allocate space for aIter[] and aTree[]. */
@@ -974,7 +990,7 @@
** initialize interators for SORTER_MAX_MERGE_COUNT of them. These PMAs
** are merged into a single PMA that is written to file pTemp2.
*/
- rc = vdbeSorterInitMerge(db, pCsr, &nWrite);
+ rc = vdbeSorterInitMerge(pSorter, &nWrite);
assert( rc!=SQLITE_OK || pSorter->aIter[ pSorter->aTree[1] ].pFile );
if( rc!=SQLITE_OK || pSorter->nPMA<=SORTER_MAX_MERGE_COUNT ){
break;
@@ -996,7 +1012,7 @@
fileWriterWriteVarint(&writer, pIter->nKey);
fileWriterWrite(&writer, pIter->aKey, pIter->nKey);
- rc = sqlite3VdbeSorterNext(db, pCsr, &bEof);
+ rc = sqlite3VdbeSorterNext(pCsr, &bEof);
}
rc2 = fileWriterFinish(db, &writer, &iWrite2);
if( rc==SQLITE_OK ) rc = rc2;
@@ -1026,17 +1042,18 @@
/*
** Advance to the next element in the sorter.
*/
-int sqlite3VdbeSorterNext(sqlite3 *db, const VdbeCursor *pCsr, int *pbEof){
+int sqlite3VdbeSorterNext(const VdbeCursor *pCsr, int *pbEof){
VdbeSorter *pSorter = pCsr->pSorter;
+ sqlite3 *db = pSorter->db;
int rc; /* Return code */
if( pSorter->aTree ){
int iPrev = pSorter->aTree[1];/* Index of iterator to advance */
int i; /* Index of aTree[] to recalculate */
- rc = vdbeSorterIterNext(db, &pSorter->aIter[iPrev]);
+ rc = vdbeSorterIterNext(&pSorter->aIter[iPrev]);
for(i=(pSorter->nTree+iPrev)/2; rc==SQLITE_OK && i>0; i=i/2){
- rc = vdbeSorterDoCompare(pCsr, i);
+ rc = vdbeSorterDoCompare(pSorter, i);
}
*pbEof = (pSorter->aIter[pSorter->aTree[1]].pFile==0);
@@ -1110,7 +1127,7 @@
void *pKey; int nKey; /* Sorter key to compare pVal with */
pKey = vdbeSorterRowkey(pSorter, &nKey);
- vdbeSorterCompare(pCsr, 1, pVal->z, pVal->n, pKey, nKey, pRes,
+ vdbeSorterCompare(pSorter, 1, pVal->z, pVal->n, pKey, nKey, pRes,
pSorter->pUnpacked);
return SQLITE_OK;
}
