4 ** The author disclaims copyright to this source code. In place of
5 ** a legal notice, here is a blessing:
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.
11 *************************************************************************
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.
19 ** Trace output macros
21 #if defined(SQLITE_TEST) || defined(SQLITE_DEBUG)
22 /***/ extern int sqlite3WhereTrace
;
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
29 # define WHERETRACE(K,X)
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
;
48 ** This object contains information needed to implement a single nested
49 ** loop in WHERE clause.
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
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.
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 u32 iLikeRepCntr
; /* LIKE range processing counter register (times 2) */
74 int addrLikeRep
; /* LIKE range processing address */
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 */
81 int nIn
; /* Number of entries in aInLoop[] */
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 */
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 */
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.
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.
112 Bitmask prereq
; /* Bitmask of other loops that must run first */
113 Bitmask maskSelf
; /* Bitmask identifying table iTab */
115 char cId
; /* Symbolic ID of this loop for debugging use */
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 */
123 struct { /* Information for internal btree tables */
124 u16 nEq
; /* Number of equality constraints */
125 u16 nBtm
; /* Size of BTM vector */
126 u16 nTop
; /* Size of TOP vector */
127 u16 nIdxCol
; /* Index column used for ORDER BY */
128 Index
*pIndex
; /* Index used, or NULL */
130 struct { /* Information for virtual tables */
131 int idxNum
; /* Index number */
132 u8 needFree
; /* True if sqlite3_free(idxStr) is needed */
133 i8 isOrdered
; /* True if satisfies ORDER BY */
134 u16 omitMask
; /* Terms that may be omitted */
135 char *idxStr
; /* Index identifier string */
138 u32 wsFlags
; /* WHERE_* flags describing the plan */
139 u16 nLTerm
; /* Number of entries in aLTerm[] */
140 u16 nSkip
; /* Number of NULL aLTerm[] entries */
141 /**** whereLoopXfer() copies fields above ***********************/
142 # define WHERE_LOOP_XFER_SZ offsetof(WhereLoop,nLSlot)
143 u16 nLSlot
; /* Number of slots allocated for aLTerm[] */
144 WhereTerm
**aLTerm
; /* WhereTerms used */
145 WhereLoop
*pNextLoop
; /* Next WhereLoop object in the WhereClause */
146 WhereTerm
*aLTermSpace
[3]; /* Initial aLTerm[] space */
149 /* This object holds the prerequisites and the cost of running a
150 ** subquery on one operand of an OR operator in the WHERE clause.
151 ** See WhereOrSet for additional information
154 Bitmask prereq
; /* Prerequisites */
155 LogEst rRun
; /* Cost of running this subquery */
156 LogEst nOut
; /* Number of outputs for this subquery */
159 /* The WhereOrSet object holds a set of possible WhereOrCosts that
160 ** correspond to the subquery(s) of OR-clause processing. Only the
161 ** best N_OR_COST elements are retained.
165 u16 n
; /* Number of valid a[] entries */
166 WhereOrCost a
[N_OR_COST
]; /* Set of best costs */
170 ** Each instance of this object holds a sequence of WhereLoop objects
171 ** that implement some or all of a query plan.
173 ** Think of each WhereLoop object as a node in a graph with arcs
174 ** showing dependencies and costs for travelling between nodes. (That is
175 ** not a completely accurate description because WhereLoop costs are a
176 ** vector, not a scalar, and because dependencies are many-to-one, not
177 ** one-to-one as are graph nodes. But it is a useful visualization aid.)
178 ** Then a WherePath object is a path through the graph that visits some
179 ** or all of the WhereLoop objects once.
181 ** The "solver" works by creating the N best WherePath objects of length
182 ** 1. Then using those as a basis to compute the N best WherePath objects
183 ** of length 2. And so forth until the length of WherePaths equals the
184 ** number of nodes in the FROM clause. The best (lowest cost) WherePath
185 ** at the end is the chosen query plan.
188 Bitmask maskLoop
; /* Bitmask of all WhereLoop objects in this path */
189 Bitmask revLoop
; /* aLoop[]s that should be reversed for ORDER BY */
190 LogEst nRow
; /* Estimated number of rows generated by this path */
191 LogEst rCost
; /* Total cost of this path */
192 LogEst rUnsorted
; /* Total cost of this path ignoring sorting costs */
193 i8 isOrdered
; /* No. of ORDER BY terms satisfied. -1 for unknown */
194 WhereLoop
**aLoop
; /* Array of WhereLoop objects implementing this path */
198 ** The query generator uses an array of instances of this structure to
199 ** help it analyze the subexpressions of the WHERE clause. Each WHERE
200 ** clause subexpression is separated from the others by AND operators,
201 ** usually, or sometimes subexpressions separated by OR.
203 ** All WhereTerms are collected into a single WhereClause structure.
204 ** The following identity holds:
206 ** WhereTerm.pWC->a[WhereTerm.idx] == WhereTerm
208 ** When a term is of the form:
212 ** where X is a column name and <op> is one of certain operators,
213 ** then WhereTerm.leftCursor and WhereTerm.u.leftColumn record the
214 ** cursor number and column number for X. WhereTerm.eOperator records
215 ** the <op> using a bitmask encoding defined by WO_xxx below. The
216 ** use of a bitmask encoding for the operator allows us to search
217 ** quickly for terms that match any of several different operators.
219 ** A WhereTerm might also be two or more subterms connected by OR:
221 ** (t1.X <op> <expr>) OR (t1.Y <op> <expr>) OR ....
223 ** In this second case, wtFlag has the TERM_ORINFO bit set and eOperator==WO_OR
224 ** and the WhereTerm.u.pOrInfo field points to auxiliary information that
225 ** is collected about the OR clause.
227 ** If a term in the WHERE clause does not match either of the two previous
228 ** categories, then eOperator==0. The WhereTerm.pExpr field is still set
229 ** to the original subexpression content and wtFlags is set up appropriately
230 ** but no other fields in the WhereTerm object are meaningful.
232 ** When eOperator!=0, prereqRight and prereqAll record sets of cursor numbers,
233 ** but they do so indirectly. A single WhereMaskSet structure translates
234 ** cursor number into bits and the translated bit is stored in the prereq
235 ** fields. The translation is used in order to maximize the number of
236 ** bits that will fit in a Bitmask. The VDBE cursor numbers might be
237 ** spread out over the non-negative integers. For example, the cursor
238 ** numbers might be 3, 8, 9, 10, 20, 23, 41, and 45. The WhereMaskSet
239 ** translates these sparse cursor numbers into consecutive integers
240 ** beginning with 0 in order to make the best possible use of the available
241 ** bits in the Bitmask. So, in the example above, the cursor numbers
242 ** would be mapped into integers 0 through 7.
244 ** The number of terms in a join is limited by the number of bits
245 ** in prereqRight and prereqAll. The default is 64 bits, hence SQLite
246 ** is only able to process joins with 64 or fewer tables.
249 Expr
*pExpr
; /* Pointer to the subexpression that is this term */
250 WhereClause
*pWC
; /* The clause this term is part of */
251 LogEst truthProb
; /* Probability of truth for this expression */
252 u16 wtFlags
; /* TERM_xxx bit flags. See below */
253 u16 eOperator
; /* A WO_xx value describing <op> */
254 u8 nChild
; /* Number of children that must disable us */
255 u8 eMatchOp
; /* Op for vtab MATCH/LIKE/GLOB/REGEXP terms */
256 int iParent
; /* Disable pWC->a[iParent] when this term disabled */
257 int leftCursor
; /* Cursor number of X in "X <op> <expr>" */
258 int iField
; /* Field in (?,?,?) IN (SELECT...) vector */
260 int leftColumn
; /* Column number of X in "X <op> <expr>" */
261 WhereOrInfo
*pOrInfo
; /* Extra information if (eOperator & WO_OR)!=0 */
262 WhereAndInfo
*pAndInfo
; /* Extra information if (eOperator& WO_AND)!=0 */
264 Bitmask prereqRight
; /* Bitmask of tables used by pExpr->pRight */
265 Bitmask prereqAll
; /* Bitmask of tables referenced by pExpr */
269 ** Allowed values of WhereTerm.wtFlags
271 #define TERM_DYNAMIC 0x01 /* Need to call sqlite3ExprDelete(db, pExpr) */
272 #define TERM_VIRTUAL 0x02 /* Added by the optimizer. Do not code */
273 #define TERM_CODED 0x04 /* This term is already coded */
274 #define TERM_COPIED 0x08 /* Has a child */
275 #define TERM_ORINFO 0x10 /* Need to free the WhereTerm.u.pOrInfo object */
276 #define TERM_ANDINFO 0x20 /* Need to free the WhereTerm.u.pAndInfo obj */
277 #define TERM_OR_OK 0x40 /* Used during OR-clause processing */
278 #ifdef SQLITE_ENABLE_STAT3_OR_STAT4
279 # define TERM_VNULL 0x80 /* Manufactured x>NULL or x<=NULL term */
281 # define TERM_VNULL 0x00 /* Disabled if not using stat3 */
283 #define TERM_LIKEOPT 0x100 /* Virtual terms from the LIKE optimization */
284 #define TERM_LIKECOND 0x200 /* Conditionally this LIKE operator term */
285 #define TERM_LIKE 0x400 /* The original LIKE operator */
286 #define TERM_IS 0x800 /* Term.pExpr is an IS operator */
287 #define TERM_VARSELECT 0x1000 /* Term.pExpr contains a correlated sub-query */
290 ** An instance of the WhereScan object is used as an iterator for locating
291 ** terms in the WHERE clause that are useful to the query planner.
294 WhereClause
*pOrigWC
; /* Original, innermost WhereClause */
295 WhereClause
*pWC
; /* WhereClause currently being scanned */
296 const char *zCollName
; /* Required collating sequence, if not NULL */
297 Expr
*pIdxExpr
; /* Search for this index expression */
298 char idxaff
; /* Must match this affinity, if zCollName!=NULL */
299 unsigned char nEquiv
; /* Number of entries in aEquiv[] */
300 unsigned char iEquiv
; /* Next unused slot in aEquiv[] */
301 u32 opMask
; /* Acceptable operators */
302 int k
; /* Resume scanning at this->pWC->a[this->k] */
303 int aiCur
[11]; /* Cursors in the equivalence class */
304 i16 aiColumn
[11]; /* Corresponding column number in the eq-class */
308 ** An instance of the following structure holds all information about a
309 ** WHERE clause. Mostly this is a container for one or more WhereTerms.
311 ** Explanation of pOuter: For a WHERE clause of the form
313 ** a AND ((b AND c) OR (d AND e)) AND f
315 ** There are separate WhereClause objects for the whole clause and for
316 ** the subclauses "(b AND c)" and "(d AND e)". The pOuter field of the
317 ** subclauses points to the WhereClause object for the whole clause.
320 WhereInfo
*pWInfo
; /* WHERE clause processing context */
321 WhereClause
*pOuter
; /* Outer conjunction */
322 u8 op
; /* Split operator. TK_AND or TK_OR */
323 int nTerm
; /* Number of terms */
324 int nSlot
; /* Number of entries in a[] */
325 WhereTerm
*a
; /* Each a[] describes a term of the WHERE cluase */
326 #if defined(SQLITE_SMALL_STACK)
327 WhereTerm aStatic
[1]; /* Initial static space for a[] */
329 WhereTerm aStatic
[8]; /* Initial static space for a[] */
334 ** A WhereTerm with eOperator==WO_OR has its u.pOrInfo pointer set to
335 ** a dynamically allocated instance of the following structure.
338 WhereClause wc
; /* Decomposition into subterms */
339 Bitmask indexable
; /* Bitmask of all indexable tables in the clause */
343 ** A WhereTerm with eOperator==WO_AND has its u.pAndInfo pointer set to
344 ** a dynamically allocated instance of the following structure.
346 struct WhereAndInfo
{
347 WhereClause wc
; /* The subexpression broken out */
351 ** An instance of the following structure keeps track of a mapping
352 ** between VDBE cursor numbers and bits of the bitmasks in WhereTerm.
354 ** The VDBE cursor numbers are small integers contained in
355 ** SrcList_item.iCursor and Expr.iTable fields. For any given WHERE
356 ** clause, the cursor numbers might not begin with 0 and they might
357 ** contain gaps in the numbering sequence. But we want to make maximum
358 ** use of the bits in our bitmasks. This structure provides a mapping
359 ** from the sparse cursor numbers into consecutive integers beginning
362 ** If WhereMaskSet.ix[A]==B it means that The A-th bit of a Bitmask
363 ** corresponds VDBE cursor number B. The A-th bit of a bitmask is 1<<A.
365 ** For example, if the WHERE clause expression used these VDBE
366 ** cursors: 4, 5, 8, 29, 57, 73. Then the WhereMaskSet structure
367 ** would map those cursor numbers into bits 0 through 5.
369 ** Note that the mapping is not necessarily ordered. In the example
370 ** above, the mapping might go like this: 4->3, 5->1, 8->2, 29->0,
371 ** 57->5, 73->4. Or one of 719 other combinations might be used. It
372 ** does not really matter. What is important is that sparse cursor
373 ** numbers all get mapped into bit numbers that begin with 0 and contain
376 struct WhereMaskSet
{
377 int bVarSelect
; /* Used by sqlite3WhereExprUsage() */
378 int n
; /* Number of assigned cursor values */
379 int ix
[BMS
]; /* Cursor assigned to each bit */
383 ** Initialize a WhereMaskSet object
385 #define initMaskSet(P) (P)->n=0
388 ** This object is a convenience wrapper holding all information needed
389 ** to construct WhereLoop objects for a particular query.
391 struct WhereLoopBuilder
{
392 WhereInfo
*pWInfo
; /* Information about this WHERE */
393 WhereClause
*pWC
; /* WHERE clause terms */
394 ExprList
*pOrderBy
; /* ORDER BY clause */
395 WhereLoop
*pNew
; /* Template WhereLoop */
396 WhereOrSet
*pOrSet
; /* Record best loops here, if not NULL */
397 #ifdef SQLITE_ENABLE_STAT3_OR_STAT4
398 UnpackedRecord
*pRec
; /* Probe for stat4 (if required) */
399 int nRecValid
; /* Number of valid fields currently in pRec */
401 unsigned int bldFlags
; /* SQLITE_BLDF_* flags */
404 /* Allowed values for WhereLoopBuider.bldFlags */
405 #define SQLITE_BLDF_INDEXED 0x0001 /* An index is used */
406 #define SQLITE_BLDF_UNIQUE 0x0002 /* All keys of a UNIQUE index used */
409 ** The WHERE clause processing routine has two halves. The
410 ** first part does the start of the WHERE loop and the second
411 ** half does the tail of the WHERE loop. An instance of
412 ** this structure is returned by the first half and passed
413 ** into the second half to give some continuity.
415 ** An instance of this object holds the complete state of the query
419 Parse
*pParse
; /* Parsing and code generating context */
420 SrcList
*pTabList
; /* List of tables in the join */
421 ExprList
*pOrderBy
; /* The ORDER BY clause or NULL */
422 ExprList
*pResultSet
; /* Result set of the query */
423 Expr
*pWhere
; /* The complete WHERE clause */
424 LogEst iLimit
; /* LIMIT if wctrlFlags has WHERE_USE_LIMIT */
425 int aiCurOnePass
[2]; /* OP_OpenWrite cursors for the ONEPASS opt */
426 int iContinue
; /* Jump here to continue with next record */
427 int iBreak
; /* Jump here to break out of the loop */
428 int savedNQueryLoop
; /* pParse->nQueryLoop outside the WHERE loop */
429 u16 wctrlFlags
; /* Flags originally passed to sqlite3WhereBegin() */
430 u8 nLevel
; /* Number of nested loop */
431 i8 nOBSat
; /* Number of ORDER BY terms satisfied by indices */
432 u8 sorted
; /* True if really sorted (not just grouped) */
433 u8 eOnePass
; /* ONEPASS_OFF, or _SINGLE, or _MULTI */
434 u8 untestedTerms
; /* Not all WHERE terms resolved by outer loop */
435 u8 eDistinct
; /* One of the WHERE_DISTINCT_* values */
436 u8 bOrderedInnerLoop
; /* True if only the inner-most loop is ordered */
437 int iTop
; /* The very beginning of the WHERE loop */
438 WhereLoop
*pLoops
; /* List of all WhereLoop objects */
439 Bitmask revMask
; /* Mask of ORDER BY terms that need reversing */
440 LogEst nRowOut
; /* Estimated number of output rows */
441 WhereClause sWC
; /* Decomposition of the WHERE clause */
442 WhereMaskSet sMaskSet
; /* Map cursor numbers to bitmasks */
443 WhereLevel a
[1]; /* Information about each nest loop in WHERE */
447 ** Private interfaces - callable only by other where.c routines.
451 Bitmask
sqlite3WhereGetMask(WhereMaskSet
*,int);
452 #ifdef WHERETRACE_ENABLED
453 void sqlite3WhereClausePrint(WhereClause
*pWC
);
455 WhereTerm
*sqlite3WhereFindTerm(
456 WhereClause
*pWC
, /* The WHERE clause to be searched */
457 int iCur
, /* Cursor number of LHS */
458 int iColumn
, /* Column number of LHS */
459 Bitmask notReady
, /* RHS must not overlap with this mask */
460 u32 op
, /* Mask of WO_xx values describing operator */
461 Index
*pIdx
/* Must be compatible with this index, if not NULL */
465 #ifndef SQLITE_OMIT_EXPLAIN
466 int sqlite3WhereExplainOneScan(
467 Parse
*pParse
, /* Parse context */
468 SrcList
*pTabList
, /* Table list this loop refers to */
469 WhereLevel
*pLevel
, /* Scan to write OP_Explain opcode for */
470 u16 wctrlFlags
/* Flags passed to sqlite3WhereBegin() */
473 # define sqlite3WhereExplainOneScan(u,v,w,x) 0
474 #endif /* SQLITE_OMIT_EXPLAIN */
475 #ifdef SQLITE_ENABLE_STMT_SCANSTATUS
476 void sqlite3WhereAddScanStatus(
477 Vdbe
*v
, /* Vdbe to add scanstatus entry to */
478 SrcList
*pSrclist
, /* FROM clause pLvl reads data from */
479 WhereLevel
*pLvl
, /* Level to add scanstatus() entry for */
480 int addrExplain
/* Address of OP_Explain (or 0) */
483 # define sqlite3WhereAddScanStatus(a, b, c, d) ((void)d)
485 Bitmask
sqlite3WhereCodeOneLoopStart(
486 WhereInfo
*pWInfo
, /* Complete information about the WHERE clause */
487 int iLevel
, /* Which level of pWInfo->a[] should be coded */
488 Bitmask notReady
/* Which tables are currently available */
492 void sqlite3WhereClauseInit(WhereClause
*,WhereInfo
*);
493 void sqlite3WhereClauseClear(WhereClause
*);
494 void sqlite3WhereSplit(WhereClause
*,Expr
*,u8
);
495 Bitmask
sqlite3WhereExprUsage(WhereMaskSet
*, Expr
*);
496 Bitmask
sqlite3WhereExprListUsage(WhereMaskSet
*, ExprList
*);
497 void sqlite3WhereExprAnalyze(SrcList
*, WhereClause
*);
498 void sqlite3WhereTabFuncArgs(Parse
*, struct SrcList_item
*, WhereClause
*);
505 ** Bitmasks for the operators on WhereTerm objects. These are all
506 ** operators that are of interest to the query planner. An
507 ** OR-ed combination of these values can be used when searching for
508 ** particular WhereTerms within a WhereClause.
510 ** Value constraints:
511 ** WO_EQ == SQLITE_INDEX_CONSTRAINT_EQ
512 ** WO_LT == SQLITE_INDEX_CONSTRAINT_LT
513 ** WO_LE == SQLITE_INDEX_CONSTRAINT_LE
514 ** WO_GT == SQLITE_INDEX_CONSTRAINT_GT
515 ** WO_GE == SQLITE_INDEX_CONSTRAINT_GE
519 #define WO_LT (WO_EQ<<(TK_LT-TK_EQ))
520 #define WO_LE (WO_EQ<<(TK_LE-TK_EQ))
521 #define WO_GT (WO_EQ<<(TK_GT-TK_EQ))
522 #define WO_GE (WO_EQ<<(TK_GE-TK_EQ))
523 #define WO_AUX 0x0040 /* Op useful to virtual tables only */
525 #define WO_ISNULL 0x0100
526 #define WO_OR 0x0200 /* Two or more OR-connected terms */
527 #define WO_AND 0x0400 /* Two or more AND-connected terms */
528 #define WO_EQUIV 0x0800 /* Of the form A==B, both columns */
529 #define WO_NOOP 0x1000 /* This term does not restrict search space */
531 #define WO_ALL 0x1fff /* Mask of all possible WO_* values */
532 #define WO_SINGLE 0x01ff /* Mask of all non-compound WO_* values */
535 ** These are definitions of bits in the WhereLoop.wsFlags field.
536 ** The particular combination of bits in each WhereLoop help to
537 ** determine the algorithm that WhereLoop represents.
539 #define WHERE_COLUMN_EQ 0x00000001 /* x=EXPR */
540 #define WHERE_COLUMN_RANGE 0x00000002 /* x<EXPR and/or x>EXPR */
541 #define WHERE_COLUMN_IN 0x00000004 /* x IN (...) */
542 #define WHERE_COLUMN_NULL 0x00000008 /* x IS NULL */
543 #define WHERE_CONSTRAINT 0x0000000f /* Any of the WHERE_COLUMN_xxx values */
544 #define WHERE_TOP_LIMIT 0x00000010 /* x<EXPR or x<=EXPR constraint */
545 #define WHERE_BTM_LIMIT 0x00000020 /* x>EXPR or x>=EXPR constraint */
546 #define WHERE_BOTH_LIMIT 0x00000030 /* Both x>EXPR and x<EXPR */
547 #define WHERE_IDX_ONLY 0x00000040 /* Use index only - omit table */
548 #define WHERE_IPK 0x00000100 /* x is the INTEGER PRIMARY KEY */
549 #define WHERE_INDEXED 0x00000200 /* WhereLoop.u.btree.pIndex is valid */
550 #define WHERE_VIRTUALTABLE 0x00000400 /* WhereLoop.u.vtab is valid */
551 #define WHERE_IN_ABLE 0x00000800 /* Able to support an IN operator */
552 #define WHERE_ONEROW 0x00001000 /* Selects no more than one row */
553 #define WHERE_MULTI_OR 0x00002000 /* OR using multiple indices */
554 #define WHERE_AUTO_INDEX 0x00004000 /* Uses an ephemeral index */
555 #define WHERE_SKIPSCAN 0x00008000 /* Uses the skip-scan algorithm */
556 #define WHERE_UNQ_WANTED 0x00010000 /* WHERE_ONEROW would have been helpful*/
557 #define WHERE_PARTIALIDX 0x00020000 /* The automatic index is partial */