Lines Matching refs:pC
83302 SQLITE_PRIVATE void sqlite3VdbeIncrWriteCounter(Vdbe *p, VdbeCursor *pC){
83303 if( pC==0
83304 || (pC->eCurType!=CURTYPE_SORTER
83305 && pC->eCurType!=CURTYPE_PSEUDO
83306 && !pC->isEphemeral)
85172 VdbeCursor *pC = p->apCsr[i];
85173 if( pC ){
85174 sqlite3VdbeFreeCursorNN(p, pC);
87578 ** Compare the key of the index entry that cursor pC is pointing to against
87580 ** that is negative, zero, or positive if pC is less than, equal to,
87590 VdbeCursor *pC, /* The cursor to compare against */
87599 assert( pC->eCurType==CURTYPE_BTREE );
87600 pCur = pC->uc.pCursor;
92996 VdbeCursor *pC;
93003 pC = p->apCsr[pOp->p1];
93004 assert( pC!=0 );
93006 if( pOp->p3<pC->nHdrParsed ){
93007 serialType = pC->aType[pOp->p3];
93100 VdbeCursor *pC;
93102 pC = p->apCsr[pOp->p1];
93103 if( ALWAYS(pC) && pC->nullRow ){
93127 VdbeCursor *pC; /* The VDBE cursor */
93129 pC = p->apCsr[pOp->p1];
93131 if( pC==0 || pC->eCurType!=CURTYPE_BTREE ){
93134 if( pC->deferredMoveto ){
93135 rc = sqlite3VdbeFinishMoveto(pC);
93138 if( sqlite3BtreeEof(pC->uc.pCursor) ){
93141 sqlite3VdbeMemSetInt64(pOut, sqlite3BtreeOffset(pC->uc.pCursor));
93172 VdbeCursor *pC; /* The VDBE cursor */
93173 BtCursor *pCrsr; /* The B-Tree cursor corresponding to pC */
93188 pC = p->apCsr[pOp->p1];
93192 assert( pC!=0 );
93193 assert( p2<(u32)pC->nField
93194 || (pC->eCurType==CURTYPE_PSEUDO && pC->seekResult==0) );
93195 aOffset = pC->aOffset;
93196 assert( aOffset==pC->aType+pC->nField );
93197 assert( pC->eCurType!=CURTYPE_VTAB );
93198 assert( pC->eCurType!=CURTYPE_PSEUDO || pC->nullRow );
93199 assert( pC->eCurType!=CURTYPE_SORTER );
93201 if( pC->cacheStatus!=p->cacheCtr ){ /*OPTIMIZATION-IF-FALSE*/
93202 if( pC->nullRow ){
93203 if( pC->eCurType==CURTYPE_PSEUDO && pC->seekResult>0 ){
93206 pReg = &aMem[pC->seekResult];
93209 pC->payloadSize = pC->szRow = pReg->n;
93210 pC->aRow = (u8*)pReg->z;
93218 pCrsr = pC->uc.pCursor;
93219 if( pC->deferredMoveto ){
93221 assert( !pC->isEphemeral );
93222 if( pC->ub.aAltMap && (iMap = pC->ub.aAltMap[1+p2])>0 ){
93223 pC = pC->pAltCursor;
93227 rc = sqlite3VdbeFinishMoveto(pC);
93230 rc = sqlite3VdbeHandleMovedCursor(pC);
93234 assert( pC->eCurType==CURTYPE_BTREE );
93237 pC->payloadSize = sqlite3BtreePayloadSize(pCrsr);
93238 pC->aRow = sqlite3BtreePayloadFetch(pCrsr, &pC->szRow);
93239 assert( pC->szRow<=pC->payloadSize );
93240 assert( pC->szRow<=65536 ); /* Maximum page size is 64KiB */
93242 pC->cacheStatus = p->cacheCtr;
93243 if( (aOffset[0] = pC->aRow[0])<0x80 ){
93244 pC->iHdrOffset = 1;
93246 pC->iHdrOffset = sqlite3GetVarint32(pC->aRow, aOffset);
93248 pC->nHdrParsed = 0;
93250 if( pC->szRow<aOffset[0] ){ /*OPTIMIZATION-IF-FALSE*/
93251 /* pC->aRow does not have to hold the entire row, but it does at least
93252 ** need to cover the header of the record. If pC->aRow does not contain
93255 pC->aRow = 0;
93256 pC->szRow = 0;
93267 if( aOffset[0] > 98307 || aOffset[0] > pC->payloadSize ){
93272 ** (ex: pC->nHdrParsed<=p2) in the next section, we achieve a
93284 zData = pC->aRow;
93285 assert( pC->nHdrParsed<=p2 ); /* Conditional skipped */
93289 }else if( sqlite3BtreeCursorHasMoved(pC->uc.pCursor) ){
93290 rc = sqlite3VdbeHandleMovedCursor(pC);
93296 ** parsed and valid information is in aOffset[] and pC->aType[].
93298 if( pC->nHdrParsed<=p2 ){
93302 if( pC->iHdrOffset<aOffset[0] ){
93304 if( pC->aRow==0 ){
93306 rc = sqlite3VdbeMemFromBtreeZeroOffset(pC->uc.pCursor,aOffset[0],&sMem);
93310 zData = pC->aRow;
93313 /* Fill in pC->aType[i] and aOffset[i] values through the p2-th field. */
93315 i = pC->nHdrParsed;
93317 zHdr = zData + pC->iHdrOffset;
93321 if( (pC->aType[i] = t = zHdr[0])<0x80 ){
93326 pC->aType[i] = t;
93337 if( (zHdr>=zEndHdr && (zHdr>zEndHdr || offset64!=pC->payloadSize))
93338 || (offset64 > pC->payloadSize)
93344 if( pC->aRow==0 ) sqlite3VdbeMemRelease(&sMem);
93349 pC->nHdrParsed = i;
93350 pC->iHdrOffset = (u32)(zHdr - zData);
93351 if( pC->aRow==0 ) sqlite3VdbeMemRelease(&sMem);
93360 if( pC->nHdrParsed<=p2 ){
93371 t = pC->aType[p2];
93375 ** reach this point if aOffset[p2], aOffset[p2+1], and pC->aType[p2] are
93378 assert( p2<pC->nHdrParsed );
93386 assert( t==pC->aType[p2] );
93387 if( pC->szRow>=aOffset[p2+1] ){
93390 zData = pC->aRow + aOffset[p2];
93436 rc = sqlite3VdbeMemFromBtree(pC->uc.pCursor, aOffset[p2], len, pDest);
94808 VdbeCursor *pC;
94810 pC = p->apCsr[pOp->p1];
94811 assert( isSorter(pC) );
94812 if( (pC->seqCount++)==0 ){
94877 VdbeCursor *pC;
94878 pC = p->apCsr[pOp->p1];
94879 assert( pC->eCurType==CURTYPE_BTREE );
94880 pC->maskUsed = *(u64*)pOp->p4.pI64;
94981 VdbeCursor *pC; /* The cursor to seek */
94989 pC = p->apCsr[pOp->p1];
94990 assert( pC!=0 );
94991 assert( pC->eCurType==CURTYPE_BTREE );
94995 assert( pC->isOrdered );
94996 assert( pC->uc.pCursor!=0 );
94999 pC->nullRow = 0;
95001 pC->seekOp = pOp->opcode;
95004 pC->deferredMoveto = 0;
95005 pC->cacheStatus = CACHE_STALE;
95006 if( pC->isTable ){
95009 assert( sqlite3BtreeCursorHasHint(pC->uc.pCursor, BTREE_SEEK_EQ)==0
95033 rc = sqlite3BtreeLast(pC->uc.pCursor, &res);
95063 rc = sqlite3BtreeTableMoveto(pC->uc.pCursor, (u64)iKey, 0, &res);
95064 pC->movetoTarget = iKey; /* Used by OP_Delete */
95074 if( sqlite3BtreeCursorHasHint(pC->uc.pCursor, BTREE_SEEK_EQ) ){
95089 r.pKeyInfo = pC->pKeyInfo;
95116 rc = sqlite3BtreeIndexMoveto(pC->uc.pCursor, &r, &res);
95131 rc = sqlite3BtreeNext(pC->uc.pCursor, 0);
95147 rc = sqlite3BtreePrevious(pC->uc.pCursor, 0);
95160 res = sqlite3BtreeEof(pC->uc.pCursor);
95245 VdbeCursor *pC;
95273 pC = p->apCsr[pOp[1].p1];
95274 assert( pC!=0 );
95275 assert( pC->eCurType==CURTYPE_BTREE );
95276 assert( !pC->isTable );
95277 if( !sqlite3BtreeCursorIsValidNN(pC->uc.pCursor) ){
95287 r.pKeyInfo = pC->pKeyInfo;
95302 rc = sqlite3VdbeIdxKeyCompare(db, pC, &r, &res);
95337 rc = sqlite3BtreeNext(pC->uc.pCursor, 0);
95367 VdbeCursor *pC;
95369 pC = p->apCsr[pOp->p1];
95370 assert( pC!=0 );
95372 if( pC->seekHit<pOp->p2 ){
95375 printf("seekHit changes from %d to %d\n", pC->seekHit, pOp->p2);
95378 pC->seekHit = pOp->p2;
95379 }else if( pC->seekHit>pOp->p3 ){
95382 printf("seekHit changes from %d to %d\n", pC->seekHit, pOp->p3);
95385 pC->seekHit = pOp->p3;
95499 VdbeCursor *pC;
95501 pC = p->apCsr[pOp->p1];
95502 assert( pC!=0 );
95505 printf("seekHit is %d\n", pC->seekHit);
95508 if( pC->seekHit>=pOp->p4.i ) break;
95517 VdbeCursor *pC;
95527 pC = p->apCsr[pOp->p1];
95528 assert( pC!=0 );
95530 pC->seekOp = pOp->opcode;
95533 assert( pC->eCurType==CURTYPE_BTREE );
95534 assert( pC->uc.pCursor!=0 );
95535 assert( pC->isTable==0 );
95539 r.pKeyInfo = pC->pKeyInfo;
95548 rc = sqlite3BtreeIndexMoveto(pC->uc.pCursor, &r, &pC->seekResult);
95556 pIdxKey = sqlite3VdbeAllocUnpackedRecord(pC->pKeyInfo);
95558 sqlite3VdbeRecordUnpack(pC->pKeyInfo, r.aMem->n, r.aMem->z, pIdxKey);
95560 rc = sqlite3BtreeIndexMoveto(pC->uc.pCursor, pIdxKey, &pC->seekResult);
95566 alreadyExists = (pC->seekResult==0);
95567 pC->nullRow = 1-alreadyExists;
95568 pC->deferredMoveto = 0;
95569 pC->cacheStatus = CACHE_STALE;
95591 pC->seekHit = pOp->p4.i;
95645 VdbeCursor *pC;
95675 pC = p->apCsr[pOp->p1];
95676 assert( pC!=0 );
95678 if( pOp->opcode==OP_SeekRowid ) pC->seekOp = OP_SeekRowid;
95680 assert( pC->isTable );
95681 assert( pC->eCurType==CURTYPE_BTREE );
95682 pCrsr = pC->uc.pCursor;
95687 pC->movetoTarget = iKey; /* Used by OP_Delete */
95688 pC->nullRow = 0;
95689 pC->cacheStatus = CACHE_STALE;
95690 pC->deferredMoveto = 0;
95692 pC->seekResult = res;
95740 VdbeCursor *pC; /* Cursor of table to get the new rowid */
95752 pC = p->apCsr[pOp->p1];
95753 assert( pC!=0 );
95754 assert( pC->isTable );
95755 assert( pC->eCurType==CURTYPE_BTREE );
95756 assert( pC->uc.pCursor!=0 );
95771 assert( pC->isTable );
95783 if( !pC->useRandomRowid ){
95784 rc = sqlite3BtreeLast(pC->uc.pCursor, &res);
95791 assert( sqlite3BtreeCursorIsValid(pC->uc.pCursor) );
95792 v = sqlite3BtreeIntegerKey(pC->uc.pCursor);
95794 pC->useRandomRowid = 1;
95821 if( pMem->u.i==MAX_ROWID || pC->useRandomRowid ){
95831 if( pC->useRandomRowid ){
95842 }while( ((rc = sqlite3BtreeTableMoveto(pC->uc.pCursor, (u64)v,
95853 pC->deferredMoveto = 0;
95854 pC->cacheStatus = CACHE_STALE;
95900 VdbeCursor *pC; /* Cursor to table into which insert is written */
95909 pC = p->apCsr[pOp->p1];
95910 assert( pC!=0 );
95911 assert( pC->eCurType==CURTYPE_BTREE );
95912 assert( pC->deferredMoveto==0 );
95913 assert( pC->uc.pCursor!=0 );
95914 assert( (pOp->p5 & OPFLAG_ISNOOP) || pC->isTable );
95917 sqlite3VdbeIncrWriteCounter(p, pC);
95926 assert( pC->iDb>=0 );
95927 zDb = db->aDb[pC->iDb].zDbSName;
95939 sqlite3VdbePreUpdateHook(p,pC,SQLITE_INSERT,zDb,pTab,x.nKey,pOp->p2,-1);
95954 seekResult = ((pOp->p5 & OPFLAG_USESEEKRESULT) ? pC->seekResult : 0);
95961 rc = sqlite3BtreeInsert(pC->uc.pCursor, &x,
95965 pC->deferredMoveto = 0;
95966 pC->cacheStatus = CACHE_STALE;
96043 VdbeCursor *pC;
96050 pC = p->apCsr[pOp->p1];
96051 assert( pC!=0 );
96052 assert( pC->eCurType==CURTYPE_BTREE );
96053 assert( pC->uc.pCursor!=0 );
96054 assert( pC->deferredMoveto==0 );
96055 sqlite3VdbeIncrWriteCounter(p, pC);
96061 && sqlite3BtreeCursorIsValidNN(pC->uc.pCursor)
96064 ** OP_Delete will have also set the pC->movetoTarget field to the rowid of
96066 i64 iKey = sqlite3BtreeIntegerKey(pC->uc.pCursor);
96067 assert( CORRUPT_DB || pC->movetoTarget==iKey );
96077 assert( pC->iDb>=0 );
96079 zDb = db->aDb[pC->iDb].zDbSName;
96081 if( (pOp->p5 & OPFLAG_SAVEPOSITION)!=0 && pC->isTable ){
96082 pC->movetoTarget = sqlite3BtreeIntegerKey(pC->uc.pCursor);
96097 sqlite3VdbePreUpdateHook(p, pC,
96099 zDb, pTab, pC->movetoTarget,
96113 if( pC->isEphemeral==0
96115 && (pC->wrFlag & OPFLAG_FORDELETE)==0
96125 rc = sqlite3BtreeDelete(pC->uc.pCursor, pOp->p5);
96126 pC->cacheStatus = CACHE_STALE;
96127 pC->seekResult = 0;
96135 pC->movetoTarget);
96136 assert( pC->iDb>=0 );
96171 VdbeCursor *pC;
96175 pC = p->apCsr[pOp->p1];
96176 assert( isSorter(pC) );
96181 rc = sqlite3VdbeSorterCompare(pC, pIn3, nKeyCol, &res);
96201 VdbeCursor *pC;
96204 pC = p->apCsr[pOp->p1];
96205 assert( isSorter(pC) );
96206 rc = sqlite3VdbeSorterRowkey(pC, pOut);
96243 VdbeCursor *pC;
96250 pC = p->apCsr[pOp->p1];
96251 assert( pC!=0 );
96252 assert( pC->eCurType==CURTYPE_BTREE );
96253 assert( isSorter(pC)==0 );
96254 assert( pC->nullRow==0 );
96255 assert( pC->uc.pCursor!=0 );
96256 pCrsr = pC->uc.pCursor;
96266 assert( pC->deferredMoveto==0 );
96293 VdbeCursor *pC;
96300 pC = p->apCsr[pOp->p1];
96301 assert( pC!=0 );
96302 assert( pC->eCurType!=CURTYPE_PSEUDO || pC->nullRow );
96303 if( pC->nullRow ){
96306 }else if( pC->deferredMoveto ){
96307 v = pC->movetoTarget;
96309 }else if( pC->eCurType==CURTYPE_VTAB ){
96310 assert( pC->uc.pVCur!=0 );
96311 pVtab = pC->uc.pVCur->pVtab;
96314 rc = pModule->xRowid(pC->uc.pVCur, &v);
96319 assert( pC->eCurType==CURTYPE_BTREE );
96320 assert( pC->uc.pCursor!=0 );
96321 rc = sqlite3VdbeCursorRestore(pC);
96323 if( pC->nullRow ){
96327 v = sqlite3BtreeIntegerKey(pC->uc.pCursor);
96343 VdbeCursor *pC;
96346 pC = p->apCsr[pOp->p1];
96347 if( pC==0 ){
96350 pC = allocateCursor(p, pOp->p1, 1, CURTYPE_PSEUDO);
96351 if( pC==0 ) goto no_mem;
96352 pC->seekResult = 0;
96353 pC->isTable = 1;
96354 pC->noReuse = 1;
96355 pC->uc.pCursor = sqlite3BtreeFakeValidCursor();
96357 pC->nullRow = 1;
96358 pC->cacheStatus = CACHE_STALE;
96359 if( pC->eCurType==CURTYPE_BTREE ){
96360 assert( pC->uc.pCursor!=0 );
96361 sqlite3BtreeClearCursor(pC->uc.pCursor);
96364 if( pC->seekOp==0 ) pC->seekOp = OP_NullRow;
96393 VdbeCursor *pC;
96398 pC = p->apCsr[pOp->p1];
96399 assert( pC!=0 );
96400 assert( pC->eCurType==CURTYPE_BTREE );
96401 pCrsr = pC->uc.pCursor;
96405 pC->seekOp = pOp->opcode;
96409 pC->seekResult = -1;
96415 pC->nullRow = (u8)res;
96416 pC->deferredMoveto = 0;
96417 pC->cacheStatus = CACHE_STALE;
96432 VdbeCursor *pC;
96438 pC = p->apCsr[pOp->p1];
96439 assert( pC!=0 );
96440 pCrsr = pC->uc.pCursor;
96498 VdbeCursor *pC;
96504 pC = p->apCsr[pOp->p1];
96505 assert( pC!=0 );
96506 assert( isSorter(pC)==(pOp->opcode==OP_SorterSort) );
96509 pC->seekOp = OP_Rewind;
96511 if( isSorter(pC) ){
96512 rc = sqlite3VdbeSorterRewind(pC, &res);
96514 assert( pC->eCurType==CURTYPE_BTREE );
96515 pCrsr = pC->uc.pCursor;
96518 pC->deferredMoveto = 0;
96519 pC->cacheStatus = CACHE_STALE;
96522 pC->nullRow = (u8)res;
96584 VdbeCursor *pC;
96586 pC = p->apCsr[pOp->p1];
96587 assert( isSorter(pC) );
96588 rc = sqlite3VdbeSorterNext(db, pC);
96596 pC = p->apCsr[pOp->p1];
96597 assert( pC!=0 );
96598 assert( pC->deferredMoveto==0 );
96599 assert( pC->eCurType==CURTYPE_BTREE );
96600 assert( pC->seekOp==OP_SeekLT || pC->seekOp==OP_SeekLE
96601 || pC->seekOp==OP_Last || pC->seekOp==OP_IfNoHope
96602 || pC->seekOp==OP_NullRow);
96603 rc = sqlite3BtreePrevious(pC->uc.pCursor, pOp->p3);
96611 pC = p->apCsr[pOp->p1];
96612 assert( pC!=0 );
96613 assert( pC->deferredMoveto==0 );
96614 assert( pC->eCurType==CURTYPE_BTREE );
96615 assert( pC->seekOp==OP_SeekGT || pC->seekOp==OP_SeekGE
96616 || pC->seekOp==OP_Rewind || pC->seekOp==OP_Found
96617 || pC->seekOp==OP_NullRow|| pC->seekOp==OP_SeekRowid
96618 || pC->seekOp==OP_IfNoHope);
96619 rc = sqlite3BtreeNext(pC->uc.pCursor, pOp->p3);
96622 pC->cacheStatus = CACHE_STALE;
96625 pC->nullRow = 0;
96634 pC->nullRow = 1;
96667 VdbeCursor *pC;
96671 pC = p->apCsr[pOp->p1];
96672 sqlite3VdbeIncrWriteCounter(p, pC);
96673 assert( pC!=0 );
96674 assert( !isSorter(pC) );
96678 assert( pC->eCurType==CURTYPE_BTREE );
96679 assert( pC->isTable==0 );
96686 rc = sqlite3BtreeInsert(pC->uc.pCursor, &x,
96688 ((pOp->p5 & OPFLAG_USESEEKRESULT) ? pC->seekResult : 0)
96690 assert( pC->deferredMoveto==0 );
96691 pC->cacheStatus = CACHE_STALE;
96704 VdbeCursor *pC;
96707 pC = p->apCsr[pOp->p1];
96708 sqlite3VdbeIncrWriteCounter(p, pC);
96709 assert( pC!=0 );
96710 assert( isSorter(pC) );
96713 assert( pC->isTable==0 );
96716 rc = sqlite3VdbeSorterWrite(pC, pIn2);
96737 VdbeCursor *pC;
96745 pC = p->apCsr[pOp->p1];
96746 assert( pC!=0 );
96747 assert( pC->eCurType==CURTYPE_BTREE );
96748 sqlite3VdbeIncrWriteCounter(p, pC);
96749 pCrsr = pC->uc.pCursor;
96751 r.pKeyInfo = pC->pKeyInfo;
96764 assert( pC->deferredMoveto==0 );
96765 pC->cacheStatus = CACHE_STALE;
96766 pC->seekResult = 0;
96800 VdbeCursor *pC; /* The P1 index cursor */
96805 pC = p->apCsr[pOp->p1];
96806 assert( pC!=0 );
96807 assert( pC->eCurType==CURTYPE_BTREE || IsNullCursor(pC) );
96808 assert( pC->uc.pCursor!=0 );
96809 assert( pC->isTable==0 || IsNullCursor(pC) );
96810 assert( pC->deferredMoveto==0 );
96811 assert( !pC->nullRow || pOp->opcode==OP_IdxRowid );
96815 rc = sqlite3VdbeCursorRestore(pC);
96822 if( !pC->nullRow ){
96824 rc = sqlite3VdbeIdxRowid(db, pC->uc.pCursor, &rowid);
96842 assert( !pC->isEphemeral );
96843 pTabCur->pAltCursor = pC;
96862 VdbeCursor *pC; /* The P1 index cursor */
96865 pC = p->apCsr[pOp->p1];
96866 if( pC->deferredMoveto ){
96867 rc = sqlite3VdbeFinishMoveto(pC);
96921 VdbeCursor *pC;
96926 pC = p->apCsr[pOp->p1];
96927 assert( pC!=0 );
96928 assert( pC->isOrdered );
96929 assert( pC->eCurType==CURTYPE_BTREE );
96930 assert( pC->uc.pCursor!=0);
96931 assert( pC->deferredMoveto==0 );
96933 r.pKeyInfo = pC->pKeyInfo;
96959 assert( pC->eCurType==CURTYPE_BTREE );
96960 pCur = pC->uc.pCursor;
97097 VdbeCursor *pC;
97100 pC = p->apCsr[pOp->p1];
97101 assert( pC!=0 );
97102 if( isSorter(pC) ){
97103 sqlite3VdbeSorterReset(db, pC->uc.pSorter);
97105 assert( pC->eCurType==CURTYPE_BTREE );
97106 assert( pC->isEphemeral );
97107 rc = sqlite3BtreeClearTableOfCursor(pC->uc.pCursor);
98221 VdbeCursor *pC;
98223 pC = p->apCsr[pOp->p1];
98224 assert( pC!=0 );
98225 assert( pC->eCurType==CURTYPE_BTREE );
98226 sqlite3BtreeCursorPin(pC->uc.pCursor);
98236 VdbeCursor *pC;
98238 pC = p->apCsr[pOp->p1];
98239 assert( pC!=0 );
98240 assert( pC->eCurType==CURTYPE_BTREE );
98241 sqlite3BtreeCursorUnpin(pC->uc.pCursor);
98401 VdbeCursor *pC; /* The cursor containing the RHS values */
98404 pC = p->apCsr[pOp->p1];
98407 pRhs->pCsr = pC->uc.pCursor;
99028 VdbeCursor *pC;
99032 pC = p->apCsr[pOp->p1];
99033 if( pC ){
99034 assert( pC->eCurType==CURTYPE_BTREE );
99035 sqlite3BtreeCursorHint(pC->uc.pCursor, BTREE_HINT_RANGE,
99334 VdbeCursor *pC = v->apCsr[0];
99336 assert( pC!=0 );
99337 assert( pC->eCurType==CURTYPE_BTREE );
99338 type = pC->nHdrParsed>p->iCol ? pC->aType[p->iCol] : 0;
99339 testcase( pC->nHdrParsed==p->iCol );
99340 testcase( pC->nHdrParsed==p->iCol+1 );
99349 p->iOffset = pC->aType[p->iCol + pC->nField];
99351 p->pCsr = pC->uc.pCursor;
138422 ** pA pB pC Return Value
138465 SQLITE_PRIVATE int sqlite3JoinType(Parse *pParse, Token *pA, Token *pB, Token *pC){
138487 apAll[2] = pC;
138511 if( pC==0 ){ zSp2++; }
138513 "%T%s%T%s%T", pA, zSp1, pB, zSp2, pC);
144545 struct AggInfo_col *pC;
144621 for(i=0, pC=pAggInfo->aCol; i<pAggInfo->nAccumulator; i++, pC++){
144622 sqlite3ExprCode(pParse, pC->pCExpr, pC->iMem);
156045 u8 c, *pC; /* Last character before the first wildcard */
156046 pC = (u8*)&pStr2->u.zToken[sqlite3Strlen30(pStr2->u.zToken)-1];
156047 c = *pC;
156058 *pC = c + 1;
160418 CollSeq *pC = 0;
160422 pC = sqlite3ExprCompareCollSeq(pHidden->pParse, pX);
160424 zRet = (pC ? pC->zName : sqlite3StrBINARY);
196390 sqlite3_tokenizer_cursor *pC;
196396 rc = sqlite3Fts3OpenTokenizer(pTab->pTokenizer, iLangid, zDoc, nDoc, &pC);
196402 rc = pMod->xNext(pC, &ZDUMMY, &DUMMY1, &DUMMY2, &DUMMY3, &iCurrent);
196404 pMod->xClose(pC);
196444 sqlite3_tokenizer_cursor *pC; /* Tokenizer cursor open on zDoc/nDoc */
196457 rc = sqlite3Fts3OpenTokenizer(pTab->pTokenizer, pCsr->iLangid, zDoc,nDoc,&pC);
196480 rc = pMod->xNext(pC, &ZDUMMY, &DUMMY1, &iBegin, &iFin, &iCurrent);
196532 pMod->xClose(pC);
197330 sqlite3_tokenizer_cursor *pC; /* Tokenizer cursor */
197365 zDoc, nDoc, &pC
197369 rc = pMod->xNext(pC, &ZDUMMY, &NDUMMY, &iStart, &iEnd, &iCurrent);
197394 rc = pMod->xNext(pC, &ZDUMMY, &NDUMMY, &iStart, &iEnd, &iCurrent);
197411 pMod->xClose(pC);
197774 sqlite3_tokenizer_cursor *pC, /* Cursor returned by simpleOpen */
197781 unicode_cursor *pCsr = (unicode_cursor *)pC;
216713 SessionChange *pC /* Update pC->nMaxSize */
216716 if( pC->op==SQLITE_INSERT ){
216726 nNew += pC->nRecord;
216728 nNew += pC->nRecord;
216732 u8 *pCsr = pC->aRecord;
216784 nNew = pC->nRecord + 2;
216799 if( nNew>pC->nMaxSize ){
216800 int nIncr = nNew - pC->nMaxSize;
216801 pC->nMaxSize = nNew;
216870 SessionChange *pC;
216871 for(pC=pTab->apChange[iHash]; pC; pC=pC->pNext){
216872 if( sessionPreupdateEqual(pSession, pTab, pC, op) ) break;
216875 if( pC==0 ){
216904 pC = (SessionChange *)sessionMalloc64(pSession, nByte);
216905 if( !pC ){
216909 memset(pC, 0, sizeof(SessionChange));
216910 pC->aRecord = (u8 *)&pC[1];
216925 sessionSerializeValue(&pC->aRecord[nByte], p, &nByte);
216930 pC->bIndirect = 1;
216932 pC->nRecord = nByte;
216933 pC->op = op;
216934 pC->pNext = pTab->apChange[iHash];
216935 pTab->apChange[iHash] = pC;
216937 }else if( pC->bIndirect ){
216943 pC->bIndirect = 0;
216949 rc = sessionUpdateMaxSize(op, pSession, pTab, pC);
239843 Fts5Config *pC = p->pConfig;
239849 pC->zContentExprlist, pC->zContent
239855 zSql = sqlite3_mprintf(azStmt[eStmt], pC->zContentExprlist,
239856 pC->zContent, pC->zContentRowid, pC->zContentRowid,
239857 pC->zContentRowid
239863 pC->zContentExprlist, pC->zContent, pC->zContentRowid
239869 int nCol = pC->nCol + 1;
239880 zSql = sqlite3_mprintf(azStmt[eStmt], pC->zDb, pC->zName, zBind);
239887 zSql = sqlite3_mprintf(azStmt[eStmt], pC->zDb, pC->zName);
239897 rc = sqlite3_prepare_v3(pC->db, zSql, -1, f, &p->aStmt[eStmt], 0);
239901 *pzErrMsg = sqlite3_mprintf("%s", sqlite3_errmsg(pC->db));