Lines Matching defs:pC
79126 SQLITE_PRIVATE void sqlite3VdbeIncrWriteCounter(Vdbe *p, VdbeCursor *pC){
79127 if( pC==0
79128 || (pC->eCurType!=CURTYPE_SORTER
79129 && pC->eCurType!=CURTYPE_PSEUDO
79130 && !pC->isEphemeral)
80883 VdbeCursor *pC = p->apCsr[i];
80884 if( pC ){
80885 sqlite3VdbeFreeCursor(p, pC);
83348 ** Compare the key of the index entry that cursor pC is pointing to against
83350 ** that is negative, zero, or positive if pC is less than, equal to,
83360 VdbeCursor *pC, /* The cursor to compare against */
83369 assert( pC->eCurType==CURTYPE_BTREE );
83370 pCur = pC->uc.pCursor;
88518 VdbeCursor *pC; /* The VDBE cursor */
88520 pC = p->apCsr[pOp->p1];
88522 if( NEVER(pC==0) || pC->eCurType!=CURTYPE_BTREE ){
88525 sqlite3VdbeMemSetInt64(pOut, sqlite3BtreeOffset(pC->uc.pCursor));
88553 VdbeCursor *pC; /* The VDBE cursor */
88568 pC = p->apCsr[pOp->p1];
88569 assert( pC!=0 );
88575 rc = sqlite3VdbeCursorMoveto(&pC, &p2);
88581 assert( pC!=0 );
88582 assert( p2<(u32)pC->nField );
88583 aOffset = pC->aOffset;
88584 assert( pC->eCurType!=CURTYPE_VTAB );
88585 assert( pC->eCurType!=CURTYPE_PSEUDO || pC->nullRow );
88586 assert( pC->eCurType!=CURTYPE_SORTER );
88588 if( pC->cacheStatus!=p->cacheCtr ){ /*OPTIMIZATION-IF-FALSE*/
88589 if( pC->nullRow ){
88590 if( pC->eCurType==CURTYPE_PSEUDO ){
88593 assert( pC->seekResult>0 );
88594 pReg = &aMem[pC->seekResult];
88597 pC->payloadSize = pC->szRow = pReg->n;
88598 pC->aRow = (u8*)pReg->z;
88604 pCrsr = pC->uc.pCursor;
88605 assert( pC->eCurType==CURTYPE_BTREE );
88608 pC->payloadSize = sqlite3BtreePayloadSize(pCrsr);
88609 pC->aRow = sqlite3BtreePayloadFetch(pCrsr, &pC->szRow);
88610 assert( pC->szRow<=pC->payloadSize );
88611 assert( pC->szRow<=65536 ); /* Maximum page size is 64KiB */
88612 if( pC->payloadSize > (u32)db->aLimit[SQLITE_LIMIT_LENGTH] ){
88616 pC->cacheStatus = p->cacheCtr;
88617 pC->iHdrOffset = getVarint32(pC->aRow, aOffset[0]);
88618 pC->nHdrParsed = 0;
88621 if( pC->szRow<aOffset[0] ){ /*OPTIMIZATION-IF-FALSE*/
88622 /* pC->aRow does not have to hold the entire row, but it does at least
88623 ** need to cover the header of the record. If pC->aRow does not contain
88626 pC->aRow = 0;
88627 pC->szRow = 0;
88638 if( aOffset[0] > 98307 || aOffset[0] > pC->payloadSize ){
88643 ** (ex: pC->nHdrParsed<=p2) in the next section, we achieve a
88655 zData = pC->aRow;
88656 assert( pC->nHdrParsed<=p2 ); /* Conditional skipped */
88663 ** parsed and valid information is in aOffset[] and pC->aType[].
88665 if( pC->nHdrParsed<=p2 ){
88669 if( pC->iHdrOffset<aOffset[0] ){
88671 if( pC->aRow==0 ){
88673 rc = sqlite3VdbeMemFromBtreeZeroOffset(pC->uc.pCursor,aOffset[0],&sMem);
88677 zData = pC->aRow;
88680 /* Fill in pC->aType[i] and aOffset[i] values through the p2-th field. */
88682 i = pC->nHdrParsed;
88684 zHdr = zData + pC->iHdrOffset;
88688 if( (pC->aType[i] = t = zHdr[0])<0x80 ){
88693 pC->aType[i] = t;
88704 if( (zHdr>=zEndHdr && (zHdr>zEndHdr || offset64!=pC->payloadSize))
88705 || (offset64 > pC->payloadSize)
88711 if( pC->aRow==0 ) sqlite3VdbeMemRelease(&sMem);
88716 pC->nHdrParsed = i;
88717 pC->iHdrOffset = (u32)(zHdr - zData);
88718 if( pC->aRow==0 ) sqlite3VdbeMemRelease(&sMem);
88727 if( pC->nHdrParsed<=p2 ){
88736 t = pC->aType[p2];
88740 ** reach this point if aOffset[p2], aOffset[p2+1], and pC->aType[p2] are
88743 assert( p2<pC->nHdrParsed );
88749 assert( t==pC->aType[p2] );
88750 if( pC->szRow>=aOffset[p2+1] ){
88753 zData = pC->aRow + aOffset[p2];
88797 rc = sqlite3VdbeMemFromBtree(pC->uc.pCursor, aOffset[p2], len, pDest);
90003 VdbeCursor *pC;
90005 pC = p->apCsr[pOp->p1];
90006 assert( isSorter(pC) );
90007 if( (pC->seqCount++)==0 ){
90072 VdbeCursor *pC;
90073 pC = p->apCsr[pOp->p1];
90074 assert( pC->eCurType==CURTYPE_BTREE );
90075 pC->maskUsed = *(u64*)pOp->p4.pI64;
90176 VdbeCursor *pC; /* The cursor to seek */
90184 pC = p->apCsr[pOp->p1];
90185 assert( pC!=0 );
90186 assert( pC->eCurType==CURTYPE_BTREE );
90190 assert( pC->isOrdered );
90191 assert( pC->uc.pCursor!=0 );
90194 pC->nullRow = 0;
90196 pC->seekOp = pOp->opcode;
90199 pC->deferredMoveto = 0;
90200 pC->cacheStatus = CACHE_STALE;
90201 if( pC->isTable ){
90204 assert( sqlite3BtreeCursorHasHint(pC->uc.pCursor, BTREE_SEEK_EQ)==0
90227 rc = sqlite3BtreeLast(pC->uc.pCursor, &res);
90256 rc = sqlite3BtreeMovetoUnpacked(pC->uc.pCursor, 0, (u64)iKey, 0, &res);
90257 pC->movetoTarget = iKey; /* Used by OP_Delete */
90267 if( sqlite3BtreeCursorHasHint(pC->uc.pCursor, BTREE_SEEK_EQ) ){
90282 r.pKeyInfo = pC->pKeyInfo;
90303 rc = sqlite3BtreeMovetoUnpacked(pC->uc.pCursor, &r, 0, 0, &res);
90318 rc = sqlite3BtreeNext(pC->uc.pCursor, 0);
90334 rc = sqlite3BtreePrevious(pC->uc.pCursor, 0);
90347 res = sqlite3BtreeEof(pC->uc.pCursor);
90410 VdbeCursor *pC;
90427 pC = p->apCsr[pOp[1].p1];
90428 assert( pC!=0 );
90429 assert( pC->eCurType==CURTYPE_BTREE );
90430 assert( !pC->isTable );
90431 if( !sqlite3BtreeCursorIsValidNN(pC->uc.pCursor) ){
90441 r.pKeyInfo = pC->pKeyInfo;
90456 rc = sqlite3VdbeIdxKeyCompare(db, pC, &r, &res);
90489 rc = sqlite3BtreeNext(pC->uc.pCursor, 0);
90519 VdbeCursor *pC;
90521 pC = p->apCsr[pOp->p1];
90522 assert( pC!=0 );
90524 if( pC->seekHit<pOp->p2 ){
90525 pC->seekHit = pOp->p2;
90526 }else if( pC->seekHit>pOp->p3 ){
90527 pC->seekHit = pOp->p3;
90637 VdbeCursor *pC;
90639 pC = p->apCsr[pOp->p1];
90640 assert( pC!=0 );
90641 if( pC->seekHit>=pOp->p4.i ) break;
90651 VdbeCursor *pC;
90663 pC = p->apCsr[pOp->p1];
90664 assert( pC!=0 );
90666 pC->seekOp = pOp->opcode;
90669 assert( pC->eCurType==CURTYPE_BTREE );
90670 assert( pC->uc.pCursor!=0 );
90671 assert( pC->isTable==0 );
90673 r.pKeyInfo = pC->pKeyInfo;
90690 pFree = pIdxKey = sqlite3VdbeAllocUnpackedRecord(pC->pKeyInfo);
90692 sqlite3VdbeRecordUnpack(pC->pKeyInfo, pIn3->n, pIn3->z, pIdxKey);
90707 rc = sqlite3BtreeMovetoUnpacked(pC->uc.pCursor, pIdxKey, 0, 0, &res);
90712 pC->seekResult = res;
90714 pC->nullRow = 1-alreadyExists;
90715 pC->deferredMoveto = 0;
90716 pC->cacheStatus = CACHE_STALE;
90723 if( pOp->opcode==OP_IfNoHope ) pC->seekHit = pOp->p4.i;
90776 VdbeCursor *pC;
90806 pC = p->apCsr[pOp->p1];
90807 assert( pC!=0 );
90809 if( pOp->opcode==OP_SeekRowid ) pC->seekOp = OP_SeekRowid;
90811 assert( pC->isTable );
90812 assert( pC->eCurType==CURTYPE_BTREE );
90813 pCrsr = pC->uc.pCursor;
90818 pC->movetoTarget = iKey; /* Used by OP_Delete */
90819 pC->nullRow = 0;
90820 pC->cacheStatus = CACHE_STALE;
90821 pC->deferredMoveto = 0;
90823 pC->seekResult = res;
90871 VdbeCursor *pC; /* Cursor of table to get the new rowid */
90883 pC = p->apCsr[pOp->p1];
90884 assert( pC!=0 );
90885 assert( pC->isTable );
90886 assert( pC->eCurType==CURTYPE_BTREE );
90887 assert( pC->uc.pCursor!=0 );
90902 assert( pC->isTable );
90914 if( !pC->useRandomRowid ){
90915 rc = sqlite3BtreeLast(pC->uc.pCursor, &res);
90922 assert( sqlite3BtreeCursorIsValid(pC->uc.pCursor) );
90923 v = sqlite3BtreeIntegerKey(pC->uc.pCursor);
90925 pC->useRandomRowid = 1;
90952 if( pMem->u.i==MAX_ROWID || pC->useRandomRowid ){
90962 if( pC->useRandomRowid ){
90973 }while( ((rc = sqlite3BtreeMovetoUnpacked(pC->uc.pCursor, 0, (u64)v,
90984 pC->deferredMoveto = 0;
90985 pC->cacheStatus = CACHE_STALE;
91031 VdbeCursor *pC; /* Cursor to table into which insert is written */
91040 pC = p->apCsr[pOp->p1];
91041 assert( pC!=0 );
91042 assert( pC->eCurType==CURTYPE_BTREE );
91043 assert( pC->deferredMoveto==0 );
91044 assert( pC->uc.pCursor!=0 );
91045 assert( (pOp->p5 & OPFLAG_ISNOOP) || pC->isTable );
91048 sqlite3VdbeIncrWriteCounter(p, pC);
91057 assert( pC->iDb>=0 );
91058 zDb = db->aDb[pC->iDb].zDbSName;
91070 sqlite3VdbePreUpdateHook(p, pC, SQLITE_INSERT, zDb, pTab, x.nKey,pOp->p2);
91085 seekResult = ((pOp->p5 & OPFLAG_USESEEKRESULT) ? pC->seekResult : 0);
91092 rc = sqlite3BtreeInsert(pC->uc.pCursor, &x,
91096 pC->deferredMoveto = 0;
91097 pC->cacheStatus = CACHE_STALE;
91174 VdbeCursor *pC;
91181 pC = p->apCsr[pOp->p1];
91182 assert( pC!=0 );
91183 assert( pC->eCurType==CURTYPE_BTREE );
91184 assert( pC->uc.pCursor!=0 );
91185 assert( pC->deferredMoveto==0 );
91186 sqlite3VdbeIncrWriteCounter(p, pC);
91192 && sqlite3BtreeCursorIsValidNN(pC->uc.pCursor)
91195 ** OP_Delete will have also set the pC->movetoTarget field to the rowid of
91197 i64 iKey = sqlite3BtreeIntegerKey(pC->uc.pCursor);
91198 assert( CORRUPT_DB || pC->movetoTarget==iKey );
91208 assert( pC->iDb>=0 );
91210 zDb = db->aDb[pC->iDb].zDbSName;
91212 if( (pOp->p5 & OPFLAG_SAVEPOSITION)!=0 && pC->isTable ){
91213 pC->movetoTarget = sqlite3BtreeIntegerKey(pC->uc.pCursor);
91227 sqlite3VdbePreUpdateHook(p, pC,
91229 zDb, pTab, pC->movetoTarget,
91243 if( pC->isEphemeral==0
91245 && (pC->wrFlag & OPFLAG_FORDELETE)==0
91255 rc = sqlite3BtreeDelete(pC->uc.pCursor, pOp->p5);
91256 pC->cacheStatus = CACHE_STALE;
91257 pC->seekResult = 0;
91265 pC->movetoTarget);
91266 assert( pC->iDb>=0 );
91301 VdbeCursor *pC;
91305 pC = p->apCsr[pOp->p1];
91306 assert( isSorter(pC) );
91311 rc = sqlite3VdbeSorterCompare(pC, pIn3, nKeyCol, &res);
91331 VdbeCursor *pC;
91334 pC = p->apCsr[pOp->p1];
91335 assert( isSorter(pC) );
91336 rc = sqlite3VdbeSorterRowkey(pC, pOut);
91373 VdbeCursor *pC;
91380 pC = p->apCsr[pOp->p1];
91381 assert( pC!=0 );
91382 assert( pC->eCurType==CURTYPE_BTREE );
91383 assert( isSorter(pC)==0 );
91384 assert( pC->nullRow==0 );
91385 assert( pC->uc.pCursor!=0 );
91386 pCrsr = pC->uc.pCursor;
91396 assert( pC->deferredMoveto==0 );
91423 VdbeCursor *pC;
91430 pC = p->apCsr[pOp->p1];
91431 assert( pC!=0 );
91432 assert( pC->eCurType!=CURTYPE_PSEUDO || pC->nullRow );
91433 if( pC->nullRow ){
91436 }else if( pC->deferredMoveto ){
91437 v = pC->movetoTarget;
91439 }else if( pC->eCurType==CURTYPE_VTAB ){
91440 assert( pC->uc.pVCur!=0 );
91441 pVtab = pC->uc.pVCur->pVtab;
91444 rc = pModule->xRowid(pC->uc.pVCur, &v);
91449 assert( pC->eCurType==CURTYPE_BTREE );
91450 assert( pC->uc.pCursor!=0 );
91451 rc = sqlite3VdbeCursorRestore(pC);
91453 if( pC->nullRow ){
91457 v = sqlite3BtreeIntegerKey(pC->uc.pCursor);
91470 VdbeCursor *pC;
91473 pC = p->apCsr[pOp->p1];
91474 assert( pC!=0 );
91475 pC->nullRow = 1;
91476 pC->cacheStatus = CACHE_STALE;
91477 if( pC->eCurType==CURTYPE_BTREE ){
91478 assert( pC->uc.pCursor!=0 );
91479 sqlite3BtreeClearCursor(pC->uc.pCursor);
91482 if( pC->seekOp==0 ) pC->seekOp = OP_NullRow;
91511 VdbeCursor *pC;
91516 pC = p->apCsr[pOp->p1];
91517 assert( pC!=0 );
91518 assert( pC->eCurType==CURTYPE_BTREE );
91519 pCrsr = pC->uc.pCursor;
91523 pC->seekOp = pOp->opcode;
91527 pC->seekResult = -1;
91533 pC->nullRow = (u8)res;
91534 pC->deferredMoveto = 0;
91535 pC->cacheStatus = CACHE_STALE;
91550 VdbeCursor *pC;
91556 pC = p->apCsr[pOp->p1];
91557 assert( pC!=0 );
91558 pCrsr = pC->uc.pCursor;
91616 VdbeCursor *pC;
91622 pC = p->apCsr[pOp->p1];
91623 assert( pC!=0 );
91624 assert( isSorter(pC)==(pOp->opcode==OP_SorterSort) );
91627 pC->seekOp = OP_Rewind;
91629 if( isSorter(pC) ){
91630 rc = sqlite3VdbeSorterRewind(pC, &res);
91632 assert( pC->eCurType==CURTYPE_BTREE );
91633 pCrsr = pC->uc.pCursor;
91636 pC->deferredMoveto = 0;
91637 pC->cacheStatus = CACHE_STALE;
91640 pC->nullRow = (u8)res;
91708 VdbeCursor *pC;
91710 pC = p->apCsr[pOp->p1];
91711 assert( isSorter(pC) );
91712 rc = sqlite3VdbeSorterNext(db, pC);
91718 pC = p->apCsr[pOp->p1];
91719 assert( pC!=0 );
91720 assert( pC->deferredMoveto==0 );
91721 assert( pC->eCurType==CURTYPE_BTREE );
91728 || pC->seekOp==OP_SeekGT || pC->seekOp==OP_SeekGE
91729 || pC->seekOp==OP_Rewind || pC->seekOp==OP_Found
91730 || pC->seekOp==OP_NullRow|| pC->seekOp==OP_SeekRowid
91731 || pC->seekOp==OP_IfNoHope);
91733 || pC->seekOp==OP_SeekLT || pC->seekOp==OP_SeekLE
91734 || pC->seekOp==OP_Last || pC->seekOp==OP_IfNoHope
91735 || pC->seekOp==OP_NullRow);
91737 rc = pOp->p4.xAdvance(pC->uc.pCursor, pOp->p3);
91739 pC->cacheStatus = CACHE_STALE;
91742 pC->nullRow = 0;
91751 pC->nullRow = 1;
91784 VdbeCursor *pC;
91788 pC = p->apCsr[pOp->p1];
91789 sqlite3VdbeIncrWriteCounter(p, pC);
91790 assert( pC!=0 );
91791 assert( !isSorter(pC) );
91795 assert( pC->eCurType==CURTYPE_BTREE );
91796 assert( pC->isTable==0 );
91803 rc = sqlite3BtreeInsert(pC->uc.pCursor, &x,
91805 ((pOp->p5 & OPFLAG_USESEEKRESULT) ? pC->seekResult : 0)
91807 assert( pC->deferredMoveto==0 );
91808 pC->cacheStatus = CACHE_STALE;
91821 VdbeCursor *pC;
91824 pC = p->apCsr[pOp->p1];
91825 sqlite3VdbeIncrWriteCounter(p, pC);
91826 assert( pC!=0 );
91827 assert( isSorter(pC) );
91830 assert( pC->isTable==0 );
91833 rc = sqlite3VdbeSorterWrite(pC, pIn2);
91853 VdbeCursor *pC;
91861 pC = p->apCsr[pOp->p1];
91862 assert( pC!=0 );
91863 assert( pC->eCurType==CURTYPE_BTREE );
91864 sqlite3VdbeIncrWriteCounter(p, pC);
91865 pCrsr = pC->uc.pCursor;
91867 r.pKeyInfo = pC->pKeyInfo;
91880 assert( pC->deferredMoveto==0 );
91881 pC->cacheStatus = CACHE_STALE;
91882 pC->seekResult = 0;
91916 VdbeCursor *pC; /* The P1 index cursor */
91921 pC = p->apCsr[pOp->p1];
91922 assert( pC!=0 );
91923 assert( pC->eCurType==CURTYPE_BTREE );
91924 assert( pC->uc.pCursor!=0 );
91925 assert( pC->isTable==0 );
91926 assert( pC->deferredMoveto==0 );
91927 assert( !pC->nullRow || pOp->opcode==OP_IdxRowid );
91931 rc = sqlite3VdbeCursorRestore(pC);
91938 if( !pC->nullRow ){
91940 rc = sqlite3VdbeIdxRowid(db, pC->uc.pCursor, &rowid);
91956 assert( !pC->isEphemeral );
91958 pTabCur->pAltCursor = pC;
91977 VdbeCursor *pC; /* The P1 index cursor */
91980 pC = p->apCsr[pOp->p1];
91981 if( pC->deferredMoveto ){
91982 rc = sqlite3VdbeFinishMoveto(pC);
92036 VdbeCursor *pC;
92041 pC = p->apCsr[pOp->p1];
92042 assert( pC!=0 );
92043 assert( pC->isOrdered );
92044 assert( pC->eCurType==CURTYPE_BTREE );
92045 assert( pC->uc.pCursor!=0);
92046 assert( pC->deferredMoveto==0 );
92048 r.pKeyInfo = pC->pKeyInfo;
92074 assert( pC->eCurType==CURTYPE_BTREE );
92075 pCur = pC->uc.pCursor;
92215 VdbeCursor *pC;
92218 pC = p->apCsr[pOp->p1];
92219 assert( pC!=0 );
92220 if( isSorter(pC) ){
92221 sqlite3VdbeSorterReset(db, pC->uc.pSorter);
92223 assert( pC->eCurType==CURTYPE_BTREE );
92224 assert( pC->isEphemeral );
92225 rc = sqlite3BtreeClearTableOfCursor(pC->uc.pCursor);
93324 VdbeCursor *pC;
93326 pC = p->apCsr[pOp->p1];
93327 assert( pC!=0 );
93328 assert( pC->eCurType==CURTYPE_BTREE );
93329 sqlite3BtreeCursorPin(pC->uc.pCursor);
93339 VdbeCursor *pC;
93341 pC = p->apCsr[pOp->p1];
93342 assert( pC!=0 );
93343 assert( pC->eCurType==CURTYPE_BTREE );
93344 sqlite3BtreeCursorUnpin(pC->uc.pCursor);
94022 VdbeCursor *pC;
94026 pC = p->apCsr[pOp->p1];
94027 if( pC ){
94028 assert( pC->eCurType==CURTYPE_BTREE );
94029 sqlite3BtreeCursorHint(pC->uc.pCursor, BTREE_HINT_RANGE,
94313 VdbeCursor *pC = v->apCsr[0];
94314 u32 type = pC->nHdrParsed>p->iCol ? pC->aType[p->iCol] : 0;
94315 testcase( pC->nHdrParsed==p->iCol );
94316 testcase( pC->nHdrParsed==p->iCol+1 );
94325 p->iOffset = pC->aType[p->iCol + pC->nField];
94327 p->pCsr = pC->uc.pCursor;
131366 SQLITE_PRIVATE int sqlite3JoinType(Parse *pParse, Token *pA, Token *pB, Token *pC){
131388 apAll[2] = pC;
131410 if( pC==0 ){ zSp++; }
131412 "%T %T%s%T", pA, pB, zSp, pC);
136845 struct AggInfo_col *pC;
136921 for(i=0, pC=pAggInfo->aCol; i<pAggInfo->nAccumulator; i++, pC++){
136922 sqlite3ExprCode(pParse, pC->pCExpr, pC->iMem);
147968 u8 c, *pC; /* Last character before the first wildcard */
147969 pC = (u8*)&pStr2->u.zToken[sqlite3Strlen30(pStr2->u.zToken)-1];
147970 c = *pC;
147981 *pC = c + 1;
151675 CollSeq *pC = 0;
151679 pC = sqlite3ExprCompareCollSeq(pHidden->pParse, pX);
151681 zRet = (pC ? pC->zName : sqlite3StrBINARY);
186709 sqlite3_tokenizer_cursor *pC;
186715 rc = sqlite3Fts3OpenTokenizer(pTab->pTokenizer, iLangid, zDoc, nDoc, &pC);
186721 rc = pMod->xNext(pC, &ZDUMMY, &DUMMY1, &DUMMY2, &DUMMY3, &iCurrent);
186723 pMod->xClose(pC);
186763 sqlite3_tokenizer_cursor *pC; /* Tokenizer cursor open on zDoc/nDoc */
186776 rc = sqlite3Fts3OpenTokenizer(pTab->pTokenizer, pCsr->iLangid, zDoc,nDoc,&pC);
186799 rc = pMod->xNext(pC, &ZDUMMY, &DUMMY1, &iBegin, &iFin, &iCurrent);
186851 pMod->xClose(pC);
187648 sqlite3_tokenizer_cursor *pC; /* Tokenizer cursor */
187683 zDoc, nDoc, &pC
187687 rc = pMod->xNext(pC, &ZDUMMY, &NDUMMY, &iStart, &iEnd, &iCurrent);
187712 rc = pMod->xNext(pC, &ZDUMMY, &NDUMMY, &iStart, &iEnd, &iCurrent);
187729 pMod->xClose(pC);
188092 sqlite3_tokenizer_cursor *pC, /* Cursor returned by simpleOpen */
188099 unicode_cursor *pCsr = (unicode_cursor *)pC;
206806 SessionChange *pC;
206807 for(pC=pTab->apChange[iHash]; pC; pC=pC->pNext){
206808 if( sessionPreupdateEqual(pSession, pTab, pC, op) ) break;
206811 if( pC==0 ){
206874 }else if( pC->bIndirect ){
206880 pC->bIndirect = 0;
229528 Fts5Config *pC = p->pConfig;
229534 pC->zContentExprlist, pC->zContent
229540 zSql = sqlite3_mprintf(azStmt[eStmt], pC->zContentExprlist,
229541 pC->zContent, pC->zContentRowid, pC->zContentRowid,
229542 pC->zContentRowid
229548 pC->zContentExprlist, pC->zContent, pC->zContentRowid
229554 int nCol = pC->nCol + 1;
229565 zSql = sqlite3_mprintf(azStmt[eStmt], pC->zDb, pC->zName, zBind);
229572 zSql = sqlite3_mprintf(azStmt[eStmt], pC->zDb, pC->zName);
229582 rc = sqlite3_prepare_v3(pC->db, zSql, -1, f, &p->aStmt[eStmt], 0);
229586 *pzErrMsg = sqlite3_mprintf("%s", sqlite3_errmsg(pC->db));