| OLD | NEW |
|---|
| (Empty) |
| 1 /* | |
| 2 ** 2015-06-06 | |
| 3 ** | |
| 4 ** The author disclaims copyright to this source code. In place of | |
| 5 ** a legal notice, here is a blessing: | |
| 6 ** | |
| 7 ** May you do good and not evil. | |
| 8 ** May you find forgiveness for yourself and forgive others. | |
| 9 ** May you share freely, never taking more than you give. | |
| 10 ** | |
| 11 ************************************************************************* | |
| 12 ** This module contains C code that generates VDBE code used to process | |
| 13 ** the WHERE clause of SQL statements. | |
| 14 ** | |
| 15 ** This file was split off from where.c on 2015-06-06 in order to reduce the | |
| 16 ** size of where.c and make it easier to edit. This file contains the routines | |
| 17 ** that actually generate the bulk of the WHERE loop code. The original where.c | |
| 18 ** file retains the code that does query planning and analysis. | |
| 19 */ | |
| 20 #include "sqliteInt.h" | |
| 21 #include "whereInt.h" | |
| 22 | |
| 23 #ifndef SQLITE_OMIT_EXPLAIN | |
| 24 /* | |
| 25 ** This routine is a helper for explainIndexRange() below | |
| 26 ** | |
| 27 ** pStr holds the text of an expression that we are building up one term | |
| 28 ** at a time. This routine adds a new term to the end of the expression. | |
| 29 ** Terms are separated by AND so add the "AND" text for second and subsequent | |
| 30 ** terms only. | |
| 31 */ | |
| 32 static void explainAppendTerm( | |
| 33 StrAccum *pStr, /* The text expression being built */ | |
| 34 int iTerm, /* Index of this term. First is zero */ | |
| 35 const char *zColumn, /* Name of the column */ | |
| 36 const char *zOp /* Name of the operator */ | |
| 37 ){ | |
| 38 if( iTerm ) sqlite3StrAccumAppend(pStr, " AND ", 5); | |
| 39 sqlite3StrAccumAppendAll(pStr, zColumn); | |
| 40 sqlite3StrAccumAppend(pStr, zOp, 1); | |
| 41 sqlite3StrAccumAppend(pStr, "?", 1); | |
| 42 } | |
| 43 | |
| 44 /* | |
| 45 ** Return the name of the i-th column of the pIdx index. | |
| 46 */ | |
| 47 static const char *explainIndexColumnName(Index *pIdx, int i){ | |
| 48 i = pIdx->aiColumn[i]; | |
| 49 if( i==XN_EXPR ) return "<expr>"; | |
| 50 if( i==XN_ROWID ) return "rowid"; | |
| 51 return pIdx->pTable->aCol[i].zName; | |
| 52 } | |
| 53 | |
| 54 /* | |
| 55 ** Argument pLevel describes a strategy for scanning table pTab. This | |
| 56 ** function appends text to pStr that describes the subset of table | |
| 57 ** rows scanned by the strategy in the form of an SQL expression. | |
| 58 ** | |
| 59 ** For example, if the query: | |
| 60 ** | |
| 61 ** SELECT * FROM t1 WHERE a=1 AND b>2; | |
| 62 ** | |
| 63 ** is run and there is an index on (a, b), then this function returns a | |
| 64 ** string similar to: | |
| 65 ** | |
| 66 ** "a=? AND b>?" | |
| 67 */ | |
| 68 static void explainIndexRange(StrAccum *pStr, WhereLoop *pLoop){ | |
| 69 Index *pIndex = pLoop->u.btree.pIndex; | |
| 70 u16 nEq = pLoop->u.btree.nEq; | |
| 71 u16 nSkip = pLoop->nSkip; | |
| 72 int i, j; | |
| 73 | |
| 74 if( nEq==0 && (pLoop->wsFlags&(WHERE_BTM_LIMIT|WHERE_TOP_LIMIT))==0 ) return; | |
| 75 sqlite3StrAccumAppend(pStr, " (", 2); | |
| 76 for(i=0; i<nEq; i++){ | |
| 77 const char *z = explainIndexColumnName(pIndex, i); | |
| 78 if( i ) sqlite3StrAccumAppend(pStr, " AND ", 5); | |
| 79 sqlite3XPrintf(pStr, 0, i>=nSkip ? "%s=?" : "ANY(%s)", z); | |
| 80 } | |
| 81 | |
| 82 j = i; | |
| 83 if( pLoop->wsFlags&WHERE_BTM_LIMIT ){ | |
| 84 const char *z = explainIndexColumnName(pIndex, i); | |
| 85 explainAppendTerm(pStr, i++, z, ">"); | |
| 86 } | |
| 87 if( pLoop->wsFlags&WHERE_TOP_LIMIT ){ | |
| 88 const char *z = explainIndexColumnName(pIndex, j); | |
| 89 explainAppendTerm(pStr, i, z, "<"); | |
| 90 } | |
| 91 sqlite3StrAccumAppend(pStr, ")", 1); | |
| 92 } | |
| 93 | |
| 94 /* | |
| 95 ** This function is a no-op unless currently processing an EXPLAIN QUERY PLAN | |
| 96 ** command, or if either SQLITE_DEBUG or SQLITE_ENABLE_STMT_SCANSTATUS was | |
| 97 ** defined at compile-time. If it is not a no-op, a single OP_Explain opcode | |
| 98 ** is added to the output to describe the table scan strategy in pLevel. | |
| 99 ** | |
| 100 ** If an OP_Explain opcode is added to the VM, its address is returned. | |
| 101 ** Otherwise, if no OP_Explain is coded, zero is returned. | |
| 102 */ | |
| 103 int sqlite3WhereExplainOneScan( | |
| 104 Parse *pParse, /* Parse context */ | |
| 105 SrcList *pTabList, /* Table list this loop refers to */ | |
| 106 WhereLevel *pLevel, /* Scan to write OP_Explain opcode for */ | |
| 107 int iLevel, /* Value for "level" column of output */ | |
| 108 int iFrom, /* Value for "from" column of output */ | |
| 109 u16 wctrlFlags /* Flags passed to sqlite3WhereBegin() */ | |
| 110 ){ | |
| 111 int ret = 0; | |
| 112 #if !defined(SQLITE_DEBUG) && !defined(SQLITE_ENABLE_STMT_SCANSTATUS) | |
| 113 if( pParse->explain==2 ) | |
| 114 #endif | |
| 115 { | |
| 116 struct SrcList_item *pItem = &pTabList->a[pLevel->iFrom]; | |
| 117 Vdbe *v = pParse->pVdbe; /* VM being constructed */ | |
| 118 sqlite3 *db = pParse->db; /* Database handle */ | |
| 119 int iId = pParse->iSelectId; /* Select id (left-most output column) */ | |
| 120 int isSearch; /* True for a SEARCH. False for SCAN. */ | |
| 121 WhereLoop *pLoop; /* The controlling WhereLoop object */ | |
| 122 u32 flags; /* Flags that describe this loop */ | |
| 123 char *zMsg; /* Text to add to EQP output */ | |
| 124 StrAccum str; /* EQP output string */ | |
| 125 char zBuf[100]; /* Initial space for EQP output string */ | |
| 126 | |
| 127 pLoop = pLevel->pWLoop; | |
| 128 flags = pLoop->wsFlags; | |
| 129 if( (flags&WHERE_MULTI_OR) || (wctrlFlags&WHERE_ONETABLE_ONLY) ) return 0; | |
| 130 | |
| 131 isSearch = (flags&(WHERE_BTM_LIMIT|WHERE_TOP_LIMIT))!=0 | |
| 132 || ((flags&WHERE_VIRTUALTABLE)==0 && (pLoop->u.btree.nEq>0)) | |
| 133 || (wctrlFlags&(WHERE_ORDERBY_MIN|WHERE_ORDERBY_MAX)); | |
| 134 | |
| 135 sqlite3StrAccumInit(&str, db, zBuf, sizeof(zBuf), SQLITE_MAX_LENGTH); | |
| 136 sqlite3StrAccumAppendAll(&str, isSearch ? "SEARCH" : "SCAN"); | |
| 137 if( pItem->pSelect ){ | |
| 138 sqlite3XPrintf(&str, 0, " SUBQUERY %d", pItem->iSelectId); | |
| 139 }else{ | |
| 140 sqlite3XPrintf(&str, 0, " TABLE %s", pItem->zName); | |
| 141 } | |
| 142 | |
| 143 if( pItem->zAlias ){ | |
| 144 sqlite3XPrintf(&str, 0, " AS %s", pItem->zAlias); | |
| 145 } | |
| 146 if( (flags & (WHERE_IPK|WHERE_VIRTUALTABLE))==0 ){ | |
| 147 const char *zFmt = 0; | |
| 148 Index *pIdx; | |
| 149 | |
| 150 assert( pLoop->u.btree.pIndex!=0 ); | |
| 151 pIdx = pLoop->u.btree.pIndex; | |
| 152 assert( !(flags&WHERE_AUTO_INDEX) || (flags&WHERE_IDX_ONLY) ); | |
| 153 if( !HasRowid(pItem->pTab) && IsPrimaryKeyIndex(pIdx) ){ | |
| 154 if( isSearch ){ | |
| 155 zFmt = "PRIMARY KEY"; | |
| 156 } | |
| 157 }else if( flags & WHERE_PARTIALIDX ){ | |
| 158 zFmt = "AUTOMATIC PARTIAL COVERING INDEX"; | |
| 159 }else if( flags & WHERE_AUTO_INDEX ){ | |
| 160 zFmt = "AUTOMATIC COVERING INDEX"; | |
| 161 }else if( flags & WHERE_IDX_ONLY ){ | |
| 162 zFmt = "COVERING INDEX %s"; | |
| 163 }else{ | |
| 164 zFmt = "INDEX %s"; | |
| 165 } | |
| 166 if( zFmt ){ | |
| 167 sqlite3StrAccumAppend(&str, " USING ", 7); | |
| 168 sqlite3XPrintf(&str, 0, zFmt, pIdx->zName); | |
| 169 explainIndexRange(&str, pLoop); | |
| 170 } | |
| 171 }else if( (flags & WHERE_IPK)!=0 && (flags & WHERE_CONSTRAINT)!=0 ){ | |
| 172 const char *zRangeOp; | |
| 173 if( flags&(WHERE_COLUMN_EQ|WHERE_COLUMN_IN) ){ | |
| 174 zRangeOp = "="; | |
| 175 }else if( (flags&WHERE_BOTH_LIMIT)==WHERE_BOTH_LIMIT ){ | |
| 176 zRangeOp = ">? AND rowid<"; | |
| 177 }else if( flags&WHERE_BTM_LIMIT ){ | |
| 178 zRangeOp = ">"; | |
| 179 }else{ | |
| 180 assert( flags&WHERE_TOP_LIMIT); | |
| 181 zRangeOp = "<"; | |
| 182 } | |
| 183 sqlite3XPrintf(&str, 0, " USING INTEGER PRIMARY KEY (rowid%s?)",zRangeOp); | |
| 184 } | |
| 185 #ifndef SQLITE_OMIT_VIRTUALTABLE | |
| 186 else if( (flags & WHERE_VIRTUALTABLE)!=0 ){ | |
| 187 sqlite3XPrintf(&str, 0, " VIRTUAL TABLE INDEX %d:%s", | |
| 188 pLoop->u.vtab.idxNum, pLoop->u.vtab.idxStr); | |
| 189 } | |
| 190 #endif | |
| 191 #ifdef SQLITE_EXPLAIN_ESTIMATED_ROWS | |
| 192 if( pLoop->nOut>=10 ){ | |
| 193 sqlite3XPrintf(&str, 0, " (~%llu rows)", sqlite3LogEstToInt(pLoop->nOut)); | |
| 194 }else{ | |
| 195 sqlite3StrAccumAppend(&str, " (~1 row)", 9); | |
| 196 } | |
| 197 #endif | |
| 198 zMsg = sqlite3StrAccumFinish(&str); | |
| 199 ret = sqlite3VdbeAddOp4(v, OP_Explain, iId, iLevel, iFrom, zMsg,P4_DYNAMIC); | |
| 200 } | |
| 201 return ret; | |
| 202 } | |
| 203 #endif /* SQLITE_OMIT_EXPLAIN */ | |
| 204 | |
| 205 #ifdef SQLITE_ENABLE_STMT_SCANSTATUS | |
| 206 /* | |
| 207 ** Configure the VM passed as the first argument with an | |
| 208 ** sqlite3_stmt_scanstatus() entry corresponding to the scan used to | |
| 209 ** implement level pLvl. Argument pSrclist is a pointer to the FROM | |
| 210 ** clause that the scan reads data from. | |
| 211 ** | |
| 212 ** If argument addrExplain is not 0, it must be the address of an | |
| 213 ** OP_Explain instruction that describes the same loop. | |
| 214 */ | |
| 215 void sqlite3WhereAddScanStatus( | |
| 216 Vdbe *v, /* Vdbe to add scanstatus entry to */ | |
| 217 SrcList *pSrclist, /* FROM clause pLvl reads data from */ | |
| 218 WhereLevel *pLvl, /* Level to add scanstatus() entry for */ | |
| 219 int addrExplain /* Address of OP_Explain (or 0) */ | |
| 220 ){ | |
| 221 const char *zObj = 0; | |
| 222 WhereLoop *pLoop = pLvl->pWLoop; | |
| 223 if( (pLoop->wsFlags & WHERE_VIRTUALTABLE)==0 && pLoop->u.btree.pIndex!=0 ){ | |
| 224 zObj = pLoop->u.btree.pIndex->zName; | |
| 225 }else{ | |
| 226 zObj = pSrclist->a[pLvl->iFrom].zName; | |
| 227 } | |
| 228 sqlite3VdbeScanStatus( | |
| 229 v, addrExplain, pLvl->addrBody, pLvl->addrVisit, pLoop->nOut, zObj | |
| 230 ); | |
| 231 } | |
| 232 #endif | |
| 233 | |
| 234 | |
| 235 /* | |
| 236 ** Disable a term in the WHERE clause. Except, do not disable the term | |
| 237 ** if it controls a LEFT OUTER JOIN and it did not originate in the ON | |
| 238 ** or USING clause of that join. | |
| 239 ** | |
| 240 ** Consider the term t2.z='ok' in the following queries: | |
| 241 ** | |
| 242 ** (1) SELECT * FROM t1 LEFT JOIN t2 ON t1.a=t2.x WHERE t2.z='ok' | |
| 243 ** (2) SELECT * FROM t1 LEFT JOIN t2 ON t1.a=t2.x AND t2.z='ok' | |
| 244 ** (3) SELECT * FROM t1, t2 WHERE t1.a=t2.x AND t2.z='ok' | |
| 245 ** | |
| 246 ** The t2.z='ok' is disabled in the in (2) because it originates | |
| 247 ** in the ON clause. The term is disabled in (3) because it is not part | |
| 248 ** of a LEFT OUTER JOIN. In (1), the term is not disabled. | |
| 249 ** | |
| 250 ** Disabling a term causes that term to not be tested in the inner loop | |
| 251 ** of the join. Disabling is an optimization. When terms are satisfied | |
| 252 ** by indices, we disable them to prevent redundant tests in the inner | |
| 253 ** loop. We would get the correct results if nothing were ever disabled, | |
| 254 ** but joins might run a little slower. The trick is to disable as much | |
| 255 ** as we can without disabling too much. If we disabled in (1), we'd get | |
| 256 ** the wrong answer. See ticket #813. | |
| 257 ** | |
| 258 ** If all the children of a term are disabled, then that term is also | |
| 259 ** automatically disabled. In this way, terms get disabled if derived | |
| 260 ** virtual terms are tested first. For example: | |
| 261 ** | |
| 262 ** x GLOB 'abc*' AND x>='abc' AND x<'acd' | |
| 263 ** \___________/ \______/ \_____/ | |
| 264 ** parent child1 child2 | |
| 265 ** | |
| 266 ** Only the parent term was in the original WHERE clause. The child1 | |
| 267 ** and child2 terms were added by the LIKE optimization. If both of | |
| 268 ** the virtual child terms are valid, then testing of the parent can be | |
| 269 ** skipped. | |
| 270 ** | |
| 271 ** Usually the parent term is marked as TERM_CODED. But if the parent | |
| 272 ** term was originally TERM_LIKE, then the parent gets TERM_LIKECOND instead. | |
| 273 ** The TERM_LIKECOND marking indicates that the term should be coded inside | |
| 274 ** a conditional such that is only evaluated on the second pass of a | |
| 275 ** LIKE-optimization loop, when scanning BLOBs instead of strings. | |
| 276 */ | |
| 277 static void disableTerm(WhereLevel *pLevel, WhereTerm *pTerm){ | |
| 278 int nLoop = 0; | |
| 279 while( pTerm | |
| 280 && (pTerm->wtFlags & TERM_CODED)==0 | |
| 281 && (pLevel->iLeftJoin==0 || ExprHasProperty(pTerm->pExpr, EP_FromJoin)) | |
| 282 && (pLevel->notReady & pTerm->prereqAll)==0 | |
| 283 ){ | |
| 284 if( nLoop && (pTerm->wtFlags & TERM_LIKE)!=0 ){ | |
| 285 pTerm->wtFlags |= TERM_LIKECOND; | |
| 286 }else{ | |
| 287 pTerm->wtFlags |= TERM_CODED; | |
| 288 } | |
| 289 if( pTerm->iParent<0 ) break; | |
| 290 pTerm = &pTerm->pWC->a[pTerm->iParent]; | |
| 291 pTerm->nChild--; | |
| 292 if( pTerm->nChild!=0 ) break; | |
| 293 nLoop++; | |
| 294 } | |
| 295 } | |
| 296 | |
| 297 /* | |
| 298 ** Code an OP_Affinity opcode to apply the column affinity string zAff | |
| 299 ** to the n registers starting at base. | |
| 300 ** | |
| 301 ** As an optimization, SQLITE_AFF_BLOB entries (which are no-ops) at the | |
| 302 ** beginning and end of zAff are ignored. If all entries in zAff are | |
| 303 ** SQLITE_AFF_BLOB, then no code gets generated. | |
| 304 ** | |
| 305 ** This routine makes its own copy of zAff so that the caller is free | |
| 306 ** to modify zAff after this routine returns. | |
| 307 */ | |
| 308 static void codeApplyAffinity(Parse *pParse, int base, int n, char *zAff){ | |
| 309 Vdbe *v = pParse->pVdbe; | |
| 310 if( zAff==0 ){ | |
| 311 assert( pParse->db->mallocFailed ); | |
| 312 return; | |
| 313 } | |
| 314 assert( v!=0 ); | |
| 315 | |
| 316 /* Adjust base and n to skip over SQLITE_AFF_BLOB entries at the beginning | |
| 317 ** and end of the affinity string. | |
| 318 */ | |
| 319 while( n>0 && zAff[0]==SQLITE_AFF_BLOB ){ | |
| 320 n--; | |
| 321 base++; | |
| 322 zAff++; | |
| 323 } | |
| 324 while( n>1 && zAff[n-1]==SQLITE_AFF_BLOB ){ | |
| 325 n--; | |
| 326 } | |
| 327 | |
| 328 /* Code the OP_Affinity opcode if there is anything left to do. */ | |
| 329 if( n>0 ){ | |
| 330 sqlite3VdbeAddOp2(v, OP_Affinity, base, n); | |
| 331 sqlite3VdbeChangeP4(v, -1, zAff, n); | |
| 332 sqlite3ExprCacheAffinityChange(pParse, base, n); | |
| 333 } | |
| 334 } | |
| 335 | |
| 336 | |
| 337 /* | |
| 338 ** Generate code for a single equality term of the WHERE clause. An equality | |
| 339 ** term can be either X=expr or X IN (...). pTerm is the term to be | |
| 340 ** coded. | |
| 341 ** | |
| 342 ** The current value for the constraint is left in register iReg. | |
| 343 ** | |
| 344 ** For a constraint of the form X=expr, the expression is evaluated and its | |
| 345 ** result is left on the stack. For constraints of the form X IN (...) | |
| 346 ** this routine sets up a loop that will iterate over all values of X. | |
| 347 */ | |
| 348 static int codeEqualityTerm( | |
| 349 Parse *pParse, /* The parsing context */ | |
| 350 WhereTerm *pTerm, /* The term of the WHERE clause to be coded */ | |
| 351 WhereLevel *pLevel, /* The level of the FROM clause we are working on */ | |
| 352 int iEq, /* Index of the equality term within this level */ | |
| 353 int bRev, /* True for reverse-order IN operations */ | |
| 354 int iTarget /* Attempt to leave results in this register */ | |
| 355 ){ | |
| 356 Expr *pX = pTerm->pExpr; | |
| 357 Vdbe *v = pParse->pVdbe; | |
| 358 int iReg; /* Register holding results */ | |
| 359 | |
| 360 assert( iTarget>0 ); | |
| 361 if( pX->op==TK_EQ || pX->op==TK_IS ){ | |
| 362 iReg = sqlite3ExprCodeTarget(pParse, pX->pRight, iTarget); | |
| 363 }else if( pX->op==TK_ISNULL ){ | |
| 364 iReg = iTarget; | |
| 365 sqlite3VdbeAddOp2(v, OP_Null, 0, iReg); | |
| 366 #ifndef SQLITE_OMIT_SUBQUERY | |
| 367 }else{ | |
| 368 int eType; | |
| 369 int iTab; | |
| 370 struct InLoop *pIn; | |
| 371 WhereLoop *pLoop = pLevel->pWLoop; | |
| 372 | |
| 373 if( (pLoop->wsFlags & WHERE_VIRTUALTABLE)==0 | |
| 374 && pLoop->u.btree.pIndex!=0 | |
| 375 && pLoop->u.btree.pIndex->aSortOrder[iEq] | |
| 376 ){ | |
| 377 testcase( iEq==0 ); | |
| 378 testcase( bRev ); | |
| 379 bRev = !bRev; | |
| 380 } | |
| 381 assert( pX->op==TK_IN ); | |
| 382 iReg = iTarget; | |
| 383 eType = sqlite3FindInIndex(pParse, pX, IN_INDEX_LOOP, 0); | |
| 384 if( eType==IN_INDEX_INDEX_DESC ){ | |
| 385 testcase( bRev ); | |
| 386 bRev = !bRev; | |
| 387 } | |
| 388 iTab = pX->iTable; | |
| 389 sqlite3VdbeAddOp2(v, bRev ? OP_Last : OP_Rewind, iTab, 0); | |
| 390 VdbeCoverageIf(v, bRev); | |
| 391 VdbeCoverageIf(v, !bRev); | |
| 392 assert( (pLoop->wsFlags & WHERE_MULTI_OR)==0 ); | |
| 393 pLoop->wsFlags |= WHERE_IN_ABLE; | |
| 394 if( pLevel->u.in.nIn==0 ){ | |
| 395 pLevel->addrNxt = sqlite3VdbeMakeLabel(v); | |
| 396 } | |
| 397 pLevel->u.in.nIn++; | |
| 398 pLevel->u.in.aInLoop = | |
| 399 sqlite3DbReallocOrFree(pParse->db, pLevel->u.in.aInLoop, | |
| 400 sizeof(pLevel->u.in.aInLoop[0])*pLevel->u.in.nIn); | |
| 401 pIn = pLevel->u.in.aInLoop; | |
| 402 if( pIn ){ | |
| 403 pIn += pLevel->u.in.nIn - 1; | |
| 404 pIn->iCur = iTab; | |
| 405 if( eType==IN_INDEX_ROWID ){ | |
| 406 pIn->addrInTop = sqlite3VdbeAddOp2(v, OP_Rowid, iTab, iReg); | |
| 407 }else{ | |
| 408 pIn->addrInTop = sqlite3VdbeAddOp3(v, OP_Column, iTab, 0, iReg); | |
| 409 } | |
| 410 pIn->eEndLoopOp = bRev ? OP_PrevIfOpen : OP_NextIfOpen; | |
| 411 sqlite3VdbeAddOp1(v, OP_IsNull, iReg); VdbeCoverage(v); | |
| 412 }else{ | |
| 413 pLevel->u.in.nIn = 0; | |
| 414 } | |
| 415 #endif | |
| 416 } | |
| 417 disableTerm(pLevel, pTerm); | |
| 418 return iReg; | |
| 419 } | |
| 420 | |
| 421 /* | |
| 422 ** Generate code that will evaluate all == and IN constraints for an | |
| 423 ** index scan. | |
| 424 ** | |
| 425 ** For example, consider table t1(a,b,c,d,e,f) with index i1(a,b,c). | |
| 426 ** Suppose the WHERE clause is this: a==5 AND b IN (1,2,3) AND c>5 AND c<10 | |
| 427 ** The index has as many as three equality constraints, but in this | |
| 428 ** example, the third "c" value is an inequality. So only two | |
| 429 ** constraints are coded. This routine will generate code to evaluate | |
| 430 ** a==5 and b IN (1,2,3). The current values for a and b will be stored | |
| 431 ** in consecutive registers and the index of the first register is returned. | |
| 432 ** | |
| 433 ** In the example above nEq==2. But this subroutine works for any value | |
| 434 ** of nEq including 0. If nEq==0, this routine is nearly a no-op. | |
| 435 ** The only thing it does is allocate the pLevel->iMem memory cell and | |
| 436 ** compute the affinity string. | |
| 437 ** | |
| 438 ** The nExtraReg parameter is 0 or 1. It is 0 if all WHERE clause constraints | |
| 439 ** are == or IN and are covered by the nEq. nExtraReg is 1 if there is | |
| 440 ** an inequality constraint (such as the "c>=5 AND c<10" in the example) that | |
| 441 ** occurs after the nEq quality constraints. | |
| 442 ** | |
| 443 ** This routine allocates a range of nEq+nExtraReg memory cells and returns | |
| 444 ** the index of the first memory cell in that range. The code that | |
| 445 ** calls this routine will use that memory range to store keys for | |
| 446 ** start and termination conditions of the loop. | |
| 447 ** key value of the loop. If one or more IN operators appear, then | |
| 448 ** this routine allocates an additional nEq memory cells for internal | |
| 449 ** use. | |
| 450 ** | |
| 451 ** Before returning, *pzAff is set to point to a buffer containing a | |
| 452 ** copy of the column affinity string of the index allocated using | |
| 453 ** sqlite3DbMalloc(). Except, entries in the copy of the string associated | |
| 454 ** with equality constraints that use BLOB or NONE affinity are set to | |
| 455 ** SQLITE_AFF_BLOB. This is to deal with SQL such as the following: | |
| 456 ** | |
| 457 ** CREATE TABLE t1(a TEXT PRIMARY KEY, b); | |
| 458 ** SELECT ... FROM t1 AS t2, t1 WHERE t1.a = t2.b; | |
| 459 ** | |
| 460 ** In the example above, the index on t1(a) has TEXT affinity. But since | |
| 461 ** the right hand side of the equality constraint (t2.b) has BLOB/NONE affinity, | |
| 462 ** no conversion should be attempted before using a t2.b value as part of | |
| 463 ** a key to search the index. Hence the first byte in the returned affinity | |
| 464 ** string in this example would be set to SQLITE_AFF_BLOB. | |
| 465 */ | |
| 466 static int codeAllEqualityTerms( | |
| 467 Parse *pParse, /* Parsing context */ | |
| 468 WhereLevel *pLevel, /* Which nested loop of the FROM we are coding */ | |
| 469 int bRev, /* Reverse the order of IN operators */ | |
| 470 int nExtraReg, /* Number of extra registers to allocate */ | |
| 471 char **pzAff /* OUT: Set to point to affinity string */ | |
| 472 ){ | |
| 473 u16 nEq; /* The number of == or IN constraints to code */ | |
| 474 u16 nSkip; /* Number of left-most columns to skip */ | |
| 475 Vdbe *v = pParse->pVdbe; /* The vm under construction */ | |
| 476 Index *pIdx; /* The index being used for this loop */ | |
| 477 WhereTerm *pTerm; /* A single constraint term */ | |
| 478 WhereLoop *pLoop; /* The WhereLoop object */ | |
| 479 int j; /* Loop counter */ | |
| 480 int regBase; /* Base register */ | |
| 481 int nReg; /* Number of registers to allocate */ | |
| 482 char *zAff; /* Affinity string to return */ | |
| 483 | |
| 484 /* This module is only called on query plans that use an index. */ | |
| 485 pLoop = pLevel->pWLoop; | |
| 486 assert( (pLoop->wsFlags & WHERE_VIRTUALTABLE)==0 ); | |
| 487 nEq = pLoop->u.btree.nEq; | |
| 488 nSkip = pLoop->nSkip; | |
| 489 pIdx = pLoop->u.btree.pIndex; | |
| 490 assert( pIdx!=0 ); | |
| 491 | |
| 492 /* Figure out how many memory cells we will need then allocate them. | |
| 493 */ | |
| 494 regBase = pParse->nMem + 1; | |
| 495 nReg = pLoop->u.btree.nEq + nExtraReg; | |
| 496 pParse->nMem += nReg; | |
| 497 | |
| 498 zAff = sqlite3DbStrDup(pParse->db,sqlite3IndexAffinityStr(pParse->db,pIdx)); | |
| 499 if( !zAff ){ | |
| 500 pParse->db->mallocFailed = 1; | |
| 501 } | |
| 502 | |
| 503 if( nSkip ){ | |
| 504 int iIdxCur = pLevel->iIdxCur; | |
| 505 sqlite3VdbeAddOp1(v, (bRev?OP_Last:OP_Rewind), iIdxCur); | |
| 506 VdbeCoverageIf(v, bRev==0); | |
| 507 VdbeCoverageIf(v, bRev!=0); | |
| 508 VdbeComment((v, "begin skip-scan on %s", pIdx->zName)); | |
| 509 j = sqlite3VdbeAddOp0(v, OP_Goto); | |
| 510 pLevel->addrSkip = sqlite3VdbeAddOp4Int(v, (bRev?OP_SeekLT:OP_SeekGT), | |
| 511 iIdxCur, 0, regBase, nSkip); | |
| 512 VdbeCoverageIf(v, bRev==0); | |
| 513 VdbeCoverageIf(v, bRev!=0); | |
| 514 sqlite3VdbeJumpHere(v, j); | |
| 515 for(j=0; j<nSkip; j++){ | |
| 516 sqlite3VdbeAddOp3(v, OP_Column, iIdxCur, j, regBase+j); | |
| 517 testcase( pIdx->aiColumn[j]==XN_EXPR ); | |
| 518 VdbeComment((v, "%s", explainIndexColumnName(pIdx, j))); | |
| 519 } | |
| 520 } | |
| 521 | |
| 522 /* Evaluate the equality constraints | |
| 523 */ | |
| 524 assert( zAff==0 || (int)strlen(zAff)>=nEq ); | |
| 525 for(j=nSkip; j<nEq; j++){ | |
| 526 int r1; | |
| 527 pTerm = pLoop->aLTerm[j]; | |
| 528 assert( pTerm!=0 ); | |
| 529 /* The following testcase is true for indices with redundant columns. | |
| 530 ** Ex: CREATE INDEX i1 ON t1(a,b,a); SELECT * FROM t1 WHERE a=0 AND b=0; */ | |
| 531 testcase( (pTerm->wtFlags & TERM_CODED)!=0 ); | |
| 532 testcase( pTerm->wtFlags & TERM_VIRTUAL ); | |
| 533 r1 = codeEqualityTerm(pParse, pTerm, pLevel, j, bRev, regBase+j); | |
| 534 if( r1!=regBase+j ){ | |
| 535 if( nReg==1 ){ | |
| 536 sqlite3ReleaseTempReg(pParse, regBase); | |
| 537 regBase = r1; | |
| 538 }else{ | |
| 539 sqlite3VdbeAddOp2(v, OP_SCopy, r1, regBase+j); | |
| 540 } | |
| 541 } | |
| 542 testcase( pTerm->eOperator & WO_ISNULL ); | |
| 543 testcase( pTerm->eOperator & WO_IN ); | |
| 544 if( (pTerm->eOperator & (WO_ISNULL|WO_IN))==0 ){ | |
| 545 Expr *pRight = pTerm->pExpr->pRight; | |
| 546 if( (pTerm->wtFlags & TERM_IS)==0 && sqlite3ExprCanBeNull(pRight) ){ | |
| 547 sqlite3VdbeAddOp2(v, OP_IsNull, regBase+j, pLevel->addrBrk); | |
| 548 VdbeCoverage(v); | |
| 549 } | |
| 550 if( zAff ){ | |
| 551 if( sqlite3CompareAffinity(pRight, zAff[j])==SQLITE_AFF_BLOB ){ | |
| 552 zAff[j] = SQLITE_AFF_BLOB; | |
| 553 } | |
| 554 if( sqlite3ExprNeedsNoAffinityChange(pRight, zAff[j]) ){ | |
| 555 zAff[j] = SQLITE_AFF_BLOB; | |
| 556 } | |
| 557 } | |
| 558 } | |
| 559 } | |
| 560 *pzAff = zAff; | |
| 561 return regBase; | |
| 562 } | |
| 563 | |
| 564 #ifndef SQLITE_LIKE_DOESNT_MATCH_BLOBS | |
| 565 /* | |
| 566 ** If the most recently coded instruction is a constant range contraint | |
| 567 ** that originated from the LIKE optimization, then change the P3 to be | |
| 568 ** pLoop->iLikeRepCntr and set P5. | |
| 569 ** | |
| 570 ** The LIKE optimization trys to evaluate "x LIKE 'abc%'" as a range | |
| 571 ** expression: "x>='ABC' AND x<'abd'". But this requires that the range | |
| 572 ** scan loop run twice, once for strings and a second time for BLOBs. | |
| 573 ** The OP_String opcodes on the second pass convert the upper and lower | |
| 574 ** bound string contants to blobs. This routine makes the necessary changes | |
| 575 ** to the OP_String opcodes for that to happen. | |
| 576 ** | |
| 577 ** Except, of course, if SQLITE_LIKE_DOESNT_MATCH_BLOBS is defined, then | |
| 578 ** only the one pass through the string space is required, so this routine | |
| 579 ** becomes a no-op. | |
| 580 */ | |
| 581 static void whereLikeOptimizationStringFixup( | |
| 582 Vdbe *v, /* prepared statement under construction */ | |
| 583 WhereLevel *pLevel, /* The loop that contains the LIKE operator */ | |
| 584 WhereTerm *pTerm /* The upper or lower bound just coded */ | |
| 585 ){ | |
| 586 if( pTerm->wtFlags & TERM_LIKEOPT ){ | |
| 587 VdbeOp *pOp; | |
| 588 assert( pLevel->iLikeRepCntr>0 ); | |
| 589 pOp = sqlite3VdbeGetOp(v, -1); | |
| 590 assert( pOp!=0 ); | |
| 591 assert( pOp->opcode==OP_String8 | |
| 592 || pTerm->pWC->pWInfo->pParse->db->mallocFailed ); | |
| 593 pOp->p3 = pLevel->iLikeRepCntr; | |
| 594 pOp->p5 = 1; | |
| 595 } | |
| 596 } | |
| 597 #else | |
| 598 # define whereLikeOptimizationStringFixup(A,B,C) | |
| 599 #endif | |
| 600 | |
| 601 #ifdef SQLITE_ENABLE_CURSOR_HINTS | |
| 602 /* | |
| 603 ** Information is passed from codeCursorHint() down to individual nodes of | |
| 604 ** the expression tree (by sqlite3WalkExpr()) using an instance of this | |
| 605 ** structure. | |
| 606 */ | |
| 607 struct CCurHint { | |
| 608 int iTabCur; /* Cursor for the main table */ | |
| 609 int iIdxCur; /* Cursor for the index, if pIdx!=0. Unused otherwise */ | |
| 610 Index *pIdx; /* The index used to access the table */ | |
| 611 }; | |
| 612 | |
| 613 /* | |
| 614 ** This function is called for every node of an expression that is a candidate | |
| 615 ** for a cursor hint on an index cursor. For TK_COLUMN nodes that reference | |
| 616 ** the table CCurHint.iTabCur, verify that the same column can be | |
| 617 ** accessed through the index. If it cannot, then set pWalker->eCode to 1. | |
| 618 */ | |
| 619 static int codeCursorHintCheckExpr(Walker *pWalker, Expr *pExpr){ | |
| 620 struct CCurHint *pHint = pWalker->u.pCCurHint; | |
| 621 assert( pHint->pIdx!=0 ); | |
| 622 if( pExpr->op==TK_COLUMN | |
| 623 && pExpr->iTable==pHint->iTabCur | |
| 624 && sqlite3ColumnOfIndex(pHint->pIdx, pExpr->iColumn)<0 | |
| 625 ){ | |
| 626 pWalker->eCode = 1; | |
| 627 } | |
| 628 return WRC_Continue; | |
| 629 } | |
| 630 | |
| 631 | |
| 632 /* | |
| 633 ** This function is called on every node of an expression tree used as an | |
| 634 ** argument to the OP_CursorHint instruction. If the node is a TK_COLUMN | |
| 635 ** that accesses any table other than the one identified by | |
| 636 ** CCurHint.iTabCur, then do the following: | |
| 637 ** | |
| 638 ** 1) allocate a register and code an OP_Column instruction to read | |
| 639 ** the specified column into the new register, and | |
| 640 ** | |
| 641 ** 2) transform the expression node to a TK_REGISTER node that reads | |
| 642 ** from the newly populated register. | |
| 643 ** | |
| 644 ** Also, if the node is a TK_COLUMN that does access the table idenified | |
| 645 ** by pCCurHint.iTabCur, and an index is being used (which we will | |
| 646 ** know because CCurHint.pIdx!=0) then transform the TK_COLUMN into | |
| 647 ** an access of the index rather than the original table. | |
| 648 */ | |
| 649 static int codeCursorHintFixExpr(Walker *pWalker, Expr *pExpr){ | |
| 650 int rc = WRC_Continue; | |
| 651 struct CCurHint *pHint = pWalker->u.pCCurHint; | |
| 652 if( pExpr->op==TK_COLUMN ){ | |
| 653 if( pExpr->iTable!=pHint->iTabCur ){ | |
| 654 Vdbe *v = pWalker->pParse->pVdbe; | |
| 655 int reg = ++pWalker->pParse->nMem; /* Register for column value */ | |
| 656 sqlite3ExprCodeGetColumnOfTable( | |
| 657 v, pExpr->pTab, pExpr->iTable, pExpr->iColumn, reg | |
| 658 ); | |
| 659 pExpr->op = TK_REGISTER; | |
| 660 pExpr->iTable = reg; | |
| 661 }else if( pHint->pIdx!=0 ){ | |
| 662 pExpr->iTable = pHint->iIdxCur; | |
| 663 pExpr->iColumn = sqlite3ColumnOfIndex(pHint->pIdx, pExpr->iColumn); | |
| 664 assert( pExpr->iColumn>=0 ); | |
| 665 } | |
| 666 }else if( pExpr->op==TK_AGG_FUNCTION ){ | |
| 667 /* An aggregate function in the WHERE clause of a query means this must | |
| 668 ** be a correlated sub-query, and expression pExpr is an aggregate from | |
| 669 ** the parent context. Do not walk the function arguments in this case. | |
| 670 ** | |
| 671 ** todo: It should be possible to replace this node with a TK_REGISTER | |
| 672 ** expression, as the result of the expression must be stored in a | |
| 673 ** register at this point. The same holds for TK_AGG_COLUMN nodes. */ | |
| 674 rc = WRC_Prune; | |
| 675 } | |
| 676 return rc; | |
| 677 } | |
| 678 | |
| 679 /* | |
| 680 ** Insert an OP_CursorHint instruction if it is appropriate to do so. | |
| 681 */ | |
| 682 static void codeCursorHint( | |
| 683 WhereInfo *pWInfo, /* The where clause */ | |
| 684 WhereLevel *pLevel, /* Which loop to provide hints for */ | |
| 685 WhereTerm *pEndRange /* Hint this end-of-scan boundary term if not NULL */ | |
| 686 ){ | |
| 687 Parse *pParse = pWInfo->pParse; | |
| 688 sqlite3 *db = pParse->db; | |
| 689 Vdbe *v = pParse->pVdbe; | |
| 690 Expr *pExpr = 0; | |
| 691 WhereLoop *pLoop = pLevel->pWLoop; | |
| 692 int iCur; | |
| 693 WhereClause *pWC; | |
| 694 WhereTerm *pTerm; | |
| 695 int i, j; | |
| 696 struct CCurHint sHint; | |
| 697 Walker sWalker; | |
| 698 | |
| 699 if( OptimizationDisabled(db, SQLITE_CursorHints) ) return; | |
| 700 iCur = pLevel->iTabCur; | |
| 701 assert( iCur==pWInfo->pTabList->a[pLevel->iFrom].iCursor ); | |
| 702 sHint.iTabCur = iCur; | |
| 703 sHint.iIdxCur = pLevel->iIdxCur; | |
| 704 sHint.pIdx = pLoop->u.btree.pIndex; | |
| 705 memset(&sWalker, 0, sizeof(sWalker)); | |
| 706 sWalker.pParse = pParse; | |
| 707 sWalker.u.pCCurHint = &sHint; | |
| 708 pWC = &pWInfo->sWC; | |
| 709 for(i=0; i<pWC->nTerm; i++){ | |
| 710 pTerm = &pWC->a[i]; | |
| 711 if( pTerm->wtFlags & (TERM_VIRTUAL|TERM_CODED) ) continue; | |
| 712 if( pTerm->prereqAll & pLevel->notReady ) continue; | |
| 713 if( ExprHasProperty(pTerm->pExpr, EP_FromJoin) ) continue; | |
| 714 | |
| 715 /* All terms in pWLoop->aLTerm[] except pEndRange are used to initialize | |
| 716 ** the cursor. These terms are not needed as hints for a pure range | |
| 717 ** scan (that has no == terms) so omit them. */ | |
| 718 if( pLoop->u.btree.nEq==0 && pTerm!=pEndRange ){ | |
| 719 for(j=0; j<pLoop->nLTerm && pLoop->aLTerm[j]!=pTerm; j++){} | |
| 720 if( j<pLoop->nLTerm ) continue; | |
| 721 } | |
| 722 | |
| 723 /* No subqueries or non-deterministic functions allowed */ | |
| 724 if( sqlite3ExprContainsSubquery(pTerm->pExpr) ) continue; | |
| 725 | |
| 726 /* For an index scan, make sure referenced columns are actually in | |
| 727 ** the index. */ | |
| 728 if( sHint.pIdx!=0 ){ | |
| 729 sWalker.eCode = 0; | |
| 730 sWalker.xExprCallback = codeCursorHintCheckExpr; | |
| 731 sqlite3WalkExpr(&sWalker, pTerm->pExpr); | |
| 732 if( sWalker.eCode ) continue; | |
| 733 } | |
| 734 | |
| 735 /* If we survive all prior tests, that means this term is worth hinting */ | |
| 736 pExpr = sqlite3ExprAnd(db, pExpr, sqlite3ExprDup(db, pTerm->pExpr, 0)); | |
| 737 } | |
| 738 if( pExpr!=0 ){ | |
| 739 sWalker.xExprCallback = codeCursorHintFixExpr; | |
| 740 sqlite3WalkExpr(&sWalker, pExpr); | |
| 741 sqlite3VdbeAddOp4(v, OP_CursorHint, | |
| 742 (sHint.pIdx ? sHint.iIdxCur : sHint.iTabCur), 0, 0, | |
| 743 (const char*)pExpr, P4_EXPR); | |
| 744 } | |
| 745 } | |
| 746 #else | |
| 747 # define codeCursorHint(A,B,C) /* No-op */ | |
| 748 #endif /* SQLITE_ENABLE_CURSOR_HINTS */ | |
| 749 | |
| 750 /* | |
| 751 ** Generate code for the start of the iLevel-th loop in the WHERE clause | |
| 752 ** implementation described by pWInfo. | |
| 753 */ | |
| 754 Bitmask sqlite3WhereCodeOneLoopStart( | |
| 755 WhereInfo *pWInfo, /* Complete information about the WHERE clause */ | |
| 756 int iLevel, /* Which level of pWInfo->a[] should be coded */ | |
| 757 Bitmask notReady /* Which tables are currently available */ | |
| 758 ){ | |
| 759 int j, k; /* Loop counters */ | |
| 760 int iCur; /* The VDBE cursor for the table */ | |
| 761 int addrNxt; /* Where to jump to continue with the next IN case */ | |
| 762 int omitTable; /* True if we use the index only */ | |
| 763 int bRev; /* True if we need to scan in reverse order */ | |
| 764 WhereLevel *pLevel; /* The where level to be coded */ | |
| 765 WhereLoop *pLoop; /* The WhereLoop object being coded */ | |
| 766 WhereClause *pWC; /* Decomposition of the entire WHERE clause */ | |
| 767 WhereTerm *pTerm; /* A WHERE clause term */ | |
| 768 Parse *pParse; /* Parsing context */ | |
| 769 sqlite3 *db; /* Database connection */ | |
| 770 Vdbe *v; /* The prepared stmt under constructions */ | |
| 771 struct SrcList_item *pTabItem; /* FROM clause term being coded */ | |
| 772 int addrBrk; /* Jump here to break out of the loop */ | |
| 773 int addrCont; /* Jump here to continue with next cycle */ | |
| 774 int iRowidReg = 0; /* Rowid is stored in this register, if not zero */ | |
| 775 int iReleaseReg = 0; /* Temp register to free before returning */ | |
| 776 | |
| 777 pParse = pWInfo->pParse; | |
| 778 v = pParse->pVdbe; | |
| 779 pWC = &pWInfo->sWC; | |
| 780 db = pParse->db; | |
| 781 pLevel = &pWInfo->a[iLevel]; | |
| 782 pLoop = pLevel->pWLoop; | |
| 783 pTabItem = &pWInfo->pTabList->a[pLevel->iFrom]; | |
| 784 iCur = pTabItem->iCursor; | |
| 785 pLevel->notReady = notReady & ~sqlite3WhereGetMask(&pWInfo->sMaskSet, iCur); | |
| 786 bRev = (pWInfo->revMask>>iLevel)&1; | |
| 787 omitTable = (pLoop->wsFlags & WHERE_IDX_ONLY)!=0 | |
| 788 && (pWInfo->wctrlFlags & WHERE_FORCE_TABLE)==0; | |
| 789 VdbeModuleComment((v, "Begin WHERE-loop%d: %s",iLevel,pTabItem->pTab->zName)); | |
| 790 | |
| 791 /* Create labels for the "break" and "continue" instructions | |
| 792 ** for the current loop. Jump to addrBrk to break out of a loop. | |
| 793 ** Jump to cont to go immediately to the next iteration of the | |
| 794 ** loop. | |
| 795 ** | |
| 796 ** When there is an IN operator, we also have a "addrNxt" label that | |
| 797 ** means to continue with the next IN value combination. When | |
| 798 ** there are no IN operators in the constraints, the "addrNxt" label | |
| 799 ** is the same as "addrBrk". | |
| 800 */ | |
| 801 addrBrk = pLevel->addrBrk = pLevel->addrNxt = sqlite3VdbeMakeLabel(v); | |
| 802 addrCont = pLevel->addrCont = sqlite3VdbeMakeLabel(v); | |
| 803 | |
| 804 /* If this is the right table of a LEFT OUTER JOIN, allocate and | |
| 805 ** initialize a memory cell that records if this table matches any | |
| 806 ** row of the left table of the join. | |
| 807 */ | |
| 808 if( pLevel->iFrom>0 && (pTabItem[0].fg.jointype & JT_LEFT)!=0 ){ | |
| 809 pLevel->iLeftJoin = ++pParse->nMem; | |
| 810 sqlite3VdbeAddOp2(v, OP_Integer, 0, pLevel->iLeftJoin); | |
| 811 VdbeComment((v, "init LEFT JOIN no-match flag")); | |
| 812 } | |
| 813 | |
| 814 /* Special case of a FROM clause subquery implemented as a co-routine */ | |
| 815 if( pTabItem->fg.viaCoroutine ){ | |
| 816 int regYield = pTabItem->regReturn; | |
| 817 sqlite3VdbeAddOp3(v, OP_InitCoroutine, regYield, 0, pTabItem->addrFillSub); | |
| 818 pLevel->p2 = sqlite3VdbeAddOp2(v, OP_Yield, regYield, addrBrk); | |
| 819 VdbeCoverage(v); | |
| 820 VdbeComment((v, "next row of \"%s\"", pTabItem->pTab->zName)); | |
| 821 pLevel->op = OP_Goto; | |
| 822 }else | |
| 823 | |
| 824 #ifndef SQLITE_OMIT_VIRTUALTABLE | |
| 825 if( (pLoop->wsFlags & WHERE_VIRTUALTABLE)!=0 ){ | |
| 826 /* Case 1: The table is a virtual-table. Use the VFilter and VNext | |
| 827 ** to access the data. | |
| 828 */ | |
| 829 int iReg; /* P3 Value for OP_VFilter */ | |
| 830 int addrNotFound; | |
| 831 int nConstraint = pLoop->nLTerm; | |
| 832 | |
| 833 sqlite3ExprCachePush(pParse); | |
| 834 iReg = sqlite3GetTempRange(pParse, nConstraint+2); | |
| 835 addrNotFound = pLevel->addrBrk; | |
| 836 for(j=0; j<nConstraint; j++){ | |
| 837 int iTarget = iReg+j+2; | |
| 838 pTerm = pLoop->aLTerm[j]; | |
| 839 if( pTerm==0 ) continue; | |
| 840 if( pTerm->eOperator & WO_IN ){ | |
| 841 codeEqualityTerm(pParse, pTerm, pLevel, j, bRev, iTarget); | |
| 842 addrNotFound = pLevel->addrNxt; | |
| 843 }else{ | |
| 844 sqlite3ExprCode(pParse, pTerm->pExpr->pRight, iTarget); | |
| 845 } | |
| 846 } | |
| 847 sqlite3VdbeAddOp2(v, OP_Integer, pLoop->u.vtab.idxNum, iReg); | |
| 848 sqlite3VdbeAddOp2(v, OP_Integer, nConstraint, iReg+1); | |
| 849 sqlite3VdbeAddOp4(v, OP_VFilter, iCur, addrNotFound, iReg, | |
| 850 pLoop->u.vtab.idxStr, | |
| 851 pLoop->u.vtab.needFree ? P4_MPRINTF : P4_STATIC); | |
| 852 VdbeCoverage(v); | |
| 853 pLoop->u.vtab.needFree = 0; | |
| 854 for(j=0; j<nConstraint && j<16; j++){ | |
| 855 if( (pLoop->u.vtab.omitMask>>j)&1 ){ | |
| 856 disableTerm(pLevel, pLoop->aLTerm[j]); | |
| 857 } | |
| 858 } | |
| 859 pLevel->p1 = iCur; | |
| 860 pLevel->op = pWInfo->eOnePass ? OP_Noop : OP_VNext; | |
| 861 pLevel->p2 = sqlite3VdbeCurrentAddr(v); | |
| 862 sqlite3ReleaseTempRange(pParse, iReg, nConstraint+2); | |
| 863 sqlite3ExprCachePop(pParse); | |
| 864 }else | |
| 865 #endif /* SQLITE_OMIT_VIRTUALTABLE */ | |
| 866 | |
| 867 if( (pLoop->wsFlags & WHERE_IPK)!=0 | |
| 868 && (pLoop->wsFlags & (WHERE_COLUMN_IN|WHERE_COLUMN_EQ))!=0 | |
| 869 ){ | |
| 870 /* Case 2: We can directly reference a single row using an | |
| 871 ** equality comparison against the ROWID field. Or | |
| 872 ** we reference multiple rows using a "rowid IN (...)" | |
| 873 ** construct. | |
| 874 */ | |
| 875 assert( pLoop->u.btree.nEq==1 ); | |
| 876 pTerm = pLoop->aLTerm[0]; | |
| 877 assert( pTerm!=0 ); | |
| 878 assert( pTerm->pExpr!=0 ); | |
| 879 assert( omitTable==0 ); | |
| 880 testcase( pTerm->wtFlags & TERM_VIRTUAL ); | |
| 881 iReleaseReg = ++pParse->nMem; | |
| 882 iRowidReg = codeEqualityTerm(pParse, pTerm, pLevel, 0, bRev, iReleaseReg); | |
| 883 if( iRowidReg!=iReleaseReg ) sqlite3ReleaseTempReg(pParse, iReleaseReg); | |
| 884 addrNxt = pLevel->addrNxt; | |
| 885 sqlite3VdbeAddOp2(v, OP_MustBeInt, iRowidReg, addrNxt); VdbeCoverage(v); | |
| 886 sqlite3VdbeAddOp3(v, OP_NotExists, iCur, addrNxt, iRowidReg); | |
| 887 VdbeCoverage(v); | |
| 888 sqlite3ExprCacheAffinityChange(pParse, iRowidReg, 1); | |
| 889 sqlite3ExprCacheStore(pParse, iCur, -1, iRowidReg); | |
| 890 VdbeComment((v, "pk")); | |
| 891 pLevel->op = OP_Noop; | |
| 892 }else if( (pLoop->wsFlags & WHERE_IPK)!=0 | |
| 893 && (pLoop->wsFlags & WHERE_COLUMN_RANGE)!=0 | |
| 894 ){ | |
| 895 /* Case 3: We have an inequality comparison against the ROWID field. | |
| 896 */ | |
| 897 int testOp = OP_Noop; | |
| 898 int start; | |
| 899 int memEndValue = 0; | |
| 900 WhereTerm *pStart, *pEnd; | |
| 901 | |
| 902 assert( omitTable==0 ); | |
| 903 j = 0; | |
| 904 pStart = pEnd = 0; | |
| 905 if( pLoop->wsFlags & WHERE_BTM_LIMIT ) pStart = pLoop->aLTerm[j++]; | |
| 906 if( pLoop->wsFlags & WHERE_TOP_LIMIT ) pEnd = pLoop->aLTerm[j++]; | |
| 907 assert( pStart!=0 || pEnd!=0 ); | |
| 908 if( bRev ){ | |
| 909 pTerm = pStart; | |
| 910 pStart = pEnd; | |
| 911 pEnd = pTerm; | |
| 912 } | |
| 913 codeCursorHint(pWInfo, pLevel, pEnd); | |
| 914 if( pStart ){ | |
| 915 Expr *pX; /* The expression that defines the start bound */ | |
| 916 int r1, rTemp; /* Registers for holding the start boundary */ | |
| 917 | |
| 918 /* The following constant maps TK_xx codes into corresponding | |
| 919 ** seek opcodes. It depends on a particular ordering of TK_xx | |
| 920 */ | |
| 921 const u8 aMoveOp[] = { | |
| 922 /* TK_GT */ OP_SeekGT, | |
| 923 /* TK_LE */ OP_SeekLE, | |
| 924 /* TK_LT */ OP_SeekLT, | |
| 925 /* TK_GE */ OP_SeekGE | |
| 926 }; | |
| 927 assert( TK_LE==TK_GT+1 ); /* Make sure the ordering.. */ | |
| 928 assert( TK_LT==TK_GT+2 ); /* ... of the TK_xx values... */ | |
| 929 assert( TK_GE==TK_GT+3 ); /* ... is correcct. */ | |
| 930 | |
| 931 assert( (pStart->wtFlags & TERM_VNULL)==0 ); | |
| 932 testcase( pStart->wtFlags & TERM_VIRTUAL ); | |
| 933 pX = pStart->pExpr; | |
| 934 assert( pX!=0 ); | |
| 935 testcase( pStart->leftCursor!=iCur ); /* transitive constraints */ | |
| 936 r1 = sqlite3ExprCodeTemp(pParse, pX->pRight, &rTemp); | |
| 937 sqlite3VdbeAddOp3(v, aMoveOp[pX->op-TK_GT], iCur, addrBrk, r1); | |
| 938 VdbeComment((v, "pk")); | |
| 939 VdbeCoverageIf(v, pX->op==TK_GT); | |
| 940 VdbeCoverageIf(v, pX->op==TK_LE); | |
| 941 VdbeCoverageIf(v, pX->op==TK_LT); | |
| 942 VdbeCoverageIf(v, pX->op==TK_GE); | |
| 943 sqlite3ExprCacheAffinityChange(pParse, r1, 1); | |
| 944 sqlite3ReleaseTempReg(pParse, rTemp); | |
| 945 disableTerm(pLevel, pStart); | |
| 946 }else{ | |
| 947 sqlite3VdbeAddOp2(v, bRev ? OP_Last : OP_Rewind, iCur, addrBrk); | |
| 948 VdbeCoverageIf(v, bRev==0); | |
| 949 VdbeCoverageIf(v, bRev!=0); | |
| 950 } | |
| 951 if( pEnd ){ | |
| 952 Expr *pX; | |
| 953 pX = pEnd->pExpr; | |
| 954 assert( pX!=0 ); | |
| 955 assert( (pEnd->wtFlags & TERM_VNULL)==0 ); | |
| 956 testcase( pEnd->leftCursor!=iCur ); /* Transitive constraints */ | |
| 957 testcase( pEnd->wtFlags & TERM_VIRTUAL ); | |
| 958 memEndValue = ++pParse->nMem; | |
| 959 sqlite3ExprCode(pParse, pX->pRight, memEndValue); | |
| 960 if( pX->op==TK_LT || pX->op==TK_GT ){ | |
| 961 testOp = bRev ? OP_Le : OP_Ge; | |
| 962 }else{ | |
| 963 testOp = bRev ? OP_Lt : OP_Gt; | |
| 964 } | |
| 965 disableTerm(pLevel, pEnd); | |
| 966 } | |
| 967 start = sqlite3VdbeCurrentAddr(v); | |
| 968 pLevel->op = bRev ? OP_Prev : OP_Next; | |
| 969 pLevel->p1 = iCur; | |
| 970 pLevel->p2 = start; | |
| 971 assert( pLevel->p5==0 ); | |
| 972 if( testOp!=OP_Noop ){ | |
| 973 iRowidReg = ++pParse->nMem; | |
| 974 sqlite3VdbeAddOp2(v, OP_Rowid, iCur, iRowidReg); | |
| 975 sqlite3ExprCacheStore(pParse, iCur, -1, iRowidReg); | |
| 976 sqlite3VdbeAddOp3(v, testOp, memEndValue, addrBrk, iRowidReg); | |
| 977 VdbeCoverageIf(v, testOp==OP_Le); | |
| 978 VdbeCoverageIf(v, testOp==OP_Lt); | |
| 979 VdbeCoverageIf(v, testOp==OP_Ge); | |
| 980 VdbeCoverageIf(v, testOp==OP_Gt); | |
| 981 sqlite3VdbeChangeP5(v, SQLITE_AFF_NUMERIC | SQLITE_JUMPIFNULL); | |
| 982 } | |
| 983 }else if( pLoop->wsFlags & WHERE_INDEXED ){ | |
| 984 /* Case 4: A scan using an index. | |
| 985 ** | |
| 986 ** The WHERE clause may contain zero or more equality | |
| 987 ** terms ("==" or "IN" operators) that refer to the N | |
| 988 ** left-most columns of the index. It may also contain | |
| 989 ** inequality constraints (>, <, >= or <=) on the indexed | |
| 990 ** column that immediately follows the N equalities. Only | |
| 991 ** the right-most column can be an inequality - the rest must | |
| 992 ** use the "==" and "IN" operators. For example, if the | |
| 993 ** index is on (x,y,z), then the following clauses are all | |
| 994 ** optimized: | |
| 995 ** | |
| 996 ** x=5 | |
| 997 ** x=5 AND y=10 | |
| 998 ** x=5 AND y<10 | |
| 999 ** x=5 AND y>5 AND y<10 | |
| 1000 ** x=5 AND y=5 AND z<=10 | |
| 1001 ** | |
| 1002 ** The z<10 term of the following cannot be used, only | |
| 1003 ** the x=5 term: | |
| 1004 ** | |
| 1005 ** x=5 AND z<10 | |
| 1006 ** | |
| 1007 ** N may be zero if there are inequality constraints. | |
| 1008 ** If there are no inequality constraints, then N is at | |
| 1009 ** least one. | |
| 1010 ** | |
| 1011 ** This case is also used when there are no WHERE clause | |
| 1012 ** constraints but an index is selected anyway, in order | |
| 1013 ** to force the output order to conform to an ORDER BY. | |
| 1014 */ | |
| 1015 static const u8 aStartOp[] = { | |
| 1016 0, | |
| 1017 0, | |
| 1018 OP_Rewind, /* 2: (!start_constraints && startEq && !bRev) */ | |
| 1019 OP_Last, /* 3: (!start_constraints && startEq && bRev) */ | |
| 1020 OP_SeekGT, /* 4: (start_constraints && !startEq && !bRev) */ | |
| 1021 OP_SeekLT, /* 5: (start_constraints && !startEq && bRev) */ | |
| 1022 OP_SeekGE, /* 6: (start_constraints && startEq && !bRev) */ | |
| 1023 OP_SeekLE /* 7: (start_constraints && startEq && bRev) */ | |
| 1024 }; | |
| 1025 static const u8 aEndOp[] = { | |
| 1026 OP_IdxGE, /* 0: (end_constraints && !bRev && !endEq) */ | |
| 1027 OP_IdxGT, /* 1: (end_constraints && !bRev && endEq) */ | |
| 1028 OP_IdxLE, /* 2: (end_constraints && bRev && !endEq) */ | |
| 1029 OP_IdxLT, /* 3: (end_constraints && bRev && endEq) */ | |
| 1030 }; | |
| 1031 u16 nEq = pLoop->u.btree.nEq; /* Number of == or IN terms */ | |
| 1032 int regBase; /* Base register holding constraint values */ | |
| 1033 WhereTerm *pRangeStart = 0; /* Inequality constraint at range start */ | |
| 1034 WhereTerm *pRangeEnd = 0; /* Inequality constraint at range end */ | |
| 1035 int startEq; /* True if range start uses ==, >= or <= */ | |
| 1036 int endEq; /* True if range end uses ==, >= or <= */ | |
| 1037 int start_constraints; /* Start of range is constrained */ | |
| 1038 int nConstraint; /* Number of constraint terms */ | |
| 1039 Index *pIdx; /* The index we will be using */ | |
| 1040 int iIdxCur; /* The VDBE cursor for the index */ | |
| 1041 int nExtraReg = 0; /* Number of extra registers needed */ | |
| 1042 int op; /* Instruction opcode */ | |
| 1043 char *zStartAff; /* Affinity for start of range constraint */ | |
| 1044 char cEndAff = 0; /* Affinity for end of range constraint */ | |
| 1045 u8 bSeekPastNull = 0; /* True to seek past initial nulls */ | |
| 1046 u8 bStopAtNull = 0; /* Add condition to terminate at NULLs */ | |
| 1047 | |
| 1048 pIdx = pLoop->u.btree.pIndex; | |
| 1049 iIdxCur = pLevel->iIdxCur; | |
| 1050 assert( nEq>=pLoop->nSkip ); | |
| 1051 | |
| 1052 /* If this loop satisfies a sort order (pOrderBy) request that | |
| 1053 ** was passed to this function to implement a "SELECT min(x) ..." | |
| 1054 ** query, then the caller will only allow the loop to run for | |
| 1055 ** a single iteration. This means that the first row returned | |
| 1056 ** should not have a NULL value stored in 'x'. If column 'x' is | |
| 1057 ** the first one after the nEq equality constraints in the index, | |
| 1058 ** this requires some special handling. | |
| 1059 */ | |
| 1060 assert( pWInfo->pOrderBy==0 | |
| 1061 || pWInfo->pOrderBy->nExpr==1 | |
| 1062 || (pWInfo->wctrlFlags&WHERE_ORDERBY_MIN)==0 ); | |
| 1063 if( (pWInfo->wctrlFlags&WHERE_ORDERBY_MIN)!=0 | |
| 1064 && pWInfo->nOBSat>0 | |
| 1065 && (pIdx->nKeyCol>nEq) | |
| 1066 ){ | |
| 1067 assert( pLoop->nSkip==0 ); | |
| 1068 bSeekPastNull = 1; | |
| 1069 nExtraReg = 1; | |
| 1070 } | |
| 1071 | |
| 1072 /* Find any inequality constraint terms for the start and end | |
| 1073 ** of the range. | |
| 1074 */ | |
| 1075 j = nEq; | |
| 1076 if( pLoop->wsFlags & WHERE_BTM_LIMIT ){ | |
| 1077 pRangeStart = pLoop->aLTerm[j++]; | |
| 1078 nExtraReg = 1; | |
| 1079 /* Like optimization range constraints always occur in pairs */ | |
| 1080 assert( (pRangeStart->wtFlags & TERM_LIKEOPT)==0 || | |
| 1081 (pLoop->wsFlags & WHERE_TOP_LIMIT)!=0 ); | |
| 1082 } | |
| 1083 if( pLoop->wsFlags & WHERE_TOP_LIMIT ){ | |
| 1084 pRangeEnd = pLoop->aLTerm[j++]; | |
| 1085 nExtraReg = 1; | |
| 1086 #ifndef SQLITE_LIKE_DOESNT_MATCH_BLOBS | |
| 1087 if( (pRangeEnd->wtFlags & TERM_LIKEOPT)!=0 ){ | |
| 1088 assert( pRangeStart!=0 ); /* LIKE opt constraints */ | |
| 1089 assert( pRangeStart->wtFlags & TERM_LIKEOPT ); /* occur in pairs */ | |
| 1090 pLevel->iLikeRepCntr = ++pParse->nMem; | |
| 1091 testcase( bRev ); | |
| 1092 testcase( pIdx->aSortOrder[nEq]==SQLITE_SO_DESC ); | |
| 1093 sqlite3VdbeAddOp2(v, OP_Integer, | |
| 1094 bRev ^ (pIdx->aSortOrder[nEq]==SQLITE_SO_DESC), | |
| 1095 pLevel->iLikeRepCntr); | |
| 1096 VdbeComment((v, "LIKE loop counter")); | |
| 1097 pLevel->addrLikeRep = sqlite3VdbeCurrentAddr(v); | |
| 1098 } | |
| 1099 #endif | |
| 1100 if( pRangeStart==0 | |
| 1101 && (j = pIdx->aiColumn[nEq])>=0 | |
| 1102 && pIdx->pTable->aCol[j].notNull==0 | |
| 1103 ){ | |
| 1104 bSeekPastNull = 1; | |
| 1105 } | |
| 1106 } | |
| 1107 assert( pRangeEnd==0 || (pRangeEnd->wtFlags & TERM_VNULL)==0 ); | |
| 1108 | |
| 1109 /* If we are doing a reverse order scan on an ascending index, or | |
| 1110 ** a forward order scan on a descending index, interchange the | |
| 1111 ** start and end terms (pRangeStart and pRangeEnd). | |
| 1112 */ | |
| 1113 if( (nEq<pIdx->nKeyCol && bRev==(pIdx->aSortOrder[nEq]==SQLITE_SO_ASC)) | |
| 1114 || (bRev && pIdx->nKeyCol==nEq) | |
| 1115 ){ | |
| 1116 SWAP(WhereTerm *, pRangeEnd, pRangeStart); | |
| 1117 SWAP(u8, bSeekPastNull, bStopAtNull); | |
| 1118 } | |
| 1119 | |
| 1120 /* Generate code to evaluate all constraint terms using == or IN | |
| 1121 ** and store the values of those terms in an array of registers | |
| 1122 ** starting at regBase. | |
| 1123 */ | |
| 1124 codeCursorHint(pWInfo, pLevel, pRangeEnd); | |
| 1125 regBase = codeAllEqualityTerms(pParse,pLevel,bRev,nExtraReg,&zStartAff); | |
| 1126 assert( zStartAff==0 || sqlite3Strlen30(zStartAff)>=nEq ); | |
| 1127 if( zStartAff ) cEndAff = zStartAff[nEq]; | |
| 1128 addrNxt = pLevel->addrNxt; | |
| 1129 | |
| 1130 testcase( pRangeStart && (pRangeStart->eOperator & WO_LE)!=0 ); | |
| 1131 testcase( pRangeStart && (pRangeStart->eOperator & WO_GE)!=0 ); | |
| 1132 testcase( pRangeEnd && (pRangeEnd->eOperator & WO_LE)!=0 ); | |
| 1133 testcase( pRangeEnd && (pRangeEnd->eOperator & WO_GE)!=0 ); | |
| 1134 startEq = !pRangeStart || pRangeStart->eOperator & (WO_LE|WO_GE); | |
| 1135 endEq = !pRangeEnd || pRangeEnd->eOperator & (WO_LE|WO_GE); | |
| 1136 start_constraints = pRangeStart || nEq>0; | |
| 1137 | |
| 1138 /* Seek the index cursor to the start of the range. */ | |
| 1139 nConstraint = nEq; | |
| 1140 if( pRangeStart ){ | |
| 1141 Expr *pRight = pRangeStart->pExpr->pRight; | |
| 1142 sqlite3ExprCode(pParse, pRight, regBase+nEq); | |
| 1143 whereLikeOptimizationStringFixup(v, pLevel, pRangeStart); | |
| 1144 if( (pRangeStart->wtFlags & TERM_VNULL)==0 | |
| 1145 && sqlite3ExprCanBeNull(pRight) | |
| 1146 ){ | |
| 1147 sqlite3VdbeAddOp2(v, OP_IsNull, regBase+nEq, addrNxt); | |
| 1148 VdbeCoverage(v); | |
| 1149 } | |
| 1150 if( zStartAff ){ | |
| 1151 if( sqlite3CompareAffinity(pRight, zStartAff[nEq])==SQLITE_AFF_BLOB){ | |
| 1152 /* Since the comparison is to be performed with no conversions | |
| 1153 ** applied to the operands, set the affinity to apply to pRight to | |
| 1154 ** SQLITE_AFF_BLOB. */ | |
| 1155 zStartAff[nEq] = SQLITE_AFF_BLOB; | |
| 1156 } | |
| 1157 if( sqlite3ExprNeedsNoAffinityChange(pRight, zStartAff[nEq]) ){ | |
| 1158 zStartAff[nEq] = SQLITE_AFF_BLOB; | |
| 1159 } | |
| 1160 } | |
| 1161 nConstraint++; | |
| 1162 testcase( pRangeStart->wtFlags & TERM_VIRTUAL ); | |
| 1163 }else if( bSeekPastNull ){ | |
| 1164 sqlite3VdbeAddOp2(v, OP_Null, 0, regBase+nEq); | |
| 1165 nConstraint++; | |
| 1166 startEq = 0; | |
| 1167 start_constraints = 1; | |
| 1168 } | |
| 1169 codeApplyAffinity(pParse, regBase, nConstraint - bSeekPastNull, zStartAff); | |
| 1170 op = aStartOp[(start_constraints<<2) + (startEq<<1) + bRev]; | |
| 1171 assert( op!=0 ); | |
| 1172 sqlite3VdbeAddOp4Int(v, op, iIdxCur, addrNxt, regBase, nConstraint); | |
| 1173 VdbeCoverage(v); | |
| 1174 VdbeCoverageIf(v, op==OP_Rewind); testcase( op==OP_Rewind ); | |
| 1175 VdbeCoverageIf(v, op==OP_Last); testcase( op==OP_Last ); | |
| 1176 VdbeCoverageIf(v, op==OP_SeekGT); testcase( op==OP_SeekGT ); | |
| 1177 VdbeCoverageIf(v, op==OP_SeekGE); testcase( op==OP_SeekGE ); | |
| 1178 VdbeCoverageIf(v, op==OP_SeekLE); testcase( op==OP_SeekLE ); | |
| 1179 VdbeCoverageIf(v, op==OP_SeekLT); testcase( op==OP_SeekLT ); | |
| 1180 | |
| 1181 /* Load the value for the inequality constraint at the end of the | |
| 1182 ** range (if any). | |
| 1183 */ | |
| 1184 nConstraint = nEq; | |
| 1185 if( pRangeEnd ){ | |
| 1186 Expr *pRight = pRangeEnd->pExpr->pRight; | |
| 1187 sqlite3ExprCacheRemove(pParse, regBase+nEq, 1); | |
| 1188 sqlite3ExprCode(pParse, pRight, regBase+nEq); | |
| 1189 whereLikeOptimizationStringFixup(v, pLevel, pRangeEnd); | |
| 1190 if( (pRangeEnd->wtFlags & TERM_VNULL)==0 | |
| 1191 && sqlite3ExprCanBeNull(pRight) | |
| 1192 ){ | |
| 1193 sqlite3VdbeAddOp2(v, OP_IsNull, regBase+nEq, addrNxt); | |
| 1194 VdbeCoverage(v); | |
| 1195 } | |
| 1196 if( sqlite3CompareAffinity(pRight, cEndAff)!=SQLITE_AFF_BLOB | |
| 1197 && !sqlite3ExprNeedsNoAffinityChange(pRight, cEndAff) | |
| 1198 ){ | |
| 1199 codeApplyAffinity(pParse, regBase+nEq, 1, &cEndAff); | |
| 1200 } | |
| 1201 nConstraint++; | |
| 1202 testcase( pRangeEnd->wtFlags & TERM_VIRTUAL ); | |
| 1203 }else if( bStopAtNull ){ | |
| 1204 sqlite3VdbeAddOp2(v, OP_Null, 0, regBase+nEq); | |
| 1205 endEq = 0; | |
| 1206 nConstraint++; | |
| 1207 } | |
| 1208 sqlite3DbFree(db, zStartAff); | |
| 1209 | |
| 1210 /* Top of the loop body */ | |
| 1211 pLevel->p2 = sqlite3VdbeCurrentAddr(v); | |
| 1212 | |
| 1213 /* Check if the index cursor is past the end of the range. */ | |
| 1214 if( nConstraint ){ | |
| 1215 op = aEndOp[bRev*2 + endEq]; | |
| 1216 sqlite3VdbeAddOp4Int(v, op, iIdxCur, addrNxt, regBase, nConstraint); | |
| 1217 testcase( op==OP_IdxGT ); VdbeCoverageIf(v, op==OP_IdxGT ); | |
| 1218 testcase( op==OP_IdxGE ); VdbeCoverageIf(v, op==OP_IdxGE ); | |
| 1219 testcase( op==OP_IdxLT ); VdbeCoverageIf(v, op==OP_IdxLT ); | |
| 1220 testcase( op==OP_IdxLE ); VdbeCoverageIf(v, op==OP_IdxLE ); | |
| 1221 } | |
| 1222 | |
| 1223 /* Seek the table cursor, if required */ | |
| 1224 disableTerm(pLevel, pRangeStart); | |
| 1225 disableTerm(pLevel, pRangeEnd); | |
| 1226 if( omitTable ){ | |
| 1227 /* pIdx is a covering index. No need to access the main table. */ | |
| 1228 }else if( HasRowid(pIdx->pTable) ){ | |
| 1229 iRowidReg = ++pParse->nMem; | |
| 1230 sqlite3VdbeAddOp2(v, OP_IdxRowid, iIdxCur, iRowidReg); | |
| 1231 sqlite3ExprCacheStore(pParse, iCur, -1, iRowidReg); | |
| 1232 if( pWInfo->eOnePass!=ONEPASS_OFF ){ | |
| 1233 sqlite3VdbeAddOp3(v, OP_NotExists, iCur, 0, iRowidReg); | |
| 1234 VdbeCoverage(v); | |
| 1235 }else{ | |
| 1236 sqlite3VdbeAddOp2(v, OP_Seek, iCur, iRowidReg); /* Deferred seek */ | |
| 1237 } | |
| 1238 }else if( iCur!=iIdxCur ){ | |
| 1239 Index *pPk = sqlite3PrimaryKeyIndex(pIdx->pTable); | |
| 1240 iRowidReg = sqlite3GetTempRange(pParse, pPk->nKeyCol); | |
| 1241 for(j=0; j<pPk->nKeyCol; j++){ | |
| 1242 k = sqlite3ColumnOfIndex(pIdx, pPk->aiColumn[j]); | |
| 1243 sqlite3VdbeAddOp3(v, OP_Column, iIdxCur, k, iRowidReg+j); | |
| 1244 } | |
| 1245 sqlite3VdbeAddOp4Int(v, OP_NotFound, iCur, addrCont, | |
| 1246 iRowidReg, pPk->nKeyCol); VdbeCoverage(v); | |
| 1247 } | |
| 1248 | |
| 1249 /* Record the instruction used to terminate the loop. Disable | |
| 1250 ** WHERE clause terms made redundant by the index range scan. | |
| 1251 */ | |
| 1252 if( pLoop->wsFlags & WHERE_ONEROW ){ | |
| 1253 pLevel->op = OP_Noop; | |
| 1254 }else if( bRev ){ | |
| 1255 pLevel->op = OP_Prev; | |
| 1256 }else{ | |
| 1257 pLevel->op = OP_Next; | |
| 1258 } | |
| 1259 pLevel->p1 = iIdxCur; | |
| 1260 pLevel->p3 = (pLoop->wsFlags&WHERE_UNQ_WANTED)!=0 ? 1:0; | |
| 1261 if( (pLoop->wsFlags & WHERE_CONSTRAINT)==0 ){ | |
| 1262 pLevel->p5 = SQLITE_STMTSTATUS_FULLSCAN_STEP; | |
| 1263 }else{ | |
| 1264 assert( pLevel->p5==0 ); | |
| 1265 } | |
| 1266 }else | |
| 1267 | |
| 1268 #ifndef SQLITE_OMIT_OR_OPTIMIZATION | |
| 1269 if( pLoop->wsFlags & WHERE_MULTI_OR ){ | |
| 1270 /* Case 5: Two or more separately indexed terms connected by OR | |
| 1271 ** | |
| 1272 ** Example: | |
| 1273 ** | |
| 1274 ** CREATE TABLE t1(a,b,c,d); | |
| 1275 ** CREATE INDEX i1 ON t1(a); | |
| 1276 ** CREATE INDEX i2 ON t1(b); | |
| 1277 ** CREATE INDEX i3 ON t1(c); | |
| 1278 ** | |
| 1279 ** SELECT * FROM t1 WHERE a=5 OR b=7 OR (c=11 AND d=13) | |
| 1280 ** | |
| 1281 ** In the example, there are three indexed terms connected by OR. | |
| 1282 ** The top of the loop looks like this: | |
| 1283 ** | |
| 1284 ** Null 1 # Zero the rowset in reg 1 | |
| 1285 ** | |
| 1286 ** Then, for each indexed term, the following. The arguments to | |
| 1287 ** RowSetTest are such that the rowid of the current row is inserted | |
| 1288 ** into the RowSet. If it is already present, control skips the | |
| 1289 ** Gosub opcode and jumps straight to the code generated by WhereEnd(). | |
| 1290 ** | |
| 1291 ** sqlite3WhereBegin(<term>) | |
| 1292 ** RowSetTest # Insert rowid into rowset | |
| 1293 ** Gosub 2 A | |
| 1294 ** sqlite3WhereEnd() | |
| 1295 ** | |
| 1296 ** Following the above, code to terminate the loop. Label A, the target | |
| 1297 ** of the Gosub above, jumps to the instruction right after the Goto. | |
| 1298 ** | |
| 1299 ** Null 1 # Zero the rowset in reg 1 | |
| 1300 ** Goto B # The loop is finished. | |
| 1301 ** | |
| 1302 ** A: <loop body> # Return data, whatever. | |
| 1303 ** | |
| 1304 ** Return 2 # Jump back to the Gosub | |
| 1305 ** | |
| 1306 ** B: <after the loop> | |
| 1307 ** | |
| 1308 ** Added 2014-05-26: If the table is a WITHOUT ROWID table, then | |
| 1309 ** use an ephemeral index instead of a RowSet to record the primary | |
| 1310 ** keys of the rows we have already seen. | |
| 1311 ** | |
| 1312 */ | |
| 1313 WhereClause *pOrWc; /* The OR-clause broken out into subterms */ | |
| 1314 SrcList *pOrTab; /* Shortened table list or OR-clause generation */ | |
| 1315 Index *pCov = 0; /* Potential covering index (or NULL) */ | |
| 1316 int iCovCur = pParse->nTab++; /* Cursor used for index scans (if any) */ | |
| 1317 | |
| 1318 int regReturn = ++pParse->nMem; /* Register used with OP_Gosub */ | |
| 1319 int regRowset = 0; /* Register for RowSet object */ | |
| 1320 int regRowid = 0; /* Register holding rowid */ | |
| 1321 int iLoopBody = sqlite3VdbeMakeLabel(v); /* Start of loop body */ | |
| 1322 int iRetInit; /* Address of regReturn init */ | |
| 1323 int untestedTerms = 0; /* Some terms not completely tested */ | |
| 1324 int ii; /* Loop counter */ | |
| 1325 u16 wctrlFlags; /* Flags for sub-WHERE clause */ | |
| 1326 Expr *pAndExpr = 0; /* An ".. AND (...)" expression */ | |
| 1327 Table *pTab = pTabItem->pTab; | |
| 1328 | |
| 1329 pTerm = pLoop->aLTerm[0]; | |
| 1330 assert( pTerm!=0 ); | |
| 1331 assert( pTerm->eOperator & WO_OR ); | |
| 1332 assert( (pTerm->wtFlags & TERM_ORINFO)!=0 ); | |
| 1333 pOrWc = &pTerm->u.pOrInfo->wc; | |
| 1334 pLevel->op = OP_Return; | |
| 1335 pLevel->p1 = regReturn; | |
| 1336 | |
| 1337 /* Set up a new SrcList in pOrTab containing the table being scanned | |
| 1338 ** by this loop in the a[0] slot and all notReady tables in a[1..] slots. | |
| 1339 ** This becomes the SrcList in the recursive call to sqlite3WhereBegin(). | |
| 1340 */ | |
| 1341 if( pWInfo->nLevel>1 ){ | |
| 1342 int nNotReady; /* The number of notReady tables */ | |
| 1343 struct SrcList_item *origSrc; /* Original list of tables */ | |
| 1344 nNotReady = pWInfo->nLevel - iLevel - 1; | |
| 1345 pOrTab = sqlite3StackAllocRaw(db, | |
| 1346 sizeof(*pOrTab)+ nNotReady*sizeof(pOrTab->a[0])); | |
| 1347 if( pOrTab==0 ) return notReady; | |
| 1348 pOrTab->nAlloc = (u8)(nNotReady + 1); | |
| 1349 pOrTab->nSrc = pOrTab->nAlloc; | |
| 1350 memcpy(pOrTab->a, pTabItem, sizeof(*pTabItem)); | |
| 1351 origSrc = pWInfo->pTabList->a; | |
| 1352 for(k=1; k<=nNotReady; k++){ | |
| 1353 memcpy(&pOrTab->a[k], &origSrc[pLevel[k].iFrom], sizeof(pOrTab->a[k])); | |
| 1354 } | |
| 1355 }else{ | |
| 1356 pOrTab = pWInfo->pTabList; | |
| 1357 } | |
| 1358 | |
| 1359 /* Initialize the rowset register to contain NULL. An SQL NULL is | |
| 1360 ** equivalent to an empty rowset. Or, create an ephemeral index | |
| 1361 ** capable of holding primary keys in the case of a WITHOUT ROWID. | |
| 1362 ** | |
| 1363 ** Also initialize regReturn to contain the address of the instruction | |
| 1364 ** immediately following the OP_Return at the bottom of the loop. This | |
| 1365 ** is required in a few obscure LEFT JOIN cases where control jumps | |
| 1366 ** over the top of the loop into the body of it. In this case the | |
| 1367 ** correct response for the end-of-loop code (the OP_Return) is to | |
| 1368 ** fall through to the next instruction, just as an OP_Next does if | |
| 1369 ** called on an uninitialized cursor. | |
| 1370 */ | |
| 1371 if( (pWInfo->wctrlFlags & WHERE_DUPLICATES_OK)==0 ){ | |
| 1372 if( HasRowid(pTab) ){ | |
| 1373 regRowset = ++pParse->nMem; | |
| 1374 sqlite3VdbeAddOp2(v, OP_Null, 0, regRowset); | |
| 1375 }else{ | |
| 1376 Index *pPk = sqlite3PrimaryKeyIndex(pTab); | |
| 1377 regRowset = pParse->nTab++; | |
| 1378 sqlite3VdbeAddOp2(v, OP_OpenEphemeral, regRowset, pPk->nKeyCol); | |
| 1379 sqlite3VdbeSetP4KeyInfo(pParse, pPk); | |
| 1380 } | |
| 1381 regRowid = ++pParse->nMem; | |
| 1382 } | |
| 1383 iRetInit = sqlite3VdbeAddOp2(v, OP_Integer, 0, regReturn); | |
| 1384 | |
| 1385 /* If the original WHERE clause is z of the form: (x1 OR x2 OR ...) AND y | |
| 1386 ** Then for every term xN, evaluate as the subexpression: xN AND z | |
| 1387 ** That way, terms in y that are factored into the disjunction will | |
| 1388 ** be picked up by the recursive calls to sqlite3WhereBegin() below. | |
| 1389 ** | |
| 1390 ** Actually, each subexpression is converted to "xN AND w" where w is | |
| 1391 ** the "interesting" terms of z - terms that did not originate in the | |
| 1392 ** ON or USING clause of a LEFT JOIN, and terms that are usable as | |
| 1393 ** indices. | |
| 1394 ** | |
| 1395 ** This optimization also only applies if the (x1 OR x2 OR ...) term | |
| 1396 ** is not contained in the ON clause of a LEFT JOIN. | |
| 1397 ** See ticket http://www.sqlite.org/src/info/f2369304e4 | |
| 1398 */ | |
| 1399 if( pWC->nTerm>1 ){ | |
| 1400 int iTerm; | |
| 1401 for(iTerm=0; iTerm<pWC->nTerm; iTerm++){ | |
| 1402 Expr *pExpr = pWC->a[iTerm].pExpr; | |
| 1403 if( &pWC->a[iTerm] == pTerm ) continue; | |
| 1404 if( ExprHasProperty(pExpr, EP_FromJoin) ) continue; | |
| 1405 if( (pWC->a[iTerm].wtFlags & TERM_VIRTUAL)!=0 ) continue; | |
| 1406 if( (pWC->a[iTerm].eOperator & WO_ALL)==0 ) continue; | |
| 1407 testcase( pWC->a[iTerm].wtFlags & TERM_ORINFO ); | |
| 1408 pExpr = sqlite3ExprDup(db, pExpr, 0); | |
| 1409 pAndExpr = sqlite3ExprAnd(db, pAndExpr, pExpr); | |
| 1410 } | |
| 1411 if( pAndExpr ){ | |
| 1412 pAndExpr = sqlite3PExpr(pParse, TK_AND|TKFLG_DONTFOLD, 0, pAndExpr, 0); | |
| 1413 } | |
| 1414 } | |
| 1415 | |
| 1416 /* Run a separate WHERE clause for each term of the OR clause. After | |
| 1417 ** eliminating duplicates from other WHERE clauses, the action for each | |
| 1418 ** sub-WHERE clause is to to invoke the main loop body as a subroutine. | |
| 1419 */ | |
| 1420 wctrlFlags = WHERE_OMIT_OPEN_CLOSE | |
| 1421 | WHERE_FORCE_TABLE | |
| 1422 | WHERE_ONETABLE_ONLY | |
| 1423 | WHERE_NO_AUTOINDEX; | |
| 1424 for(ii=0; ii<pOrWc->nTerm; ii++){ | |
| 1425 WhereTerm *pOrTerm = &pOrWc->a[ii]; | |
| 1426 if( pOrTerm->leftCursor==iCur || (pOrTerm->eOperator & WO_AND)!=0 ){ | |
| 1427 WhereInfo *pSubWInfo; /* Info for single OR-term scan */ | |
| 1428 Expr *pOrExpr = pOrTerm->pExpr; /* Current OR clause term */ | |
| 1429 int jmp1 = 0; /* Address of jump operation */ | |
| 1430 if( pAndExpr && !ExprHasProperty(pOrExpr, EP_FromJoin) ){ | |
| 1431 pAndExpr->pLeft = pOrExpr; | |
| 1432 pOrExpr = pAndExpr; | |
| 1433 } | |
| 1434 /* Loop through table entries that match term pOrTerm. */ | |
| 1435 WHERETRACE(0xffff, ("Subplan for OR-clause:\n")); | |
| 1436 pSubWInfo = sqlite3WhereBegin(pParse, pOrTab, pOrExpr, 0, 0, | |
| 1437 wctrlFlags, iCovCur); | |
| 1438 assert( pSubWInfo || pParse->nErr || db->mallocFailed ); | |
| 1439 if( pSubWInfo ){ | |
| 1440 WhereLoop *pSubLoop; | |
| 1441 int addrExplain = sqlite3WhereExplainOneScan( | |
| 1442 pParse, pOrTab, &pSubWInfo->a[0], iLevel, pLevel->iFrom, 0 | |
| 1443 ); | |
| 1444 sqlite3WhereAddScanStatus(v, pOrTab, &pSubWInfo->a[0], addrExplain); | |
| 1445 | |
| 1446 /* This is the sub-WHERE clause body. First skip over | |
| 1447 ** duplicate rows from prior sub-WHERE clauses, and record the | |
| 1448 ** rowid (or PRIMARY KEY) for the current row so that the same | |
| 1449 ** row will be skipped in subsequent sub-WHERE clauses. | |
| 1450 */ | |
| 1451 if( (pWInfo->wctrlFlags & WHERE_DUPLICATES_OK)==0 ){ | |
| 1452 int r; | |
| 1453 int iSet = ((ii==pOrWc->nTerm-1)?-1:ii); | |
| 1454 if( HasRowid(pTab) ){ | |
| 1455 r = sqlite3ExprCodeGetColumn(pParse, pTab, -1, iCur, regRowid, 0); | |
| 1456 jmp1 = sqlite3VdbeAddOp4Int(v, OP_RowSetTest, regRowset, 0, | |
| 1457 r,iSet); | |
| 1458 VdbeCoverage(v); | |
| 1459 }else{ | |
| 1460 Index *pPk = sqlite3PrimaryKeyIndex(pTab); | |
| 1461 int nPk = pPk->nKeyCol; | |
| 1462 int iPk; | |
| 1463 | |
| 1464 /* Read the PK into an array of temp registers. */ | |
| 1465 r = sqlite3GetTempRange(pParse, nPk); | |
| 1466 for(iPk=0; iPk<nPk; iPk++){ | |
| 1467 int iCol = pPk->aiColumn[iPk]; | |
| 1468 sqlite3ExprCodeGetColumnToReg(pParse, pTab, iCol, iCur, r+iPk); | |
| 1469 } | |
| 1470 | |
| 1471 /* Check if the temp table already contains this key. If so, | |
| 1472 ** the row has already been included in the result set and | |
| 1473 ** can be ignored (by jumping past the Gosub below). Otherwise, | |
| 1474 ** insert the key into the temp table and proceed with processing | |
| 1475 ** the row. | |
| 1476 ** | |
| 1477 ** Use some of the same optimizations as OP_RowSetTest: If iSet | |
| 1478 ** is zero, assume that the key cannot already be present in | |
| 1479 ** the temp table. And if iSet is -1, assume that there is no | |
| 1480 ** need to insert the key into the temp table, as it will never | |
| 1481 ** be tested for. */ | |
| 1482 if( iSet ){ | |
| 1483 jmp1 = sqlite3VdbeAddOp4Int(v, OP_Found, regRowset, 0, r, nPk); | |
| 1484 VdbeCoverage(v); | |
| 1485 } | |
| 1486 if( iSet>=0 ){ | |
| 1487 sqlite3VdbeAddOp3(v, OP_MakeRecord, r, nPk, regRowid); | |
| 1488 sqlite3VdbeAddOp3(v, OP_IdxInsert, regRowset, regRowid, 0); | |
| 1489 if( iSet ) sqlite3VdbeChangeP5(v, OPFLAG_USESEEKRESULT); | |
| 1490 } | |
| 1491 | |
| 1492 /* Release the array of temp registers */ | |
| 1493 sqlite3ReleaseTempRange(pParse, r, nPk); | |
| 1494 } | |
| 1495 } | |
| 1496 | |
| 1497 /* Invoke the main loop body as a subroutine */ | |
| 1498 sqlite3VdbeAddOp2(v, OP_Gosub, regReturn, iLoopBody); | |
| 1499 | |
| 1500 /* Jump here (skipping the main loop body subroutine) if the | |
| 1501 ** current sub-WHERE row is a duplicate from prior sub-WHEREs. */ | |
| 1502 if( jmp1 ) sqlite3VdbeJumpHere(v, jmp1); | |
| 1503 | |
| 1504 /* The pSubWInfo->untestedTerms flag means that this OR term | |
| 1505 ** contained one or more AND term from a notReady table. The | |
| 1506 ** terms from the notReady table could not be tested and will | |
| 1507 ** need to be tested later. | |
| 1508 */ | |
| 1509 if( pSubWInfo->untestedTerms ) untestedTerms = 1; | |
| 1510 | |
| 1511 /* If all of the OR-connected terms are optimized using the same | |
| 1512 ** index, and the index is opened using the same cursor number | |
| 1513 ** by each call to sqlite3WhereBegin() made by this loop, it may | |
| 1514 ** be possible to use that index as a covering index. | |
| 1515 ** | |
| 1516 ** If the call to sqlite3WhereBegin() above resulted in a scan that | |
| 1517 ** uses an index, and this is either the first OR-connected term | |
| 1518 ** processed or the index is the same as that used by all previous | |
| 1519 ** terms, set pCov to the candidate covering index. Otherwise, set | |
| 1520 ** pCov to NULL to indicate that no candidate covering index will | |
| 1521 ** be available. | |
| 1522 */ | |
| 1523 pSubLoop = pSubWInfo->a[0].pWLoop; | |
| 1524 assert( (pSubLoop->wsFlags & WHERE_AUTO_INDEX)==0 ); | |
| 1525 if( (pSubLoop->wsFlags & WHERE_INDEXED)!=0 | |
| 1526 && (ii==0 || pSubLoop->u.btree.pIndex==pCov) | |
| 1527 && (HasRowid(pTab) || !IsPrimaryKeyIndex(pSubLoop->u.btree.pIndex)) | |
| 1528 ){ | |
| 1529 assert( pSubWInfo->a[0].iIdxCur==iCovCur ); | |
| 1530 pCov = pSubLoop->u.btree.pIndex; | |
| 1531 wctrlFlags |= WHERE_REOPEN_IDX; | |
| 1532 }else{ | |
| 1533 pCov = 0; | |
| 1534 } | |
| 1535 | |
| 1536 /* Finish the loop through table entries that match term pOrTerm. */ | |
| 1537 sqlite3WhereEnd(pSubWInfo); | |
| 1538 } | |
| 1539 } | |
| 1540 } | |
| 1541 pLevel->u.pCovidx = pCov; | |
| 1542 if( pCov ) pLevel->iIdxCur = iCovCur; | |
| 1543 if( pAndExpr ){ | |
| 1544 pAndExpr->pLeft = 0; | |
| 1545 sqlite3ExprDelete(db, pAndExpr); | |
| 1546 } | |
| 1547 sqlite3VdbeChangeP1(v, iRetInit, sqlite3VdbeCurrentAddr(v)); | |
| 1548 sqlite3VdbeGoto(v, pLevel->addrBrk); | |
| 1549 sqlite3VdbeResolveLabel(v, iLoopBody); | |
| 1550 | |
| 1551 if( pWInfo->nLevel>1 ) sqlite3StackFree(db, pOrTab); | |
| 1552 if( !untestedTerms ) disableTerm(pLevel, pTerm); | |
| 1553 }else | |
| 1554 #endif /* SQLITE_OMIT_OR_OPTIMIZATION */ | |
| 1555 | |
| 1556 { | |
| 1557 /* Case 6: There is no usable index. We must do a complete | |
| 1558 ** scan of the entire table. | |
| 1559 */ | |
| 1560 static const u8 aStep[] = { OP_Next, OP_Prev }; | |
| 1561 static const u8 aStart[] = { OP_Rewind, OP_Last }; | |
| 1562 assert( bRev==0 || bRev==1 ); | |
| 1563 if( pTabItem->fg.isRecursive ){ | |
| 1564 /* Tables marked isRecursive have only a single row that is stored in | |
| 1565 ** a pseudo-cursor. No need to Rewind or Next such cursors. */ | |
| 1566 pLevel->op = OP_Noop; | |
| 1567 }else{ | |
| 1568 codeCursorHint(pWInfo, pLevel, 0); | |
| 1569 pLevel->op = aStep[bRev]; | |
| 1570 pLevel->p1 = iCur; | |
| 1571 pLevel->p2 = 1 + sqlite3VdbeAddOp2(v, aStart[bRev], iCur, addrBrk); | |
| 1572 VdbeCoverageIf(v, bRev==0); | |
| 1573 VdbeCoverageIf(v, bRev!=0); | |
| 1574 pLevel->p5 = SQLITE_STMTSTATUS_FULLSCAN_STEP; | |
| 1575 } | |
| 1576 } | |
| 1577 | |
| 1578 #ifdef SQLITE_ENABLE_STMT_SCANSTATUS | |
| 1579 pLevel->addrVisit = sqlite3VdbeCurrentAddr(v); | |
| 1580 #endif | |
| 1581 | |
| 1582 /* Insert code to test every subexpression that can be completely | |
| 1583 ** computed using the current set of tables. | |
| 1584 */ | |
| 1585 for(pTerm=pWC->a, j=pWC->nTerm; j>0; j--, pTerm++){ | |
| 1586 Expr *pE; | |
| 1587 int skipLikeAddr = 0; | |
| 1588 testcase( pTerm->wtFlags & TERM_VIRTUAL ); | |
| 1589 testcase( pTerm->wtFlags & TERM_CODED ); | |
| 1590 if( pTerm->wtFlags & (TERM_VIRTUAL|TERM_CODED) ) continue; | |
| 1591 if( (pTerm->prereqAll & pLevel->notReady)!=0 ){ | |
| 1592 testcase( pWInfo->untestedTerms==0 | |
| 1593 && (pWInfo->wctrlFlags & WHERE_ONETABLE_ONLY)!=0 ); | |
| 1594 pWInfo->untestedTerms = 1; | |
| 1595 continue; | |
| 1596 } | |
| 1597 pE = pTerm->pExpr; | |
| 1598 assert( pE!=0 ); | |
| 1599 if( pLevel->iLeftJoin && !ExprHasProperty(pE, EP_FromJoin) ){ | |
| 1600 continue; | |
| 1601 } | |
| 1602 if( pTerm->wtFlags & TERM_LIKECOND ){ | |
| 1603 #ifdef SQLITE_LIKE_DOESNT_MATCH_BLOBS | |
| 1604 continue; | |
| 1605 #else | |
| 1606 assert( pLevel->iLikeRepCntr>0 ); | |
| 1607 skipLikeAddr = sqlite3VdbeAddOp1(v, OP_IfNot, pLevel->iLikeRepCntr); | |
| 1608 VdbeCoverage(v); | |
| 1609 #endif | |
| 1610 } | |
| 1611 sqlite3ExprIfFalse(pParse, pE, addrCont, SQLITE_JUMPIFNULL); | |
| 1612 if( skipLikeAddr ) sqlite3VdbeJumpHere(v, skipLikeAddr); | |
| 1613 pTerm->wtFlags |= TERM_CODED; | |
| 1614 } | |
| 1615 | |
| 1616 /* Insert code to test for implied constraints based on transitivity | |
| 1617 ** of the "==" operator. | |
| 1618 ** | |
| 1619 ** Example: If the WHERE clause contains "t1.a=t2.b" and "t2.b=123" | |
| 1620 ** and we are coding the t1 loop and the t2 loop has not yet coded, | |
| 1621 ** then we cannot use the "t1.a=t2.b" constraint, but we can code | |
| 1622 ** the implied "t1.a=123" constraint. | |
| 1623 */ | |
| 1624 for(pTerm=pWC->a, j=pWC->nTerm; j>0; j--, pTerm++){ | |
| 1625 Expr *pE, *pEAlt; | |
| 1626 WhereTerm *pAlt; | |
| 1627 if( pTerm->wtFlags & (TERM_VIRTUAL|TERM_CODED) ) continue; | |
| 1628 if( (pTerm->eOperator & (WO_EQ|WO_IS))==0 ) continue; | |
| 1629 if( (pTerm->eOperator & WO_EQUIV)==0 ) continue; | |
| 1630 if( pTerm->leftCursor!=iCur ) continue; | |
| 1631 if( pLevel->iLeftJoin ) continue; | |
| 1632 pE = pTerm->pExpr; | |
| 1633 assert( !ExprHasProperty(pE, EP_FromJoin) ); | |
| 1634 assert( (pTerm->prereqRight & pLevel->notReady)!=0 ); | |
| 1635 pAlt = sqlite3WhereFindTerm(pWC, iCur, pTerm->u.leftColumn, notReady, | |
| 1636 WO_EQ|WO_IN|WO_IS, 0); | |
| 1637 if( pAlt==0 ) continue; | |
| 1638 if( pAlt->wtFlags & (TERM_CODED) ) continue; | |
| 1639 testcase( pAlt->eOperator & WO_EQ ); | |
| 1640 testcase( pAlt->eOperator & WO_IS ); | |
| 1641 testcase( pAlt->eOperator & WO_IN ); | |
| 1642 VdbeModuleComment((v, "begin transitive constraint")); | |
| 1643 pEAlt = sqlite3StackAllocRaw(db, sizeof(*pEAlt)); | |
| 1644 if( pEAlt ){ | |
| 1645 *pEAlt = *pAlt->pExpr; | |
| 1646 pEAlt->pLeft = pE->pLeft; | |
| 1647 sqlite3ExprIfFalse(pParse, pEAlt, addrCont, SQLITE_JUMPIFNULL); | |
| 1648 sqlite3StackFree(db, pEAlt); | |
| 1649 } | |
| 1650 } | |
| 1651 | |
| 1652 /* For a LEFT OUTER JOIN, generate code that will record the fact that | |
| 1653 ** at least one row of the right table has matched the left table. | |
| 1654 */ | |
| 1655 if( pLevel->iLeftJoin ){ | |
| 1656 pLevel->addrFirst = sqlite3VdbeCurrentAddr(v); | |
| 1657 sqlite3VdbeAddOp2(v, OP_Integer, 1, pLevel->iLeftJoin); | |
| 1658 VdbeComment((v, "record LEFT JOIN hit")); | |
| 1659 sqlite3ExprCacheClear(pParse); | |
| 1660 for(pTerm=pWC->a, j=0; j<pWC->nTerm; j++, pTerm++){ | |
| 1661 testcase( pTerm->wtFlags & TERM_VIRTUAL ); | |
| 1662 testcase( pTerm->wtFlags & TERM_CODED ); | |
| 1663 if( pTerm->wtFlags & (TERM_VIRTUAL|TERM_CODED) ) continue; | |
| 1664 if( (pTerm->prereqAll & pLevel->notReady)!=0 ){ | |
| 1665 assert( pWInfo->untestedTerms ); | |
| 1666 continue; | |
| 1667 } | |
| 1668 assert( pTerm->pExpr ); | |
| 1669 sqlite3ExprIfFalse(pParse, pTerm->pExpr, addrCont, SQLITE_JUMPIFNULL); | |
| 1670 pTerm->wtFlags |= TERM_CODED; | |
| 1671 } | |
| 1672 } | |
| 1673 | |
| 1674 return pLevel->notReady; | |
| 1675 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2846743003:
[sql] Remove SQLite 3.10.2 reference directory. (Closed)
