Lines Matching refs:pIdx
21508 SQLITE_PRIVATE int sqlite3ExprCoveredByIndex(Expr*, int iCur, Index *pIdx);
71807 Index *pIdx = (Index *)sqliteHashData(p); local
71808 if( pIdx->tnum==iRoot ){
71815 iTab = pIdx->pTable->tnum;
73371 static SQLITE_INLINE int allocateSpace(MemPage *pPage, int nByte, int *pIdx){
73419 *pIdx = g2 = (int)(pSpace-data);
73453 *pIdx = top;
85255 Index *pIdx; member
85277 Index *pIdx = p->pIdx; /* Index being probed */ local
85280 int nCol = pIdx->nColumn; /* Number of index columns including rowid */
85285 pRec->pKeyInfo = sqlite3KeyInfoOfIndex(p->pParse, pIdx);
85723 Index *pIdx, /* Index being probed */
85738 alloc.pIdx = pIdx;
85744 u8 aff = sqlite3IndexColumnAffinity(pParse->db, pIdx, iVal+i);
87523 SQLITE_PRIVATE void sqlite3VdbeSetP4KeyInfo(Parse *pParse, Index *pIdx){
87527 assert( pIdx!=0 );
87528 pKeyInfo = sqlite3KeyInfoOfIndex(pParse, pIdx);
103789 Index *pIdx;
103808 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
103810 for(j=0; j<pIdx->nKeyCol; j++){
103812 if( pIdx->aiColumn[j]==iCol || pIdx->aiColumn[j]==XN_EXPR ){
107105 Index *pIdx = (Index*)sqliteHashData(k);
107106 if( pIdx->tnum==iRoot ){
107107 pCur->zName = pIdx->zName;
113551 Index *pIdx; /* Iterator variable */
113583 for(pIdx=pTab->pIndex; pIdx && eType==0; pIdx=pIdx->pNext){
113586 if( pIdx->nColumn<nExpr ) continue;
113587 if( pIdx->pPartIdxWhere!=0 ) continue;
113590 testcase( pIdx->nColumn==BMS-2 );
113591 testcase( pIdx->nColumn==BMS-1 );
113592 if( pIdx->nColumn>=BMS-1 ) continue;
113594 if( pIdx->nKeyCol>nExpr
113595 ||(pIdx->nColumn>nExpr && !IsUniqueIndex(pIdx))
113609 if( pIdx->aiColumn[j]!=pRhs->iColumn ) continue;
113610 assert( pIdx->azColl[j] );
113611 if( pReq!=0 && sqlite3StrICmp(pReq->zName, pIdx->azColl[j])!=0 ){
113629 "USING INDEX %s FOR IN-OPERATOR",pIdx->zName));
113630 sqlite3VdbeAddOp3(v, OP_OpenRead, iTab, pIdx->tnum, iDb);
113631 sqlite3VdbeSetP4KeyInfo(pParse, pIdx);
113632 VdbeComment((v, "%s", pIdx->zName));
113634 eType = IN_INDEX_INDEX_ASC + pIdx->aSortOrder[0];
114576 Index *pIdx, /* The index whose column is to be loaded */
114581 i16 iTabCol = pIdx->aiColumn[iIdxCol];
114583 assert( pIdx->aColExpr );
114584 assert( pIdx->aColExpr->nExpr>iIdxCol );
114586 sqlite3ExprCodeCopy(pParse, pIdx->aColExpr->a[iIdxCol].pExpr, regOut);
114589 sqlite3ExprCodeGetColumnOfTable(pParse->pVdbe, pIdx->pTable, iTabCur,
117081 Index *pIdx; /* The index to be tested for coverage */
117093 && sqlite3TableColumnToIndex(pWalker->u.pIdxCover->pIdx, pExpr->iColumn)<0
117114 Index *pIdx /* The index that might be used for coverage */
117120 xcov.pIdx = pIdx;
119211 Index *pIdx;
119216 while( (pIdx = pParse->pNewIndex)!=0 ){
119217 pParse->pNewIndex = pIdx->pNext;
119218 sqlite3FreeIndex(db, pIdx);
119268 Index *pIdx;
119330 for(pIdx=sParse.pNewTable->pIndex; pIdx; pIdx=pIdx->pNext){
119331 sqlite3WalkExprList(&sWalker, pIdx->aColExpr);
119333 for(pIdx=sParse.pNewIndex; pIdx; pIdx=pIdx->pNext){
119334 sqlite3WalkExprList(&sWalker, pIdx->aColExpr);
121028 Index *pIdx, /* Index whose column is being loaded */
121032 assert( k>=0 && k<pIdx->nColumn );
121033 i = pIdx->aiColumn[k];
121035 VdbeComment((v,"%s.rowid",pIdx->zName));
121037 assert( pIdx->bHasExpr );
121038 VdbeComment((v,"%s.expr(%d)",pIdx->zName, k));
121040 VdbeComment((v,"%s.%s", pIdx->zName, pIdx->pTable->aCol[i].zCnName));
121060 Index *pIdx; /* An index to being analyzed */
121133 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
121140 if( pOnlyIdx && pOnlyIdx!=pIdx ) continue;
121141 if( pIdx->pPartIdxWhere==0 ) needTableCnt = 0;
121142 if( !HasRowid(pTab) && IsPrimaryKeyIndex(pIdx) ){
121143 nCol = pIdx->nKeyCol;
121147 nCol = pIdx->nColumn;
121148 zIdxName = pIdx->zName;
121149 nColTest = pIdx->uniqNotNull ? pIdx->nKeyCol-1 : nCol-1;
121200 assert( iDb==sqlite3SchemaToIndex(db, pIdx->pSchema) );
121201 sqlite3VdbeAddOp3(v, OP_OpenRead, iIdxCur, pIdx->tnum, iDb);
121202 sqlite3VdbeSetP4KeyInfo(pParse, pIdx);
121203 VdbeComment((v, "%s", pIdx->zName));
121227 sqlite3VdbeAddOp2(v, OP_Integer, pIdx->nKeyCol, regRowid);
121256 if( nColTest==1 && pIdx->nKeyCol==1 && IsUniqueIndex(pIdx) ){
121264 char *pColl = (char*)sqlite3LocateCollSeq(pParse, pIdx->azColl[i]);
121267 analyzeVdbeCommentIndexWithColumnName(v,pIdx,i);
121288 analyzeVdbeCommentIndexWithColumnName(v,pIdx,i);
121307 Index *pPk = sqlite3PrimaryKeyIndex(pIdx->pTable);
121311 k = sqlite3TableColumnToIndex(pIdx, pPk->aiColumn[j]);
121312 assert( k>=0 && k<pIdx->nColumn );
121314 analyzeVdbeCommentIndexWithColumnName(v,pIdx,k);
121341 if( pIdx->pPartIdxWhere ){
121417 sqlite3ExprCodeLoadIndexColumn(pParse, pIdx, iTabCur, i, regCol+i);
121537 Index *pIdx;
121565 if( (pIdx = sqlite3FindIndex(db, z, zDb))!=0 ){
121566 analyzeTable(pParse, pIdx->pTable, pIdx);
121730 SQLITE_PRIVATE void sqlite3DeleteIndexSamples(sqlite3 *db, Index *pIdx){
121732 assert( pIdx!=0 );
121734 if( pIdx->aSample ){
121736 for(j=0; j<pIdx->nSample; j++){
121737 IndexSample *p = &pIdx->aSample[j];
121740 sqlite3DbFree(db, pIdx->aSample);
121743 pIdx->nSample = 0;
121744 pIdx->aSample = 0;
121748 UNUSED_PARAMETER(pIdx);
121757 static void initAvgEq(Index *pIdx){
121758 if( pIdx ){
121759 IndexSample *aSample = pIdx->aSample;
121760 IndexSample *pFinal = &aSample[pIdx->nSample-1];
121763 if( pIdx->nSampleCol>1 ){
121768 nCol = pIdx->nSampleCol-1;
121769 pIdx->aAvgEq[nCol] = 1;
121772 int nSample = pIdx->nSample;
121780 if( !pIdx->aiRowEst || iCol>=pIdx->nKeyCol || pIdx->aiRowEst[iCol+1]==0 ){
121785 nRow = pIdx->aiRowEst[0];
121786 nDist100 = ((i64)100 * pIdx->aiRowEst[0]) / pIdx->aiRowEst[iCol+1];
121788 pIdx->nRowEst0 = nRow;
121795 if( i==(pIdx->nSample-1)
121807 pIdx->aAvgEq[iCol] = avgEq;
121821 Index *pIdx = sqlite3FindIndex(db, zName, zDb);
121822 if( pIdx==0 ){
121824 if( pTab && !HasRowid(pTab) ) pIdx = sqlite3PrimaryKeyIndex(pTab);
121826 return pIdx;
121866 Index *pIdx; /* Pointer to the index object */
121876 pIdx = findIndexOrPrimaryKey(db, zIndex, zDb);
121877 assert( pIdx==0 || pIdx->nSample==0 );
121878 if( pIdx==0 ) continue;
121879 if( pIdx->aSample!=0 ){
121883 assert( !HasRowid(pIdx->pTable) || pIdx->nColumn==pIdx->nKeyCol+1 );
121884 if( !HasRowid(pIdx->pTable) && IsPrimaryKeyIndex(pIdx) ){
121885 nIdxCol = pIdx->nKeyCol;
121887 nIdxCol = pIdx->nColumn;
121889 pIdx->nSampleCol = nIdxCol;
121890 pIdx->mxSample = nSample;
121895 pIdx->aSample = sqlite3DbMallocZero(db, nByte);
121896 if( pIdx->aSample==0 ){
121900 pPtr = (u8*)pIdx->aSample;
121901 pPtr += ROUND8(nSample*sizeof(pIdx->aSample[0]));
121904 pIdx->aAvgEq = pSpace; pSpace += nIdxCol;
121905 pIdx->pTable->tabFlags |= TF_HasStat4;
121907 pIdx->aSample[i].anEq = pSpace; pSpace += nIdxCol;
121908 pIdx->aSample[i].anLt = pSpace; pSpace += nIdxCol;
121909 pIdx->aSample[i].anDLt = pSpace; pSpace += nIdxCol;
121911 assert( ((u8*)pSpace)-nByte==(u8*)(pIdx->aSample) );
121926 Index *pIdx; /* Pointer to the index object */
121931 pIdx = findIndexOrPrimaryKey(db, zIndex, zDb);
121932 if( pIdx==0 ) continue;
121933 if( pIdx->nSample>=pIdx->mxSample ){
121940 nCol = pIdx->nSampleCol;
121941 if( pIdx!=pPrevIdx ){
121943 pPrevIdx = pIdx;
121945 pSample = &pIdx->aSample[pIdx->nSample];
121966 pIdx->nSample++;
122034 Index *pIdx = sqliteHashData(i);
122035 pIdx->hasStat1 = 0;
122037 sqlite3DeleteIndexSamples(db, pIdx);
122038 pIdx->aSample = 0;
122061 Index *pIdx = sqliteHashData(i);
122062 if( !pIdx->hasStat1 ) sqlite3DefaultRowEst(pIdx);
122073 Index *pIdx = sqliteHashData(i);
122074 sqlite3_free(pIdx->aiRowEst);
122075 pIdx->aiRowEst = 0;
124047 SQLITE_PRIVATE int sqlite3TableColumnToIndex(Index *pIdx, int iCol){
124051 assert( pIdx->nColumn<=SQLITE_MAX_COLUMN+1 );
124053 for(i=0; i<pIdx->nColumn; i++){
124054 if( iCol16==pIdx->aiColumn[i] ){
124579 Index *pIdx;
124580 for(pIdx=p->pIndex; pIdx; pIdx=pIdx->pNext){
124581 assert( pIdx->nKeyCol==1 && pIdx->onError!=OE_None );
124582 if( pIdx->aiColumn[0]==p->nCol-1 ){
124583 pIdx->uniqNotNull = 1;
124914 Index *pIdx;
124921 for(pIdx=p->pIndex; pIdx; pIdx=pIdx->pNext){
124922 assert( pIdx->nKeyCol==1 );
124923 if( pIdx->aiColumn[0]==i ){
124924 pIdx->azColl[0] = sqlite3ColumnColl(&p->aCol[i]);
125047 static void identPut(char *z, int *pIdx, char *zSignedIdent){
125050 i = *pIdx;
125067 *pIdx = i;
125153 static int resizeIndexObject(Parse *pParse, Index *pIdx, int N){
125157 if( pIdx->nColumn>=N ) return SQLITE_OK;
125162 assert( pIdx->isResized==0 );
125166 memcpy(zExtra, pIdx->azColl, sizeof(char*)*pIdx->nColumn);
125167 pIdx->azColl = (const char**)zExtra;
125169 memcpy(zExtra, pIdx->aiRowLogEst, sizeof(LogEst)*(pIdx->nKeyCol+1));
125170 pIdx->aiRowLogEst = (LogEst*)zExtra;
125172 memcpy(zExtra, pIdx->aiColumn, sizeof(i16)*pIdx->nColumn);
125173 pIdx->aiColumn = (i16*)zExtra;
125175 memcpy(zExtra, pIdx->aSortOrder, pIdx->nColumn);
125176 pIdx->aSortOrder = (u8*)zExtra;
125177 pIdx->nColumn = (u16)N; /* See tag-20250221-1 above for proof of safety */
125178 pIdx->isResized = 1;
125199 static void estimateIndexWidth(Index *pIdx){
125202 const Column *aCol = pIdx->pTable->aCol;
125203 for(i=0; i<pIdx->nColumn; i++){
125204 i16 x = pIdx->aiColumn[i];
125205 assert( x<pIdx->pTable->nCol );
125208 pIdx->szIdxRow = sqlite3LogEst(wIndex*4);
125237 static int isDupColumn(Index *pIdx, int nKey, Index *pPk, int iCol){
125239 assert( nKey<=pIdx->nColumn );
125243 assert( pPk->pTable==pIdx->pTable );
125244 testcase( pPk==pIdx );
125248 assert( pIdx->aiColumn[i]>=0 || j>=0 );
125249 if( pIdx->aiColumn[i]==j
125250 && sqlite3StrICmp(pIdx->azColl[i], pPk->azColl[iCol])==0
125277 static void recomputeColumnsNotIndexed(Index *pIdx){
125280 Table *pTab = pIdx->pTable;
125281 for(j=pIdx->nColumn-1; j>=0; j--){
125282 int x = pIdx->aiColumn[j];
125289 pIdx->colNotIdxed = ~m;
125290 assert( (pIdx->colNotIdxed>>63)==1 ); /* See note-20221022-a */
125318 Index *pIdx;
125417 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
125419 if( IsPrimaryKeyIndex(pIdx) ) continue;
125421 if( !isDupColumn(pIdx, pIdx->nKeyCol, pPk, i) ){
125422 testcase( hasColumn(pIdx->aiColumn, pIdx->nKeyCol, pPk->aiColumn[i]) );
125428 pIdx->nColumn = pIdx->nKeyCol;
125431 if( resizeIndexObject(pParse, pIdx, pIdx->nKeyCol+n) ) return;
125432 for(i=0, j=pIdx->nKeyCol; i<nPk; i++){
125433 if( !isDupColumn(pIdx, pIdx->nKeyCol, pPk, i) ){
125434 testcase( hasColumn(pIdx->aiColumn, pIdx->nKeyCol, pPk->aiColumn[i]) );
125435 pIdx->aiColumn[j] = pPk->aiColumn[i];
125436 pIdx->azColl[j] = pPk->azColl[i];
125439 pIdx->bAscKeyBug = 1;
125444 assert( pIdx->nColumn>=pIdx->nKeyCol+n );
125445 assert( pIdx->nColumn>=j );
125608 Index *pIdx; /* An implied index of the table */
125746 for(pIdx=p->pIndex; pIdx; pIdx=pIdx->pNext){
125747 estimateIndexWidth(pIdx);
126230 Index *pIdx = sqliteHashData(pElem);
126231 if( pIdx->tnum==iFrom ){
126232 pIdx->tnum = iTo;
126295 Index *pIdx;
126301 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
126302 Pgno iIdx = pIdx->tnum;
126303 assert( pIdx->pSchema==pTab->pSchema );
127297 Index *pIdx;
127298 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
127300 assert( IsUniqueIndex(pIdx) );
127301 assert( pIdx->idxType!=SQLITE_IDXTYPE_APPDEF );
127304 if( pIdx->nKeyCol!=pIndex->nKeyCol ) continue;
127305 for(k=0; k<pIdx->nKeyCol; k++){
127308 assert( pIdx->aiColumn[k]>=0 );
127309 if( pIdx->aiColumn[k]!=pIndex->aiColumn[k] ) break;
127310 z1 = pIdx->azColl[k];
127314 if( k==pIdx->nKeyCol ){
127315 if( pIdx->onError!=pIndex->onError ){
127323 if( !(pIdx->onError==OE_Default || pIndex->onError==OE_Default) ){
127327 if( pIdx->onError==OE_Default ){
127328 pIdx->onError = pIndex->onError;
127331 if( idxType==SQLITE_IDXTYPE_PRIMARYKEY ) pIdx->idxType = idxType;
127511 SQLITE_PRIVATE void sqlite3DefaultRowEst(Index *pIdx){
127514 LogEst *a = pIdx->aiRowLogEst;
127516 int nCopy = MIN(ArraySize(aVal), pIdx->nKeyCol);
127520 assert( !pIdx->hasStat1 );
127532 x = pIdx->pTable->nRowLogEst;
127535 pIdx->pTable->nRowLogEst = x = 99;
127537 if( pIdx->pPartIdxWhere!=0 ){ x -= 10; assert( 10==sqlite3LogEst(2) ); }
127543 for(i=nCopy+1; i<=pIdx->nKeyCol; i++){
127548 if( IsUniqueIndex(pIdx) ) a[pIdx->nKeyCol] = 0;
127644 int *pIdx /* Write the index of a new slot here */
127647 sqlite3_int64 n = *pIdx = *pnEntry;
127652 *pIdx = -1;
128426 Index *pIdx /* The index that triggers the constraint */
128431 Table *pTab = pIdx->pTable;
128435 if( pIdx->aColExpr ){
128436 sqlite3_str_appendf(&errMsg, "index '%q'", pIdx->zName);
128438 for(j=0; j<pIdx->nKeyCol; j++){
128440 assert( pIdx->aiColumn[j]>=0 );
128441 zCol = pTab->aCol[pIdx->aiColumn[j]].zCnName;
128450 IsPrimaryKeyIndex(pIdx) ? SQLITE_CONSTRAINT_PRIMARYKEY
128616 SQLITE_PRIVATE KeyInfo *sqlite3KeyInfoOfIndex(Parse *pParse, Index *pIdx){
128618 int nCol = pIdx->nColumn;
128619 int nKey = pIdx->nKeyCol;
128622 if( pIdx->uniqNotNull ){
128630 const char *zColl = pIdx->azColl[i];
128633 pKey->aSortFlags[i] = pIdx->aSortOrder[i];
128638 if( pIdx->bNoQuery==0 ){
128646 pIdx->bNoQuery = 1;
129620 Index *pIdx; /* For looping over indices of the table */
129726 for(nIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdx++){
129806 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
129807 assert( pIdx->pSchema==pTab->pSchema );
129808 if( IsPrimaryKeyIndex(pIdx) && !HasRowid(pTab) ){
129809 sqlite3VdbeAddOp3(v, OP_Clear, pIdx->tnum, iDb, memCnt ? memCnt : -1);
129811 sqlite3VdbeAddOp2(v, OP_Clear, pIdx->tnum, iDb);
130231 Index *pIdx; /* Current index */
130238 for(i=0, pIdx=pTab->pIndex; pIdx; i++, pIdx=pIdx->pNext){
130239 assert( iIdxCur+i!=iDataCur || pPk==pIdx );
130241 if( pIdx==pPk ) continue;
130243 VdbeModuleComment((v, "GenRowIdxDel for %s", pIdx->zName));
130244 r1 = sqlite3GenerateIndexKey(pParse, pIdx, iDataCur, 0, 1,
130247 pIdx->uniqNotNull ? pIdx->nKeyCol : pIdx->nColumn);
130250 pPrior = pIdx;
130287 Index *pIdx, /* The index for which to generate a key */
130301 if( pIdx->pPartIdxWhere ){
130304 sqlite3ExprIfFalseDup(pParse, pIdx->pPartIdxWhere, *piPartIdxLabel,
130313 nCol = (prefixOnly && pIdx->uniqNotNull) ? pIdx->nKeyCol : pIdx->nColumn;
130318 && pPrior->aiColumn[j]==pIdx->aiColumn[j]
130324 sqlite3ExprCodeLoadIndexColumn(pParse, pIdx, iDataCur, j, regBase+j);
130325 if( pIdx->aiColumn[j]>=0 ){
133492 Index *pIdx = 0; /* Value to return via *ppIdx */
133531 for(pIdx=pParent->pIndex; pIdx; pIdx=pIdx->pNext){
133532 if( pIdx->nKeyCol==nCol && IsUniqueIndex(pIdx) && pIdx->pPartIdxWhere==0 ){
133541 if( IsPrimaryKeyIndex(pIdx) ){
133555 i16 iCol = pIdx->aiColumn[i]; /* Index of column in parent tbl */
133566 if( sqlite3StrICmp(pIdx->azColl[i], zDfltColl) ) break;
133582 if( !pIdx ){
133592 *ppIdx = pIdx;
133626 Index *pIdx, /* Unique index on parent key columns in pTab */
133661 if( pIdx==0 ){
133696 sqlite3VdbeAddOp3(v, OP_OpenRead, iCur, pIdx->tnum, iDb);
133697 sqlite3VdbeSetP4KeyInfo(pParse, pIdx);
133720 iParent += sqlite3TableColumnToStorage(pIdx->pTable,
133721 pIdx->aiColumn[i]);
133722 assert( pIdx->aiColumn[i]>=0 );
133724 if( pIdx->aiColumn[i]==pTab->iPKey ){
133735 sqlite3IndexAffinityStr(pParse->db,pIdx), nCol);
133853 Index *pIdx, /* Index on parent covering the foreign key */
133867 assert( pIdx==0 || pIdx->pTable==pTab );
133868 assert( pIdx==0 || pIdx->nKeyCol==pFKey->nCol );
133869 assert( pIdx!=0 || pFKey->nCol==1 );
133870 assert( pIdx!=0 || HasRowid(pTab) );
133892 iCol = pIdx ? pIdx->aiColumn[i] : -1;
133926 assert( pIdx!=0 );
133927 for(i=0; i<pIdx->nKeyCol; i++){
133928 i16 iCol = pIdx->aiColumn[i];
134218 Index *pIdx = 0; /* Index on key columns in pTo */
134241 if( !pTo || sqlite3FkLocateIndex(pParse, pTo, pFKey, &pIdx, &aiFree) ){
134264 assert( pFKey->nCol==1 || (aiFree && pIdx) );
134276 assert( pIdx==0 || pIdx->aiColumn[i]>=0 );
134283 char *zCol = pTo->aCol[pIdx ? pIdx->aiColumn[i] : pTo->iPKey].zCnName;
134300 fkLookupParent(pParse, iDb, pTo, pIdx, pFKey, aiCol, regOld, -1, bIgnore);
134311 fkLookupParent(pParse, iDb, pTo, pIdx, pFKey, aiCol, regNew, +1, bIgnore);
134320 Index *pIdx = 0; /* Foreign key index for pFKey */
134337 if( sqlite3FkLocateIndex(pParse, pTab, pFKey, &pIdx, &aiCol) ){
134354 fkScanChildren(pParse, pSrc, pTab, pIdx, pFKey, aiCol, regNew, -1);
134360 fkScanChildren(pParse, pSrc, pTab, pIdx, pFKey, aiCol, regOld, 1);
134407 Index *pIdx = 0;
134408 sqlite3FkLocateIndex(pParse, pTab, p, &pIdx, 0);
134409 if( pIdx ){
134410 for(i=0; i<pIdx->nKeyCol; i++){
134411 assert( pIdx->aiColumn[i]>=0 );
134412 mask |= COLUMN_MASK(pIdx->aiColumn[i]);
134538 Index *pIdx = 0; /* Parent key index for this FK */
134547 if( sqlite3FkLocateIndex(pParse, pTab, pFKey, &pIdx, &aiCol) ) return 0;
134560 assert( pIdx!=0 || (pTab->iPKey>=0 && pTab->iPKey<pTab->nCol) );
134561 assert( pIdx==0 || pIdx->aiColumn[i]>=0 );
134563 pTab->aCol[pIdx ? pIdx->aiColumn[i] : pTab->iPKey].zCnName);
134864 static SQLITE_NOINLINE const char *computeIndexAffStr(sqlite3 *db, Index *pIdx){
134874 Table *pTab = pIdx->pTable;
134875 pIdx->zColAff = (char *)sqlite3DbMallocRaw(0, pIdx->nColumn+1);
134876 if( !pIdx->zColAff ){
134880 for(n=0; n<pIdx->nColumn; n++){
134881 i16 x = pIdx->aiColumn[n];
134889 assert( pIdx->bHasExpr );
134890 assert( pIdx->aColExpr!=0 );
134891 aff = sqlite3ExprAffinity(pIdx->aColExpr->a[n].pExpr);
134895 pIdx->zColAff[n] = aff;
134897 pIdx->zColAff[n] = 0;
134898 return pIdx->zColAff;
134900 SQLITE_PRIVATE const char *sqlite3IndexAffinityStr(sqlite3 *db, Index *pIdx){
134901 if( !pIdx->zColAff ) return computeIndexAffStr(db, pIdx);
134902 return pIdx->zColAff;
135692 Index *pIdx; /* For looping over indices of the table */
136067 for(i=0, pIdx=pTab->pIndex; i<nIdx; pIdx=pIdx->pNext, i++){
136068 assert( pIdx );
136070 pParse->nMem += pIdx->nColumn;
136544 Index *pIdx; /* The current Index */
136569 return pIter->u.lx.pIdx;
136585 pIter->u.lx.pIdx = pIter->u.lx.pIdx->pNext;
136586 return pIter->u.lx.pIdx;
136697 Index *pIdx; /* Pointer to one of the indices */
136923 sIdxIter.u.lx.pIdx = pTab->pIndex;
136945 for(nIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdx++){
136959 pIdx = pTab->pIndex;
136960 while( ALWAYS(pIdx!=0) && pIdx!=pTerm->pUpsertIdx ){
136961 pIdx = pIdx->pNext;
136966 sIdxIter.u.ax.aIdx[i].p = pIdx;
136970 for(jj=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, jj++){
136972 sIdxIter.u.ax.aIdx[i].p = pIdx;
137175 for(pIdx = indexIteratorFirst(&sIdxIter, &ix);
137176 pIdx;
137177 pIdx = indexIteratorNext(&sIdxIter, &ix)
137187 pUpsertClause = sqlite3UpsertOfIndex(pUpsert, pIdx);
137197 VdbeNoopComment((v, "prep index %s", pIdx->zName));
137202 if( pIdx->pPartIdxWhere ){
137205 sqlite3ExprIfFalseDup(pParse, pIdx->pPartIdxWhere, addrUniqueOk,
137214 for(i=0; i<pIdx->nColumn; i++){
137215 int iField = pIdx->aiColumn[i];
137219 sqlite3ExprCodeCopy(pParse, pIdx->aColExpr->a[i].pExpr, regIdx+i);
137221 VdbeComment((v, "%s column %d", pIdx->zName, i));
137233 sqlite3VdbeAddOp3(v, OP_MakeRecord, regIdx, pIdx->nColumn, aRegIdx[ix]);
137234 VdbeComment((v, "for %s", pIdx->zName));
137236 if( pIdx->idxType==SQLITE_IDXTYPE_PRIMARYKEY ){
137237 sqlite3SetMakeRecordP5(v, pIdx->pTable);
137240 sqlite3VdbeReleaseRegisters(pParse, regIdx, pIdx->nColumn, 0, 0);
137246 if( isUpdate && pPk==pIdx && pkChng==0 ){
137252 onError = pIdx->onError;
137284 if( (ix==0 && pIdx->pNext==0) /* Condition 3 */
137285 && pPk==pIdx /* Condition 2 */
137301 regIdx, pIdx->nKeyCol); VdbeCoverage(v);
137304 regR = pIdx==pPk ? regIdx : sqlite3GetTempRange(pParse, nPkField);
137319 if( pIdx!=pPk ){
137322 x = sqlite3TableColumnToIndex(pIdx, pPk->aiColumn[i]);
137338 int regCmp = (IsPrimaryKeyIndex(pIdx) ? regIdx : regR);
137370 sqlite3UniqueConstraint(pParse, onError, pIdx);
137375 sqlite3UpsertDoUpdate(pParse, pUpsert, pTab, pIdx, iIdxCur+ix);
137401 (pIdx==pPk ? ONEPASS_SINGLE : ONEPASS_OFF), iThisCur);
137417 if( pIdx->pPartIdxWhere ){
137449 sqlite3UniqueConstraint(pParse, OE_Abort, pIdx);
137580 Index *pIdx; /* An index being inserted or updated */
137592 for(i=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){
137594 assert( pIdx->onError!=OE_Replace
137595 || pIdx->pNext==0
137596 || pIdx->pNext->onError==OE_Replace );
137598 if( pIdx->pPartIdxWhere ){
137603 if( IsPrimaryKeyIndex(pIdx) && !HasRowid(pTab) ){
137612 pIdx->uniqNotNull ? pIdx->nKeyCol: pIdx->nColumn);
137669 Index *pIdx;
137695 for(i=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){
137697 assert( pIdx->pSchema==pTab->pSchema );
137698 if( IsPrimaryKeyIndex(pIdx) && !HasRowid(pTab) ){
137703 sqlite3VdbeAddOp3(v, op, iIdxCur, pIdx->tnum, iDb);
137704 sqlite3VdbeSetP4KeyInfo(pParse, pIdx);
137706 VdbeComment((v, "%s", pIdx->zName));
141971 Index *pIdx;
141983 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
141985 pIdx->zName,
141986 pIdx->szIdxRow,
141987 pIdx->aiRowLogEst[0],
141988 pIdx->hasStat1);
141997 Index *pIdx;
141999 pIdx = sqlite3FindIndex(db, zRight, zDb);
142000 if( pIdx==0 ){
142006 pIdx = sqlite3PrimaryKeyIndex(pTab);
142009 if( pIdx ){
142010 int iIdxDb = sqlite3SchemaToIndex(db, pIdx->pSchema);
142015 mx = pIdx->nColumn;
142019 mx = pIdx->nKeyCol;
142022 pTab = pIdx->pTable;
142026 i16 cnum = pIdx->aiColumn[i];
142031 pIdx->aSortOrder[i],
142032 pIdx->azColl[i],
142033 i<pIdx->nKeyCol);
142042 Index *pIdx;
142050 for(pIdx=pTab->pIndex, i=0; pIdx; pIdx=pIdx->pNext, i++){
142054 pIdx->zName,
142055 IsUniqueIndex(pIdx),
142056 azOrigin[pIdx->idxType],
142057 pIdx->pPartIdxWhere!=0);
142172 Index *pIdx; /* Index in the parent table */
142207 pIdx = 0;
142209 x = sqlite3FkLocateIndex(pParse, pParent, pFK, &pIdx, 0);
142211 if( pIdx==0 ){
142214 sqlite3VdbeAddOp3(v, OP_OpenRead, i, pIdx->tnum, iDb);
142215 sqlite3VdbeSetP4KeyInfo(pParse, pIdx);
142229 pIdx = 0;
142232 x = sqlite3FkLocateIndex(pParse, pParent, pFK, &pIdx, &aiCols);
142250 if( pIdx ){
142252 sqlite3IndexAffinityStr(db,pIdx), pFK->nCol);
142380 Index *pIdx; /* An index on pTab */
142384 for(nIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdx++){ cnt++; }
142394 Index *pIdx;
142397 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
142398 aRoot[++cnt] = pIdx->tnum;
142425 Index *pIdx;
142431 for(pIdx=pTab->pIndex; ALWAYS(pIdx); pIdx=pIdx->pNext){
142432 if( IsPrimaryKeyIndex(pIdx) ) break;
142436 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
142437 if( pIdx->pPartIdxWhere==0 ){
142440 sqlite3VdbeLoadString(v, 4, pIdx->zName);
142453 Index *pIdx, *pPk;
142478 for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){
142687 for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){
142691 if( pPk==pIdx ) continue;
142692 r1 = sqlite3GenerateIndexKey(pParse, pIdx, iDataCur, 0, 0, &jmp3,
142694 pPrior = pIdx;
142698 pIdx->nColumn); VdbeCoverage(v);
142703 jmp5 = sqlite3VdbeLoadString(v, 4, pIdx->zName);
142715 jmp7 = sqlite3VdbeAddOp3(v, OP_Eq, 3, 0, r1+pIdx->nColumn-1);
142728 for(kk=0; kk<pIdx->nKeyCol; kk++){
142729 if( pIdx->azColl[kk]==sqlite3StrBINARY ) continue;
142747 if( IsUniqueIndex(pIdx) ){
142750 for(kk=0; kk<pIdx->nKeyCol; kk++){
142751 int iCol = pIdx->aiColumn[kk];
142761 pIdx->nKeyCol); VdbeCoverage(v);
143136 Index *pIdx; /* An index of the table */
143179 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
143181 if( !pIdx->hasStat1 ){
150380 Index *pIdx;
150384 for(pIdx=pTab->pIndex;
150385 pIdx && sqlite3StrICmp(pIdx->zName, zIndexedBy);
150386 pIdx=pIdx->pNext
150388 if( !pIdx ){
150394 pFrom->u2.pIBIndex = pIdx;
151873 Index *pIdx /* Index used to optimize scan, or NULL */
151876 int bCover = (pIdx!=0 && (HasRowid(pTab) || !IsPrimaryKeyIndex(pIdx)));
151880 bCover ? pIdx->zName : ""
153445 Index *pIdx; /* Iterator variable */
153464 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
153465 if( pIdx->bUnordered==0
153466 && pIdx->szIdxRow<pTab->szTabRow
153467 && pIdx->pPartIdxWhere==0
153468 && (!pBest || pIdx->szIdxRow<pBest->szIdxRow)
153470 pBest = pIdx;
155507 Index *pIdx, /* The index to check */
155512 i16 iIdxCol = pIdx->aiColumn[iCol];
155518 assert( pIdx->aColExpr!=0 );
155519 assert( pIdx->aColExpr->a[iCol].pExpr!=0 );
155520 return sqlite3ExprReferencesUpdatedColumn(pIdx->aColExpr->a[iCol].pExpr,
155537 Index *pIdx, /* The index to check */
155541 if( pIdx->pPartIdxWhere==0 ) return 0;
155542 return sqlite3ExprReferencesUpdatedColumn(pIdx->pPartIdxWhere,
155709 Index *pIdx; /* For looping over indices */
155833 for(nIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nIdx++){
155834 if( pPk==pIdx ){
155976 for(nAllIdx=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, nAllIdx++){
155978 if( chngKey || hasFK>1 || pIdx==pPk
155979 || indexWhereClauseMightChange(pIdx,aXRef,chngRowid)
155982 pParse->nMem += pIdx->nColumn;
155985 for(i=0; i<pIdx->nKeyCol; i++){
155986 if( indexColumnIsBeingUpdated(pIdx, i, aXRef, chngRowid) ){
155988 pParse->nMem += pIdx->nColumn;
155989 if( onError==OE_Default && pIdx->onError==OE_Replace ){
156873 Index *pIdx; /* One of the indexes of pTab */
156926 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
156928 if( !IsUniqueIndex(pIdx) ) continue;
156929 if( pTarget->nExpr!=pIdx->nKeyCol ) continue;
156930 if( pIdx->pPartIdxWhere ){
156933 pIdx->pPartIdxWhere, iCursor)!=0 ){
156937 nn = pIdx->nKeyCol;
156940 sCol[0].u.zToken = (char*)pIdx->azColl[ii];
156941 if( pIdx->aiColumn[ii]==XN_EXPR ){
156942 assert( pIdx->aColExpr!=0 );
156943 assert( pIdx->aColExpr->nExpr>ii );
156944 assert( pIdx->bHasExpr );
156945 pExpr = pIdx->aColExpr->a[ii].pExpr;
156952 sCol[1].iColumn = pIdx->aiColumn[ii];
156970 pUpsert->pUpsertIdx = pIdx;
156971 if( sqlite3UpsertOfIndex(pAll,pIdx)!=pUpsert ){
157021 SQLITE_PRIVATE Upsert *sqlite3UpsertOfIndex(Upsert *pUpsert, Index *pIdx){
157025 && pUpsert->pUpsertIdx!=pIdx
157045 Index *pIdx, /* The UNIQUE constraint that failed */
157058 pUpsert = sqlite3UpsertOfIndex(pTop, pIdx);
157060 if( pIdx && iCur!=iDataCur ){
157075 k = sqlite3TableColumnToIndex(pIdx, pPk->aiColumn[i]);
157077 VdbeComment((v, "%s.%s", pIdx->zName,
158398 Index *pIdx;
158416 pIdx = pNew->pIndex;
158417 if( pIdx ){
158418 assert( pIdx->pNext==0 );
158419 pTab->pIndex = pIdx;
158421 pIdx->pTable = pTab;
159458 Index *pIdx /* Must be compatible with this index, if not NULL */
159603 static const char *explainIndexColumnName(Index *pIdx, int i){
159604 i = pIdx->aiColumn[i];
159607 return pIdx->pTable->aCol[i].zCnName;
159620 Index *pIdx, /* Index to read column names from */
159634 sqlite3_str_appendall(pStr, explainIndexColumnName(pIdx, iTerm+i));
159730 Index *pIdx;
159733 pIdx = pLoop->u.btree.pIndex;
159735 if( !HasRowid(pItem->pSTab) && IsPrimaryKeyIndex(pIdx) ){
159750 sqlite3_str_appendf(&str, zFmt, pIdx->zName);
160482 Index *pIdx; /* The index being used for this loop */
160495 pIdx = pLoop->u.btree.pIndex;
160496 assert( pIdx!=0 );
160504 zAff = sqlite3DbStrDup(pParse->db,sqlite3IndexAffinityStr(pParse->db,pIdx));
160513 VdbeComment((v, "begin skip-scan on %s", pIdx->zName));
160523 testcase( pIdx->aiColumn[j]==XN_EXPR );
160524 VdbeComment((v, "%s", explainIndexColumnName(pIdx, j)));
160624 Index *pIdx; /* The index used to access the table */
160635 assert( pHint->pIdx!=0 );
160638 && sqlite3TableColumnToIndex(pHint->pIdx, pExpr->iColumn)<0
160705 }else if( pHint->pIdx!=0 ){
160707 pExpr->iColumn = sqlite3TableColumnToIndex(pHint->pIdx, pExpr->iColumn);
160749 sHint.pIdx = pLoop->u.btree.pIndex;
160808 if( sHint.pIdx!=0 ){
160822 (sHint.pIdx ? sHint.iIdxCur : sHint.iTabCur), 0, 0,
160858 Index *pIdx, /* Index scan is using */
160866 assert( pIdx->aiColumn[pIdx->nColumn-1]==-1 );
160874 Table *pTab = pIdx->pTable;
160878 for(i=0; i<pIdx->nColumn-1; i++){
160880 assert( pIdx->aiColumn[i]<pTab->nCol );
160881 x1 = pIdx->aiColumn[i];
161067 Index *pIdx = 0; /* Index used by loop (if any) */
161477 pIdx = pLoop->u.btree.pIndex;
161506 testcase( pIdx->aSortOrder[nEq]==SQLITE_SO_DESC );
161509 pLevel->iLikeRepCntr |= bRev ^ (pIdx->aSortOrder[nEq]==SQLITE_SO_DESC);
161513 j = pIdx->aiColumn[nEq];
161514 if( (j>=0 && pIdx->pTable->aCol[j].notNull==0) || j==XN_EXPR ){
161547 if( (nEq<pIdx->nColumn && bRev==(pIdx->aSortOrder[nEq]==SQLITE_SO_ASC)) ){
161642 (pIdx->aiRowLogEst[0]+9)/10);
161763 }else if( HasRowid(pIdx->pTable) ){
161764 codeDeferredSeek(pWInfo, pIdx, iCur, iIdxCur);
161766 Index *pPk = sqlite3PrimaryKeyIndex(pIdx->pTable);
161769 k = sqlite3TableColumnToIndex(pIdx, pPk->aiColumn[j]);
161785 if( pIdx->pPartIdxWhere && pLevel->pRJ==0 ){
161786 whereApplyPartialIndexConstraints(pIdx->pPartIdxWhere, iCur, pWC);
161789 testcase( pIdx->pPartIdxWhere );
161813 if( omitTable ) pIdx = 0;
162195 iLoop = (pIdx ? 1 : 2);
162228 if( iLoop==1 && !sqlite3ExprCoveredByIndex(pE, pLevel->iTabCur, pIdx) ){
163548 Index *pIdx;
163553 for(pIdx=pFrom->a[j].pSTab->pIndex; pIdx; pIdx=pIdx->pNext){
163554 if( pIdx->aColExpr==0 ) continue;
163555 for(i=0; i<pIdx->nKeyCol; i++){
163556 if( pIdx->aiColumn[i]!=XN_EXPR ) continue;
163557 assert( pIdx->bHasExpr );
163558 if( sqlite3ExprCompareSkip(pExpr,pIdx->aColExpr->a[i].pExpr,iCur)==0
163559 && !sqlite3ExprIsConstant(0,pIdx->aColExpr->a[i].pExpr)
163596 Index *pIdx;
163597 for(pIdx=pFrom->a[i].pSTab->pIndex; pIdx; pIdx=pIdx->pNext){
163598 if( pIdx->aColExpr ){
164940 Index *pIdx /* Must be compatible with this index */
164952 if( pIdx ){
164954 iColumn = pIdx->aiColumn[j];
164955 if( iColumn==pIdx->pTable->iPKey ){
164958 pScan->idxaff = pIdx->pTable->aCol[iColumn].affinity;
164959 pScan->zCollName = pIdx->azColl[j];
164961 pScan->pIdxExpr = pIdx->aColExpr->a[j].pExpr;
164962 pScan->zCollName = pIdx->azColl[j];
165004 Index *pIdx /* Must be compatible with this index, if not NULL */
165010 p = whereScanInit(&scan, pWC, iCur, iColumn, op, pIdx);
165036 Index *pIdx, /* Index to match column of */
165040 const char *zColl = pIdx->azColl[iCol];
165046 && p->iColumn==pIdx->aiColumn[iCol]
165062 static int indexColumnNotNull(Index *pIdx, int iCol){
165064 assert( pIdx!=0 );
165065 assert( iCol>=0 && iCol<pIdx->nColumn );
165066 j = pIdx->aiColumn[iCol];
165068 return pIdx->pTable->aCol[j].notNull;
165092 Index *pIdx;
165127 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
165128 if( !IsUniqueIndex(pIdx) ) continue;
165129 if( pIdx->pPartIdxWhere ) continue;
165130 for(i=0; i<pIdx->nKeyCol; i++){
165131 if( 0==sqlite3WhereFindTerm(pWC, iBase, i, ~(Bitmask)0, WO_EQ, pIdx) ){
165132 if( findIndexCol(pParse, pDistinct, iBase, pIdx, i)<0 ) break;
165133 if( indexColumnNotNull(pIdx, i)==0 ) break;
165136 if( i==pIdx->nKeyCol ){
165327 const Index *pIdx;
165328 for(pIdx = pTab->pIndex; pIdx!=0; pIdx=pIdx->pNext){
165330 for(j=0; j<pIdx->nKeyCol; j++){
165331 if( pIdx->aiColumn[j]==iCol ){
165333 if( pIdx->hasStat1 && pIdx->aiRowLogEst[j+1]>20 ) return 0;
165394 Index *pIdx, /* Automatic index to explain */
165399 Table *pTab = pIdx->pTable;
165405 assert( pIdx->nColumn>1 );
165406 assert( pIdx->aiColumn[pIdx->nColumn-1]==XN_ROWID || !HasRowid(pTab) );
165407 for(ii=0; ii<(pIdx->nColumn-1); ii++){
165409 int iCol = pIdx->aiColumn[ii];
165444 Index *pIdx; /* Object describing the transient index */
165563 pIdx = sqlite3AllocateIndexObject(pParse->db, nKeyCol+HasRowid(pTable),
165565 if( pIdx==0 ) goto end_auto_index_create;
165566 pLoop->u.btree.pIndex = pIdx;
165567 pIdx->zName = "auto-index";
165568 pIdx->pTable = pTable;
165583 pIdx->aiColumn[n] = pTerm->u.x.leftColumn;
165586 pIdx->azColl[n] = pColl ? pColl->zName : sqlite3StrBINARY;
165607 pIdx->aiColumn[n] = i;
165608 pIdx->azColl[n] = sqlite3StrBINARY;
165614 pIdx->aiColumn[n] = i;
165615 pIdx->azColl[n] = sqlite3StrBINARY;
165621 pIdx->aiColumn[n] = XN_ROWID;
165622 pIdx->azColl[n] = sqlite3StrBINARY;
165626 explainAutomaticIndex(pParse, pIdx, pPartial!=0, &addrExp);
165630 sqlite3VdbeSetP4KeyInfo(pParse, pIdx);
165662 pParse, pIdx, pLevel->iTabCur, regRecord, 0, 0, 0, 0
165795 Index *pIdx = pLoop->u.btree.pIndex;
165800 assert( pIdx->pTable==pItem->pSTab );
165801 sqlite3ExprCodeLoadIndexColumn(pParse, pIdx, iCur, jj, r1+jj);
166161 Index *pIdx, /* Index to consider domain of */
166166 IndexSample *aSample = pIdx->aSample;
166180 assert( pIdx->nSample>0 );
166228 if( !HasRowid(pIdx->pTable) && IsPrimaryKeyIndex(pIdx) ){
166229 nField = pIdx->nKeyCol;
166231 nField = pIdx->nColumn;
166235 iSample = pIdx->nSample * nField;
166276 assert( i<pIdx->nSample );
166286 assert( i<=pIdx->nSample && i>=0 );
166288 assert( i==pIdx->nSample
166320 if( i>=pIdx->nSample ){
166321 iUpper = pIdx->nRowEst0;
166337 aStat[1] = pIdx->aAvgEq[nField-1];
166374 SQLITE_PRIVATE char sqlite3IndexColumnAffinity(sqlite3 *db, Index *pIdx, int iCol){
166375 assert( iCol>=0 && iCol<pIdx->nColumn );
166376 if( !pIdx->zColAff ){
166377 if( sqlite3IndexAffinityStr(db, pIdx)==0 ) return SQLITE_AFF_BLOB;
166379 assert( pIdx->zColAff[iCol]!=0 );
166380 return pIdx->zColAff[iCol];
167497 Index *pIdx, /* The index to be used for a inequality constraint */
167504 nCmp = MIN(nCmp, (pIdx->nColumn - nEq));
167528 || pLhs->iColumn!=pIdx->aiColumn[i+nEq]
167529 || pIdx->aSortOrder[i+nEq]!=pIdx->aSortOrder[nEq]
167536 idxaff = sqlite3TableColumnAffinity(pIdx->pTable, pLhs->iColumn);
167541 if( sqlite3StrICmp(pColl->zName, pIdx->azColl[i+nEq]) ) break;
168069 const Index *pIdx,
168073 for(i=0; i<pIdx->nColumn; i++){
168074 if( pIdx->aiColumn[i]==XN_EXPR
168075 && sqlite3ExprCompare(0, pExpr, pIdx->aColExpr->a[i].pExpr, iTabCur)==0
168088 Index *pIdx; /* The index */
168113 const Index *pIdx; /* The index of interest */
168119 pIdx = pCk->pIdx;
168123 pIdx = pWalk->u.pCovIdxCk->pIdx;
168124 aiColumn = pIdx->aiColumn;
168125 nColumn = pIdx->nColumn;
168131 }else if( pIdx->bHasExpr
168132 && exprIsCoveredByIndex(pExpr, pIdx, pWalk->u.pCovIdxCk->iTabCur) ){
168165 Index *pIdx, /* Index that is being tested */
168176 if( pIdx->bHasExpr==0 ){
168177 for(i=0; i<pIdx->nColumn; i++){
168178 if( pIdx->aiColumn[i]>=BMS-1 ) break;
168180 if( i>=pIdx->nColumn ){
168187 ck.pIdx = pIdx;
168249 Index *pIdx, /* Partial index being processed */
168259 wherePartIdxExpr(pParse, pIdx, pPart->pRight, pMask, iIdxCur, pItem);
168272 aff = pIdx->pTable->aCol[pLeft->iColumn].affinity;
170630 Index *pIdx;
170660 for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
170663 if( !IsUniqueIndex(pIdx)
170664 || pIdx->pPartIdxWhere!=0
170665 || pIdx->nKeyCol>ArraySize(pLoop->aLTermSpace)
170667 opMask = pIdx->uniqNotNull ? (WO_EQ|WO_IS) : WO_EQ;
170668 for(j=0; j<pIdx->nKeyCol; j++){
170669 pTerm = whereScanInit(&scan, pWC, iCur, j, opMask, pIdx);
170675 if( j!=pIdx->nKeyCol ) continue;
170677 if( pIdx->isCovering || (pItem->colUsed & pIdx->colNotIdxed)==0 ){
170682 pLoop->u.btree.pIndex = pIdx;
170940 Index *pIdx, /* The index-on-expression that contains the expressions */
170947 assert( pIdx->bHasExpr );
170948 pTab = pIdx->pTable;
170949 for(i=0; i<pIdx->nColumn; i++){
170951 int j = pIdx->aiColumn[i];
170953 pExpr = pIdx->aColExpr->a[i].pExpr;
170974 if( sqlite3IndexAffinityStr(pParse->db, pIdx) ){
170975 p->aff = pIdx->zColAff[i];
170978 p->zIdxName = pIdx->zName;
171806 Index *pIdx;
171811 && (pIdx = pLoop->u.btree.pIndex)->hasStat1
171813 && pIdx->aiRowLogEst[n]>=36
171954 Index *pIdx = 0;
171994 pIdx = pLoop->u.btree.pIndex;
171996 pIdx = pLevel->u.pCoveringIdx;
171998 if( pIdx
172001 if( pWInfo->eOnePass==ONEPASS_OFF || !HasRowid(pIdx->pTable) ){
172006 if( pIdx->bHasExpr ){
172047 assert( pIdx->pTable==pTab );
172061 x = sqlite3TableColumnToIndex(pIdx, x);
222151 sqlite3_stmt *pIdx = pIter->pIdxIter;
222152 rc = sqlite3_bind_text(pIdx, 1, pIter->zTbl, -1, SQLITE_STATIC);
236327 static int sqlite3Fts5ExprFirst(Fts5Expr*, Fts5Index *pIdx, i64 iMin, int bDesc);
241896 static int sqlite3Fts5ExprFirst(Fts5Expr *p, Fts5Index *pIdx, i64 iFirst, int bDesc){
241900 p->pIndex = pIdx;
249245 Fts5Index *pIdx;
258001 Fts5Index *pIdx = pCtx->pStorage->pIndex;
258007 return sqlite3Fts5IndexWrite(pIdx, pCtx->iCol, pCtx->szCol-1, pToken, nToken);