8925 SQLITE_PRIVATE int sqlite3BtreeLockTable(Btree *pBtree, int iTab, u8 isWriteLock);
51706   Pgno iTab = 0;
51737         iTab = pIdx->pTable->tnum;
51741     iTab = iRoot;
51744   /* Search for the required lock. Either a write-lock on root-page iTab, a 
51746   ** read-lock on iTab will suffice. Return 1 if any of these are found.  */
51749      && (pLock->iTable==iTab || (pLock->eLock==WRITE_LOCK && pLock->iTable==1))
51796 ** (READ_LOCK or WRITE_LOCK) on the table with root-page iTab. Return
51800 static int querySharedCacheTableLock(Btree *p, Pgno iTab, u8 eLock){
51807   assert( !(p->db->flags&SQLITE_ReadUncommitted)||eLock==WRITE_LOCK||iTab==1 );
51841     if( pIter->pBtree!=p && pIter->iTable==iTab && pIter->eLock!=eLock ){
59952 ** Obtain a lock on the table whose root page is iTab.  The
59956 SQLITE_PRIVATE int sqlite3BtreeLockTable(Btree *p, int iTab, u8 isWriteLock){
59965     rc = querySharedCacheTableLock(p, iTab, lockType);
59967       rc = setSharedCacheTableLock(p, iTab, lockType);
79835   int iTab = pParse->nTab++;            /* Cursor of the RHS table */
79876       sqlite3OpenTable(pParse, iTab, iDb, pTab, OP_OpenRead);
79900           sqlite3VdbeAddOp3(v, OP_OpenRead, iTab, pIdx->tnum, iDb);
79908             sqlite3SetHasNullFlag(v, iTab, *prRhsHasNull);
79950     pX->iTable = iTab;
80454 SQLITE_PRIVATE void sqlite3ExprCacheStore(Parse *pParse, int iTab, int iCol, int iReg){
80476     assert( p->iReg==0 || p->iTable!=iTab || p->iColumn!=iCol );
80484       p->iTable = iTab;
80505     p->iTable = iTab;
80769       int iTab = pExpr->iTable;
80770       if( iTab<0 ){
80777           iTab = pParse->iPartIdxTab;
80781                                pExpr->iColumn, iTab, target,
82151 ** to compare equal to an equivalent element in pA with Expr.iTable==iTab.
82166 SQLITE_PRIVATE int sqlite3ExprCompare(Expr *pA, Expr *pB, int iTab){
82179     if( pA->op==TK_COLLATE && sqlite3ExprCompare(pA->pLeft, pB, iTab)<2 ){
82182     if( pB->op==TK_COLLATE && sqlite3ExprCompare(pA, pB->pLeft, iTab)<2 ){
82195     if( sqlite3ExprCompare(pA->pLeft, pB->pLeft, iTab) ) return 2;
82196     if( sqlite3ExprCompare(pA->pRight, pB->pRight, iTab) ) return 2;
82197     if( sqlite3ExprListCompare(pA->x.pList, pB->x.pList, iTab) ) return 2;
82201        && (pA->iTable!=iTab || NEVER(pB->iTable>=0)) ) return 2;
82212 ** to compare equal to an equivalent element in pA with Expr.iTable==iTab.
82222 SQLITE_PRIVATE int sqlite3ExprListCompare(ExprList *pA, ExprList *pB, int iTab){
82231     if( sqlite3ExprCompare(pExprA, pExprB, iTab) ) return 1;
82250 ** Expr.iTable<0 then assume a table number given by iTab.
82256 SQLITE_PRIVATE int sqlite3ExprImpliesExpr(Expr *pE1, Expr *pE2, int iTab){
82257   if( sqlite3ExprCompare(pE1, pE2, iTab)==0 ){
82261    && (sqlite3ExprImpliesExpr(pE1, pE2->pLeft, iTab)
82262              || sqlite3ExprImpliesExpr(pE1, pE2->pRight, iTab) )
82267    && sqlite3ExprCompare(pE1->pLeft, pE2->pLeft, iTab)==0
84387   int iTab         /* Next available cursor */
84439   iTabCur = iTab++;
84440   iIdxCur = iTab++;
84441   pParse->nTab = MAX(pParse->nTab, iTab);
84722   int iTab;
84729   iTab = pParse->nTab;
84733     analyzeOneTable(pParse, pTab, 0, iStatCur, iMem, iTab);
86154   int iTab;            /* The root page of the table to be locked */
86162 ** The table to be locked has root page iTab and is found in database iDb.
86172   int iTab,          /* Root page number of the table to be locked */
86184     if( p->iDb==iDb && p->iTab==iTab ){
86196     p->iTab = iTab;
86219     sqlite3VdbeAddOp4(pVdbe, OP_TableLock, p1, p->iTab, p->isWriteLock,
88381   int iTab = pTab->tnum;
88388     if( iDestroyed==0 || iTab<iDestroyed ){
88389       iLargest = iTab;
88766   int iTab = pParse->nTab++;     /* Btree cursor used for pTab */
88805   sqlite3OpenTable(pParse, iTab, iDb, pTab, OP_OpenRead);
88806   addr1 = sqlite3VdbeAddOp2(v, OP_Rewind, iTab, 0); VdbeCoverage(v);
88809   sqlite3GenerateIndexKey(pParse,pIndex,iTab,regRecord,0,&iPartIdxLabel,0,0);
88812   sqlite3VdbeAddOp2(v, OP_Next, iTab, addr1+1); VdbeCoverage(v);
88838   sqlite3VdbeAddOp1(v, OP_Close, iTab);
102022 ** form a distinct entry.  iTab is a sorting index that holds previously
102023 ** seen combinations of the N values.  A new entry is made in iTab
102031   int iTab,          /* A sorting index used to test for distinctness */
102041   sqlite3VdbeAddOp4Int(v, OP_Found, iTab, addrRepeat, iMem, N); VdbeCoverage(v);
102043   sqlite3VdbeAddOp2(v, OP_IdxInsert, iTab, r1);
102595   int iTab;
102610   iTab = pSort->iECursor;
102625     addr = 1 + sqlite3VdbeAddOp2(v, OP_SorterSort, iTab, addrBreak);
102628     sqlite3VdbeAddOp2(v, OP_SorterData, iTab, regSortOut);
102633     addr = 1 + sqlite3VdbeAddOp2(v, OP_Sort, iTab, addrBreak); VdbeCoverage(v);
102635     sqlite3VdbeAddOp3(v, OP_Column, iTab, nKey+1, regRow);
102691     sqlite3VdbeAddOp2(v, OP_SorterNext, iTab, addr); VdbeCoverage(v);
102693     sqlite3VdbeAddOp2(v, OP_Next, iTab, addr); VdbeCoverage(v);
110576   Bitmask maskSelf;     /* Bitmask identifying table iTab */
110580   u8 iTab;              /* Position in FROM clause of table for this loop */
113425     int iTab;
113444     iTab = pX->iTable;
113445     sqlite3VdbeAddOp2(v, bRev ? OP_Last : OP_Rewind, iTab, 0);
113460       pIn->iCur = iTab;
113462         pIn->addrInTop = sqlite3VdbeAddOp2(v, OP_Rowid, iTab, iReg);
113464         pIn->addrInTop = sqlite3VdbeAddOp3(v, OP_Column, iTab, 0, iReg);
114691   struct SrcList_item *pItem = pWInfo->pTabList->a + p->iTab;
114694                      p->iTab, nb, p->maskSelf, nb, p->prereq);
114904     if( p->iTab!=pTemplate->iTab ) continue;
114940     if( p->iTab!=pTemplate->iTab || p->iSortIdx!=pTemplate->iSortIdx ){
114941       /* If either the iTab or iSortIdx values for two WhereLoop are different
115016 **    (1)  They have the same iTab.
115469 static int whereUsablePartialIndex(int iTab, WhereClause *pWC, Expr *pWhere){
115473     if( sqlite3ExprImpliesExpr(pTerm->pExpr, pWhere, iTab) ) return 1;
115480 ** is idenfied by pBuilder->pNew->iTab.  That table is guaranteed to be
115537   pSrc = pTabList->a + pNew->iTab;
115619      && !whereUsablePartialIndex(pNew->iTab, pWC, pProbe->pPartIdxWhere) ){
115703 ** pBuilder->pNew->iTab.  That table is guaranteed to be a virtual table.
115733   pSrc = &pWInfo->pTabList->a[pNew->iTab];
115890   pItem = pWInfo->pTabList->a + pNew->iTab;
115985   int iTab;
115997   for(iTab=0, pItem=pTabList->a; iTab<nTabList; iTab++, pItem++){
115998     pNew->iTab = iTab;
116108     iCur = pWInfo->pTabList->a[pLoop->iTab].iCursor;
116653     pLevel->iFrom = pWLoop->iTab;
117124       if( (pWInfo->pTabList->a[pLoop->iTab].jointype & JT_LEFT)==0 ) break;

Indexes created Fri Mar 13 02:32:08 CET 2015