Lines Matching defs:iCur
19567 int iCur; /* A cursor number */
19676 int iCur; /* Ephemeral table holding the materialization */
20209 SQLITE_PRIVATE void sqlite3OpenTable(Parse*, int iCur, int iDb, Table*, int);
20274 SQLITE_PRIVATE int sqlite3ExprCoveredByIndex(Expr*, int iCur, Index *pIdx);
23262 sqlite3_int64 iCur = 0, iHwtr = 0;
23267 rc = sqlite3_status64(op, &iCur, &iHwtr, resetFlag);
23269 *pCurrent = (int)iCur;
90507 ** Allocate VdbeCursor number iCur. Return a pointer to it. Return NULL
90512 int iCur, /* Index of the new VdbeCursor */
90534 Mem *pMem = iCur>0 ? &p->aMem[p->nMem-iCur] : p->aMem;
90542 assert( iCur>=0 && iCur<p->nCursor );
90543 if( p->apCsr[iCur] ){ /*OPTIMIZATION-IF-FALSE*/
90544 sqlite3VdbeFreeCursorNN(p, p->apCsr[iCur]);
90545 p->apCsr[iCur] = 0;
90567 p->apCsr[iCur] = pCx = (VdbeCursor*)pMem->zMalloc;
108033 if( pWalker->eCode==3 && pExpr->iTable==pWalker->u.iCur ){
108064 static int exprIsConst(Expr *p, int initFlag, int iCur){
108072 w.u.iCur = iCur;
108108 ** for any single row of the table with cursor iCur. In other words, the
108110 ** table other than iCur.
108112 SQLITE_PRIVATE int sqlite3ExprIsTableConstant(Expr *p, int iCur){
108113 return exprIsConst(p, 3, iCur);
108435 ** Generate code that checks the left-most column of index table iCur to see if
108437 ** to a non-NULL value if iCur contains no NULLs. Cause register regHasNull
108438 ** to be set to NULL if iCur contains one or more NULL values.
108440 static void sqlite3SetHasNullFlag(Vdbe *v, int iCur, int regHasNull){
108443 addr1 = sqlite3VdbeAddOp1(v, OP_Rewind, iCur); VdbeCoverage(v);
108444 sqlite3VdbeAddOp3(v, OP_Column, iCur, 0, regHasNull);
108446 VdbeComment((v, "first_entry_in(%d)", iCur));
111655 ** If the expression node requires that the table at pWalker->iCur
111689 if( pWalker->u.iCur==pExpr->iTable ){
111787 w.u.iCur = iTab;
111796 ** table entry. The IdxCover.pIdx field is the index. IdxCover.iCur
111801 int iCur; /* Cursor number for the table corresponding to the index */
111806 ** pWalker->u.pIdxCover->iCur can be satisfied using the index
111811 && pExpr->iTable==pWalker->u.pIdxCover->iCur
111821 ** Determine if an index pIdx on table with cursor iCur contains will
111832 int iCur, /* The cursor number for the corresponding table */
111838 xcov.iCur = iCur;
114530 int iCur;
114532 iCur = pParse->nTab++;
114533 sqlite3OpenTable(pParse, iCur, iDb, pTab, OP_OpenWrite);
114534 addr = sqlite3VdbeAddOp1(v, OP_Rewind, iCur); VdbeCoverage(v);
114537 sqlite3VdbeAddOp2(v, OP_Rowid, iCur, reg);
114543 sqlite3VdbeAddOp3(v, OP_Column, iCur, i, reg+i+1);
114562 sqlite3ExprCodeGetColumnOfTable(v, pTab, iCur, i, regOut);
114575 sqlite3VdbeAddOp4Int(v, OP_IdxInsert, iCur, regRec, reg+1, pPk->nKeyCol);
114577 sqlite3VdbeAddOp3(v, OP_Insert, iCur, regRec, reg);
114581 sqlite3VdbeAddOp2(v, OP_Next, iCur, addr+1); VdbeCoverage(v);
123841 int iCur /* Cursor number for ephemeral table */
123859 sqlite3SelectDestInit(&dest, SRT_EphemTab, iCur);
124453 /* Seek cursor iCur to the row to delete. If this row no longer exists
124619 ** iCur is the index of a cursor open on the pTab table and pointing to
124621 ** iCur must be the cursor of the PRIMARY KEY index.
127457 int iCur = pParse->nTab - 1; /* Cursor number to use */
127508 sqlite3OpenTable(pParse, iCur, iDb, pTab, OP_OpenRead);
127509 sqlite3VdbeAddOp3(v, OP_NotExists, iCur, 0, regTemp); VdbeCoverage(v);
127518 sqlite3VdbeAddOp3(v, OP_OpenRead, iCur, pIdx->tnum, iDb);
127558 sqlite3VdbeAddOp4Int(v, OP_Found, iCur, iOk, regTemp, nCol);
127583 sqlite3VdbeAddOp1(v, OP_Close, iCur);
127625 ** has cursor iCur.
128623 ** (2) open pTab as cursor iCur.
128630 int iCur, /* The cursor number of the table */
128643 sqlite3VdbeAddOp4Int(v, opcode, iCur, pTab->tnum, iDb, pTab->nNVCol);
128649 sqlite3VdbeAddOp3(v, opcode, iCur, pPk->tnum, iDb);
131121 ** number is iCur, and register regData contains the new record for the
131129 int iCur, /* Cursor number for table */
131137 sqlite3VdbeAddOp4(v, OP_Insert, iCur, regData, r, (char*)pTab, P4_TABLE);
145309 if( pItem->iCursor!=pCteUse->iCur ){
145310 sqlite3VdbeAddOp2(v, OP_OpenDup, pItem->iCursor, pCteUse->iCur);
145358 pCteUse->iCur = pItem->iCursor;
148595 int iCur = aiCurOnePass[1];
148596 if( iCur>=0 && iCur!=iDataCur && aToOpen[iCur-iBaseCur] ){
148599 assert( iCur!=iDataCur || !HasRowid(pTab) );
149440 ** In this case parameter iCur is a cursor open on the table b-tree that
149442 ** is not NULL, then pIdx is the constraint that failed and iCur is a
149450 int iCur /* Cursor for pIdx (or pTab if pIdx==NULL) */
149464 if( pIdx && iCur!=iDataCur ){
149467 sqlite3VdbeAddOp2(v, OP_IdxRowid, iCur, regRowid);
149480 sqlite3VdbeAddOp3(v, OP_Column, iCur, k, iPk+i);
151404 int iCur; /* The VDBE cursor used by this IN operator */
151815 int iCur, /* Cursor number of LHS */
152596 pIn->iCur = iTab;
152955 int iCur;
152963 iCur = pLevel->iTabCur;
152964 assert( iCur==pWInfo->pTabList->a[pLevel->iFrom].iCursor );
152965 sHint.iTabCur = iCur;
153049 ** Cursor iCur is open on an intkey b-tree (a table). Register iRowid contains
153051 ** function generates code to do a deferred seek of cursor iCur to the
153056 ** OP_DeferredSeek $iCur $iRowid
153058 ** Which causes a seek on $iCur to the row with rowid $iRowid.
153077 int iCur, /* Cursor for IPK b-tree */
153087 sqlite3VdbeAddOp3(v, OP_DeferredSeek, iIdxCur, 0, iCur);
153251 int iCur; /* The VDBE cursor for the table */
153271 iCur = pTabItem->iCursor;
153272 pLevel->notReady = notReady & ~sqlite3WhereGetMask(&pWInfo->sMaskSet, iCur);
153376 sqlite3VdbeAddOp4(v, OP_VFilter, iCur, addrNotFound, iReg,
153384 pLevel->p1 = iCur;
153484 sqlite3VdbeAddOp3(v, OP_SeekRowid, iCur, addrNxt, iRowidReg);
153530 testcase( pStart->leftCursor!=iCur ); /* transitive constraints */
153548 sqlite3VdbeAddOp3(v, op, iCur, addrBrk, r1);
153556 sqlite3VdbeAddOp2(v, bRev ? OP_Last : OP_Rewind, iCur, addrHalt);
153565 testcase( pEnd->leftCursor!=iCur ); /* Transitive constraints */
153582 pLevel->p1 = iCur;
153587 sqlite3VdbeAddOp2(v, OP_Rowid, iCur, iRowidReg);
153960 codeDeferredSeek(pWInfo, pIdx, iCur, iIdxCur);
153961 }else if( iCur!=iIdxCur ){
153968 sqlite3VdbeAddOp4Int(v, OP_NotFound, iCur, addrCont,
153981 whereApplyPartialIndexConstraints(pIdx->pPartIdxWhere, iCur, pWC);
154186 if( pOrTerm->leftCursor==iCur || (pOrTerm->eOperator & WO_AND)!=0 ){
154224 sqlite3ExprCodeGetColumnOfTable(v, pTab, iCur, -1, regRowid);
154238 sqlite3ExprCodeGetColumnOfTable(v, pTab, iCur, iCol,r+iPk);
154357 pLevel->p1 = iCur;
154358 pLevel->p2 = 1 + sqlite3VdbeAddOp2(v, aStart[bRev], iCur, addrHalt);
154473 if( pTerm->leftCursor!=iCur ) continue;
154485 pAlt = sqlite3WhereFindTerm(pWC, iCur, pTerm->u.x.leftColumn, notReady,
154532 sqlite3ExprCodeGetColumnOfTable(v, pTab, iCur, iCol,r+1+iPk);
154663 int iCur = pLevel->iTabCur;
154670 sqlite3ExprCodeGetColumnOfTable(v, pTab, iCur, -1, r);
154679 sqlite3ExprCodeGetColumnOfTable(v, pTab, iCur, iCol,r+iPk);
155680 int iCur;
155682 iCur = pFrom->a[i].iCursor;
155688 if( sqlite3ExprCompareSkip(pExpr, pIdx->aColExpr->a[i].pExpr, iCur)==0 ){
155689 aiCurCol[0] = iCur;
156861 int iCur; /* The cursor on the LHS of the term */
156872 iCur = pScan->aiCur[pScan->iEquiv-1];
156874 assert( iCur>=0 );
156878 if( pTerm->leftCursor==iCur
156882 pScan->pIdxExpr,iCur)==0)
156973 ** iCur. Or if pIdx!=0 then X is column iColumn of index pIdx. pIdx
156974 ** must be one of the indexes of table iCur.
156989 int iCur, /* Cursor to scan for */
157001 pScan->aiCur[0] = iCur;
157027 ** where X is a reference to the iColumn of table iCur or of index pIdx
157031 ** If pIdx!=0 then it must be one of the indexes of table iCur.
157033 ** rather than the iColumn-th column of table iCur.
157052 int iCur, /* Cursor number of LHS */
157062 p = whereScanInit(&scan, pWC, iCur, iColumn, op, pIdx);
157618 int iCur; /* Cursor for table getting the filter */
157631 iCur = pLevel->iTabCur;
157654 addrTop = sqlite3VdbeAddOp1(v, OP_Rewind, iCur); VdbeCoverage(v);
157666 sqlite3VdbeAddOp2(v, OP_Rowid, iCur, r1);
157677 sqlite3ExprCodeGetColumnOfTable(v, pIdx->pTable, iCur, iCol,r1+jj);
159262 int iCur, /* Cursor open on pIdx */
159293 || pLhs->iTable!=iCur
160138 int iCur = pSrc->iCursor;
160142 if( !sqlite3ExprCoveredByIndex(pTerm->pExpr, iCur, pProbe) ){
160686 int iCur;
160697 iCur = pItem->iCursor;
160719 }else if( pOrTerm->leftCursor==iCur ){
160925 int iCur; /* Cursor number for current WhereLoop */
160926 int iColumn; /* A column number within table iCur */
160992 iCur = pWInfo->pTabList->a[pLoop->iTab].iCursor;
161004 if( pOBExpr->iTable!=iCur ) continue;
161005 pTerm = sqlite3WhereFindTerm(&pWInfo->sWC, iCur, pOBExpr->iColumn,
161141 if( pOBExpr->iTable!=iCur ) continue;
161145 if( sqlite3ExprCompareSkip(pOBExpr, pIdxExpr, iCur) ){
161734 int iCur;
161751 iCur = pItem->iCursor;
161756 pTerm = whereScanInit(&scan, pWC, iCur, -1, WO_EQ|WO_IS, 0);
161776 pTerm = whereScanInit(&scan, pWC, iCur, j, opMask, pIdx);
161798 assert( pWInfo->sMaskSet.n==1 && iCur==pWInfo->sMaskSet.ix[0] );
161799 pLoop->maskSelf = 1; /* sqlite3WhereGetMask(&pWInfo->sMaskSet, iCur); */
161800 pWInfo->a[0].iTabCur = iCur;
162554 int iCur = pTabItem->iCursor;
162555 sqlite3VdbeAddOp4(v, OP_VOpen, iCur, 0, 0, pVTab, P4_VTAB);
162783 ** Return true if cursor iCur is opened by instruction k of the
162786 static int cursorIsOpen(Vdbe *v, int iCur, int k){
162789 if( pOp->p1!=iCur ) continue;
162892 /* For LEFT JOIN queries, cursor pIn->iCur may not have been
162900 sqlite3VdbeAddOp2(v, OP_IfNotOpen, pIn->iCur,
162916 sqlite3VdbeAddOp2(v, pIn->eEndLoopOp, pIn->iCur, pIn->addrInTop);