Lines Matching refs:pC
85668 SQLITE_PRIVATE void sqlite3VdbeIncrWriteCounter(Vdbe *p, VdbeCursor *pC){
85669 if( pC==0
85670 || (pC->eCurType!=CURTYPE_SORTER
85671 && pC->eCurType!=CURTYPE_PSEUDO
85672 && !pC->isEphemeral)
87609 VdbeCursor *pC = p->apCsr[i];
87610 if( pC ){
87611 sqlite3VdbeFreeCursorNN(p, pC);
90066 ** Compare the key of the index entry that cursor pC is pointing to against
90068 ** that is negative, zero, or positive if pC is less than, equal to,
90078 VdbeCursor *pC, /* The cursor to compare against */
90087 assert( pC->eCurType==CURTYPE_BTREE );
90088 pCur = pC->uc.pCursor;
93821 VdbeCursor *pC, /* The BTree cursor from which we are reading */
93833 assert( pC->eCurType==CURTYPE_BTREE );
93835 if( len > 4000 && pC->pKeyInfo==0 ){
93848 if( pC->colCache==0 ){
93849 pC->pCache = sqlite3DbMallocZero(db, sizeof(VdbeTxtBlbCache) );
93850 if( pC->pCache==0 ) return SQLITE_NOMEM;
93851 pC->colCache = 1;
93853 pCache = pC->pCache;
93858 || pCache->iOffset!=sqlite3BtreeOffset(pC->uc.pCursor)
93863 rc = sqlite3BtreePayload(pC->uc.pCursor, iOffset, len, pBuf);
93871 pCache->iOffset = sqlite3BtreeOffset(pC->uc.pCursor);
93886 rc = sqlite3VdbeMemFromBtree(pC->uc.pCursor, iOffset, len, pDest);
95848 VdbeCursor *pC;
95855 pC = p->apCsr[pOp->p1];
95856 assert( pC!=0 );
95858 if( pOp->p3<pC->nHdrParsed ){
95859 serialType = pC->aType[pOp->p3];
95952 VdbeCursor *pC;
95954 pC = p->apCsr[pOp->p1];
95955 if( pC && pC->nullRow ){
95979 VdbeCursor *pC; /* The VDBE cursor */
95981 pC = p->apCsr[pOp->p1];
95983 if( pC==0 || pC->eCurType!=CURTYPE_BTREE ){
95986 if( pC->deferredMoveto ){
95987 rc = sqlite3VdbeFinishMoveto(pC);
95990 if( sqlite3BtreeEof(pC->uc.pCursor) ){
95993 sqlite3VdbeMemSetInt64(pOut, sqlite3BtreeOffset(pC->uc.pCursor));
96024 VdbeCursor *pC; /* The VDBE cursor */
96025 BtCursor *pCrsr; /* The B-Tree cursor corresponding to pC */
96040 pC = p->apCsr[pOp->p1];
96044 assert( pC!=0 );
96045 assert( p2<(u32)pC->nField
96046 || (pC->eCurType==CURTYPE_PSEUDO && pC->seekResult==0) );
96047 aOffset = pC->aOffset;
96048 assert( aOffset==pC->aType+pC->nField );
96049 assert( pC->eCurType!=CURTYPE_VTAB );
96050 assert( pC->eCurType!=CURTYPE_PSEUDO || pC->nullRow );
96051 assert( pC->eCurType!=CURTYPE_SORTER );
96053 if( pC->cacheStatus!=p->cacheCtr ){ /*OPTIMIZATION-IF-FALSE*/
96054 if( pC->nullRow ){
96055 if( pC->eCurType==CURTYPE_PSEUDO && pC->seekResult>0 ){
96058 pReg = &aMem[pC->seekResult];
96061 pC->payloadSize = pC->szRow = pReg->n;
96062 pC->aRow = (u8*)pReg->z;
96070 pCrsr = pC->uc.pCursor;
96071 if( pC->deferredMoveto ){
96073 assert( !pC->isEphemeral );
96074 if( pC->ub.aAltMap && (iMap = pC->ub.aAltMap[1+p2])>0 ){
96075 pC = pC->pAltCursor;
96079 rc = sqlite3VdbeFinishMoveto(pC);
96082 rc = sqlite3VdbeHandleMovedCursor(pC);
96086 assert( pC->eCurType==CURTYPE_BTREE );
96089 pC->payloadSize = sqlite3BtreePayloadSize(pCrsr);
96090 pC->aRow = sqlite3BtreePayloadFetch(pCrsr, &pC->szRow);
96091 assert( pC->szRow<=pC->payloadSize );
96092 assert( pC->szRow<=65536 ); /* Maximum page size is 64KiB */
96094 pC->cacheStatus = p->cacheCtr;
96095 if( (aOffset[0] = pC->aRow[0])<0x80 ){
96096 pC->iHdrOffset = 1;
96098 pC->iHdrOffset = sqlite3GetVarint32(pC->aRow, aOffset);
96100 pC->nHdrParsed = 0;
96102 if( pC->szRow<aOffset[0] ){ /*OPTIMIZATION-IF-FALSE*/
96103 /* pC->aRow does not have to hold the entire row, but it does at least
96104 ** need to cover the header of the record. If pC->aRow does not contain
96107 pC->aRow = 0;
96108 pC->szRow = 0;
96119 if( aOffset[0] > 98307 || aOffset[0] > pC->payloadSize ){
96124 ** (ex: pC->nHdrParsed<=p2) in the next section, we achieve a
96136 zData = pC->aRow;
96137 assert( pC->nHdrParsed<=p2 ); /* Conditional skipped */
96141 }else if( sqlite3BtreeCursorHasMoved(pC->uc.pCursor) ){
96142 rc = sqlite3VdbeHandleMovedCursor(pC);
96148 ** parsed and valid information is in aOffset[] and pC->aType[].
96150 if( pC->nHdrParsed<=p2 ){
96154 if( pC->iHdrOffset<aOffset[0] ){
96156 if( pC->aRow==0 ){
96158 rc = sqlite3VdbeMemFromBtreeZeroOffset(pC->uc.pCursor,aOffset[0],&sMem);
96162 zData = pC->aRow;
96165 /* Fill in pC->aType[i] and aOffset[i] values through the p2-th field. */
96167 i = pC->nHdrParsed;
96169 zHdr = zData + pC->iHdrOffset;
96173 if( (pC->aType[i] = t = zHdr[0])<0x80 ){
96178 pC->aType[i] = t;
96189 if( (zHdr>=zEndHdr && (zHdr>zEndHdr || offset64!=pC->payloadSize))
96190 || (offset64 > pC->payloadSize)
96196 if( pC->aRow==0 ) sqlite3VdbeMemRelease(&sMem);
96201 pC->nHdrParsed = i;
96202 pC->iHdrOffset = (u32)(zHdr - zData);
96203 if( pC->aRow==0 ) sqlite3VdbeMemRelease(&sMem);
96212 if( pC->nHdrParsed<=p2 ){
96223 t = pC->aType[p2];
96227 ** reach this point if aOffset[p2], aOffset[p2+1], and pC->aType[p2] are
96230 assert( p2<pC->nHdrParsed );
96238 assert( t==pC->aType[p2] );
96239 if( pC->szRow>=aOffset[p2+1] ){
96242 zData = pC->aRow + aOffset[p2];
96292 rc = vdbeColumnFromOverflow(pC, p2, t, aOffset[p2],
97676 VdbeCursor *pC;
97678 pC = p->apCsr[pOp->p1];
97679 assert( isSorter(pC) );
97680 if( (pC->seqCount++)==0 ){
97746 VdbeCursor *pC;
97747 pC = p->apCsr[pOp->p1];
97748 assert( pC->eCurType==CURTYPE_BTREE );
97749 pC->maskUsed = *(u64*)pOp->p4.pI64;
97850 VdbeCursor *pC; /* The cursor to seek */
97858 pC = p->apCsr[pOp->p1];
97859 assert( pC!=0 );
97860 assert( pC->eCurType==CURTYPE_BTREE );
97864 assert( pC->isOrdered );
97865 assert( pC->uc.pCursor!=0 );
97868 pC->nullRow = 0;
97870 pC->seekOp = pOp->opcode;
97873 pC->deferredMoveto = 0;
97874 pC->cacheStatus = CACHE_STALE;
97875 if( pC->isTable ){
97878 assert( sqlite3BtreeCursorHasHint(pC->uc.pCursor, BTREE_SEEK_EQ)==0
97902 rc = sqlite3BtreeLast(pC->uc.pCursor, &res);
97932 rc = sqlite3BtreeTableMoveto(pC->uc.pCursor, (u64)iKey, 0, &res);
97933 pC->movetoTarget = iKey; /* Used by OP_Delete */
97943 if( sqlite3BtreeCursorHasHint(pC->uc.pCursor, BTREE_SEEK_EQ) ){
97958 r.pKeyInfo = pC->pKeyInfo;
97985 rc = sqlite3BtreeIndexMoveto(pC->uc.pCursor, &r, &res);
98000 rc = sqlite3BtreeNext(pC->uc.pCursor, 0);
98016 rc = sqlite3BtreePrevious(pC->uc.pCursor, 0);
98029 res = sqlite3BtreeEof(pC->uc.pCursor);
98114 VdbeCursor *pC;
98142 pC = p->apCsr[pOp[1].p1];
98143 assert( pC!=0 );
98144 assert( pC->eCurType==CURTYPE_BTREE );
98145 assert( !pC->isTable );
98146 if( !sqlite3BtreeCursorIsValidNN(pC->uc.pCursor) ){
98156 r.pKeyInfo = pC->pKeyInfo;
98171 rc = sqlite3VdbeIdxKeyCompare(db, pC, &r, &res);
98206 pC->cacheStatus = CACHE_STALE;
98207 rc = sqlite3BtreeNext(pC->uc.pCursor, 0);
98237 VdbeCursor *pC;
98239 pC = p->apCsr[pOp->p1];
98240 assert( pC!=0 );
98242 if( pC->seekHit<pOp->p2 ){
98245 printf("seekHit changes from %d to %d\n", pC->seekHit, pOp->p2);
98248 pC->seekHit = pOp->p2;
98249 }else if( pC->seekHit>pOp->p3 ){
98252 printf("seekHit changes from %d to %d\n", pC->seekHit, pOp->p3);
98255 pC->seekHit = pOp->p3;
98369 VdbeCursor *pC;
98371 pC = p->apCsr[pOp->p1];
98372 assert( pC!=0 );
98375 printf("seekHit is %d\n", pC->seekHit);
98378 if( pC->seekHit>=pOp->p4.i ) break;
98387 VdbeCursor *pC;
98397 pC = p->apCsr[pOp->p1];
98398 assert( pC!=0 );
98400 pC->seekOp = pOp->opcode;
98403 assert( pC->eCurType==CURTYPE_BTREE );
98404 assert( pC->uc.pCursor!=0 );
98405 assert( pC->isTable==0 );
98409 r.pKeyInfo = pC->pKeyInfo;
98418 rc = sqlite3BtreeIndexMoveto(pC->uc.pCursor, &r, &pC->seekResult);
98426 pIdxKey = sqlite3VdbeAllocUnpackedRecord(pC->pKeyInfo);
98428 sqlite3VdbeRecordUnpack(pC->pKeyInfo, r.aMem->n, r.aMem->z, pIdxKey);
98430 rc = sqlite3BtreeIndexMoveto(pC->uc.pCursor, pIdxKey, &pC->seekResult);
98436 alreadyExists = (pC->seekResult==0);
98437 pC->nullRow = 1-alreadyExists;
98438 pC->deferredMoveto = 0;
98439 pC->cacheStatus = CACHE_STALE;
98461 pC->seekHit = pOp->p4.i;
98515 VdbeCursor *pC;
98545 pC = p->apCsr[pOp->p1];
98546 assert( pC!=0 );
98548 if( pOp->opcode==OP_SeekRowid ) pC->seekOp = OP_SeekRowid;
98550 assert( pC->isTable );
98551 assert( pC->eCurType==CURTYPE_BTREE );
98552 pCrsr = pC->uc.pCursor;
98557 pC->movetoTarget = iKey; /* Used by OP_Delete */
98558 pC->nullRow = 0;
98559 pC->cacheStatus = CACHE_STALE;
98560 pC->deferredMoveto = 0;
98562 pC->seekResult = res;
98610 VdbeCursor *pC; /* Cursor of table to get the new rowid */
98622 pC = p->apCsr[pOp->p1];
98623 assert( pC!=0 );
98624 assert( pC->isTable );
98625 assert( pC->eCurType==CURTYPE_BTREE );
98626 assert( pC->uc.pCursor!=0 );
98641 assert( pC->isTable );
98653 if( !pC->useRandomRowid ){
98654 rc = sqlite3BtreeLast(pC->uc.pCursor, &res);
98661 assert( sqlite3BtreeCursorIsValid(pC->uc.pCursor) );
98662 v = sqlite3BtreeIntegerKey(pC->uc.pCursor);
98664 pC->useRandomRowid = 1;
98691 if( pMem->u.i==MAX_ROWID || pC->useRandomRowid ){
98701 if( pC->useRandomRowid ){
98712 }while( ((rc = sqlite3BtreeTableMoveto(pC->uc.pCursor, (u64)v,
98723 pC->deferredMoveto = 0;
98724 pC->cacheStatus = CACHE_STALE;
98770 VdbeCursor *pC; /* Cursor to table into which insert is written */
98779 pC = p->apCsr[pOp->p1];
98780 assert( pC!=0 );
98781 assert( pC->eCurType==CURTYPE_BTREE );
98782 assert( pC->deferredMoveto==0 );
98783 assert( pC->uc.pCursor!=0 );
98784 assert( (pOp->p5 & OPFLAG_ISNOOP) || pC->isTable );
98787 sqlite3VdbeIncrWriteCounter(p, pC);
98796 assert( pC->iDb>=0 );
98797 zDb = db->aDb[pC->iDb].zDbSName;
98809 sqlite3VdbePreUpdateHook(p,pC,SQLITE_INSERT,zDb,pTab,x.nKey,pOp->p2,-1);
98827 seekResult = ((pOp->p5 & OPFLAG_USESEEKRESULT) ? pC->seekResult : 0);
98835 rc = sqlite3BtreeInsert(pC->uc.pCursor, &x,
98839 pC->deferredMoveto = 0;
98840 pC->cacheStatus = CACHE_STALE;
98923 VdbeCursor *pC;
98930 pC = p->apCsr[pOp->p1];
98931 assert( pC!=0 );
98932 assert( pC->eCurType==CURTYPE_BTREE );
98933 assert( pC->uc.pCursor!=0 );
98934 assert( pC->deferredMoveto==0 );
98935 sqlite3VdbeIncrWriteCounter(p, pC);
98941 && sqlite3BtreeCursorIsValidNN(pC->uc.pCursor)
98944 ** OP_Delete will have also set the pC->movetoTarget field to the rowid of
98946 i64 iKey = sqlite3BtreeIntegerKey(pC->uc.pCursor);
98947 assert( CORRUPT_DB || pC->movetoTarget==iKey );
98957 assert( pC->iDb>=0 );
98959 zDb = db->aDb[pC->iDb].zDbSName;
98961 if( (pOp->p5 & OPFLAG_SAVEPOSITION)!=0 && pC->isTable ){
98962 pC->movetoTarget = sqlite3BtreeIntegerKey(pC->uc.pCursor);
98977 sqlite3VdbePreUpdateHook(p, pC,
98979 zDb, pTab, pC->movetoTarget,
98993 if( pC->isEphemeral==0
98995 && (pC->wrFlag & OPFLAG_FORDELETE)==0
99005 rc = sqlite3BtreeDelete(pC->uc.pCursor, pOp->p5);
99006 pC->cacheStatus = CACHE_STALE;
99008 pC->seekResult = 0;
99016 pC->movetoTarget);
99017 assert( pC->iDb>=0 );
99052 VdbeCursor *pC;
99056 pC = p->apCsr[pOp->p1];
99057 assert( isSorter(pC) );
99062 rc = sqlite3VdbeSorterCompare(pC, pIn3, nKeyCol, &res);
99082 VdbeCursor *pC;
99085 pC = p->apCsr[pOp->p1];
99086 assert( isSorter(pC) );
99087 rc = sqlite3VdbeSorterRowkey(pC, pOut);
99124 VdbeCursor *pC;
99131 pC = p->apCsr[pOp->p1];
99132 assert( pC!=0 );
99133 assert( pC->eCurType==CURTYPE_BTREE );
99134 assert( isSorter(pC)==0 );
99135 assert( pC->nullRow==0 );
99136 assert( pC->uc.pCursor!=0 );
99137 pCrsr = pC->uc.pCursor;
99147 assert( pC->deferredMoveto==0 );
99174 VdbeCursor *pC;
99181 pC = p->apCsr[pOp->p1];
99182 assert( pC!=0 );
99183 assert( pC->eCurType!=CURTYPE_PSEUDO || pC->nullRow );
99184 if( pC->nullRow ){
99187 }else if( pC->deferredMoveto ){
99188 v = pC->movetoTarget;
99190 }else if( pC->eCurType==CURTYPE_VTAB ){
99191 assert( pC->uc.pVCur!=0 );
99192 pVtab = pC->uc.pVCur->pVtab;
99195 rc = pModule->xRowid(pC->uc.pVCur, &v);
99200 assert( pC->eCurType==CURTYPE_BTREE );
99201 assert( pC->uc.pCursor!=0 );
99202 rc = sqlite3VdbeCursorRestore(pC);
99204 if( pC->nullRow ){
99208 v = sqlite3BtreeIntegerKey(pC->uc.pCursor);
99224 VdbeCursor *pC;
99227 pC = p->apCsr[pOp->p1];
99228 if( pC==0 ){
99231 pC = allocateCursor(p, pOp->p1, 1, CURTYPE_PSEUDO);
99232 if( pC==0 ) goto no_mem;
99233 pC->seekResult = 0;
99234 pC->isTable = 1;
99235 pC->noReuse = 1;
99236 pC->uc.pCursor = sqlite3BtreeFakeValidCursor();
99238 pC->nullRow = 1;
99239 pC->cacheStatus = CACHE_STALE;
99240 if( pC->eCurType==CURTYPE_BTREE ){
99241 assert( pC->uc.pCursor!=0 );
99242 sqlite3BtreeClearCursor(pC->uc.pCursor);
99245 if( pC->seekOp==0 ) pC->seekOp = OP_NullRow;
99274 VdbeCursor *pC;
99279 pC = p->apCsr[pOp->p1];
99280 assert( pC!=0 );
99281 assert( pC->eCurType==CURTYPE_BTREE );
99282 pCrsr = pC->uc.pCursor;
99286 pC->seekOp = pOp->opcode;
99290 pC->seekResult = -1;
99296 pC->nullRow = (u8)res;
99297 pC->deferredMoveto = 0;
99298 pC->cacheStatus = CACHE_STALE;
99316 VdbeCursor *pC;
99325 pC = p->apCsr[pOp->p1];
99326 assert( pC!=0 );
99327 pCrsr = pC->uc.pCursor;
99392 VdbeCursor *pC;
99400 pC = p->apCsr[pOp->p1];
99401 assert( pC!=0 );
99402 assert( isSorter(pC)==(pOp->opcode==OP_SorterSort) );
99405 pC->seekOp = OP_Rewind;
99407 if( isSorter(pC) ){
99408 rc = sqlite3VdbeSorterRewind(pC, &res);
99410 assert( pC->eCurType==CURTYPE_BTREE );
99411 pCrsr = pC->uc.pCursor;
99414 pC->deferredMoveto = 0;
99415 pC->cacheStatus = CACHE_STALE;
99418 pC->nullRow = (u8)res;
99481 VdbeCursor *pC;
99483 pC = p->apCsr[pOp->p1];
99484 assert( isSorter(pC) );
99485 rc = sqlite3VdbeSorterNext(db, pC);
99493 pC = p->apCsr[pOp->p1];
99494 assert( pC!=0 );
99495 assert( pC->deferredMoveto==0 );
99496 assert( pC->eCurType==CURTYPE_BTREE );
99497 assert( pC->seekOp==OP_SeekLT || pC->seekOp==OP_SeekLE
99498 || pC->seekOp==OP_Last || pC->seekOp==OP_IfNoHope
99499 || pC->seekOp==OP_NullRow);
99500 rc = sqlite3BtreePrevious(pC->uc.pCursor, pOp->p3);
99508 pC = p->apCsr[pOp->p1];
99509 assert( pC!=0 );
99510 assert( pC->deferredMoveto==0 );
99511 assert( pC->eCurType==CURTYPE_BTREE );
99512 assert( pC->seekOp==OP_SeekGT || pC->seekOp==OP_SeekGE
99513 || pC->seekOp==OP_Rewind || pC->seekOp==OP_Found
99514 || pC->seekOp==OP_NullRow|| pC->seekOp==OP_SeekRowid
99515 || pC->seekOp==OP_IfNoHope);
99516 rc = sqlite3BtreeNext(pC->uc.pCursor, pOp->p3);
99519 pC->cacheStatus = CACHE_STALE;
99522 pC->nullRow = 0;
99531 pC->nullRow = 1;
99564 VdbeCursor *pC;
99568 pC = p->apCsr[pOp->p1];
99569 sqlite3VdbeIncrWriteCounter(p, pC);
99570 assert( pC!=0 );
99571 assert( !isSorter(pC) );
99575 assert( pC->eCurType==CURTYPE_BTREE );
99576 assert( pC->isTable==0 );
99583 rc = sqlite3BtreeInsert(pC->uc.pCursor, &x,
99585 ((pOp->p5 & OPFLAG_USESEEKRESULT) ? pC->seekResult : 0)
99587 assert( pC->deferredMoveto==0 );
99588 pC->cacheStatus = CACHE_STALE;
99601 VdbeCursor *pC;
99604 pC = p->apCsr[pOp->p1];
99605 sqlite3VdbeIncrWriteCounter(p, pC);
99606 assert( pC!=0 );
99607 assert( isSorter(pC) );
99610 assert( pC->isTable==0 );
99613 rc = sqlite3VdbeSorterWrite(pC, pIn2);
99634 VdbeCursor *pC;
99642 pC = p->apCsr[pOp->p1];
99643 assert( pC!=0 );
99644 assert( pC->eCurType==CURTYPE_BTREE );
99645 sqlite3VdbeIncrWriteCounter(p, pC);
99646 pCrsr = pC->uc.pCursor;
99648 r.pKeyInfo = pC->pKeyInfo;
99661 assert( pC->deferredMoveto==0 );
99662 pC->cacheStatus = CACHE_STALE;
99663 pC->seekResult = 0;
99697 VdbeCursor *pC; /* The P1 index cursor */
99702 pC = p->apCsr[pOp->p1];
99703 assert( pC!=0 );
99704 assert( pC->eCurType==CURTYPE_BTREE || IsNullCursor(pC) );
99705 assert( pC->uc.pCursor!=0 );
99706 assert( pC->isTable==0 || IsNullCursor(pC) );
99707 assert( pC->deferredMoveto==0 );
99708 assert( !pC->nullRow || pOp->opcode==OP_IdxRowid );
99712 rc = sqlite3VdbeCursorRestore(pC);
99719 if( !pC->nullRow ){
99721 rc = sqlite3VdbeIdxRowid(db, pC->uc.pCursor, &rowid);
99739 assert( !pC->isEphemeral );
99740 pTabCur->pAltCursor = pC;
99759 VdbeCursor *pC; /* The P1 index cursor */
99762 pC = p->apCsr[pOp->p1];
99763 if( pC->deferredMoveto ){
99764 rc = sqlite3VdbeFinishMoveto(pC);
99818 VdbeCursor *pC;
99823 pC = p->apCsr[pOp->p1];
99824 assert( pC!=0 );
99825 assert( pC->isOrdered );
99826 assert( pC->eCurType==CURTYPE_BTREE );
99827 assert( pC->uc.pCursor!=0);
99828 assert( pC->deferredMoveto==0 );
99830 r.pKeyInfo = pC->pKeyInfo;
99856 assert( pC->eCurType==CURTYPE_BTREE );
99857 pCur = pC->uc.pCursor;
99994 VdbeCursor *pC;
99997 pC = p->apCsr[pOp->p1];
99998 assert( pC!=0 );
99999 if( isSorter(pC) ){
100000 sqlite3VdbeSorterReset(db, pC->uc.pSorter);
100002 assert( pC->eCurType==CURTYPE_BTREE );
100003 assert( pC->isEphemeral );
100004 rc = sqlite3BtreeClearTableOfCursor(pC->uc.pCursor);
101145 VdbeCursor *pC;
101147 pC = p->apCsr[pOp->p1];
101148 assert( pC!=0 );
101149 assert( pC->eCurType==CURTYPE_BTREE );
101150 sqlite3BtreeCursorPin(pC->uc.pCursor);
101160 VdbeCursor *pC;
101162 pC = p->apCsr[pOp->p1];
101163 assert( pC!=0 );
101164 assert( pC->eCurType==CURTYPE_BTREE );
101165 sqlite3BtreeCursorUnpin(pC->uc.pCursor);
101371 VdbeCursor *pC; /* The cursor containing the RHS values */
101374 pC = p->apCsr[pOp->p1];
101377 pRhs->pCsr = pC->uc.pCursor;
102038 VdbeCursor *pC;
102042 pC = p->apCsr[pOp->p1];
102043 if( pC ){
102044 assert( pC->eCurType==CURTYPE_BTREE );
102045 sqlite3BtreeCursorHint(pC->uc.pCursor, BTREE_HINT_RANGE,
102359 VdbeCursor *pC = v->apCsr[0];
102361 assert( pC!=0 );
102362 assert( pC->eCurType==CURTYPE_BTREE );
102363 type = pC->nHdrParsed>p->iCol ? pC->aType[p->iCol] : 0;
102364 testcase( pC->nHdrParsed==p->iCol );
102365 testcase( pC->nHdrParsed==p->iCol+1 );
102374 p->iOffset = pC->aType[p->iCol + pC->nField];
102376 p->pCsr = pC->uc.pCursor;
143110 ** pA pB pC Return Value
143153 SQLITE_PRIVATE int sqlite3JoinType(Parse *pParse, Token *pA, Token *pB, Token *pC){
143175 apAll[2] = pC;
143199 if( pC==0 ){ zSp2++; }
143201 "%T%s%T%s%T", pA, zSp1, pB, zSp2, pC);
149707 struct AggInfo_col *pC;
149845 for(i=0, pC=pAggInfo->aCol; i<pAggInfo->nAccumulator; i++, pC++){
149846 sqlite3ExprCode(pParse, pC->pCExpr, AggInfoColumnReg(pAggInfo,i));
161599 u8 c, *pC; /* Last character before the first wildcard */
161600 pC = (u8*)&pStr2->u.zToken[sqlite3Strlen30(pStr2->u.zToken)-1];
161601 c = *pC;
161612 *pC = c + 1;
166418 CollSeq *pC = 0;
166422 pC = sqlite3ExprCompareCollSeq(pHidden->pParse, pX);
166424 zRet = (pC ? pC->zName : sqlite3StrBINARY);
202996 sqlite3_tokenizer_cursor *pC;
203002 rc = sqlite3Fts3OpenTokenizer(pTab->pTokenizer, iLangid, zDoc, nDoc, &pC);
203008 rc = pMod->xNext(pC, &ZDUMMY, &DUMMY1, &DUMMY2, &DUMMY3, &iCurrent);
203010 pMod->xClose(pC);
203050 sqlite3_tokenizer_cursor *pC; /* Tokenizer cursor open on zDoc/nDoc */
203063 rc = sqlite3Fts3OpenTokenizer(pTab->pTokenizer, pCsr->iLangid, zDoc,nDoc,&pC);
203086 rc = pMod->xNext(pC, &ZDUMMY, &DUMMY1, &iBegin, &iFin, &iCurrent);
203138 pMod->xClose(pC);
203936 sqlite3_tokenizer_cursor *pC; /* Tokenizer cursor */
203973 zDoc, nDoc, &pC
203977 rc = pMod->xNext(pC, &ZDUMMY, &NDUMMY, &iStart, &iEnd, &iCurrent);
204002 rc = pMod->xNext(pC, &ZDUMMY, &NDUMMY, &iStart, &iEnd, &iCurrent);
204019 pMod->xClose(pC);
204382 sqlite3_tokenizer_cursor *pC, /* Cursor returned by simpleOpen */
204389 unicode_cursor *pCsr = (unicode_cursor *)pC;
226454 SessionChange *pC /* Update pC->nMaxSize */
226457 if( pC->op==SQLITE_INSERT ){
226468 nNew += pC->nRecord;
226470 nNew += pC->nRecord;
226474 u8 *pCsr = pC->aRecord;
226530 nNew = pC->nRecord + 2;
226545 if( nNew>pC->nMaxSize ){
226546 int nIncr = nNew - pC->nMaxSize;
226547 pC->nMaxSize = nNew;
226625 SessionChange *pC;
226626 for(pC=pTab->apChange[iHash]; pC; pC=pC->pNext){
226627 if( sessionPreupdateEqual(pSession, iRowid, pTab, pC, op) ) break;
226630 if( pC==0 ){
226662 pC = (SessionChange*)sessionMalloc64(pSession, nByte);
226663 if( !pC ){
226667 memset(pC, 0, sizeof(SessionChange));
226668 pC->aRecord = (u8 *)&pC[1];
226677 pC->aRecord[0] = SQLITE_INTEGER;
226678 sessionPutI64(&pC->aRecord[1], iRowid);
226688 sessionSerializeValue(&pC->aRecord[nByte], p, &nByte);
226693 pC->bIndirect = 1;
226695 pC->nRecordField = pTab->nCol;
226696 pC->nRecord = nByte;
226697 pC->op = op;
226698 pC->pNext = pTab->apChange[iHash];
226699 pTab->apChange[iHash] = pC;
226701 }else if( pC->bIndirect ){
226707 pC->bIndirect = 0;
226713 rc = sessionUpdateMaxSize(op, pSession, pTab, pC);
252800 Fts5Config *pC = p->pConfig;
252806 pC->zContentExprlist, pC->zContent
252812 zSql = sqlite3_mprintf(azStmt[eStmt], pC->zContentExprlist,
252813 pC->zContent, pC->zContentRowid, pC->zContentRowid,
252814 pC->zContentRowid
252820 pC->zContentExprlist, pC->zContent, pC->zContentRowid
252826 int nCol = pC->nCol + 1;
252837 zSql = sqlite3_mprintf(azStmt[eStmt], pC->zDb, pC->zName, zBind);
252844 zSql = sqlite3_mprintf(azStmt[eStmt], pC->zDb, pC->zName,
252845 (pC->bContentlessDelete ? ",?" : "")
252851 (pC->bContentlessDelete ? ",origin" : ""),
252852 pC->zDb, pC->zName
252857 zSql = sqlite3_mprintf(azStmt[eStmt], pC->zDb, pC->zName);
252867 rc = sqlite3_prepare_v3(pC->db, zSql, -1, f, &p->aStmt[eStmt], 0);
252871 *pzErrMsg = sqlite3_mprintf("%s", sqlite3_errmsg(pC->db));