| OLD | NEW |
|---|
| (Empty) |
| 1 /* | |
| 2 ** 2013-11-12 | |
| 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 ** | |
| 13 ** This file contains structure and macro definitions for the query | |
| 14 ** planner logic in "where.c". These definitions are broken out into | |
| 15 ** a separate source file for easier editing. | |
| 16 */ | |
| 17 | |
| 18 /* | |
| 19 ** Trace output macros | |
| 20 */ | |
| 21 #if defined(SQLITE_TEST) || defined(SQLITE_DEBUG) | |
| 22 /***/ int sqlite3WhereTrace; | |
| 23 #endif | |
| 24 #if defined(SQLITE_DEBUG) \ | |
| 25 && (defined(SQLITE_TEST) || defined(SQLITE_ENABLE_WHERETRACE)) | |
| 26 # define WHERETRACE(K,X) if(sqlite3WhereTrace&(K)) sqlite3DebugPrintf X | |
| 27 # define WHERETRACE_ENABLED 1 | |
| 28 #else | |
| 29 # define WHERETRACE(K,X) | |
| 30 #endif | |
| 31 | |
| 32 /* Forward references | |
| 33 */ | |
| 34 typedef struct WhereClause WhereClause; | |
| 35 typedef struct WhereMaskSet WhereMaskSet; | |
| 36 typedef struct WhereOrInfo WhereOrInfo; | |
| 37 typedef struct WhereAndInfo WhereAndInfo; | |
| 38 typedef struct WhereLevel WhereLevel; | |
| 39 typedef struct WhereLoop WhereLoop; | |
| 40 typedef struct WherePath WherePath; | |
| 41 typedef struct WhereTerm WhereTerm; | |
| 42 typedef struct WhereLoopBuilder WhereLoopBuilder; | |
| 43 typedef struct WhereScan WhereScan; | |
| 44 typedef struct WhereOrCost WhereOrCost; | |
| 45 typedef struct WhereOrSet WhereOrSet; | |
| 46 | |
| 47 /* | |
| 48 ** This object contains information needed to implement a single nested | |
| 49 ** loop in WHERE clause. | |
| 50 ** | |
| 51 ** Contrast this object with WhereLoop. This object describes the | |
| 52 ** implementation of the loop. WhereLoop describes the algorithm. | |
| 53 ** This object contains a pointer to the WhereLoop algorithm as one of | |
| 54 ** its elements. | |
| 55 ** | |
| 56 ** The WhereInfo object contains a single instance of this object for | |
| 57 ** each term in the FROM clause (which is to say, for each of the | |
| 58 ** nested loops as implemented). The order of WhereLevel objects determines | |
| 59 ** the loop nested order, with WhereInfo.a[0] being the outer loop and | |
| 60 ** WhereInfo.a[WhereInfo.nLevel-1] being the inner loop. | |
| 61 */ | |
| 62 struct WhereLevel { | |
| 63 int iLeftJoin; /* Memory cell used to implement LEFT OUTER JOIN */ | |
| 64 int iTabCur; /* The VDBE cursor used to access the table */ | |
| 65 int iIdxCur; /* The VDBE cursor used to access pIdx */ | |
| 66 int addrBrk; /* Jump here to break out of the loop */ | |
| 67 int addrNxt; /* Jump here to start the next IN combination */ | |
| 68 int addrSkip; /* Jump here for next iteration of skip-scan */ | |
| 69 int addrCont; /* Jump here to continue with the next loop cycle */ | |
| 70 int addrFirst; /* First instruction of interior of the loop */ | |
| 71 int addrBody; /* Beginning of the body of this loop */ | |
| 72 #ifndef SQLITE_LIKE_DOESNT_MATCH_BLOBS | |
| 73 int iLikeRepCntr; /* LIKE range processing counter register */ | |
| 74 int addrLikeRep; /* LIKE range processing address */ | |
| 75 #endif | |
| 76 u8 iFrom; /* Which entry in the FROM clause */ | |
| 77 u8 op, p3, p5; /* Opcode, P3 & P5 of the opcode that ends the loop */ | |
| 78 int p1, p2; /* Operands of the opcode used to ends the loop */ | |
| 79 union { /* Information that depends on pWLoop->wsFlags */ | |
| 80 struct { | |
| 81 int nIn; /* Number of entries in aInLoop[] */ | |
| 82 struct InLoop { | |
| 83 int iCur; /* The VDBE cursor used by this IN operator */ | |
| 84 int addrInTop; /* Top of the IN loop */ | |
| 85 u8 eEndLoopOp; /* IN Loop terminator. OP_Next or OP_Prev */ | |
| 86 } *aInLoop; /* Information about each nested IN operator */ | |
| 87 } in; /* Used when pWLoop->wsFlags&WHERE_IN_ABLE */ | |
| 88 Index *pCovidx; /* Possible covering index for WHERE_MULTI_OR */ | |
| 89 } u; | |
| 90 struct WhereLoop *pWLoop; /* The selected WhereLoop object */ | |
| 91 Bitmask notReady; /* FROM entries not usable at this level */ | |
| 92 #ifdef SQLITE_ENABLE_STMT_SCANSTATUS | |
| 93 int addrVisit; /* Address at which row is visited */ | |
| 94 #endif | |
| 95 }; | |
| 96 | |
| 97 /* | |
| 98 ** Each instance of this object represents an algorithm for evaluating one | |
| 99 ** term of a join. Every term of the FROM clause will have at least | |
| 100 ** one corresponding WhereLoop object (unless INDEXED BY constraints | |
| 101 ** prevent a query solution - which is an error) and many terms of the | |
| 102 ** FROM clause will have multiple WhereLoop objects, each describing a | |
| 103 ** potential way of implementing that FROM-clause term, together with | |
| 104 ** dependencies and cost estimates for using the chosen algorithm. | |
| 105 ** | |
| 106 ** Query planning consists of building up a collection of these WhereLoop | |
| 107 ** objects, then computing a particular sequence of WhereLoop objects, with | |
| 108 ** one WhereLoop object per FROM clause term, that satisfy all dependencies | |
| 109 ** and that minimize the overall cost. | |
| 110 */ | |
| 111 struct WhereLoop { | |
| 112 Bitmask prereq; /* Bitmask of other loops that must run first */ | |
| 113 Bitmask maskSelf; /* Bitmask identifying table iTab */ | |
| 114 #ifdef SQLITE_DEBUG | |
| 115 char cId; /* Symbolic ID of this loop for debugging use */ | |
| 116 #endif | |
| 117 u8 iTab; /* Position in FROM clause of table for this loop */ | |
| 118 u8 iSortIdx; /* Sorting index number. 0==None */ | |
| 119 LogEst rSetup; /* One-time setup cost (ex: create transient index) */ | |
| 120 LogEst rRun; /* Cost of running each loop */ | |
| 121 LogEst nOut; /* Estimated number of output rows */ | |
| 122 union { | |
| 123 struct { /* Information for internal btree tables */ | |
| 124 u16 nEq; /* Number of equality constraints */ | |
| 125 Index *pIndex; /* Index used, or NULL */ | |
| 126 } btree; | |
| 127 struct { /* Information for virtual tables */ | |
| 128 int idxNum; /* Index number */ | |
| 129 u8 needFree; /* True if sqlite3_free(idxStr) is needed */ | |
| 130 i8 isOrdered; /* True if satisfies ORDER BY */ | |
| 131 u16 omitMask; /* Terms that may be omitted */ | |
| 132 char *idxStr; /* Index identifier string */ | |
| 133 } vtab; | |
| 134 } u; | |
| 135 u32 wsFlags; /* WHERE_* flags describing the plan */ | |
| 136 u16 nLTerm; /* Number of entries in aLTerm[] */ | |
| 137 u16 nSkip; /* Number of NULL aLTerm[] entries */ | |
| 138 /**** whereLoopXfer() copies fields above ***********************/ | |
| 139 # define WHERE_LOOP_XFER_SZ offsetof(WhereLoop,nLSlot) | |
| 140 u16 nLSlot; /* Number of slots allocated for aLTerm[] */ | |
| 141 WhereTerm **aLTerm; /* WhereTerms used */ | |
| 142 WhereLoop *pNextLoop; /* Next WhereLoop object in the WhereClause */ | |
| 143 WhereTerm *aLTermSpace[3]; /* Initial aLTerm[] space */ | |
| 144 }; | |
| 145 | |
| 146 /* This object holds the prerequisites and the cost of running a | |
| 147 ** subquery on one operand of an OR operator in the WHERE clause. | |
| 148 ** See WhereOrSet for additional information | |
| 149 */ | |
| 150 struct WhereOrCost { | |
| 151 Bitmask prereq; /* Prerequisites */ | |
| 152 LogEst rRun; /* Cost of running this subquery */ | |
| 153 LogEst nOut; /* Number of outputs for this subquery */ | |
| 154 }; | |
| 155 | |
| 156 /* The WhereOrSet object holds a set of possible WhereOrCosts that | |
| 157 ** correspond to the subquery(s) of OR-clause processing. Only the | |
| 158 ** best N_OR_COST elements are retained. | |
| 159 */ | |
| 160 #define N_OR_COST 3 | |
| 161 struct WhereOrSet { | |
| 162 u16 n; /* Number of valid a[] entries */ | |
| 163 WhereOrCost a[N_OR_COST]; /* Set of best costs */ | |
| 164 }; | |
| 165 | |
| 166 /* | |
| 167 ** Each instance of this object holds a sequence of WhereLoop objects | |
| 168 ** that implement some or all of a query plan. | |
| 169 ** | |
| 170 ** Think of each WhereLoop object as a node in a graph with arcs | |
| 171 ** showing dependencies and costs for travelling between nodes. (That is | |
| 172 ** not a completely accurate description because WhereLoop costs are a | |
| 173 ** vector, not a scalar, and because dependencies are many-to-one, not | |
| 174 ** one-to-one as are graph nodes. But it is a useful visualization aid.) | |
| 175 ** Then a WherePath object is a path through the graph that visits some | |
| 176 ** or all of the WhereLoop objects once. | |
| 177 ** | |
| 178 ** The "solver" works by creating the N best WherePath objects of length | |
| 179 ** 1. Then using those as a basis to compute the N best WherePath objects | |
| 180 ** of length 2. And so forth until the length of WherePaths equals the | |
| 181 ** number of nodes in the FROM clause. The best (lowest cost) WherePath | |
| 182 ** at the end is the chosen query plan. | |
| 183 */ | |
| 184 struct WherePath { | |
| 185 Bitmask maskLoop; /* Bitmask of all WhereLoop objects in this path */ | |
| 186 Bitmask revLoop; /* aLoop[]s that should be reversed for ORDER BY */ | |
| 187 LogEst nRow; /* Estimated number of rows generated by this path */ | |
| 188 LogEst rCost; /* Total cost of this path */ | |
| 189 LogEst rUnsorted; /* Total cost of this path ignoring sorting costs */ | |
| 190 i8 isOrdered; /* No. of ORDER BY terms satisfied. -1 for unknown */ | |
| 191 WhereLoop **aLoop; /* Array of WhereLoop objects implementing this path */ | |
| 192 }; | |
| 193 | |
| 194 /* | |
| 195 ** The query generator uses an array of instances of this structure to | |
| 196 ** help it analyze the subexpressions of the WHERE clause. Each WHERE | |
| 197 ** clause subexpression is separated from the others by AND operators, | |
| 198 ** usually, or sometimes subexpressions separated by OR. | |
| 199 ** | |
| 200 ** All WhereTerms are collected into a single WhereClause structure. | |
| 201 ** The following identity holds: | |
| 202 ** | |
| 203 ** WhereTerm.pWC->a[WhereTerm.idx] == WhereTerm | |
| 204 ** | |
| 205 ** When a term is of the form: | |
| 206 ** | |
| 207 ** X <op> <expr> | |
| 208 ** | |
| 209 ** where X is a column name and <op> is one of certain operators, | |
| 210 ** then WhereTerm.leftCursor and WhereTerm.u.leftColumn record the | |
| 211 ** cursor number and column number for X. WhereTerm.eOperator records | |
| 212 ** the <op> using a bitmask encoding defined by WO_xxx below. The | |
| 213 ** use of a bitmask encoding for the operator allows us to search | |
| 214 ** quickly for terms that match any of several different operators. | |
| 215 ** | |
| 216 ** A WhereTerm might also be two or more subterms connected by OR: | |
| 217 ** | |
| 218 ** (t1.X <op> <expr>) OR (t1.Y <op> <expr>) OR .... | |
| 219 ** | |
| 220 ** In this second case, wtFlag has the TERM_ORINFO bit set and eOperator==WO_OR | |
| 221 ** and the WhereTerm.u.pOrInfo field points to auxiliary information that | |
| 222 ** is collected about the OR clause. | |
| 223 ** | |
| 224 ** If a term in the WHERE clause does not match either of the two previous | |
| 225 ** categories, then eOperator==0. The WhereTerm.pExpr field is still set | |
| 226 ** to the original subexpression content and wtFlags is set up appropriately | |
| 227 ** but no other fields in the WhereTerm object are meaningful. | |
| 228 ** | |
| 229 ** When eOperator!=0, prereqRight and prereqAll record sets of cursor numbers, | |
| 230 ** but they do so indirectly. A single WhereMaskSet structure translates | |
| 231 ** cursor number into bits and the translated bit is stored in the prereq | |
| 232 ** fields. The translation is used in order to maximize the number of | |
| 233 ** bits that will fit in a Bitmask. The VDBE cursor numbers might be | |
| 234 ** spread out over the non-negative integers. For example, the cursor | |
| 235 ** numbers might be 3, 8, 9, 10, 20, 23, 41, and 45. The WhereMaskSet | |
| 236 ** translates these sparse cursor numbers into consecutive integers | |
| 237 ** beginning with 0 in order to make the best possible use of the available | |
| 238 ** bits in the Bitmask. So, in the example above, the cursor numbers | |
| 239 ** would be mapped into integers 0 through 7. | |
| 240 ** | |
| 241 ** The number of terms in a join is limited by the number of bits | |
| 242 ** in prereqRight and prereqAll. The default is 64 bits, hence SQLite | |
| 243 ** is only able to process joins with 64 or fewer tables. | |
| 244 */ | |
| 245 struct WhereTerm { | |
| 246 Expr *pExpr; /* Pointer to the subexpression that is this term */ | |
| 247 int iParent; /* Disable pWC->a[iParent] when this term disabled */ | |
| 248 int leftCursor; /* Cursor number of X in "X <op> <expr>" */ | |
| 249 union { | |
| 250 int leftColumn; /* Column number of X in "X <op> <expr>" */ | |
| 251 WhereOrInfo *pOrInfo; /* Extra information if (eOperator & WO_OR)!=0 */ | |
| 252 WhereAndInfo *pAndInfo; /* Extra information if (eOperator& WO_AND)!=0 */ | |
| 253 } u; | |
| 254 LogEst truthProb; /* Probability of truth for this expression */ | |
| 255 u16 eOperator; /* A WO_xx value describing <op> */ | |
| 256 u16 wtFlags; /* TERM_xxx bit flags. See below */ | |
| 257 u8 nChild; /* Number of children that must disable us */ | |
| 258 u8 eMatchOp; /* Op for vtab MATCH/LIKE/GLOB/REGEXP terms */ | |
| 259 WhereClause *pWC; /* The clause this term is part of */ | |
| 260 Bitmask prereqRight; /* Bitmask of tables used by pExpr->pRight */ | |
| 261 Bitmask prereqAll; /* Bitmask of tables referenced by pExpr */ | |
| 262 }; | |
| 263 | |
| 264 /* | |
| 265 ** Allowed values of WhereTerm.wtFlags | |
| 266 */ | |
| 267 #define TERM_DYNAMIC 0x01 /* Need to call sqlite3ExprDelete(db, pExpr) */ | |
| 268 #define TERM_VIRTUAL 0x02 /* Added by the optimizer. Do not code */ | |
| 269 #define TERM_CODED 0x04 /* This term is already coded */ | |
| 270 #define TERM_COPIED 0x08 /* Has a child */ | |
| 271 #define TERM_ORINFO 0x10 /* Need to free the WhereTerm.u.pOrInfo object */ | |
| 272 #define TERM_ANDINFO 0x20 /* Need to free the WhereTerm.u.pAndInfo obj */ | |
| 273 #define TERM_OR_OK 0x40 /* Used during OR-clause processing */ | |
| 274 #ifdef SQLITE_ENABLE_STAT3_OR_STAT4 | |
| 275 # define TERM_VNULL 0x80 /* Manufactured x>NULL or x<=NULL term */ | |
| 276 #else | |
| 277 # define TERM_VNULL 0x00 /* Disabled if not using stat3 */ | |
| 278 #endif | |
| 279 #define TERM_LIKEOPT 0x100 /* Virtual terms from the LIKE optimization */ | |
| 280 #define TERM_LIKECOND 0x200 /* Conditionally this LIKE operator term */ | |
| 281 #define TERM_LIKE 0x400 /* The original LIKE operator */ | |
| 282 #define TERM_IS 0x800 /* Term.pExpr is an IS operator */ | |
| 283 | |
| 284 /* | |
| 285 ** An instance of the WhereScan object is used as an iterator for locating | |
| 286 ** terms in the WHERE clause that are useful to the query planner. | |
| 287 */ | |
| 288 struct WhereScan { | |
| 289 WhereClause *pOrigWC; /* Original, innermost WhereClause */ | |
| 290 WhereClause *pWC; /* WhereClause currently being scanned */ | |
| 291 const char *zCollName; /* Required collating sequence, if not NULL */ | |
| 292 Expr *pIdxExpr; /* Search for this index expression */ | |
| 293 char idxaff; /* Must match this affinity, if zCollName!=NULL */ | |
| 294 unsigned char nEquiv; /* Number of entries in aEquiv[] */ | |
| 295 unsigned char iEquiv; /* Next unused slot in aEquiv[] */ | |
| 296 u32 opMask; /* Acceptable operators */ | |
| 297 int k; /* Resume scanning at this->pWC->a[this->k] */ | |
| 298 int aiCur[11]; /* Cursors in the equivalence class */ | |
| 299 i16 aiColumn[11]; /* Corresponding column number in the eq-class */ | |
| 300 }; | |
| 301 | |
| 302 /* | |
| 303 ** An instance of the following structure holds all information about a | |
| 304 ** WHERE clause. Mostly this is a container for one or more WhereTerms. | |
| 305 ** | |
| 306 ** Explanation of pOuter: For a WHERE clause of the form | |
| 307 ** | |
| 308 ** a AND ((b AND c) OR (d AND e)) AND f | |
| 309 ** | |
| 310 ** There are separate WhereClause objects for the whole clause and for | |
| 311 ** the subclauses "(b AND c)" and "(d AND e)". The pOuter field of the | |
| 312 ** subclauses points to the WhereClause object for the whole clause. | |
| 313 */ | |
| 314 struct WhereClause { | |
| 315 WhereInfo *pWInfo; /* WHERE clause processing context */ | |
| 316 WhereClause *pOuter; /* Outer conjunction */ | |
| 317 u8 op; /* Split operator. TK_AND or TK_OR */ | |
| 318 int nTerm; /* Number of terms */ | |
| 319 int nSlot; /* Number of entries in a[] */ | |
| 320 WhereTerm *a; /* Each a[] describes a term of the WHERE cluase */ | |
| 321 #if defined(SQLITE_SMALL_STACK) | |
| 322 WhereTerm aStatic[1]; /* Initial static space for a[] */ | |
| 323 #else | |
| 324 WhereTerm aStatic[8]; /* Initial static space for a[] */ | |
| 325 #endif | |
| 326 }; | |
| 327 | |
| 328 /* | |
| 329 ** A WhereTerm with eOperator==WO_OR has its u.pOrInfo pointer set to | |
| 330 ** a dynamically allocated instance of the following structure. | |
| 331 */ | |
| 332 struct WhereOrInfo { | |
| 333 WhereClause wc; /* Decomposition into subterms */ | |
| 334 Bitmask indexable; /* Bitmask of all indexable tables in the clause */ | |
| 335 }; | |
| 336 | |
| 337 /* | |
| 338 ** A WhereTerm with eOperator==WO_AND has its u.pAndInfo pointer set to | |
| 339 ** a dynamically allocated instance of the following structure. | |
| 340 */ | |
| 341 struct WhereAndInfo { | |
| 342 WhereClause wc; /* The subexpression broken out */ | |
| 343 }; | |
| 344 | |
| 345 /* | |
| 346 ** An instance of the following structure keeps track of a mapping | |
| 347 ** between VDBE cursor numbers and bits of the bitmasks in WhereTerm. | |
| 348 ** | |
| 349 ** The VDBE cursor numbers are small integers contained in | |
| 350 ** SrcList_item.iCursor and Expr.iTable fields. For any given WHERE | |
| 351 ** clause, the cursor numbers might not begin with 0 and they might | |
| 352 ** contain gaps in the numbering sequence. But we want to make maximum | |
| 353 ** use of the bits in our bitmasks. This structure provides a mapping | |
| 354 ** from the sparse cursor numbers into consecutive integers beginning | |
| 355 ** with 0. | |
| 356 ** | |
| 357 ** If WhereMaskSet.ix[A]==B it means that The A-th bit of a Bitmask | |
| 358 ** corresponds VDBE cursor number B. The A-th bit of a bitmask is 1<<A. | |
| 359 ** | |
| 360 ** For example, if the WHERE clause expression used these VDBE | |
| 361 ** cursors: 4, 5, 8, 29, 57, 73. Then the WhereMaskSet structure | |
| 362 ** would map those cursor numbers into bits 0 through 5. | |
| 363 ** | |
| 364 ** Note that the mapping is not necessarily ordered. In the example | |
| 365 ** above, the mapping might go like this: 4->3, 5->1, 8->2, 29->0, | |
| 366 ** 57->5, 73->4. Or one of 719 other combinations might be used. It | |
| 367 ** does not really matter. What is important is that sparse cursor | |
| 368 ** numbers all get mapped into bit numbers that begin with 0 and contain | |
| 369 ** no gaps. | |
| 370 */ | |
| 371 struct WhereMaskSet { | |
| 372 int n; /* Number of assigned cursor values */ | |
| 373 int ix[BMS]; /* Cursor assigned to each bit */ | |
| 374 }; | |
| 375 | |
| 376 /* | |
| 377 ** Initialize a WhereMaskSet object | |
| 378 */ | |
| 379 #define initMaskSet(P) (P)->n=0 | |
| 380 | |
| 381 /* | |
| 382 ** This object is a convenience wrapper holding all information needed | |
| 383 ** to construct WhereLoop objects for a particular query. | |
| 384 */ | |
| 385 struct WhereLoopBuilder { | |
| 386 WhereInfo *pWInfo; /* Information about this WHERE */ | |
| 387 WhereClause *pWC; /* WHERE clause terms */ | |
| 388 ExprList *pOrderBy; /* ORDER BY clause */ | |
| 389 WhereLoop *pNew; /* Template WhereLoop */ | |
| 390 WhereOrSet *pOrSet; /* Record best loops here, if not NULL */ | |
| 391 #ifdef SQLITE_ENABLE_STAT3_OR_STAT4 | |
| 392 UnpackedRecord *pRec; /* Probe for stat4 (if required) */ | |
| 393 int nRecValid; /* Number of valid fields currently in pRec */ | |
| 394 #endif | |
| 395 }; | |
| 396 | |
| 397 /* | |
| 398 ** The WHERE clause processing routine has two halves. The | |
| 399 ** first part does the start of the WHERE loop and the second | |
| 400 ** half does the tail of the WHERE loop. An instance of | |
| 401 ** this structure is returned by the first half and passed | |
| 402 ** into the second half to give some continuity. | |
| 403 ** | |
| 404 ** An instance of this object holds the complete state of the query | |
| 405 ** planner. | |
| 406 */ | |
| 407 struct WhereInfo { | |
| 408 Parse *pParse; /* Parsing and code generating context */ | |
| 409 SrcList *pTabList; /* List of tables in the join */ | |
| 410 ExprList *pOrderBy; /* The ORDER BY clause or NULL */ | |
| 411 ExprList *pResultSet; /* Result set. DISTINCT operates on these */ | |
| 412 WhereLoop *pLoops; /* List of all WhereLoop objects */ | |
| 413 Bitmask revMask; /* Mask of ORDER BY terms that need reversing */ | |
| 414 LogEst nRowOut; /* Estimated number of output rows */ | |
| 415 u16 wctrlFlags; /* Flags originally passed to sqlite3WhereBegin() */ | |
| 416 i8 nOBSat; /* Number of ORDER BY terms satisfied by indices */ | |
| 417 u8 sorted; /* True if really sorted (not just grouped) */ | |
| 418 u8 eOnePass; /* ONEPASS_OFF, or _SINGLE, or _MULTI */ | |
| 419 u8 untestedTerms; /* Not all WHERE terms resolved by outer loop */ | |
| 420 u8 eDistinct; /* One of the WHERE_DISTINCT_* values below */ | |
| 421 u8 nLevel; /* Number of nested loop */ | |
| 422 int iTop; /* The very beginning of the WHERE loop */ | |
| 423 int iContinue; /* Jump here to continue with next record */ | |
| 424 int iBreak; /* Jump here to break out of the loop */ | |
| 425 int savedNQueryLoop; /* pParse->nQueryLoop outside the WHERE loop */ | |
| 426 int aiCurOnePass[2]; /* OP_OpenWrite cursors for the ONEPASS opt */ | |
| 427 WhereMaskSet sMaskSet; /* Map cursor numbers to bitmasks */ | |
| 428 WhereClause sWC; /* Decomposition of the WHERE clause */ | |
| 429 WhereLevel a[1]; /* Information about each nest loop in WHERE */ | |
| 430 }; | |
| 431 | |
| 432 /* | |
| 433 ** Private interfaces - callable only by other where.c routines. | |
| 434 ** | |
| 435 ** where.c: | |
| 436 */ | |
| 437 Bitmask sqlite3WhereGetMask(WhereMaskSet*,int); | |
| 438 WhereTerm *sqlite3WhereFindTerm( | |
| 439 WhereClause *pWC, /* The WHERE clause to be searched */ | |
| 440 int iCur, /* Cursor number of LHS */ | |
| 441 int iColumn, /* Column number of LHS */ | |
| 442 Bitmask notReady, /* RHS must not overlap with this mask */ | |
| 443 u32 op, /* Mask of WO_xx values describing operator */ | |
| 444 Index *pIdx /* Must be compatible with this index, if not NULL */ | |
| 445 ); | |
| 446 | |
| 447 /* wherecode.c: */ | |
| 448 #ifndef SQLITE_OMIT_EXPLAIN | |
| 449 int sqlite3WhereExplainOneScan( | |
| 450 Parse *pParse, /* Parse context */ | |
| 451 SrcList *pTabList, /* Table list this loop refers to */ | |
| 452 WhereLevel *pLevel, /* Scan to write OP_Explain opcode for */ | |
| 453 int iLevel, /* Value for "level" column of output */ | |
| 454 int iFrom, /* Value for "from" column of output */ | |
| 455 u16 wctrlFlags /* Flags passed to sqlite3WhereBegin() */ | |
| 456 ); | |
| 457 #else | |
| 458 # define sqlite3WhereExplainOneScan(u,v,w,x,y,z) 0 | |
| 459 #endif /* SQLITE_OMIT_EXPLAIN */ | |
| 460 #ifdef SQLITE_ENABLE_STMT_SCANSTATUS | |
| 461 void sqlite3WhereAddScanStatus( | |
| 462 Vdbe *v, /* Vdbe to add scanstatus entry to */ | |
| 463 SrcList *pSrclist, /* FROM clause pLvl reads data from */ | |
| 464 WhereLevel *pLvl, /* Level to add scanstatus() entry for */ | |
| 465 int addrExplain /* Address of OP_Explain (or 0) */ | |
| 466 ); | |
| 467 #else | |
| 468 # define sqlite3WhereAddScanStatus(a, b, c, d) ((void)d) | |
| 469 #endif | |
| 470 Bitmask sqlite3WhereCodeOneLoopStart( | |
| 471 WhereInfo *pWInfo, /* Complete information about the WHERE clause */ | |
| 472 int iLevel, /* Which level of pWInfo->a[] should be coded */ | |
| 473 Bitmask notReady /* Which tables are currently available */ | |
| 474 ); | |
| 475 | |
| 476 /* whereexpr.c: */ | |
| 477 void sqlite3WhereClauseInit(WhereClause*,WhereInfo*); | |
| 478 void sqlite3WhereClauseClear(WhereClause*); | |
| 479 void sqlite3WhereSplit(WhereClause*,Expr*,u8); | |
| 480 Bitmask sqlite3WhereExprUsage(WhereMaskSet*, Expr*); | |
| 481 Bitmask sqlite3WhereExprListUsage(WhereMaskSet*, ExprList*); | |
| 482 void sqlite3WhereExprAnalyze(SrcList*, WhereClause*); | |
| 483 void sqlite3WhereTabFuncArgs(Parse*, struct SrcList_item*, WhereClause*); | |
| 484 | |
| 485 | |
| 486 | |
| 487 | |
| 488 | |
| 489 /* | |
| 490 ** Bitmasks for the operators on WhereTerm objects. These are all | |
| 491 ** operators that are of interest to the query planner. An | |
| 492 ** OR-ed combination of these values can be used when searching for | |
| 493 ** particular WhereTerms within a WhereClause. | |
| 494 */ | |
| 495 #define WO_IN 0x0001 | |
| 496 #define WO_EQ 0x0002 | |
| 497 #define WO_LT (WO_EQ<<(TK_LT-TK_EQ)) | |
| 498 #define WO_LE (WO_EQ<<(TK_LE-TK_EQ)) | |
| 499 #define WO_GT (WO_EQ<<(TK_GT-TK_EQ)) | |
| 500 #define WO_GE (WO_EQ<<(TK_GE-TK_EQ)) | |
| 501 #define WO_MATCH 0x0040 | |
| 502 #define WO_IS 0x0080 | |
| 503 #define WO_ISNULL 0x0100 | |
| 504 #define WO_OR 0x0200 /* Two or more OR-connected terms */ | |
| 505 #define WO_AND 0x0400 /* Two or more AND-connected terms */ | |
| 506 #define WO_EQUIV 0x0800 /* Of the form A==B, both columns */ | |
| 507 #define WO_NOOP 0x1000 /* This term does not restrict search space */ | |
| 508 | |
| 509 #define WO_ALL 0x1fff /* Mask of all possible WO_* values */ | |
| 510 #define WO_SINGLE 0x01ff /* Mask of all non-compound WO_* values */ | |
| 511 | |
| 512 /* | |
| 513 ** These are definitions of bits in the WhereLoop.wsFlags field. | |
| 514 ** The particular combination of bits in each WhereLoop help to | |
| 515 ** determine the algorithm that WhereLoop represents. | |
| 516 */ | |
| 517 #define WHERE_COLUMN_EQ 0x00000001 /* x=EXPR */ | |
| 518 #define WHERE_COLUMN_RANGE 0x00000002 /* x<EXPR and/or x>EXPR */ | |
| 519 #define WHERE_COLUMN_IN 0x00000004 /* x IN (...) */ | |
| 520 #define WHERE_COLUMN_NULL 0x00000008 /* x IS NULL */ | |
| 521 #define WHERE_CONSTRAINT 0x0000000f /* Any of the WHERE_COLUMN_xxx values */ | |
| 522 #define WHERE_TOP_LIMIT 0x00000010 /* x<EXPR or x<=EXPR constraint */ | |
| 523 #define WHERE_BTM_LIMIT 0x00000020 /* x>EXPR or x>=EXPR constraint */ | |
| 524 #define WHERE_BOTH_LIMIT 0x00000030 /* Both x>EXPR and x<EXPR */ | |
| 525 #define WHERE_IDX_ONLY 0x00000040 /* Use index only - omit table */ | |
| 526 #define WHERE_IPK 0x00000100 /* x is the INTEGER PRIMARY KEY */ | |
| 527 #define WHERE_INDEXED 0x00000200 /* WhereLoop.u.btree.pIndex is valid */ | |
| 528 #define WHERE_VIRTUALTABLE 0x00000400 /* WhereLoop.u.vtab is valid */ | |
| 529 #define WHERE_IN_ABLE 0x00000800 /* Able to support an IN operator */ | |
| 530 #define WHERE_ONEROW 0x00001000 /* Selects no more than one row */ | |
| 531 #define WHERE_MULTI_OR 0x00002000 /* OR using multiple indices */ | |
| 532 #define WHERE_AUTO_INDEX 0x00004000 /* Uses an ephemeral index */ | |
| 533 #define WHERE_SKIPSCAN 0x00008000 /* Uses the skip-scan algorithm */ | |
| 534 #define WHERE_UNQ_WANTED 0x00010000 /* WHERE_ONEROW would have been helpful*/ | |
| 535 #define WHERE_PARTIALIDX 0x00020000 /* The automatic index is partial */ | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2846743003:
[sql] Remove SQLite 3.10.2 reference directory. (Closed)
