Lines Matching refs:pSorter
21099 VdbeSorter *pSorter; /* CURTYPE_SORTER. Sorter object */
92221 sqlite3VdbeSorterReset(db, pC->uc.pSorter);
95045 VdbeSorter *pSorter; /* Sorter that owns this sub-task */
95362 if( pFile->iEof<=(i64)(pTask->pSorter->db->nMaxSorterMmap) ){
95398 int pgsz = pTask->pSorter->pgsz;
95512 sqlite3VdbeRecordUnpack(pTask->pSorter->pKeyInfo, nKey2, pKey2, r2);
95539 sqlite3VdbeRecordUnpack(pTask->pSorter->pKeyInfo, nKey2, pKey2, r2);
95573 if( pTask->pSorter->pKeyInfo->nKeyField>1 ){
95579 assert( !(pTask->pSorter->pKeyInfo->aSortFlags[0]&KEYINFO_ORDER_BIGNULL) );
95580 if( pTask->pSorter->pKeyInfo->aSortFlags[0] ){
95643 if( pTask->pSorter->pKeyInfo->nKeyField>1 ){
95648 }else if( pTask->pSorter->pKeyInfo->aSortFlags[0] ){
95649 assert( !(pTask->pSorter->pKeyInfo->aSortFlags[0]&KEYINFO_ORDER_BIGNULL) );
95682 VdbeSorter *pSorter; /* The new sorter */
95685 int sz; /* Size of pSorter in bytes */
95715 pSorter = (VdbeSorter*)sqlite3DbMallocZero(db, sz + szKeyInfo);
95716 pCsr->uc.pSorter = pSorter;
95717 if( pSorter==0 ){
95721 pSorter->pKeyInfo = pKeyInfo = (KeyInfo*)((u8*)pSorter + sz);
95728 pSorter->pgsz = pgsz = sqlite3BtreeGetPageSize(pBt);
95730 pSorter->nTask = nWorker + 1;
95731 pSorter->iPrev = (u8)(nWorker - 1);
95732 pSorter->bUseThreads = (pSorter->nTask>1);
95733 pSorter->db = db;
95734 for(i=0; i<pSorter->nTask; i++){
95735 SortSubtask *pTask = &pSorter->aTask[i];
95736 pTask->pSorter = pSorter;
95742 pSorter->mnPmaSize = szPma * pgsz;
95753 pSorter->mxPmaSize = MAX(pSorter->mnPmaSize, (int)mxCache);
95758 assert( pSorter->iMemory==0 );
95759 pSorter->nMemory = pgsz;
95760 pSorter->list.aMemory = (u8*)sqlite3Malloc(pgsz);
95761 if( !pSorter->list.aMemory ) rc = SQLITE_NOMEM_BKPT;
95769 pSorter->typeMask = SORTER_TYPE_INTEGER | SORTER_TYPE_TEXT;
95818 int iTask = (pTask - pTask->pSorter->aTask);
95819 sqlite3OsCurrentTimeInt64(pTask->pSorter->db->pVfs, &t);
95832 int iTask = (pTask - pTask->pSorter->aTask);
95833 sqlite3OsCurrentTimeInt64(pTask->pSorter->db->pVfs, &t);
95843 sqlite3OsCurrentTimeInt64(pTask->pSorter->db->pVfs, &t);
95892 static int vdbeSorterJoinAll(VdbeSorter *pSorter, int rcin){
95899 ** it is possible that thread pSorter->aTask[pSorter->nTask-1].pThread
95902 ** thread pSorter->aTask[pSorter->nTask-1].pThread first. */
95903 for(i=pSorter->nTask-1; i>=0; i--){
95904 SortSubtask *pTask = &pSorter->aTask[i];
95976 SQLITE_PRIVATE void sqlite3VdbeSorterReset(sqlite3 *db, VdbeSorter *pSorter){
95978 (void)vdbeSorterJoinAll(pSorter, SQLITE_OK);
95979 assert( pSorter->bUseThreads || pSorter->pReader==0 );
95981 if( pSorter->pReader ){
95982 vdbePmaReaderClear(pSorter->pReader);
95983 sqlite3DbFree(db, pSorter->pReader);
95984 pSorter->pReader = 0;
95987 vdbeMergeEngineFree(pSorter->pMerger);
95988 pSorter->pMerger = 0;
95989 for(i=0; i<pSorter->nTask; i++){
95990 SortSubtask *pTask = &pSorter->aTask[i];
95992 pTask->pSorter = pSorter;
95994 if( pSorter->list.aMemory==0 ){
95995 vdbeSorterRecordFree(0, pSorter->list.pList);
95997 pSorter->list.pList = 0;
95998 pSorter->list.szPMA = 0;
95999 pSorter->bUsePMA = 0;
96000 pSorter->iMemory = 0;
96001 pSorter->mxKeysize = 0;
96002 sqlite3DbFree(db, pSorter->pUnpacked);
96003 pSorter->pUnpacked = 0;
96010 VdbeSorter *pSorter;
96012 pSorter = pCsr->uc.pSorter;
96013 if( pSorter ){
96014 sqlite3VdbeSorterReset(db, pSorter);
96015 sqlite3_free(pSorter->list.aMemory);
96016 sqlite3DbFree(db, pSorter);
96017 pCsr->uc.pSorter = 0;
96079 pTask->pUnpacked = sqlite3VdbeAllocUnpackedRecord(pTask->pSorter->pKeyInfo);
96081 pTask->pUnpacked->nField = pTask->pSorter->pKeyInfo->nKeyField;
96157 pTask->xCompare = vdbeSorterGetCompare(pTask->pSorter);
96294 sqlite3 *db = pTask->pSorter->db;
96330 vdbePmaWriterInit(pTask->file.pFd, &writer, pTask->pSorter->pgsz,
96442 static int vdbeSorterFlushPMA(VdbeSorter *pSorter){
96444 pSorter->bUsePMA = 1;
96445 return vdbeSorterListToPMA(&pSorter->aTask[0], &pSorter->list);
96450 int nWorker = (pSorter->nTask-1);
96454 pSorter->bUsePMA = 1;
96458 ** round-robin between the first (pSorter->nTask-1) tasks. Except, if
96460 ** skip it. If the first (pSorter->nTask-1) sub-tasks are all still busy,
96461 ** fall back to using the final sub-task. The first (pSorter->nTask-1)
96465 int iTest = (pSorter->iPrev + i + 1) % nWorker;
96466 pTask = &pSorter->aTask[iTest];
96476 rc = vdbeSorterListToPMA(&pSorter->aTask[nWorker], &pSorter->list);
96485 assert( pTask->list.aMemory==0 || pSorter->list.aMemory!=0 );
96489 pSorter->iPrev = (u8)(pTask - pSorter->aTask);
96490 pTask->list = pSorter->list;
96491 pSorter->list.pList = 0;
96492 pSorter->list.szPMA = 0;
96494 pSorter->list.aMemory = aMem;
96495 pSorter->nMemory = sqlite3MallocSize(aMem);
96496 }else if( pSorter->list.aMemory ){
96497 pSorter->list.aMemory = sqlite3Malloc(pSorter->nMemory);
96498 if( !pSorter->list.aMemory ) return SQLITE_NOMEM_BKPT;
96516 VdbeSorter *pSorter;
96525 pSorter = pCsr->uc.pSorter;
96528 pSorter->typeMask &= SORTER_TYPE_INTEGER;
96530 pSorter->typeMask &= SORTER_TYPE_TEXT;
96532 pSorter->typeMask = 0;
96535 assert( pSorter );
96540 ** If using the single large allocation mode (pSorter->aMemory!=0), then
96555 if( pSorter->mxPmaSize ){
96556 if( pSorter->list.aMemory ){
96557 bFlush = pSorter->iMemory && (pSorter->iMemory+nReq) > pSorter->mxPmaSize;
96560 (pSorter->list.szPMA > pSorter->mxPmaSize)
96561 || (pSorter->list.szPMA > pSorter->mnPmaSize && sqlite3HeapNearlyFull())
96565 rc = vdbeSorterFlushPMA(pSorter);
96566 pSorter->list.szPMA = 0;
96567 pSorter->iMemory = 0;
96568 assert( rc!=SQLITE_OK || pSorter->list.pList==0 );
96572 pSorter->list.szPMA += nPMA;
96573 if( nPMA>pSorter->mxKeysize ){
96574 pSorter->mxKeysize = nPMA;
96577 if( pSorter->list.aMemory ){
96578 int nMin = pSorter->iMemory + nReq;
96580 if( nMin>pSorter->nMemory ){
96582 sqlite3_int64 nNew = 2 * (sqlite3_int64)pSorter->nMemory;
96584 if( pSorter->list.pList ){
96585 iListOff = (u8*)pSorter->list.pList - pSorter->list.aMemory;
96588 if( nNew > pSorter->mxPmaSize ) nNew = pSorter->mxPmaSize;
96590 aNew = sqlite3Realloc(pSorter->list.aMemory, nNew);
96593 pSorter->list.pList = (SorterRecord*)&aNew[iListOff];
96595 pSorter->list.aMemory = aNew;
96596 pSorter->nMemory = nNew;
96599 pNew = (SorterRecord*)&pSorter->list.aMemory[pSorter->iMemory];
96600 pSorter->iMemory += ROUND8(nReq);
96601 if( pSorter->list.pList ){
96602 pNew->u.iNext = (int)((u8*)(pSorter->list.pList) - pSorter->list.aMemory);
96609 pNew->u.pNext = pSorter->list.pList;
96614 pSorter->list.pList = pNew;
96636 vdbePmaWriterInit(pOut->pFd, &writer, pTask->pSorter->pgsz, iStart);
96750 pIncr->mxSz = MAX(pTask->pSorter->mxKeysize+9,pTask->pSorter->mxPmaSize/2);
96938 sqlite3 *db = pTask->pSorter->db;
97166 VdbeSorter *pSorter, /* The VDBE cursor that implements the sort */
97177 assert( pSorter->bUseThreads || pSorter->nTask==1 );
97178 if( pSorter->nTask>1 ){
97179 pMain = vdbeMergeEngineNew(pSorter->nTask);
97184 for(iTask=0; rc==SQLITE_OK && iTask<pSorter->nTask; iTask++){
97185 SortSubtask *pTask = &pSorter->aTask[iTask];
97244 static int vdbeSorterSetupMerge(VdbeSorter *pSorter){
97246 SortSubtask *pTask0 = &pSorter->aTask[0];
97249 sqlite3 *db = pTask0->pSorter->db;
97251 SorterCompare xCompare = vdbeSorterGetCompare(pSorter);
97252 for(i=0; i<pSorter->nTask; i++){
97253 pSorter->aTask[i].xCompare = xCompare;
97257 rc = vdbeSorterMergeTreeBuild(pSorter, &pMain);
97260 assert( pSorter->bUseThreads==0 || pSorter->nTask>1 );
97261 if( pSorter->bUseThreads ){
97264 SortSubtask *pLast = &pSorter->aTask[pSorter->nTask-1];
97268 pSorter->pReader = pReadr;
97275 for(iTask=0; iTask<(pSorter->nTask-1); iTask++){
97282 for(iTask=0; rc==SQLITE_OK && iTask<pSorter->nTask; iTask++){
97294 (p->pIncr->pTask==&pSorter->aTask[iTask]) /* a */
97295 && (iTask!=pSorter->nTask-1 || p->pIncr->bUseThread==0) /* b */
97309 pSorter->pMerger = pMain;
97327 VdbeSorter *pSorter;
97331 pSorter = pCsr->uc.pSorter;
97332 assert( pSorter );
97337 if( pSorter->bUsePMA==0 ){
97338 if( pSorter->list.pList ){
97340 rc = vdbeSorterSort(&pSorter->aTask[0], &pSorter->list);
97351 assert( pSorter->list.pList );
97352 rc = vdbeSorterFlushPMA(pSorter);
97355 rc = vdbeSorterJoinAll(pSorter, rc);
97361 assert( pSorter->pReader==0 );
97363 rc = vdbeSorterSetupMerge(pSorter);
97379 VdbeSorter *pSorter;
97383 pSorter = pCsr->uc.pSorter;
97384 assert( pSorter->bUsePMA || (pSorter->pReader==0 && pSorter->pMerger==0) );
97385 if( pSorter->bUsePMA ){
97386 assert( pSorter->pReader==0 || pSorter->pMerger==0 );
97387 assert( pSorter->bUseThreads==0 || pSorter->pReader );
97388 assert( pSorter->bUseThreads==1 || pSorter->pMerger );
97390 if( pSorter->bUseThreads ){
97391 rc = vdbePmaReaderNext(pSorter->pReader);
97392 if( rc==SQLITE_OK && pSorter->pReader->pFd==0 ) rc = SQLITE_DONE;
97395 /*if( !pSorter->bUseThreads )*/ {
97397 assert( pSorter->pMerger!=0 );
97398 assert( pSorter->pMerger->pTask==(&pSorter->aTask[0]) );
97399 rc = vdbeMergeEngineStep(pSorter->pMerger, &res);
97403 SorterRecord *pFree = pSorter->list.pList;
97404 pSorter->list.pList = pFree->u.pNext;
97406 if( pSorter->list.aMemory==0 ) vdbeSorterRecordFree(db, pFree);
97407 rc = pSorter->list.pList ? SQLITE_OK : SQLITE_DONE;
97417 const VdbeSorter *pSorter, /* Sorter object */
97421 if( pSorter->bUsePMA ){
97424 if( pSorter->bUseThreads ){
97425 pReader = pSorter->pReader;
97428 /*if( !pSorter->bUseThreads )*/{
97429 pReader = &pSorter->pMerger->aReadr[pSorter->pMerger->aTree[1]];
97434 *pnKey = pSorter->list.pList->nVal;
97435 pKey = SRVAL(pSorter->list.pList);
97444 VdbeSorter *pSorter;
97448 pSorter = pCsr->uc.pSorter;
97449 pKey = vdbeSorterRowkey(pSorter, &nKey);
97482 VdbeSorter *pSorter;
97489 pSorter = pCsr->uc.pSorter;
97490 r2 = pSorter->pUnpacked;
97493 r2 = pSorter->pUnpacked = sqlite3VdbeAllocUnpackedRecord(pKeyInfo);
97499 pKey = vdbeSorterRowkey(pSorter, &nKey);
226696 Fts5Sorter *pSorter; /* Sorter for "ORDER BY rank" queries */
227267 if( pCsr->pSorter ){
227268 Fts5Sorter *pSorter = pCsr->pSorter;
227269 sqlite3_finalize(pSorter->pStmt);
227270 sqlite3_free(pSorter);
227317 Fts5Sorter *pSorter = pCsr->pSorter;
227320 rc = sqlite3_step(pSorter->pStmt);
227332 pSorter->iRowid = sqlite3_column_int64(pSorter->pStmt, 0);
227333 nBlob = sqlite3_column_bytes(pSorter->pStmt, 1);
227334 aBlob = a = sqlite3_column_blob(pSorter->pStmt, 1);
227338 for(i=0; i<(pSorter->nIdx-1); i++){
227342 pSorter->aIdx[i] = iOff;
227344 pSorter->aIdx[i] = &aBlob[nBlob] - a;
227345 pSorter->aPoslist = a;
227502 Fts5Sorter *pSorter;
227511 pSorter = (Fts5Sorter*)sqlite3_malloc64(nByte);
227512 if( pSorter==0 ) return SQLITE_NOMEM;
227513 memset(pSorter, 0, (size_t)nByte);
227514 pSorter->nIdx = nPhrase;
227523 rc = fts5PrepareStatement(&pSorter->pStmt, pConfig,
227531 pCsr->pSorter = pSorter;
227540 sqlite3_finalize(pSorter->pStmt);
227541 sqlite3_free(pSorter);
227542 pCsr->pSorter = 0;
227926 if( pCsr->pSorter ){
227927 return pCsr->pSorter->iRowid;
228382 int bLive = (pCsr->pSorter==0);
228402 if( pCsr->pSorter ){
228403 sqlite3Fts5ExprCheckPoslists(pCsr->pExpr, pCsr->pSorter->iRowid);
228409 if( pCsr->pSorter && pConfig->eDetail==FTS5_DETAIL_FULL ){
228410 Fts5Sorter *pSorter = pCsr->pSorter;
228411 int i1 = (iPhrase==0 ? 0 : pSorter->aIdx[iPhrase-1]);
228412 *pn = pSorter->aIdx[iPhrase] - i1;
228413 *pa = &pSorter->aPoslist[i1];
228748 Fts5Sorter *pSorter = pCsr->pSorter;
228750 if( pSorter ){
228751 int i1 = (iPhrase==0 ? 0 : pSorter->aIdx[iPhrase-1]);
228752 n = pSorter->aIdx[iPhrase] - i1;
228753 pIter->a = &pSorter->aPoslist[i1];