Lines Matching refs:pC
75070 VdbeCursor *pC = p->apCsr[i];
75071 if( pC ){
75072 sqlite3VdbeFreeCursor(p, pC);
77458 VdbeCursor *pC, /* The cursor to compare against */
77467 assert( pC->eCurType==CURTYPE_BTREE );
77468 pCur = pC->uc.pCursor;
82349 VdbeCursor *pC; /* The VDBE cursor */
82351 pC = p->apCsr[pOp->p1];
82353 if( NEVER(pC==0) || pC->eCurType!=CURTYPE_BTREE ){
82356 sqlite3VdbeMemSetInt64(pOut, sqlite3BtreeOffset(pC->uc.pCursor));
82389 VdbeCursor *pC; /* The VDBE cursor */
82403 pC = p->apCsr[pOp->p1];
82409 rc = sqlite3VdbeCursorMoveto(&pC, &p2);
82416 assert( pC!=0 );
82417 assert( p2<pC->nField );
82418 aOffset = pC->aOffset;
82419 assert( pC->eCurType!=CURTYPE_VTAB );
82420 assert( pC->eCurType!=CURTYPE_PSEUDO || pC->nullRow );
82421 assert( pC->eCurType!=CURTYPE_SORTER );
82423 if( pC->cacheStatus!=p->cacheCtr ){ /*OPTIMIZATION-IF-FALSE*/
82424 if( pC->nullRow ){
82425 if( pC->eCurType==CURTYPE_PSEUDO ){
82428 assert( pC->seekResult>0 );
82429 pReg = &aMem[pC->seekResult];
82432 pC->payloadSize = pC->szRow = pReg->n;
82433 pC->aRow = (u8*)pReg->z;
82439 pCrsr = pC->uc.pCursor;
82440 assert( pC->eCurType==CURTYPE_BTREE );
82443 pC->payloadSize = sqlite3BtreePayloadSize(pCrsr);
82444 pC->aRow = sqlite3BtreePayloadFetch(pCrsr, &pC->szRow);
82445 assert( pC->szRow<=pC->payloadSize );
82446 assert( pC->szRow<=65536 ); /* Maximum page size is 64KiB */
82447 if( pC->payloadSize > (u32)db->aLimit[SQLITE_LIMIT_LENGTH] ){
82451 pC->cacheStatus = p->cacheCtr;
82452 pC->iHdrOffset = getVarint32(pC->aRow, aOffset[0]);
82453 pC->nHdrParsed = 0;
82456 if( pC->szRow<aOffset[0] ){ /*OPTIMIZATION-IF-FALSE*/
82461 pC->aRow = 0;
82462 pC->szRow = 0;
82473 if( aOffset[0] > 98307 || aOffset[0] > pC->payloadSize ){
82490 zData = pC->aRow;
82491 assert( pC->nHdrParsed<=p2 ); /* Conditional skipped */
82500 if( pC->nHdrParsed<=p2 ){
82504 if( pC->iHdrOffset<aOffset[0] ){
82506 if( pC->aRow==0 ){
82508 rc = sqlite3VdbeMemFromBtree(pC->uc.pCursor, 0, aOffset[0], &sMem);
82512 zData = pC->aRow;
82517 i = pC->nHdrParsed;
82519 zHdr = zData + pC->iHdrOffset;
82530 pC->aType[i++] = t;
82539 if( (zHdr>=zEndHdr && (zHdr>zEndHdr || offset64!=pC->payloadSize))
82540 || (offset64 > pC->payloadSize)
82546 if( pC->aRow==0 ) sqlite3VdbeMemRelease(&sMem);
82551 pC->nHdrParsed = i;
82552 pC->iHdrOffset = (u32)(zHdr - zData);
82553 if( pC->aRow==0 ) sqlite3VdbeMemRelease(&sMem);
82562 if( pC->nHdrParsed<=p2 ){
82571 t = pC->aType[p2];
82578 assert( p2<pC->nHdrParsed );
82584 assert( t==pC->aType[p2] );
82585 if( pC->szRow>=aOffset[p2+1] ){
82588 zData = pC->aRow + aOffset[p2];
82631 rc = sqlite3VdbeMemFromBtree(pC->uc.pCursor, aOffset[p2], len, pDest);
83626 VdbeCursor *pC;
83628 pC = p->apCsr[pOp->p1];
83629 assert( isSorter(pC) );
83630 if( (pC->seqCount++)==0 ){
83695 VdbeCursor *pC;
83696 pC = p->apCsr[pOp->p1];
83697 assert( pC->eCurType==CURTYPE_BTREE );
83698 pC->maskUsed = *(u64*)pOp->p4.pI64;
83795 VdbeCursor *pC; /* The cursor to seek */
83803 pC = p->apCsr[pOp->p1];
83804 assert( pC!=0 );
83805 assert( pC->eCurType==CURTYPE_BTREE );
83809 assert( pC->isOrdered );
83810 assert( pC->uc.pCursor!=0 );
83813 pC->nullRow = 0;
83815 pC->seekOp = pOp->opcode;
83818 if( pC->isTable ){
83820 assert( sqlite3BtreeCursorHasHint(pC->uc.pCursor, BTREE_SEEK_EQ)==0
83865 rc = sqlite3BtreeMovetoUnpacked(pC->uc.pCursor, 0, (u64)iKey, 0, &res);
83866 pC->movetoTarget = iKey; /* Used by OP_Delete */
83875 if( sqlite3BtreeCursorHasHint(pC->uc.pCursor, BTREE_SEEK_EQ) ){
83888 r.pKeyInfo = pC->pKeyInfo;
83909 rc = sqlite3BtreeMovetoUnpacked(pC->uc.pCursor, &r, 0, 0, &res);
83918 pC->deferredMoveto = 0;
83919 pC->cacheStatus = CACHE_STALE;
83926 rc = sqlite3BtreeNext(pC->uc.pCursor, 0);
83942 rc = sqlite3BtreePrevious(pC->uc.pCursor, 0);
83955 res = sqlite3BtreeEof(pC->uc.pCursor);
84035 VdbeCursor *pC;
84047 pC = p->apCsr[pOp->p1];
84048 assert( pC!=0 );
84050 pC->seekOp = pOp->opcode;
84053 assert( pC->eCurType==CURTYPE_BTREE );
84054 assert( pC->uc.pCursor!=0 );
84055 assert( pC->isTable==0 );
84057 r.pKeyInfo = pC->pKeyInfo;
84074 pFree = pIdxKey = sqlite3VdbeAllocUnpackedRecord(pC->pKeyInfo);
84076 sqlite3VdbeRecordUnpack(pC->pKeyInfo, pIn3->n, pIn3->z, pIdxKey);
84091 rc = sqlite3BtreeMovetoUnpacked(pC->uc.pCursor, pIdxKey, 0, 0, &res);
84096 pC->seekResult = res;
84098 pC->nullRow = 1-alreadyExists;
84099 pC->deferredMoveto = 0;
84100 pC->cacheStatus = CACHE_STALE;
84159 VdbeCursor *pC;
84174 pC = p->apCsr[pOp->p1];
84175 assert( pC!=0 );
84177 pC->seekOp = 0;
84179 assert( pC->isTable );
84180 assert( pC->eCurType==CURTYPE_BTREE );
84181 pCrsr = pC->uc.pCursor;
84187 pC->movetoTarget = iKey; /* Used by OP_Delete */
84188 pC->nullRow = 0;
84189 pC->cacheStatus = CACHE_STALE;
84190 pC->deferredMoveto = 0;
84192 pC->seekResult = res;
84240 VdbeCursor *pC; /* Cursor of table to get the new rowid */
84250 pC = p->apCsr[pOp->p1];
84251 assert( pC!=0 );
84252 assert( pC->eCurType==CURTYPE_BTREE );
84253 assert( pC->uc.pCursor!=0 );
84268 assert( pC->isTable );
84280 if( !pC->useRandomRowid ){
84281 rc = sqlite3BtreeLast(pC->uc.pCursor, &res);
84288 assert( sqlite3BtreeCursorIsValid(pC->uc.pCursor) );
84289 v = sqlite3BtreeIntegerKey(pC->uc.pCursor);
84291 pC->useRandomRowid = 1;
84318 if( pMem->u.i==MAX_ROWID || pC->useRandomRowid ){
84328 if( pC->useRandomRowid ){
84339 }while( ((rc = sqlite3BtreeMovetoUnpacked(pC->uc.pCursor, 0, (u64)v,
84350 pC->deferredMoveto = 0;
84351 pC->cacheStatus = CACHE_STALE;
84404 VdbeCursor *pC; /* Cursor to table into which insert is written */
84413 pC = p->apCsr[pOp->p1];
84414 assert( pC!=0 );
84415 assert( pC->eCurType==CURTYPE_BTREE );
84416 assert( pC->uc.pCursor!=0 );
84417 assert( (pOp->p5 & OPFLAG_ISNOOP) || pC->isTable );
84433 assert( pC->iDb>=0 );
84434 zDb = db->aDb[pC->iDb].zDbSName;
84446 sqlite3VdbePreUpdateHook(p, pC, SQLITE_INSERT, zDb, pTab, x.nKey,pOp->p2);
84461 seekResult = ((pOp->p5 & OPFLAG_USESEEKRESULT) ? pC->seekResult : 0);
84468 rc = sqlite3BtreeInsert(pC->uc.pCursor, &x,
84471 pC->deferredMoveto = 0;
84472 pC->cacheStatus = CACHE_STALE;
84522 VdbeCursor *pC;
84529 pC = p->apCsr[pOp->p1];
84530 assert( pC!=0 );
84531 assert( pC->eCurType==CURTYPE_BTREE );
84532 assert( pC->uc.pCursor!=0 );
84533 assert( pC->deferredMoveto==0 );
84540 i64 iKey = sqlite3BtreeIntegerKey(pC->uc.pCursor);
84541 assert( pC->movetoTarget==iKey );
84551 assert( pC->iDb>=0 );
84553 zDb = db->aDb[pC->iDb].zDbSName;
84555 if( (pOp->p5 & OPFLAG_SAVEPOSITION)!=0 && pC->isTable ){
84556 pC->movetoTarget = sqlite3BtreeIntegerKey(pC->uc.pCursor);
84570 sqlite3VdbePreUpdateHook(p, pC,
84572 zDb, pTab, pC->movetoTarget,
84586 if( pC->isEphemeral==0
84588 && (pC->wrFlag & OPFLAG_FORDELETE)==0
84598 rc = sqlite3BtreeDelete(pC->uc.pCursor, pOp->p5);
84599 pC->cacheStatus = CACHE_STALE;
84600 pC->seekResult = 0;
84608 pC->movetoTarget);
84609 assert( pC->iDb>=0 );
84644 VdbeCursor *pC;
84648 pC = p->apCsr[pOp->p1];
84649 assert( isSorter(pC) );
84654 rc = sqlite3VdbeSorterCompare(pC, pIn3, nKeyCol, &res);
84674 VdbeCursor *pC;
84677 pC = p->apCsr[pOp->p1];
84678 assert( isSorter(pC) );
84679 rc = sqlite3VdbeSorterRowkey(pC, pOut);
84716 VdbeCursor *pC;
84723 pC = p->apCsr[pOp->p1];
84724 assert( pC!=0 );
84725 assert( pC->eCurType==CURTYPE_BTREE );
84726 assert( isSorter(pC)==0 );
84727 assert( pC->nullRow==0 );
84728 assert( pC->uc.pCursor!=0 );
84729 pCrsr = pC->uc.pCursor;
84739 assert( pC->deferredMoveto==0 );
84742 rc = sqlite3VdbeCursorMoveto(pC);
84770 VdbeCursor *pC;
84777 pC = p->apCsr[pOp->p1];
84778 assert( pC!=0 );
84779 assert( pC->eCurType!=CURTYPE_PSEUDO || pC->nullRow );
84780 if( pC->nullRow ){
84783 }else if( pC->deferredMoveto ){
84784 v = pC->movetoTarget;
84786 }else if( pC->eCurType==CURTYPE_VTAB ){
84787 assert( pC->uc.pVCur!=0 );
84788 pVtab = pC->uc.pVCur->pVtab;
84791 rc = pModule->xRowid(pC->uc.pVCur, &v);
84796 assert( pC->eCurType==CURTYPE_BTREE );
84797 assert( pC->uc.pCursor!=0 );
84798 rc = sqlite3VdbeCursorRestore(pC);
84800 if( pC->nullRow ){
84804 v = sqlite3BtreeIntegerKey(pC->uc.pCursor);
84817 VdbeCursor *pC;
84820 pC = p->apCsr[pOp->p1];
84821 assert( pC!=0 );
84822 pC->nullRow = 1;
84823 pC->cacheStatus = CACHE_STALE;
84824 if( pC->eCurType==CURTYPE_BTREE ){
84825 assert( pC->uc.pCursor!=0 );
84826 sqlite3BtreeClearCursor(pC->uc.pCursor);
84855 VdbeCursor *pC;
84860 pC = p->apCsr[pOp->p1];
84861 assert( pC!=0 );
84862 assert( pC->eCurType==CURTYPE_BTREE );
84863 pCrsr = pC->uc.pCursor;
84867 pC->seekOp = pOp->opcode;
84871 pC->seekResult = -1;
84877 pC->nullRow = (u8)res;
84878 pC->deferredMoveto = 0;
84879 pC->cacheStatus = CACHE_STALE;
84894 VdbeCursor *pC;
84900 pC = p->apCsr[pOp->p1];
84901 assert( pC!=0 );
84902 pCrsr = pC->uc.pCursor;
84959 VdbeCursor *pC;
84964 pC = p->apCsr[pOp->p1];
84965 assert( pC!=0 );
84966 assert( isSorter(pC)==(pOp->opcode==OP_SorterSort) );
84969 pC->seekOp = OP_Rewind;
84971 if( isSorter(pC) ){
84972 rc = sqlite3VdbeSorterRewind(pC, &res);
84974 assert( pC->eCurType==CURTYPE_BTREE );
84975 pCrsr = pC->uc.pCursor;
84978 pC->deferredMoveto = 0;
84979 pC->cacheStatus = CACHE_STALE;
84982 pC->nullRow = (u8)res;
85060 VdbeCursor *pC;
85062 pC = p->apCsr[pOp->p1];
85063 assert( isSorter(pC) );
85064 rc = sqlite3VdbeSorterNext(db, pC);
85074 pC = p->apCsr[pOp->p1];
85075 assert( pC!=0 );
85076 assert( pC->deferredMoveto==0 );
85077 assert( pC->eCurType==CURTYPE_BTREE );
85086 || pC->seekOp==OP_SeekGT || pC->seekOp==OP_SeekGE
85087 || pC->seekOp==OP_Rewind || pC->seekOp==OP_Found);
85089 || pC->seekOp==OP_SeekLT || pC->seekOp==OP_SeekLE
85090 || pC->seekOp==OP_Last );
85092 rc = pOp->p4.xAdvance(pC->uc.pCursor, pOp->p3);
85094 pC->cacheStatus = CACHE_STALE;
85097 pC->nullRow = 0;
85106 pC->nullRow = 1;
85147 VdbeCursor *pC;
85151 pC = p->apCsr[pOp->p1];
85152 assert( pC!=0 );
85153 assert( isSorter(pC)==(pOp->opcode==OP_SorterInsert) );
85157 assert( pC->eCurType==CURTYPE_BTREE || pOp->opcode==OP_SorterInsert );
85158 assert( pC->isTable==0 );
85162 rc = sqlite3VdbeSorterWrite(pC, pIn2);
85168 rc = sqlite3BtreeInsert(pC->uc.pCursor, &x,
85170 ((pOp->p5 & OPFLAG_USESEEKRESULT) ? pC->seekResult : 0)
85172 assert( pC->deferredMoveto==0 );
85173 pC->cacheStatus = CACHE_STALE;
85187 VdbeCursor *pC;
85195 pC = p->apCsr[pOp->p1];
85196 assert( pC!=0 );
85197 assert( pC->eCurType==CURTYPE_BTREE );
85198 pCrsr = pC->uc.pCursor;
85201 r.pKeyInfo = pC->pKeyInfo;
85211 assert( pC->deferredMoveto==0 );
85212 pC->cacheStatus = CACHE_STALE;
85213 pC->seekResult = 0;
85247 VdbeCursor *pC; /* The P1 index cursor */
85252 pC = p->apCsr[pOp->p1];
85253 assert( pC!=0 );
85254 assert( pC->eCurType==CURTYPE_BTREE );
85255 assert( pC->uc.pCursor!=0 );
85256 assert( pC->isTable==0 );
85257 assert( pC->deferredMoveto==0 );
85258 assert( !pC->nullRow || pOp->opcode==OP_IdxRowid );
85262 rc = sqlite3VdbeCursorRestore(pC);
85269 if( !pC->nullRow ){
85271 rc = sqlite3VdbeIdxRowid(db, pC->uc.pCursor, &rowid);
85287 pTabCur->pAltCursor = pC;
85347 VdbeCursor *pC;
85352 pC = p->apCsr[pOp->p1];
85353 assert( pC!=0 );
85354 assert( pC->isOrdered );
85355 assert( pC->eCurType==CURTYPE_BTREE );
85356 assert( pC->uc.pCursor!=0);
85357 assert( pC->deferredMoveto==0 );
85360 r.pKeyInfo = pC->pKeyInfo;
85374 rc = sqlite3VdbeIdxKeyCompare(db, pC, &r, &res);
85496 VdbeCursor *pC;
85499 pC = p->apCsr[pOp->p1];
85500 assert( pC!=0 );
85501 if( isSorter(pC) ){
85502 sqlite3VdbeSorterReset(db, pC->uc.pSorter);
85504 assert( pC->eCurType==CURTYPE_BTREE );
85505 assert( pC->isEphemeral );
85506 rc = sqlite3BtreeClearTableOfCursor(pC->uc.pCursor);
87160 VdbeCursor *pC;
87164 pC = p->apCsr[pOp->p1];
87165 if( pC ){
87166 assert( pC->eCurType==CURTYPE_BTREE );
87167 sqlite3BtreeCursorHint(pC->uc.pCursor, BTREE_HINT_RANGE,
87368 VdbeCursor *pC = v->apCsr[0];
87369 u32 type = pC->nHdrParsed>p->iCol ? pC->aType[p->iCol] : 0;
87370 testcase( pC->nHdrParsed==p->iCol );
87371 testcase( pC->nHdrParsed==p->iCol+1 );
87380 p->iOffset = pC->aType[p->iCol + pC->nField];
87382 p->pCsr = pC->uc.pCursor;
118883 SQLITE_PRIVATE int sqlite3JoinType(Parse *pParse, Token *pA, Token *pB, Token *pC){
118905 apAll[2] = pC;
118927 if( pC==0 ){ zSp++; }
118929 "%T %T%s%T", pA, pB, zSp, pC);
123501 struct AggInfo_col *pC;
123563 for(i=0, pC=pAggInfo->aCol; i<pAggInfo->nAccumulator; i++, pC++){
123564 sqlite3ExprCode(pParse, pC->pExpr, pC->iMem);
132555 u8 c, *pC; /* Last character before the first wildcard */
132556 pC = (u8*)&pStr2->u.zToken[sqlite3Strlen30(pStr2->u.zToken)-1];
132557 c = *pC;
132568 *pC = c + 1;
136079 CollSeq *pC = 0;
136083 pC = sqlite3BinaryCompareCollSeq(pHidden->pParse, pX->pLeft, pX->pRight);
136085 zRet = (pC ? pC->zName : "BINARY");
165260 sqlite3_tokenizer_cursor *pC;
165266 rc = sqlite3Fts3OpenTokenizer(pTab->pTokenizer, iLangid, zDoc, nDoc, &pC);
165272 rc = pMod->xNext(pC, &ZDUMMY, &DUMMY1, &DUMMY2, &DUMMY3, &iCurrent);
165274 pMod->xClose(pC);
165314 sqlite3_tokenizer_cursor *pC; /* Tokenizer cursor open on zDoc/nDoc */
165327 rc = sqlite3Fts3OpenTokenizer(pTab->pTokenizer, pCsr->iLangid, zDoc,nDoc,&pC);
165350 rc = pMod->xNext(pC, &ZDUMMY, &DUMMY1, &iBegin, &iFin, &iCurrent);
165402 pMod->xClose(pC);
166164 sqlite3_tokenizer_cursor *pC; /* Tokenizer cursor */
166199 zDoc, nDoc, &pC
166203 rc = pMod->xNext(pC, &ZDUMMY, &NDUMMY, &iStart, &iEnd, &iCurrent);
166228 rc = pMod->xNext(pC, &ZDUMMY, &NDUMMY, &iStart, &iEnd, &iCurrent);
166245 pMod->xClose(pC);
166604 sqlite3_tokenizer_cursor *pC, /* Cursor returned by simpleOpen */
166611 unicode_cursor *pCsr = (unicode_cursor *)pC;
179937 SessionChange *pC;
179938 for(pC=pTab->apChange[iHash]; pC; pC=pC->pNext){
179939 if( sessionPreupdateEqual(pSession, pTab, pC, op) ) break;
179942 if( pC==0 ){
180005 }else if( pC->bIndirect ){
180011 pC->bIndirect = 0;
201327 struct Constraint *pC = &aConstraint[j];
201328 if( iCol==aColMap[pC->iCol] && p->op & pC->op && p->usable ){
201329 pC->iConsIndex = i;
201330 idxFlags |= pC->fts5op;
201368 struct Constraint *pC = &aConstraint[i];
201369 if( pC->iConsIndex>=0 ){
201370 pInfo->aConstraintUsage[pC->iConsIndex].argvIndex = iNext++;
201371 pInfo->aConstraintUsage[pC->iConsIndex].omit = (unsigned char)pC->omit;
203603 Fts5Config *pC = p->pConfig;
203609 pC->zContentExprlist, pC->zContent
203615 zSql = sqlite3_mprintf(azStmt[eStmt], pC->zContentExprlist,
203616 pC->zContent, pC->zContentRowid, pC->zContentRowid,
203617 pC->zContentRowid
203623 pC->zContentExprlist, pC->zContent, pC->zContentRowid
203629 int nCol = pC->nCol + 1;
203640 zSql = sqlite3_mprintf(azStmt[eStmt], pC->zDb, pC->zName, zBind);
203647 zSql = sqlite3_mprintf(azStmt[eStmt], pC->zDb, pC->zName);
203654 rc = sqlite3_prepare_v3(pC->db, zSql, -1,
203658 *pzErrMsg = sqlite3_mprintf("%s", sqlite3_errmsg(pC->db));