Lines Matching defs:pC
61572 VdbeCursor *pC = p->apCsr[i];
61573 if( pC ){
61574 sqlite3VdbeFreeCursor(p, pC);
63080 ** Compare the key of the index entry that cursor pC is pointing to against
63082 ** that is negative, zero, or positive if pC is less than, equal to,
63091 VdbeCursor *pC, /* The cursor to compare against */
63097 BtCursor *pCur = pC->pCursor;
63110 rc = sqlite3VdbeMemFromBtree(pC->pCursor, 0, (int)nCellKey, 1, &m);
65543 VdbeCursor *pC; /* The VDBE cursor */
65641 VdbeCursor *pC;
65647 VdbeCursor *pC;
65651 VdbeCursor *pC;
65668 VdbeCursor *pC;
65675 VdbeCursor *pC; /* Cursor of table to get the new rowid */
65685 VdbeCursor *pC; /* Cursor to table into which insert is written */
65694 VdbeCursor *pC;
65697 VdbeCursor *pC;
65701 VdbeCursor *pC;
65704 VdbeCursor *pC;
65710 VdbeCursor *pC;
65716 VdbeCursor *pC;
65719 VdbeCursor *pC;
65724 VdbeCursor *pC;
65729 VdbeCursor *pC;
65733 VdbeCursor *pC;
65739 VdbeCursor *pC;
65746 VdbeCursor *pC;
65750 VdbeCursor *pC;
67520 VdbeCursor *pC; /* The VDBE cursor */
67544 u.ao.pC = 0;
67558 ** might be available in the u.ao.pC->aRow cache. Or it might not be.
67564 u.ao.pC = p->apCsr[u.ao.p1];
67565 assert( u.ao.pC!=0 );
67567 assert( u.ao.pC->pVtabCursor==0 );
67569 u.ao.pCrsr = u.ao.pC->pCursor;
67572 rc = sqlite3VdbeCursorMoveto(u.ao.pC);
67574 if( u.ao.pC->nullRow ){
67576 }else if( u.ao.pC->cacheStatus==p->cacheCtr ){
67577 u.ao.payloadSize = u.ao.pC->payloadSize;
67578 u.ao.zRec = (char*)u.ao.pC->aRow;
67579 }else if( u.ao.pC->isIndex ){
67593 }else if( ALWAYS(u.ao.pC->pseudoTableReg>0) ){
67594 u.ao.pReg = &aMem[u.ao.pC->pseudoTableReg];
67595 if( u.ao.pC->multiPseudo ){
67604 u.ao.pC->cacheStatus = (pOp->p5&OPFLAG_CLEARCACHE) ? CACHE_STALE : p->cacheCtr;
67622 u.ao.nField = u.ao.pC->nField;
67628 u.ao.aType = u.ao.pC->aType;
67629 if( u.ao.pC->cacheStatus==p->cacheCtr ){
67630 u.ao.aOffset = u.ao.pC->aOffset;
67634 u.ao.pC->aOffset = u.ao.aOffset = &u.ao.aType[u.ao.nField];
67635 u.ao.pC->payloadSize = u.ao.payloadSize;
67636 u.ao.pC->cacheStatus = p->cacheCtr;
67642 if( u.ao.pC->isIndex ){
67648 ** save the payload in the u.ao.pC->aRow cache. That will save us from
67655 u.ao.pC->aRow = (u8*)u.ao.zData;
67657 u.ao.pC->aRow = 0;
67704 rc = sqlite3VdbeMemFromBtree(u.ao.pCrsr, 0, u.ao.len, u.ao.pC->isIndex, &u.ao.sMem);
67787 rc = sqlite3VdbeMemFromBtree(u.ao.pCrsr, u.ao.aOffset[u.ao.p2], u.ao.len, u.ao.pC->isIndex,
68803 VdbeCursor *pC;
68811 u.bc.pC = p->apCsr[pOp->p1];
68812 assert( u.bc.pC!=0 );
68813 assert( u.bc.pC->pseudoTableReg==0 );
68817 assert( u.bc.pC->isOrdered );
68818 if( ALWAYS(u.bc.pC->pCursor!=0) ){
68820 u.bc.pC->nullRow = 0;
68821 if( u.bc.pC->isTable ){
68828 u.bc.pC->rowidIsValid = 0;
68849 rc = sqlite3BtreeFirst(u.bc.pC->pCursor, &u.bc.res);
68854 rc = sqlite3BtreeLast(u.bc.pC->pCursor, &u.bc.res);
68871 rc = sqlite3BtreeMovetoUnpacked(u.bc.pC->pCursor, 0, (u64)u.bc.iKey, 0, &u.bc.res);
68876 u.bc.pC->rowidIsValid = 1;
68877 u.bc.pC->lastRowid = u.bc.iKey;
68883 u.bc.r.pKeyInfo = u.bc.pC->pKeyInfo;
68904 rc = sqlite3BtreeMovetoUnpacked(u.bc.pC->pCursor, &u.bc.r, 0, 0, &u.bc.res);
68908 u.bc.pC->rowidIsValid = 0;
68910 u.bc.pC->deferredMoveto = 0;
68911 u.bc.pC->cacheStatus = CACHE_STALE;
68917 rc = sqlite3BtreeNext(u.bc.pC->pCursor, &u.bc.res);
68919 u.bc.pC->rowidIsValid = 0;
68926 rc = sqlite3BtreePrevious(u.bc.pC->pCursor, &u.bc.res);
68928 u.bc.pC->rowidIsValid = 0;
68933 u.bc.res = sqlite3BtreeEof(u.bc.pC->pCursor);
68961 VdbeCursor *pC;
68965 u.bd.pC = p->apCsr[pOp->p1];
68966 assert( u.bd.pC!=0 );
68967 if( ALWAYS(u.bd.pC->pCursor!=0) ){
68968 assert( u.bd.pC->isTable );
68969 u.bd.pC->nullRow = 0;
68971 u.bd.pC->movetoTarget = sqlite3VdbeIntValue(pIn2);
68972 u.bd.pC->rowidIsValid = 0;
68973 u.bd.pC->deferredMoveto = 1;
69007 VdbeCursor *pC;
69022 u.be.pC = p->apCsr[pOp->p1];
69023 assert( u.be.pC!=0 );
69025 if( ALWAYS(u.be.pC->pCursor!=0) ){
69027 assert( u.be.pC->isTable==0 );
69029 u.be.r.pKeyInfo = u.be.pC->pKeyInfo;
69039 u.be.pC->pKeyInfo, u.be.aTempRec, sizeof(u.be.aTempRec), &u.be.pFree
69044 sqlite3VdbeRecordUnpack(u.be.pC->pKeyInfo, pIn3->n, pIn3->z, u.be.pIdxKey);
69047 rc = sqlite3BtreeMovetoUnpacked(u.be.pC->pCursor, u.be.pIdxKey, 0, 0, &u.be.res);
69055 u.be.pC->deferredMoveto = 0;
69056 u.be.pC->cacheStatus = CACHE_STALE;
69171 VdbeCursor *pC;
69180 u.bg.pC = p->apCsr[pOp->p1];
69181 assert( u.bg.pC!=0 );
69182 assert( u.bg.pC->isTable );
69183 assert( u.bg.pC->pseudoTableReg==0 );
69184 u.bg.pCrsr = u.bg.pC->pCursor;
69189 u.bg.pC->lastRowid = pIn3->u.i;
69190 u.bg.pC->rowidIsValid = u.bg.res==0 ?1:0;
69191 u.bg.pC->nullRow = 0;
69192 u.bg.pC->cacheStatus = CACHE_STALE;
69193 u.bg.pC->deferredMoveto = 0;
69196 assert( u.bg.pC->rowidIsValid==0 );
69198 u.bg.pC->seekResult = u.bg.res;
69204 assert( u.bg.pC->rowidIsValid==0 );
69205 u.bg.pC->seekResult = 0;
69242 VdbeCursor *pC; /* Cursor of table to get the new rowid */
69252 u.bh.pC = p->apCsr[pOp->p1];
69253 assert( u.bh.pC!=0 );
69254 if( NEVER(u.bh.pC->pCursor==0) ){
69270 assert( u.bh.pC->isTable );
69282 if( !u.bh.pC->useRandomRowid ){
69283 u.bh.v = sqlite3BtreeGetCachedRowid(u.bh.pC->pCursor);
69285 rc = sqlite3BtreeLast(u.bh.pC->pCursor, &u.bh.res);
69292 assert( sqlite3BtreeCursorIsValid(u.bh.pC->pCursor) );
69293 rc = sqlite3BtreeKeySize(u.bh.pC->pCursor, &u.bh.v);
69296 u.bh.pC->useRandomRowid = 1;
69323 if( u.bh.pMem->u.i==MAX_ROWID || u.bh.pC->useRandomRowid ){
69334 sqlite3BtreeSetCachedRowid(u.bh.pC->pCursor, u.bh.v<MAX_ROWID ? u.bh.v+1 : 0);
69336 if( u.bh.pC->useRandomRowid ){
69348 while( ((rc = sqlite3BtreeMovetoUnpacked(u.bh.pC->pCursor, 0, (u64)u.bh.v,
69368 u.bh.pC->rowidIsValid = 0;
69369 u.bh.pC->deferredMoveto = 0;
69370 u.bh.pC->cacheStatus = CACHE_STALE;
69426 VdbeCursor *pC; /* Cursor to table into which insert is written */
69437 u.bi.pC = p->apCsr[pOp->p1];
69438 assert( u.bi.pC!=0 );
69439 assert( u.bi.pC->pCursor!=0 );
69440 assert( u.bi.pC->pseudoTableReg==0 );
69441 assert( u.bi.pC->isTable );
69463 u.bi.seekResult = ((pOp->p5 & OPFLAG_USESEEKRESULT) ? u.bi.pC->seekResult : 0);
69469 sqlite3BtreeSetCachedRowid(u.bi.pC->pCursor, 0);
69470 rc = sqlite3BtreeInsert(u.bi.pC->pCursor, 0, u.bi.iKey,
69474 u.bi.pC->rowidIsValid = 0;
69475 u.bi.pC->deferredMoveto = 0;
69476 u.bi.pC->cacheStatus = CACHE_STALE;
69480 u.bi.zDb = db->aDb[u.bi.pC->iDb].zName;
69483 assert( u.bi.pC->isTable );
69485 assert( u.bi.pC->iDb>=0 );
69513 VdbeCursor *pC;
69518 u.bj.pC = p->apCsr[pOp->p1];
69519 assert( u.bj.pC!=0 );
69520 assert( u.bj.pC->pCursor!=0 ); /* Only valid for real tables, no pseudotables */
69526 assert( u.bj.pC->isTable );
69527 assert( u.bj.pC->rowidIsValid ); /* lastRowid set by previous OP_NotFound */
69528 u.bj.iKey = u.bj.pC->lastRowid;
69533 ** might move or invalidate the cursor. Hence cursor u.bj.pC is always pointing
69538 assert( u.bj.pC->deferredMoveto==0 );
69539 rc = sqlite3VdbeCursorMoveto(u.bj.pC);
69542 sqlite3BtreeSetCachedRowid(u.bj.pC->pCursor, 0);
69543 rc = sqlite3BtreeDelete(u.bj.pC->pCursor);
69544 u.bj.pC->cacheStatus = CACHE_STALE;
69548 const char *zDb = db->aDb[u.bj.pC->iDb].zName;
69551 assert( u.bj.pC->iDb>=0 );
69578 VdbeCursor *pC;
69582 u.bk.pC = p->apCsr[pOp->p1];
69583 assert( isSorter(u.bk.pC) );
69585 rc = sqlite3VdbeSorterCompare(u.bk.pC, pIn3, &u.bk.res);
69598 VdbeCursor *pC;
69602 u.bl.pC = p->apCsr[pOp->p1];
69603 assert( u.bl.pC->isSorter );
69604 rc = sqlite3VdbeSorterRowkey(u.bl.pC, pOut);
69631 VdbeCursor *pC;
69642 u.bm.pC = p->apCsr[pOp->p1];
69643 assert( u.bm.pC->isSorter==0 );
69644 assert( u.bm.pC->isTable || pOp->opcode!=OP_RowData );
69645 assert( u.bm.pC->isIndex || pOp->opcode==OP_RowData );
69646 assert( u.bm.pC!=0 );
69647 assert( u.bm.pC->nullRow==0 );
69648 assert( u.bm.pC->pseudoTableReg==0 );
69649 assert( u.bm.pC->pCursor!=0 );
69650 u.bm.pCrsr = u.bm.pC->pCursor;
69658 assert( u.bm.pC->deferredMoveto==0 );
69659 rc = sqlite3VdbeCursorMoveto(u.bm.pC);
69662 if( u.bm.pC->isIndex ){
69663 assert( !u.bm.pC->isTable );
69682 if( u.bm.pC->isIndex ){
69703 VdbeCursor *pC;
69710 u.bn.pC = p->apCsr[pOp->p1];
69711 assert( u.bn.pC!=0 );
69712 assert( u.bn.pC->pseudoTableReg==0 || u.bn.pC->nullRow );
69713 if( u.bn.pC->nullRow ){
69716 }else if( u.bn.pC->deferredMoveto ){
69717 u.bn.v = u.bn.pC->movetoTarget;
69719 }else if( u.bn.pC->pVtabCursor ){
69720 u.bn.pVtab = u.bn.pC->pVtabCursor->pVtab;
69723 rc = u.bn.pModule->xRowid(u.bn.pC->pVtabCursor, &u.bn.v);
69727 assert( u.bn.pC->pCursor!=0 );
69728 rc = sqlite3VdbeCursorMoveto(u.bn.pC);
69730 if( u.bn.pC->rowidIsValid ){
69731 u.bn.v = u.bn.pC->lastRowid;
69733 rc = sqlite3BtreeKeySize(u.bn.pC->pCursor, &u.bn.v);
69749 VdbeCursor *pC;
69753 u.bo.pC = p->apCsr[pOp->p1];
69754 assert( u.bo.pC!=0 );
69755 u.bo.pC->nullRow = 1;
69756 u.bo.pC->rowidIsValid = 0;
69757 assert( u.bo.pC->pCursor || u.bo.pC->pVtabCursor );
69758 if( u.bo.pC->pCursor ){
69759 sqlite3BtreeClearCursor(u.bo.pC->pCursor);
69774 VdbeCursor *pC;
69780 u.bp.pC = p->apCsr[pOp->p1];
69781 assert( u.bp.pC!=0 );
69782 u.bp.pCrsr = u.bp.pC->pCursor;
69787 u.bp.pC->nullRow = (u8)u.bp.res;
69788 u.bp.pC->deferredMoveto = 0;
69789 u.bp.pC->rowidIsValid = 0;
69790 u.bp.pC->cacheStatus = CACHE_STALE;
69829 VdbeCursor *pC;
69835 u.bq.pC = p->apCsr[pOp->p1];
69836 assert( u.bq.pC!=0 );
69837 assert( u.bq.pC->isSorter==(pOp->opcode==OP_SorterSort) );
69839 if( isSorter(u.bq.pC) ){
69840 rc = sqlite3VdbeSorterRewind(db, u.bq.pC, &u.bq.res);
69842 u.bq.pCrsr = u.bq.pC->pCursor;
69845 u.bq.pC->atFirst = u.bq.res==0 ?1:0;
69846 u.bq.pC->deferredMoveto = 0;
69847 u.bq.pC->cacheStatus = CACHE_STALE;
69848 u.bq.pC->rowidIsValid = 0;
69850 u.bq.pC->nullRow = (u8)u.bq.res;
69894 VdbeCursor *pC;
69901 u.br.pC = p->apCsr[pOp->p1];
69902 if( u.br.pC==0 ){
69905 assert( u.br.pC->isSorter==(pOp->opcode==OP_SorterNext) );
69906 if( isSorter(u.br.pC) ){
69908 rc = sqlite3VdbeSorterNext(db, u.br.pC, &u.br.res);
69911 assert( u.br.pC->deferredMoveto==0 );
69912 assert( u.br.pC->pCursor );
69915 rc = pOp->p4.xAdvance(u.br.pC->pCursor, &u.br.res);
69917 u.br.pC->nullRow = (u8)u.br.res;
69918 u.br.pC->cacheStatus = CACHE_STALE;
69926 u.br.pC->rowidIsValid = 0;
69945 VdbeCursor *pC;
69952 u.bs.pC = p->apCsr[pOp->p1];
69953 assert( u.bs.pC!=0 );
69954 assert( u.bs.pC->isSorter==(pOp->opcode==OP_SorterInsert) );
69957 u.bs.pCrsr = u.bs.pC->pCursor;
69959 assert( u.bs.pC->isTable==0 );
69962 if( isSorter(u.bs.pC) ){
69963 rc = sqlite3VdbeSorterWrite(db, u.bs.pC, pIn2);
69968 ((pOp->p5 & OPFLAG_USESEEKRESULT) ? u.bs.pC->seekResult : 0)
69970 assert( u.bs.pC->deferredMoveto==0 );
69971 u.bs.pC->cacheStatus = CACHE_STALE;
69986 VdbeCursor *pC;
69995 u.bt.pC = p->apCsr[pOp->p1];
69996 assert( u.bt.pC!=0 );
69997 u.bt.pCrsr = u.bt.pC->pCursor;
69999 u.bt.r.pKeyInfo = u.bt.pC->pKeyInfo;
70010 assert( u.bt.pC->deferredMoveto==0 );
70011 u.bt.pC->cacheStatus = CACHE_STALE;
70027 VdbeCursor *pC;
70032 u.bu.pC = p->apCsr[pOp->p1];
70033 assert( u.bu.pC!=0 );
70034 u.bu.pCrsr = u.bu.pC->pCursor;
70037 rc = sqlite3VdbeCursorMoveto(u.bu.pC);
70039 assert( u.bu.pC->deferredMoveto==0 );
70040 assert( u.bu.pC->isTable==0 );
70041 if( !u.bu.pC->nullRow ){
70082 VdbeCursor *pC;
70088 u.bv.pC = p->apCsr[pOp->p1];
70089 assert( u.bv.pC!=0 );
70090 assert( u.bv.pC->isOrdered );
70091 if( ALWAYS(u.bv.pC->pCursor!=0) ){
70092 assert( u.bv.pC->deferredMoveto==0 );
70095 u.bv.r.pKeyInfo = u.bv.pC->pKeyInfo;
70106 rc = sqlite3VdbeIdxKeyCompare(u.bv.pC, &u.bv.r, &u.bv.res);
96199 SQLITE_PRIVATE int sqlite3JoinType(Parse *pParse, Token *pA, Token *pB, Token *pC){
96221 apAll[2] = pC;
96243 if( pC==0 ){ zSp++; }
96245 "%T %T%s%T", pA, pB, zSp, pC);
99875 struct AggInfo_col *pC;
99926 ** to pC->iMem. But by the time the value is used, the original register
99937 for(i=0, pC=pAggInfo->aCol; i<pAggInfo->nAccumulator; i++, pC++){
99938 sqlite3ExprCode(pParse, pC->pExpr, pC->iMem);
105769 u8 c, *pC; /* Last character before the first wildcard */
105770 pC = (u8*)&pStr2->u.zToken[sqlite3Strlen30(pStr2->u.zToken)-1];
105771 c = *pC;
105784 *pC = c + 1;
134611 sqlite3_tokenizer_cursor *pC;
134617 rc = sqlite3Fts3OpenTokenizer(pTab->pTokenizer, iLangid, zDoc, nDoc, &pC);
134623 rc = pMod->xNext(pC, &ZDUMMY, &DUMMY1, &DUMMY2, &DUMMY3, &iCurrent);
134625 pMod->xClose(pC);
134665 sqlite3_tokenizer_cursor *pC; /* Tokenizer cursor open on zDoc/nDoc */
134678 rc = sqlite3Fts3OpenTokenizer(pTab->pTokenizer, pCsr->iLangid, zDoc,nDoc,&pC);
134701 rc = pMod->xNext(pC, &ZDUMMY, &DUMMY1, &iBegin, &iFin, &iCurrent);
134749 pMod->xClose(pC);
135421 sqlite3_tokenizer_cursor *pC; /* Tokenizer cursor */
135456 zDoc, nDoc, &pC
135460 rc = pMod->xNext(pC, &ZDUMMY, &NDUMMY, &iStart, &iEnd, &iCurrent);
135485 rc = pMod->xNext(pC, &ZDUMMY, &NDUMMY, &iStart, &iEnd, &iCurrent);
135502 pMod->xClose(pC);
135876 sqlite3_tokenizer_cursor *pC, /* Cursor returned by simpleOpen */
135883 unicode_cursor *pCsr = (unicode_cursor *)pC;