| | @@ -352,11 +352,11 @@ |
| 352 | 352 | |
| 353 | 353 | /* |
| 354 | 354 | ** The SQLITE_THREADSAFE macro must be defined as 0, 1, or 2. |
| 355 | 355 | ** 0 means mutexes are permanently disable and the library is never |
| 356 | 356 | ** threadsafe. 1 means the library is serialized which is the highest |
| 357 | | -** level of threadsafety. 2 means the libary is multithreaded - multiple |
| 357 | +** level of threadsafety. 2 means the library is multithreaded - multiple |
| 358 | 358 | ** threads can use SQLite as long as no two threads try to use the same |
| 359 | 359 | ** database connection at the same time. |
| 360 | 360 | ** |
| 361 | 361 | ** Older versions of SQLite used an optional THREADSAFE macro. |
| 362 | 362 | ** We support that for legacy. |
| | @@ -431,24 +431,16 @@ |
| 431 | 431 | # define SQLITE_MALLOC_SOFT_LIMIT 1024 |
| 432 | 432 | #endif |
| 433 | 433 | |
| 434 | 434 | /* |
| 435 | 435 | ** We need to define _XOPEN_SOURCE as follows in order to enable |
| 436 | | -** recursive mutexes on most Unix systems. But Mac OS X is different. |
| 437 | | -** The _XOPEN_SOURCE define causes problems for Mac OS X we are told, |
| 438 | | -** so it is omitted there. See ticket #2673. |
| 439 | | -** |
| 440 | | -** Later we learn that _XOPEN_SOURCE is poorly or incorrectly |
| 441 | | -** implemented on some systems. So we avoid defining it at all |
| 442 | | -** if it is already defined or if it is unneeded because we are |
| 443 | | -** not doing a threadsafe build. Ticket #2681. |
| 444 | | -** |
| 445 | | -** See also ticket #2741. |
| 436 | +** recursive mutexes on most Unix systems and fchmod() on OpenBSD. |
| 437 | +** But _XOPEN_SOURCE define causes problems for Mac OS X, so omit |
| 438 | +** it. |
| 446 | 439 | */ |
| 447 | | -#if !defined(_XOPEN_SOURCE) && !defined(__DARWIN__) \ |
| 448 | | - && !defined(__APPLE__) && SQLITE_THREADSAFE |
| 449 | | -# define _XOPEN_SOURCE 500 /* Needed to enable pthread recursive mutexes */ |
| 440 | +#if !defined(_XOPEN_SOURCE) && !defined(__DARWIN__) && !defined(__APPLE__) |
| 441 | +# define _XOPEN_SOURCE 600 |
| 450 | 442 | #endif |
| 451 | 443 | |
| 452 | 444 | /* |
| 453 | 445 | ** The TCL headers are only needed when compiling the TCL bindings. |
| 454 | 446 | */ |
| | @@ -678,11 +670,11 @@ |
| 678 | 670 | ** [sqlite3_libversion_number()], [sqlite3_sourceid()], |
| 679 | 671 | ** [sqlite_version()] and [sqlite_source_id()]. |
| 680 | 672 | */ |
| 681 | 673 | #define SQLITE_VERSION "3.7.17" |
| 682 | 674 | #define SQLITE_VERSION_NUMBER 3007017 |
| 683 | | -#define SQLITE_SOURCE_ID "2013-05-15 18:34:17 00231fb0127960d700de3549e34e82f8ec1b5819" |
| 675 | +#define SQLITE_SOURCE_ID "2013-06-20 14:17:39 d94db3fd921890ab1d6414ab629410ae50779686" |
| 684 | 676 | |
| 685 | 677 | /* |
| 686 | 678 | ** CAPI3REF: Run-Time Library Version Numbers |
| 687 | 679 | ** KEYWORDS: sqlite3_version, sqlite3_sourceid |
| 688 | 680 | ** |
| | @@ -5087,10 +5079,15 @@ |
| 5087 | 5079 | */ |
| 5088 | 5080 | SQLITE_API int sqlite3_key( |
| 5089 | 5081 | sqlite3 *db, /* Database to be rekeyed */ |
| 5090 | 5082 | const void *pKey, int nKey /* The key */ |
| 5091 | 5083 | ); |
| 5084 | +SQLITE_API int sqlite3_key_v2( |
| 5085 | + sqlite3 *db, /* Database to be rekeyed */ |
| 5086 | + const char *zDbName, /* Name of the database */ |
| 5087 | + const void *pKey, int nKey /* The key */ |
| 5088 | +); |
| 5092 | 5089 | |
| 5093 | 5090 | /* |
| 5094 | 5091 | ** Change the key on an open database. If the current database is not |
| 5095 | 5092 | ** encrypted, this routine will encrypt it. If pNew==0 or nNew==0, the |
| 5096 | 5093 | ** database is decrypted. |
| | @@ -5100,10 +5097,15 @@ |
| 5100 | 5097 | */ |
| 5101 | 5098 | SQLITE_API int sqlite3_rekey( |
| 5102 | 5099 | sqlite3 *db, /* Database to be rekeyed */ |
| 5103 | 5100 | const void *pKey, int nKey /* The new key */ |
| 5104 | 5101 | ); |
| 5102 | +SQLITE_API int sqlite3_rekey_v2( |
| 5103 | + sqlite3 *db, /* Database to be rekeyed */ |
| 5104 | + const char *zDbName, /* Name of the database */ |
| 5105 | + const void *pKey, int nKey /* The new key */ |
| 5106 | +); |
| 5105 | 5107 | |
| 5106 | 5108 | /* |
| 5107 | 5109 | ** Specify the activation key for a SEE database. Unless |
| 5108 | 5110 | ** activated, none of the SEE routines will work. |
| 5109 | 5111 | */ |
| | @@ -8151,10 +8153,16 @@ |
| 8151 | 8153 | */ |
| 8152 | 8154 | #ifndef offsetof |
| 8153 | 8155 | #define offsetof(STRUCTURE,FIELD) ((int)((char*)&((STRUCTURE*)0)->FIELD)) |
| 8154 | 8156 | #endif |
| 8155 | 8157 | |
| 8158 | +/* |
| 8159 | +** Macros to compute minimum and maximum of two numbers. |
| 8160 | +*/ |
| 8161 | +#define MIN(A,B) ((A)<(B)?(A):(B)) |
| 8162 | +#define MAX(A,B) ((A)>(B)?(A):(B)) |
| 8163 | + |
| 8156 | 8164 | /* |
| 8157 | 8165 | ** Check to see if this machine uses EBCDIC. (Yes, believe it or |
| 8158 | 8166 | ** not, there are still machines out there that use EBCDIC.) |
| 8159 | 8167 | */ |
| 8160 | 8168 | #if 'A' == '\301' |
| | @@ -8476,13 +8484,11 @@ |
| 8476 | 8484 | typedef struct TriggerStep TriggerStep; |
| 8477 | 8485 | typedef struct UnpackedRecord UnpackedRecord; |
| 8478 | 8486 | typedef struct VTable VTable; |
| 8479 | 8487 | typedef struct VtabCtx VtabCtx; |
| 8480 | 8488 | typedef struct Walker Walker; |
| 8481 | | -typedef struct WherePlan WherePlan; |
| 8482 | 8489 | typedef struct WhereInfo WhereInfo; |
| 8483 | | -typedef struct WhereLevel WhereLevel; |
| 8484 | 8490 | |
| 8485 | 8491 | /* |
| 8486 | 8492 | ** Defer sourcing vdbe.h and btree.h until after the "u8" and |
| 8487 | 8493 | ** "BusyHandler" typedefs. vdbe.h also requires a few of the opaque |
| 8488 | 8494 | ** pointer types (i.e. FuncDef) defined above. |
| | @@ -9915,11 +9921,10 @@ |
| 9915 | 9921 | ** databases may be attached. |
| 9916 | 9922 | */ |
| 9917 | 9923 | struct Db { |
| 9918 | 9924 | char *zName; /* Name of this database */ |
| 9919 | 9925 | Btree *pBt; /* The B*Tree structure for this database file */ |
| 9920 | | - u8 inTrans; /* 0: not writable. 1: Transaction. 2: Checkpoint */ |
| 9921 | 9926 | u8 safety_level; /* How aggressive at syncing data to disk */ |
| 9922 | 9927 | Schema *pSchema; /* Pointer to database schema (possibly shared) */ |
| 9923 | 9928 | }; |
| 9924 | 9929 | |
| 9925 | 9930 | /* |
| | @@ -10713,10 +10718,11 @@ |
| 10713 | 10718 | int tnum; /* DB Page containing root of this index */ |
| 10714 | 10719 | u16 nColumn; /* Number of columns in table used by this index */ |
| 10715 | 10720 | u8 onError; /* OE_Abort, OE_Ignore, OE_Replace, or OE_None */ |
| 10716 | 10721 | unsigned autoIndex:2; /* 1==UNIQUE, 2==PRIMARY KEY, 0==CREATE INDEX */ |
| 10717 | 10722 | unsigned bUnordered:1; /* Use this index for == or IN queries only */ |
| 10723 | + unsigned uniqNotNull:1; /* True if UNIQUE and NOT NULL for all columns */ |
| 10718 | 10724 | #ifdef SQLITE_ENABLE_STAT3 |
| 10719 | 10725 | int nSample; /* Number of elements in aSample[] */ |
| 10720 | 10726 | tRowcnt avgEq; /* Average nEq value for key values not in aSample */ |
| 10721 | 10727 | IndexSample *aSample; /* Samples of the left-most key */ |
| 10722 | 10728 | #endif |
| | @@ -11058,10 +11064,15 @@ |
| 11058 | 11064 | /* |
| 11059 | 11065 | ** The number of bits in a Bitmask. "BMS" means "BitMask Size". |
| 11060 | 11066 | */ |
| 11061 | 11067 | #define BMS ((int)(sizeof(Bitmask)*8)) |
| 11062 | 11068 | |
| 11069 | +/* |
| 11070 | +** A bit in a Bitmask |
| 11071 | +*/ |
| 11072 | +#define MASKBIT(n) (((Bitmask)1)<<(n)) |
| 11073 | + |
| 11063 | 11074 | /* |
| 11064 | 11075 | ** The following structure describes the FROM clause of a SELECT statement. |
| 11065 | 11076 | ** Each table or subquery in the FROM clause is a separate element of |
| 11066 | 11077 | ** the SrcList.a[] array. |
| 11067 | 11078 | ** |
| | @@ -11078,12 +11089,12 @@ |
| 11078 | 11089 | ** |
| 11079 | 11090 | ** In the colUsed field, the high-order bit (bit 63) is set if the table |
| 11080 | 11091 | ** contains more than 63 columns and the 64-th or later column is used. |
| 11081 | 11092 | */ |
| 11082 | 11093 | struct SrcList { |
| 11083 | | - i16 nSrc; /* Number of tables or subqueries in the FROM clause */ |
| 11084 | | - i16 nAlloc; /* Number of entries allocated in a[] below */ |
| 11094 | + u8 nSrc; /* Number of tables or subqueries in the FROM clause */ |
| 11095 | + u8 nAlloc; /* Number of entries allocated in a[] below */ |
| 11085 | 11096 | struct SrcList_item { |
| 11086 | 11097 | Schema *pSchema; /* Schema to which this item is fixed */ |
| 11087 | 11098 | char *zDatabase; /* Name of database holding this table */ |
| 11088 | 11099 | char *zName; /* Name of the table */ |
| 11089 | 11100 | char *zAlias; /* The "B" part of a "A AS B" phrase. zName is the "A" */ |
| | @@ -11117,83 +11128,10 @@ |
| 11117 | 11128 | #define JT_RIGHT 0x0010 /* Right outer join */ |
| 11118 | 11129 | #define JT_OUTER 0x0020 /* The "OUTER" keyword is present */ |
| 11119 | 11130 | #define JT_ERROR 0x0040 /* unknown or unsupported join type */ |
| 11120 | 11131 | |
| 11121 | 11132 | |
| 11122 | | -/* |
| 11123 | | -** A WherePlan object holds information that describes a lookup |
| 11124 | | -** strategy. |
| 11125 | | -** |
| 11126 | | -** This object is intended to be opaque outside of the where.c module. |
| 11127 | | -** It is included here only so that that compiler will know how big it |
| 11128 | | -** is. None of the fields in this object should be used outside of |
| 11129 | | -** the where.c module. |
| 11130 | | -** |
| 11131 | | -** Within the union, pIdx is only used when wsFlags&WHERE_INDEXED is true. |
| 11132 | | -** pTerm is only used when wsFlags&WHERE_MULTI_OR is true. And pVtabIdx |
| 11133 | | -** is only used when wsFlags&WHERE_VIRTUALTABLE is true. It is never the |
| 11134 | | -** case that more than one of these conditions is true. |
| 11135 | | -*/ |
| 11136 | | -struct WherePlan { |
| 11137 | | - u32 wsFlags; /* WHERE_* flags that describe the strategy */ |
| 11138 | | - u16 nEq; /* Number of == constraints */ |
| 11139 | | - u16 nOBSat; /* Number of ORDER BY terms satisfied */ |
| 11140 | | - double nRow; /* Estimated number of rows (for EQP) */ |
| 11141 | | - union { |
| 11142 | | - Index *pIdx; /* Index when WHERE_INDEXED is true */ |
| 11143 | | - struct WhereTerm *pTerm; /* WHERE clause term for OR-search */ |
| 11144 | | - sqlite3_index_info *pVtabIdx; /* Virtual table index to use */ |
| 11145 | | - } u; |
| 11146 | | -}; |
| 11147 | | - |
| 11148 | | -/* |
| 11149 | | -** For each nested loop in a WHERE clause implementation, the WhereInfo |
| 11150 | | -** structure contains a single instance of this structure. This structure |
| 11151 | | -** is intended to be private to the where.c module and should not be |
| 11152 | | -** access or modified by other modules. |
| 11153 | | -** |
| 11154 | | -** The pIdxInfo field is used to help pick the best index on a |
| 11155 | | -** virtual table. The pIdxInfo pointer contains indexing |
| 11156 | | -** information for the i-th table in the FROM clause before reordering. |
| 11157 | | -** All the pIdxInfo pointers are freed by whereInfoFree() in where.c. |
| 11158 | | -** All other information in the i-th WhereLevel object for the i-th table |
| 11159 | | -** after FROM clause ordering. |
| 11160 | | -*/ |
| 11161 | | -struct WhereLevel { |
| 11162 | | - WherePlan plan; /* query plan for this element of the FROM clause */ |
| 11163 | | - int iLeftJoin; /* Memory cell used to implement LEFT OUTER JOIN */ |
| 11164 | | - int iTabCur; /* The VDBE cursor used to access the table */ |
| 11165 | | - int iIdxCur; /* The VDBE cursor used to access pIdx */ |
| 11166 | | - int addrBrk; /* Jump here to break out of the loop */ |
| 11167 | | - int addrNxt; /* Jump here to start the next IN combination */ |
| 11168 | | - int addrCont; /* Jump here to continue with the next loop cycle */ |
| 11169 | | - int addrFirst; /* First instruction of interior of the loop */ |
| 11170 | | - u8 iFrom; /* Which entry in the FROM clause */ |
| 11171 | | - u8 op, p5; /* Opcode and P5 of the opcode that ends the loop */ |
| 11172 | | - int p1, p2; /* Operands of the opcode used to ends the loop */ |
| 11173 | | - union { /* Information that depends on plan.wsFlags */ |
| 11174 | | - struct { |
| 11175 | | - int nIn; /* Number of entries in aInLoop[] */ |
| 11176 | | - struct InLoop { |
| 11177 | | - int iCur; /* The VDBE cursor used by this IN operator */ |
| 11178 | | - int addrInTop; /* Top of the IN loop */ |
| 11179 | | - u8 eEndLoopOp; /* IN Loop terminator. OP_Next or OP_Prev */ |
| 11180 | | - } *aInLoop; /* Information about each nested IN operator */ |
| 11181 | | - } in; /* Used when plan.wsFlags&WHERE_IN_ABLE */ |
| 11182 | | - Index *pCovidx; /* Possible covering index for WHERE_MULTI_OR */ |
| 11183 | | - } u; |
| 11184 | | - double rOptCost; /* "Optimal" cost for this level */ |
| 11185 | | - |
| 11186 | | - /* The following field is really not part of the current level. But |
| 11187 | | - ** we need a place to cache virtual table index information for each |
| 11188 | | - ** virtual table in the FROM clause and the WhereLevel structure is |
| 11189 | | - ** a convenient place since there is one WhereLevel for each FROM clause |
| 11190 | | - ** element. |
| 11191 | | - */ |
| 11192 | | - sqlite3_index_info *pIdxInfo; /* Index info for n-th source table */ |
| 11193 | | -}; |
| 11194 | | - |
| 11195 | 11133 | /* |
| 11196 | 11134 | ** Flags appropriate for the wctrlFlags parameter of sqlite3WhereBegin() |
| 11197 | 11135 | ** and the WhereInfo.wctrlFlags member. |
| 11198 | 11136 | */ |
| 11199 | 11137 | #define WHERE_ORDERBY_NORMAL 0x0000 /* No-op */ |
| | @@ -11203,37 +11141,15 @@ |
| 11203 | 11141 | #define WHERE_DUPLICATES_OK 0x0008 /* Ok to return a row more than once */ |
| 11204 | 11142 | #define WHERE_OMIT_OPEN_CLOSE 0x0010 /* Table cursors are already open */ |
| 11205 | 11143 | #define WHERE_FORCE_TABLE 0x0020 /* Do not use an index-only search */ |
| 11206 | 11144 | #define WHERE_ONETABLE_ONLY 0x0040 /* Only code the 1st table in pTabList */ |
| 11207 | 11145 | #define WHERE_AND_ONLY 0x0080 /* Don't use indices for OR terms */ |
| 11208 | | - |
| 11209 | | -/* |
| 11210 | | -** The WHERE clause processing routine has two halves. The |
| 11211 | | -** first part does the start of the WHERE loop and the second |
| 11212 | | -** half does the tail of the WHERE loop. An instance of |
| 11213 | | -** this structure is returned by the first half and passed |
| 11214 | | -** into the second half to give some continuity. |
| 11215 | | -*/ |
| 11216 | | -struct WhereInfo { |
| 11217 | | - Parse *pParse; /* Parsing and code generating context */ |
| 11218 | | - SrcList *pTabList; /* List of tables in the join */ |
| 11219 | | - u16 nOBSat; /* Number of ORDER BY terms satisfied by indices */ |
| 11220 | | - u16 wctrlFlags; /* Flags originally passed to sqlite3WhereBegin() */ |
| 11221 | | - u8 okOnePass; /* Ok to use one-pass algorithm for UPDATE/DELETE */ |
| 11222 | | - u8 untestedTerms; /* Not all WHERE terms resolved by outer loop */ |
| 11223 | | - u8 eDistinct; /* One of the WHERE_DISTINCT_* values below */ |
| 11224 | | - int iTop; /* The very beginning of the WHERE loop */ |
| 11225 | | - int iContinue; /* Jump here to continue with next record */ |
| 11226 | | - int iBreak; /* Jump here to break out of the loop */ |
| 11227 | | - int nLevel; /* Number of nested loop */ |
| 11228 | | - struct WhereClause *pWC; /* Decomposition of the WHERE clause */ |
| 11229 | | - double savedNQueryLoop; /* pParse->nQueryLoop outside the WHERE loop */ |
| 11230 | | - double nRowOut; /* Estimated number of output rows */ |
| 11231 | | - WhereLevel a[1]; /* Information about each nest loop in WHERE */ |
| 11232 | | -}; |
| 11233 | | - |
| 11234 | | -/* Allowed values for WhereInfo.eDistinct and DistinctCtx.eTnctType */ |
| 11146 | +#define WHERE_GROUPBY 0x0100 /* pOrderBy is really a GROUP BY */ |
| 11147 | +#define WHERE_DISTINCTBY 0x0200 /* pOrderby is really a DISTINCT clause */ |
| 11148 | + |
| 11149 | +/* Allowed return values from sqlite3WhereIsDistinct() |
| 11150 | +*/ |
| 11235 | 11151 | #define WHERE_DISTINCT_NOOP 0 /* DISTINCT keyword not used */ |
| 11236 | 11152 | #define WHERE_DISTINCT_UNIQUE 1 /* No duplicates */ |
| 11237 | 11153 | #define WHERE_DISTINCT_ORDERED 2 /* All duplicates are adjacent */ |
| 11238 | 11154 | #define WHERE_DISTINCT_UNORDERED 3 /* Duplicates are scattered */ |
| 11239 | 11155 | |
| | @@ -11303,11 +11219,11 @@ |
| 11303 | 11219 | ExprList *pEList; /* The fields of the result */ |
| 11304 | 11220 | u8 op; /* One of: TK_UNION TK_ALL TK_INTERSECT TK_EXCEPT */ |
| 11305 | 11221 | u16 selFlags; /* Various SF_* values */ |
| 11306 | 11222 | int iLimit, iOffset; /* Memory registers holding LIMIT & OFFSET counters */ |
| 11307 | 11223 | int addrOpenEphm[3]; /* OP_OpenEphem opcodes related to this select */ |
| 11308 | | - double nSelectRow; /* Estimated number of result rows */ |
| 11224 | + u64 nSelectRow; /* Estimated number of result rows */ |
| 11309 | 11225 | SrcList *pSrc; /* The FROM clause */ |
| 11310 | 11226 | Expr *pWhere; /* The WHERE clause */ |
| 11311 | 11227 | ExprList *pGroupBy; /* The GROUP BY clause */ |
| 11312 | 11228 | Expr *pHaving; /* The HAVING clause */ |
| 11313 | 11229 | ExprList *pOrderBy; /* The ORDER BY clause */ |
| | @@ -11487,11 +11403,11 @@ |
| 11487 | 11403 | AutoincInfo *pAinc; /* Information about AUTOINCREMENT counters */ |
| 11488 | 11404 | |
| 11489 | 11405 | /* Information used while coding trigger programs. */ |
| 11490 | 11406 | Parse *pToplevel; /* Parse structure for main program (or NULL) */ |
| 11491 | 11407 | Table *pTriggerTab; /* Table triggers are being coded for */ |
| 11492 | | - double nQueryLoop; /* Estimated number of iterations of a query */ |
| 11408 | + u32 nQueryLoop; /* Est number of iterations of a query (10*log2(N)) */ |
| 11493 | 11409 | u32 oldmask; /* Mask of old.* columns referenced */ |
| 11494 | 11410 | u32 newmask; /* Mask of new.* columns referenced */ |
| 11495 | 11411 | u8 eTriggerOp; /* TK_UPDATE, TK_INSERT or TK_DELETE */ |
| 11496 | 11412 | u8 eOrconf; /* Default ON CONFLICT policy for trigger steps */ |
| 11497 | 11413 | u8 disableTriggers; /* True to disable triggers */ |
| | @@ -12057,10 +11973,16 @@ |
| 12057 | 11973 | #endif |
| 12058 | 11974 | SQLITE_PRIVATE void sqlite3DeleteFrom(Parse*, SrcList*, Expr*); |
| 12059 | 11975 | SQLITE_PRIVATE void sqlite3Update(Parse*, SrcList*, ExprList*, Expr*, int); |
| 12060 | 11976 | SQLITE_PRIVATE WhereInfo *sqlite3WhereBegin(Parse*,SrcList*,Expr*,ExprList*,ExprList*,u16,int); |
| 12061 | 11977 | SQLITE_PRIVATE void sqlite3WhereEnd(WhereInfo*); |
| 11978 | +SQLITE_PRIVATE u64 sqlite3WhereOutputRowCount(WhereInfo*); |
| 11979 | +SQLITE_PRIVATE int sqlite3WhereIsDistinct(WhereInfo*); |
| 11980 | +SQLITE_PRIVATE int sqlite3WhereIsOrdered(WhereInfo*); |
| 11981 | +SQLITE_PRIVATE int sqlite3WhereContinueLabel(WhereInfo*); |
| 11982 | +SQLITE_PRIVATE int sqlite3WhereBreakLabel(WhereInfo*); |
| 11983 | +SQLITE_PRIVATE int sqlite3WhereOkOnePass(WhereInfo*); |
| 12062 | 11984 | SQLITE_PRIVATE int sqlite3ExprCodeGetColumn(Parse*, Table*, int, int, int, u8); |
| 12063 | 11985 | SQLITE_PRIVATE void sqlite3ExprCodeGetColumnOfTable(Vdbe*, Table*, int, int, int); |
| 12064 | 11986 | SQLITE_PRIVATE void sqlite3ExprCodeMove(Parse*, int, int, int); |
| 12065 | 11987 | SQLITE_PRIVATE void sqlite3ExprCacheStore(Parse*, int, int, int); |
| 12066 | 11988 | SQLITE_PRIVATE void sqlite3ExprCachePush(Parse*); |
| | @@ -19960,17 +19882,11 @@ |
| 19960 | 19882 | if( flag_plussign ) prefix = '+'; |
| 19961 | 19883 | else if( flag_blanksign ) prefix = ' '; |
| 19962 | 19884 | else prefix = 0; |
| 19963 | 19885 | } |
| 19964 | 19886 | if( xtype==etGENERIC && precision>0 ) precision--; |
| 19965 | | -#if 0 |
| 19966 | | - /* Rounding works like BSD when the constant 0.4999 is used. Wierd! */ |
| 19967 | | - for(idx=precision, rounder=0.4999; idx>0; idx--, rounder*=0.1); |
| 19968 | | -#else |
| 19969 | | - /* It makes more sense to use 0.5 */ |
| 19970 | 19887 | for(idx=precision, rounder=0.5; idx>0; idx--, rounder*=0.1){} |
| 19971 | | -#endif |
| 19972 | 19888 | if( xtype==etFLOAT ) realvalue += rounder; |
| 19973 | 19889 | /* Normalize realvalue to within 10.0 > realvalue >= 1.0 */ |
| 19974 | 19890 | exp = 0; |
| 19975 | 19891 | if( sqlite3IsNaN((double)realvalue) ){ |
| 19976 | 19892 | bufpt = "NaN"; |
| | @@ -22929,17 +22845,10 @@ |
| 22929 | 22845 | ** * Definitions of sqlite3_vfs objects for all locking methods |
| 22930 | 22846 | ** plus implementations of sqlite3_os_init() and sqlite3_os_end(). |
| 22931 | 22847 | */ |
| 22932 | 22848 | #if SQLITE_OS_UNIX /* This file is used on unix only */ |
| 22933 | 22849 | |
| 22934 | | -/* Use posix_fallocate() if it is available |
| 22935 | | -*/ |
| 22936 | | -#if !defined(HAVE_POSIX_FALLOCATE) \ |
| 22937 | | - && (_XOPEN_SOURCE >= 600 || _POSIX_C_SOURCE >= 200112L) |
| 22938 | | -# define HAVE_POSIX_FALLOCATE 1 |
| 22939 | | -#endif |
| 22940 | | - |
| 22941 | 22850 | /* |
| 22942 | 22851 | ** There are various methods for file locking used for concurrency |
| 22943 | 22852 | ** control: |
| 22944 | 22853 | ** |
| 22945 | 22854 | ** 1. POSIX locking (the default), |
| | @@ -26866,19 +26775,23 @@ |
| 26866 | 26775 | } |
| 26867 | 26776 | return SQLITE_OK; |
| 26868 | 26777 | } |
| 26869 | 26778 | case SQLITE_FCNTL_MMAP_SIZE: { |
| 26870 | 26779 | i64 newLimit = *(i64*)pArg; |
| 26780 | + int rc = SQLITE_OK; |
| 26871 | 26781 | if( newLimit>sqlite3GlobalConfig.mxMmap ){ |
| 26872 | 26782 | newLimit = sqlite3GlobalConfig.mxMmap; |
| 26873 | 26783 | } |
| 26874 | 26784 | *(i64*)pArg = pFile->mmapSizeMax; |
| 26875 | | - if( newLimit>=0 ){ |
| 26785 | + if( newLimit>=0 && newLimit!=pFile->mmapSizeMax && pFile->nFetchOut==0 ){ |
| 26876 | 26786 | pFile->mmapSizeMax = newLimit; |
| 26877 | | - if( newLimit<pFile->mmapSize ) pFile->mmapSize = newLimit; |
| 26787 | + if( pFile->mmapSize>0 ){ |
| 26788 | + unixUnmapfile(pFile); |
| 26789 | + rc = unixMapfile(pFile, -1); |
| 26790 | + } |
| 26878 | 26791 | } |
| 26879 | | - return SQLITE_OK; |
| 26792 | + return rc; |
| 26880 | 26793 | } |
| 26881 | 26794 | #ifdef SQLITE_DEBUG |
| 26882 | 26795 | /* The pager calls this method to signal that it has done |
| 26883 | 26796 | ** a rollback and that the database is therefore unchanged and |
| 26884 | 26797 | ** it hence it is OK for the transaction change counter to be |
| | @@ -28244,11 +28157,11 @@ |
| 28244 | 28157 | OSTRACE(("OPEN %-3d %s\n", h, zFilename)); |
| 28245 | 28158 | pNew->h = h; |
| 28246 | 28159 | pNew->pVfs = pVfs; |
| 28247 | 28160 | pNew->zPath = zFilename; |
| 28248 | 28161 | pNew->ctrlFlags = (u8)ctrlFlags; |
| 28249 | | - pNew->mmapSizeMax = sqlite3GlobalConfig.mxMmap; |
| 28162 | + pNew->mmapSizeMax = sqlite3GlobalConfig.szMmap; |
| 28250 | 28163 | if( sqlite3_uri_boolean(((ctrlFlags & UNIXFILE_URI) ? zFilename : 0), |
| 28251 | 28164 | "psow", SQLITE_POWERSAFE_OVERWRITE) ){ |
| 28252 | 28165 | pNew->ctrlFlags |= UNIXFILE_PSOW; |
| 28253 | 28166 | } |
| 28254 | 28167 | if( strcmp(pVfs->zName,"unix-excl")==0 ){ |
| | @@ -30799,17 +30712,10 @@ |
| 30799 | 30712 | ** This file mapping API is common to both Win32 and WinRT. |
| 30800 | 30713 | */ |
| 30801 | 30714 | WINBASEAPI BOOL WINAPI UnmapViewOfFile(LPCVOID); |
| 30802 | 30715 | #endif /* SQLITE_WIN32_FILEMAPPING_API && !defined(SQLITE_OMIT_WAL) */ |
| 30803 | 30716 | |
| 30804 | | -/* |
| 30805 | | -** Macro to find the minimum of two numeric values. |
| 30806 | | -*/ |
| 30807 | | -#ifndef MIN |
| 30808 | | -# define MIN(x,y) ((x)<(y)?(x):(y)) |
| 30809 | | -#endif |
| 30810 | | - |
| 30811 | 30717 | /* |
| 30812 | 30718 | ** Some Microsoft compilers lack this definition. |
| 30813 | 30719 | */ |
| 30814 | 30720 | #ifndef INVALID_FILE_ATTRIBUTES |
| 30815 | 30721 | # define INVALID_FILE_ATTRIBUTES ((DWORD)-1) |
| | @@ -33531,10 +33437,13 @@ |
| 33531 | 33437 | } |
| 33532 | 33438 | } |
| 33533 | 33439 | |
| 33534 | 33440 | /* Forward declaration */ |
| 33535 | 33441 | static int getTempname(int nBuf, char *zBuf); |
| 33442 | +#if SQLITE_MAX_MMAP_SIZE>0 |
| 33443 | +static int winMapfile(winFile*, sqlite3_int64); |
| 33444 | +#endif |
| 33536 | 33445 | |
| 33537 | 33446 | /* |
| 33538 | 33447 | ** Control and query of the open file handle. |
| 33539 | 33448 | */ |
| 33540 | 33449 | static int winFileControl(sqlite3_file *id, int op, void *pArg){ |
| | @@ -33614,17 +33523,24 @@ |
| 33614 | 33523 | return SQLITE_OK; |
| 33615 | 33524 | } |
| 33616 | 33525 | #if SQLITE_MAX_MMAP_SIZE>0 |
| 33617 | 33526 | case SQLITE_FCNTL_MMAP_SIZE: { |
| 33618 | 33527 | i64 newLimit = *(i64*)pArg; |
| 33528 | + int rc = SQLITE_OK; |
| 33619 | 33529 | if( newLimit>sqlite3GlobalConfig.mxMmap ){ |
| 33620 | 33530 | newLimit = sqlite3GlobalConfig.mxMmap; |
| 33621 | 33531 | } |
| 33622 | 33532 | *(i64*)pArg = pFile->mmapSizeMax; |
| 33623 | | - if( newLimit>=0 ) pFile->mmapSizeMax = newLimit; |
| 33624 | | - OSTRACE(("FCNTL file=%p, rc=SQLITE_OK\n", pFile->h)); |
| 33625 | | - return SQLITE_OK; |
| 33533 | + if( newLimit>=0 && newLimit!=pFile->mmapSizeMax && pFile->nFetchOut==0 ){ |
| 33534 | + pFile->mmapSizeMax = newLimit; |
| 33535 | + if( pFile->mmapSize>0 ){ |
| 33536 | + (void)winUnmapfile(pFile); |
| 33537 | + rc = winMapfile(pFile, -1); |
| 33538 | + } |
| 33539 | + } |
| 33540 | + OSTRACE(("FCNTL file=%p, rc=%d\n", pFile->h, rc)); |
| 33541 | + return rc; |
| 33626 | 33542 | } |
| 33627 | 33543 | #endif |
| 33628 | 33544 | } |
| 33629 | 33545 | OSTRACE(("FCNTL file=%p, rc=SQLITE_NOTFOUND\n", pFile->h)); |
| 33630 | 33546 | return SQLITE_NOTFOUND; |
| | @@ -33652,19 +33568,19 @@ |
| 33652 | 33568 | winFile *p = (winFile*)id; |
| 33653 | 33569 | return SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN | |
| 33654 | 33570 | ((p->ctrlFlags & WINFILE_PSOW)?SQLITE_IOCAP_POWERSAFE_OVERWRITE:0); |
| 33655 | 33571 | } |
| 33656 | 33572 | |
| 33657 | | -#ifndef SQLITE_OMIT_WAL |
| 33658 | | - |
| 33659 | 33573 | /* |
| 33660 | 33574 | ** Windows will only let you create file view mappings |
| 33661 | 33575 | ** on allocation size granularity boundaries. |
| 33662 | 33576 | ** During sqlite3_os_init() we do a GetSystemInfo() |
| 33663 | 33577 | ** to get the granularity size. |
| 33664 | 33578 | */ |
| 33665 | 33579 | SYSTEM_INFO winSysInfo; |
| 33580 | + |
| 33581 | +#ifndef SQLITE_OMIT_WAL |
| 33666 | 33582 | |
| 33667 | 33583 | /* |
| 33668 | 33584 | ** Helper functions to obtain and relinquish the global mutex. The |
| 33669 | 33585 | ** global mutex is used to protect the winLockInfo objects used by |
| 33670 | 33586 | ** this file, all of which may be shared by multiple threads. |
| | @@ -34961,11 +34877,11 @@ |
| 34961 | 34877 | #if SQLITE_MAX_MMAP_SIZE>0 |
| 34962 | 34878 | pFile->hMap = NULL; |
| 34963 | 34879 | pFile->pMapRegion = 0; |
| 34964 | 34880 | pFile->mmapSize = 0; |
| 34965 | 34881 | pFile->mmapSizeActual = 0; |
| 34966 | | - pFile->mmapSizeMax = sqlite3GlobalConfig.mxMmap; |
| 34882 | + pFile->mmapSizeMax = sqlite3GlobalConfig.szMmap; |
| 34967 | 34883 | #endif |
| 34968 | 34884 | |
| 34969 | 34885 | OpenCounter(+1); |
| 34970 | 34886 | return rc; |
| 34971 | 34887 | } |
| | @@ -37220,11 +37136,11 @@ |
| 37220 | 37136 | PCache1 *pCache; /* The newly created page cache */ |
| 37221 | 37137 | PGroup *pGroup; /* The group the new page cache will belong to */ |
| 37222 | 37138 | int sz; /* Bytes of memory required to allocate the new cache */ |
| 37223 | 37139 | |
| 37224 | 37140 | /* |
| 37225 | | - ** The seperateCache variable is true if each PCache has its own private |
| 37141 | + ** The separateCache variable is true if each PCache has its own private |
| 37226 | 37142 | ** PGroup. In other words, separateCache is true for mode (1) where no |
| 37227 | 37143 | ** mutexing is required. |
| 37228 | 37144 | ** |
| 37229 | 37145 | ** * Always use a unified cache (mode-2) if ENABLE_MEMORY_MANAGEMENT |
| 37230 | 37146 | ** |
| | @@ -42544,11 +42460,12 @@ |
| 42544 | 42460 | /* Before the first write, give the VFS a hint of what the final |
| 42545 | 42461 | ** file size will be. |
| 42546 | 42462 | */ |
| 42547 | 42463 | assert( rc!=SQLITE_OK || isOpen(pPager->fd) ); |
| 42548 | 42464 | if( rc==SQLITE_OK |
| 42549 | | - && (pList->pDirty ? pPager->dbSize : pList->pgno+1)>pPager->dbHintSize |
| 42465 | + && pPager->dbHintSize<pPager->dbSize |
| 42466 | + && (pList->pDirty || pList->pgno>pPager->dbHintSize) |
| 42550 | 42467 | ){ |
| 42551 | 42468 | sqlite3_int64 szFile = pPager->pageSize * (sqlite3_int64)pPager->dbSize; |
| 42552 | 42469 | sqlite3OsFileControlHint(pPager->fd, SQLITE_FCNTL_SIZE_HINT, &szFile); |
| 42553 | 42470 | pPager->dbHintSize = pPager->dbSize; |
| 42554 | 42471 | } |
| | @@ -43509,11 +43426,11 @@ |
| 43509 | 43426 | ** requested page is not already stored in the cache, then no |
| 43510 | 43427 | ** actual disk read occurs. In this case the memory image of the |
| 43511 | 43428 | ** page is initialized to all zeros. |
| 43512 | 43429 | ** |
| 43513 | 43430 | ** If noContent is true, it means that we do not care about the contents |
| 43514 | | -** of the page. This occurs in two seperate scenarios: |
| 43431 | +** of the page. This occurs in two scenarios: |
| 43515 | 43432 | ** |
| 43516 | 43433 | ** a) When reading a free-list leaf page from the database, and |
| 43517 | 43434 | ** |
| 43518 | 43435 | ** b) When a savepoint is being rolled back and we need to load |
| 43519 | 43436 | ** a new page into the cache to be filled with the data read |
| | @@ -44919,11 +44836,31 @@ |
| 44919 | 44836 | pagerReportSize(pPager); |
| 44920 | 44837 | } |
| 44921 | 44838 | SQLITE_PRIVATE void *sqlite3PagerGetCodec(Pager *pPager){ |
| 44922 | 44839 | return pPager->pCodec; |
| 44923 | 44840 | } |
| 44924 | | -#endif |
| 44841 | + |
| 44842 | +/* |
| 44843 | +** This function is called by the wal module when writing page content |
| 44844 | +** into the log file. |
| 44845 | +** |
| 44846 | +** This function returns a pointer to a buffer containing the encrypted |
| 44847 | +** page content. If a malloc fails, this function may return NULL. |
| 44848 | +*/ |
| 44849 | +SQLITE_PRIVATE void *sqlite3PagerCodec(PgHdr *pPg){ |
| 44850 | + void *aData = 0; |
| 44851 | + CODEC2(pPg->pPager, pPg->pData, pPg->pgno, 6, return 0, aData); |
| 44852 | + return aData; |
| 44853 | +} |
| 44854 | + |
| 44855 | +/* |
| 44856 | +** Return the current pager state |
| 44857 | +*/ |
| 44858 | +SQLITE_PRIVATE int sqlite3PagerState(Pager *pPager){ |
| 44859 | + return pPager->eState; |
| 44860 | +} |
| 44861 | +#endif /* SQLITE_HAS_CODEC */ |
| 44925 | 44862 | |
| 44926 | 44863 | #ifndef SQLITE_OMIT_AUTOVACUUM |
| 44927 | 44864 | /* |
| 44928 | 44865 | ** Move the page pPg to location pgno in the file. |
| 44929 | 44866 | ** |
| | @@ -45474,25 +45411,10 @@ |
| 45474 | 45411 | assert( pPager->eState==PAGER_READER ); |
| 45475 | 45412 | return sqlite3WalFramesize(pPager->pWal); |
| 45476 | 45413 | } |
| 45477 | 45414 | #endif |
| 45478 | 45415 | |
| 45479 | | -#ifdef SQLITE_HAS_CODEC |
| 45480 | | -/* |
| 45481 | | -** This function is called by the wal module when writing page content |
| 45482 | | -** into the log file. |
| 45483 | | -** |
| 45484 | | -** This function returns a pointer to a buffer containing the encrypted |
| 45485 | | -** page content. If a malloc fails, this function may return NULL. |
| 45486 | | -*/ |
| 45487 | | -SQLITE_PRIVATE void *sqlite3PagerCodec(PgHdr *pPg){ |
| 45488 | | - void *aData = 0; |
| 45489 | | - CODEC2(pPg->pPager, pPg->pData, pPg->pgno, 6, return 0, aData); |
| 45490 | | - return aData; |
| 45491 | | -} |
| 45492 | | -#endif /* SQLITE_HAS_CODEC */ |
| 45493 | | - |
| 45494 | 45416 | #endif /* SQLITE_OMIT_DISKIO */ |
| 45495 | 45417 | |
| 45496 | 45418 | /************** End of pager.c ***********************************************/ |
| 45497 | 45419 | /************** Begin file wal.c *********************************************/ |
| 45498 | 45420 | /* |
| | @@ -50759,11 +50681,11 @@ |
| 50759 | 50681 | if( rc ) return rc; |
| 50760 | 50682 | top = get2byteNotZero(&data[hdr+5]); |
| 50761 | 50683 | }else if( gap+2<=top ){ |
| 50762 | 50684 | /* Search the freelist looking for a free slot big enough to satisfy |
| 50763 | 50685 | ** the request. The allocation is made from the first free slot in |
| 50764 | | - ** the list that is large enough to accomadate it. |
| 50686 | + ** the list that is large enough to accommodate it. |
| 50765 | 50687 | */ |
| 50766 | 50688 | int pc, addr; |
| 50767 | 50689 | for(addr=hdr+1; (pc = get2byte(&data[addr]))>0; addr=pc){ |
| 50768 | 50690 | int size; /* Size of the free slot */ |
| 50769 | 50691 | if( pc>usableSize-4 || pc<addr+4 ){ |
| | @@ -52702,11 +52624,11 @@ |
| 52702 | 52624 | return rc; |
| 52703 | 52625 | } |
| 52704 | 52626 | |
| 52705 | 52627 | /* |
| 52706 | 52628 | ** This routine is called prior to sqlite3PagerCommit when a transaction |
| 52707 | | -** is commited for an auto-vacuum database. |
| 52629 | +** is committed for an auto-vacuum database. |
| 52708 | 52630 | ** |
| 52709 | 52631 | ** If SQLITE_OK is returned, then *pnTrunc is set to the number of pages |
| 52710 | 52632 | ** the database file should be truncated to during the commit process. |
| 52711 | 52633 | ** i.e. the database has been reorganized so that only the first *pnTrunc |
| 52712 | 52634 | ** pages are in use. |
| | @@ -58045,16 +57967,10 @@ |
| 58045 | 57967 | ************************************************************************* |
| 58046 | 57968 | ** This file contains the implementation of the sqlite3_backup_XXX() |
| 58047 | 57969 | ** API functions and the related features. |
| 58048 | 57970 | */ |
| 58049 | 57971 | |
| 58050 | | -/* Macro to find the minimum of two numeric values. |
| 58051 | | -*/ |
| 58052 | | -#ifndef MIN |
| 58053 | | -# define MIN(x,y) ((x)<(y)?(x):(y)) |
| 58054 | | -#endif |
| 58055 | | - |
| 58056 | 57972 | /* |
| 58057 | 57973 | ** Structure allocated for each backup operation. |
| 58058 | 57974 | */ |
| 58059 | 57975 | struct sqlite3_backup { |
| 58060 | 57976 | sqlite3* pDestDb; /* Destination database handle */ |
| | @@ -61942,11 +61858,11 @@ |
| 61942 | 61858 | /* |
| 61943 | 61859 | ** If the Vdbe passed as the first argument opened a statement-transaction, |
| 61944 | 61860 | ** close it now. Argument eOp must be either SAVEPOINT_ROLLBACK or |
| 61945 | 61861 | ** SAVEPOINT_RELEASE. If it is SAVEPOINT_ROLLBACK, then the statement |
| 61946 | 61862 | ** transaction is rolled back. If eOp is SAVEPOINT_RELEASE, then the |
| 61947 | | -** statement transaction is commtted. |
| 61863 | +** statement transaction is committed. |
| 61948 | 61864 | ** |
| 61949 | 61865 | ** If an IO error occurs, an SQLITE_IOERR_XXX error code is returned. |
| 61950 | 61866 | ** Otherwise SQLITE_OK. |
| 61951 | 61867 | */ |
| 61952 | 61868 | SQLITE_PRIVATE int sqlite3VdbeCloseStatement(Vdbe *p, int eOp){ |
| | @@ -64011,17 +63927,10 @@ |
| 64011 | 63927 | int iType = sqlite3_value_type( columnMem(pStmt,i) ); |
| 64012 | 63928 | columnMallocFailure(pStmt); |
| 64013 | 63929 | return iType; |
| 64014 | 63930 | } |
| 64015 | 63931 | |
| 64016 | | -/* The following function is experimental and subject to change or |
| 64017 | | -** removal */ |
| 64018 | | -/*int sqlite3_column_numeric_type(sqlite3_stmt *pStmt, int i){ |
| 64019 | | -** return sqlite3_value_numeric_type( columnMem(pStmt,i) ); |
| 64020 | | -**} |
| 64021 | | -*/ |
| 64022 | | - |
| 64023 | 63932 | /* |
| 64024 | 63933 | ** Convert the N-th element of pStmt->pColName[] into a string using |
| 64025 | 63934 | ** xFunc() then return that string. If N is out of range, return 0. |
| 64026 | 63935 | ** |
| 64027 | 63936 | ** There are up to 5 names for each column. useType determines which |
| | @@ -64643,18 +64552,18 @@ |
| 64643 | 64552 | pVar = &utf8; |
| 64644 | 64553 | } |
| 64645 | 64554 | #endif |
| 64646 | 64555 | nOut = pVar->n; |
| 64647 | 64556 | #ifdef SQLITE_TRACE_SIZE_LIMIT |
| 64648 | | - if( n>SQLITE_TRACE_SIZE_LIMIT ){ |
| 64557 | + if( nOut>SQLITE_TRACE_SIZE_LIMIT ){ |
| 64649 | 64558 | nOut = SQLITE_TRACE_SIZE_LIMIT; |
| 64650 | | - while( nOut<pVar->n && (pVar->z[n]&0xc0)==0x80 ){ n++; } |
| 64559 | + while( nOut<pVar->n && (pVar->z[nOut]&0xc0)==0x80 ){ nOut++; } |
| 64651 | 64560 | } |
| 64652 | 64561 | #endif |
| 64653 | 64562 | sqlite3XPrintf(&out, "'%.*q'", nOut, pVar->z); |
| 64654 | 64563 | #ifdef SQLITE_TRACE_SIZE_LIMIT |
| 64655 | | - if( nOut<pVar->n ) sqlite3XPrintf(&out, "/*+%d bytes*/", pVar->n-n); |
| 64564 | + if( nOut<pVar->n ) sqlite3XPrintf(&out, "/*+%d bytes*/", pVar->n-nOut); |
| 64656 | 64565 | #endif |
| 64657 | 64566 | #ifndef SQLITE_OMIT_UTF16 |
| 64658 | 64567 | if( enc!=SQLITE_UTF8 ) sqlite3VdbeMemRelease(&utf8); |
| 64659 | 64568 | #endif |
| 64660 | 64569 | }else if( pVar->flags & MEM_Zero ){ |
| | @@ -64670,11 +64579,11 @@ |
| 64670 | 64579 | for(i=0; i<nOut; i++){ |
| 64671 | 64580 | sqlite3XPrintf(&out, "%02x", pVar->z[i]&0xff); |
| 64672 | 64581 | } |
| 64673 | 64582 | sqlite3StrAccumAppend(&out, "'", 1); |
| 64674 | 64583 | #ifdef SQLITE_TRACE_SIZE_LIMIT |
| 64675 | | - if( nOut<pVar->n ) sqlite3XPrintf(&out, "/*+%d bytes*/", pVar->n-n); |
| 64584 | + if( nOut<pVar->n ) sqlite3XPrintf(&out, "/*+%d bytes*/", pVar->n-nOut); |
| 64676 | 64585 | #endif |
| 64677 | 64586 | } |
| 64678 | 64587 | } |
| 64679 | 64588 | } |
| 64680 | 64589 | return sqlite3StrAccumFinish(&out); |
| | @@ -68269,12 +68178,12 @@ |
| 68269 | 68178 | ** If P2 is non-zero, then a write-transaction is started. A RESERVED lock is |
| 68270 | 68179 | ** obtained on the database file when a write-transaction is started. No |
| 68271 | 68180 | ** other process can start another write transaction while this transaction is |
| 68272 | 68181 | ** underway. Starting a write transaction also creates a rollback journal. A |
| 68273 | 68182 | ** write transaction must be started before any changes can be made to the |
| 68274 | | -** database. If P2 is 2 or greater then an EXCLUSIVE lock is also obtained |
| 68275 | | -** on the file. |
| 68183 | +** database. If P2 is greater than or equal to 2 then an EXCLUSIVE lock is |
| 68184 | +** also obtained on the file. |
| 68276 | 68185 | ** |
| 68277 | 68186 | ** If a write-transaction is started and the Vdbe.usesStmtJournal flag is |
| 68278 | 68187 | ** true (this flag is set if the Vdbe may modify more than one row and may |
| 68279 | 68188 | ** throw an ABORT exception), a statement transaction may also be opened. |
| 68280 | 68189 | ** More specifically, a statement transaction is opened iff the database |
| | @@ -72224,11 +72133,11 @@ |
| 72224 | 72133 | ** |
| 72225 | 72134 | ** For the purposes of this comparison, EOF is considered greater than any |
| 72226 | 72135 | ** other key value. If the keys are equal (only possible with two EOF |
| 72227 | 72136 | ** values), it doesn't matter which index is stored. |
| 72228 | 72137 | ** |
| 72229 | | -** The (N/4) elements of aTree[] that preceed the final (N/2) described |
| 72138 | +** The (N/4) elements of aTree[] that precede the final (N/2) described |
| 72230 | 72139 | ** above contains the index of the smallest of each block of 4 iterators. |
| 72231 | 72140 | ** And so on. So that aTree[1] contains the index of the iterator that |
| 72232 | 72141 | ** currently points to the smallest key value. aTree[0] is unused. |
| 72233 | 72142 | ** |
| 72234 | 72143 | ** Example: |
| | @@ -73499,16 +73408,10 @@ |
| 73499 | 73408 | ** a power-of-two allocation. This mimimizes wasted space in power-of-two |
| 73500 | 73409 | ** memory allocators. |
| 73501 | 73410 | */ |
| 73502 | 73411 | #define JOURNAL_CHUNKSIZE ((int)(1024-sizeof(FileChunk*))) |
| 73503 | 73412 | |
| 73504 | | -/* Macro to find the minimum of two numeric values. |
| 73505 | | -*/ |
| 73506 | | -#ifndef MIN |
| 73507 | | -# define MIN(x,y) ((x)<(y)?(x):(y)) |
| 73508 | | -#endif |
| 73509 | | - |
| 73510 | 73413 | /* |
| 73511 | 73414 | ** The rollback journal is composed of a linked list of these structures. |
| 73512 | 73415 | */ |
| 73513 | 73416 | struct FileChunk { |
| 73514 | 73417 | FileChunk *pNext; /* Next chunk in the journal */ |
| | @@ -75045,12 +74948,12 @@ |
| 75045 | 74948 | ** |
| 75046 | 74949 | ** Minor point: If this is the case, then the expression will be |
| 75047 | 74950 | ** re-evaluated for each reference to it. |
| 75048 | 74951 | */ |
| 75049 | 74952 | sNC.pEList = p->pEList; |
| 75050 | | - if( sqlite3ResolveExprNames(&sNC, p->pHaving) ) return WRC_Abort; |
| 75051 | 74953 | sNC.ncFlags |= NC_AsMaybe; |
| 74954 | + if( sqlite3ResolveExprNames(&sNC, p->pHaving) ) return WRC_Abort; |
| 75052 | 74955 | if( sqlite3ResolveExprNames(&sNC, p->pWhere) ) return WRC_Abort; |
| 75053 | 74956 | sNC.ncFlags &= ~NC_AsMaybe; |
| 75054 | 74957 | |
| 75055 | 74958 | /* The ORDER BY and GROUP BY clauses may not refer to terms in |
| 75056 | 74959 | ** outer queries |
| | @@ -76817,19 +76720,19 @@ |
| 76817 | 76720 | |
| 76818 | 76721 | if( eType==0 ){ |
| 76819 | 76722 | /* Could not found an existing table or index to use as the RHS b-tree. |
| 76820 | 76723 | ** We will have to generate an ephemeral table to do the job. |
| 76821 | 76724 | */ |
| 76822 | | - double savedNQueryLoop = pParse->nQueryLoop; |
| 76725 | + u32 savedNQueryLoop = pParse->nQueryLoop; |
| 76823 | 76726 | int rMayHaveNull = 0; |
| 76824 | 76727 | eType = IN_INDEX_EPH; |
| 76825 | 76728 | if( prNotFound ){ |
| 76826 | 76729 | *prNotFound = rMayHaveNull = ++pParse->nMem; |
| 76827 | 76730 | sqlite3VdbeAddOp2(v, OP_Null, 0, *prNotFound); |
| 76828 | 76731 | }else{ |
| 76829 | | - testcase( pParse->nQueryLoop>(double)1 ); |
| 76830 | | - pParse->nQueryLoop = (double)1; |
| 76732 | + testcase( pParse->nQueryLoop>0 ); |
| 76733 | + pParse->nQueryLoop = 0; |
| 76831 | 76734 | if( pX->pLeft->iColumn<0 && !ExprHasAnyProperty(pX, EP_xIsSelect) ){ |
| 76832 | 76735 | eType = IN_INDEX_ROWID; |
| 76833 | 76736 | } |
| 76834 | 76737 | } |
| 76835 | 76738 | sqlite3CodeSubselect(pParse, pX, rMayHaveNull, eType==IN_INDEX_ROWID); |
| | @@ -76867,11 +76770,11 @@ |
| 76867 | 76770 | ** the register given by rMayHaveNull to NULL. Calling routines will take |
| 76868 | 76771 | ** care of changing this register value to non-NULL if the RHS is NULL-free. |
| 76869 | 76772 | ** |
| 76870 | 76773 | ** If rMayHaveNull is zero, that means that the subquery is being used |
| 76871 | 76774 | ** for membership testing only. There is no need to initialize any |
| 76872 | | -** registers to indicate the presense or absence of NULLs on the RHS. |
| 76775 | +** registers to indicate the presence or absence of NULLs on the RHS. |
| 76873 | 76776 | ** |
| 76874 | 76777 | ** For a SELECT or EXISTS operator, return the register that holds the |
| 76875 | 76778 | ** result. For IN operators or if an error occurs, the return value is 0. |
| 76876 | 76779 | */ |
| 76877 | 76780 | #ifndef SQLITE_OMIT_SUBQUERY |
| | @@ -80267,11 +80170,11 @@ |
| 80267 | 80170 | ** |
| 80268 | 80171 | ** Additional tables might be added in future releases of SQLite. |
| 80269 | 80172 | ** The sqlite_stat2 table is not created or used unless the SQLite version |
| 80270 | 80173 | ** is between 3.6.18 and 3.7.8, inclusive, and unless SQLite is compiled |
| 80271 | 80174 | ** with SQLITE_ENABLE_STAT2. The sqlite_stat2 table is deprecated. |
| 80272 | | -** The sqlite_stat2 table is superceded by sqlite_stat3, which is only |
| 80175 | +** The sqlite_stat2 table is superseded by sqlite_stat3, which is only |
| 80273 | 80176 | ** created and used by SQLite versions 3.7.9 and later and with |
| 80274 | 80177 | ** SQLITE_ENABLE_STAT3 defined. The fucntionality of sqlite_stat3 |
| 80275 | 80178 | ** is a superset of sqlite_stat2. |
| 80276 | 80179 | ** |
| 80277 | 80180 | ** Format of sqlite_stat1: |
| | @@ -83455,10 +83358,11 @@ |
| 83455 | 83358 | zColl = sqlite3NameFromToken(db, pToken); |
| 83456 | 83359 | if( !zColl ) return; |
| 83457 | 83360 | |
| 83458 | 83361 | if( sqlite3LocateCollSeq(pParse, zColl) ){ |
| 83459 | 83362 | Index *pIdx; |
| 83363 | + sqlite3DbFree(db, p->aCol[i].zColl); |
| 83460 | 83364 | p->aCol[i].zColl = zColl; |
| 83461 | 83365 | |
| 83462 | 83366 | /* If the column is declared as "<name> PRIMARY KEY COLLATE <type>", |
| 83463 | 83367 | ** then an index may have been created on this column before the |
| 83464 | 83368 | ** collation type was added. Correct this if it is the case. |
| | @@ -84874,10 +84778,11 @@ |
| 84874 | 84778 | zExtra = (char *)(&pIndex->zName[nName+1]); |
| 84875 | 84779 | memcpy(pIndex->zName, zName, nName+1); |
| 84876 | 84780 | pIndex->pTable = pTab; |
| 84877 | 84781 | pIndex->nColumn = pList->nExpr; |
| 84878 | 84782 | pIndex->onError = (u8)onError; |
| 84783 | + pIndex->uniqNotNull = onError==OE_Abort; |
| 84879 | 84784 | pIndex->autoIndex = (u8)(pName==0); |
| 84880 | 84785 | pIndex->pSchema = db->aDb[iDb].pSchema; |
| 84881 | 84786 | assert( sqlite3SchemaMutexHeld(db, iDb, 0) ); |
| 84882 | 84787 | |
| 84883 | 84788 | /* Check to see if we should honor DESC requests on index columns |
| | @@ -84932,10 +84837,11 @@ |
| 84932 | 84837 | goto exit_create_index; |
| 84933 | 84838 | } |
| 84934 | 84839 | pIndex->azColl[i] = zColl; |
| 84935 | 84840 | requestedSortOrder = pListItem->sortOrder & sortOrderMask; |
| 84936 | 84841 | pIndex->aSortOrder[i] = (u8)requestedSortOrder; |
| 84842 | + if( pTab->aCol[j].notNull==0 ) pIndex->uniqNotNull = 0; |
| 84937 | 84843 | } |
| 84938 | 84844 | sqlite3DefaultRowEst(pIndex); |
| 84939 | 84845 | |
| 84940 | 84846 | if( pTab==pParse->pNewTable ){ |
| 84941 | 84847 | /* This routine has been called to create an automatic index as a |
| | @@ -85363,19 +85269,19 @@ |
| 85363 | 85269 | assert( db->mallocFailed ); |
| 85364 | 85270 | return pSrc; |
| 85365 | 85271 | } |
| 85366 | 85272 | pSrc = pNew; |
| 85367 | 85273 | nGot = (sqlite3DbMallocSize(db, pNew) - sizeof(*pSrc))/sizeof(pSrc->a[0])+1; |
| 85368 | | - pSrc->nAlloc = (u16)nGot; |
| 85274 | + pSrc->nAlloc = (u8)nGot; |
| 85369 | 85275 | } |
| 85370 | 85276 | |
| 85371 | 85277 | /* Move existing slots that come after the newly inserted slots |
| 85372 | 85278 | ** out of the way */ |
| 85373 | 85279 | for(i=pSrc->nSrc-1; i>=iStart; i--){ |
| 85374 | 85280 | pSrc->a[i+nExtra] = pSrc->a[i]; |
| 85375 | 85281 | } |
| 85376 | | - pSrc->nSrc += (i16)nExtra; |
| 85282 | + pSrc->nSrc += (i8)nExtra; |
| 85377 | 85283 | |
| 85378 | 85284 | /* Zero the newly allocated slots */ |
| 85379 | 85285 | memset(&pSrc->a[iStart], 0, sizeof(pSrc->a[0])*nExtra); |
| 85380 | 85286 | for(i=iStart; i<iStart+nExtra; i++){ |
| 85381 | 85287 | pSrc->a[i].iCursor = -1; |
| | @@ -87378,11 +87284,11 @@ |
| 87378 | 87284 | ** of x. If x is text, then we actually count UTF-8 characters. |
| 87379 | 87285 | ** If x is a blob, then we count bytes. |
| 87380 | 87286 | ** |
| 87381 | 87287 | ** If p1 is negative, then we begin abs(p1) from the end of x[]. |
| 87382 | 87288 | ** |
| 87383 | | -** If p2 is negative, return the p2 characters preceeding p1. |
| 87289 | +** If p2 is negative, return the p2 characters preceding p1. |
| 87384 | 87290 | */ |
| 87385 | 87291 | static void substrFunc( |
| 87386 | 87292 | sqlite3_context *context, |
| 87387 | 87293 | int argc, |
| 87388 | 87294 | sqlite3_value **argv |
| | @@ -88037,14 +87943,10 @@ |
| 88037 | 87943 | '0', '1', '2', '3', '4', '5', '6', '7', |
| 88038 | 87944 | '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' |
| 88039 | 87945 | }; |
| 88040 | 87946 | |
| 88041 | 87947 | /* |
| 88042 | | -** EXPERIMENTAL - This is not an official function. The interface may |
| 88043 | | -** change. This function may disappear. Do not write code that depends |
| 88044 | | -** on this function. |
| 88045 | | -** |
| 88046 | 87948 | ** Implementation of the QUOTE() function. This function takes a single |
| 88047 | 87949 | ** argument. If the argument is numeric, the return value is the same as |
| 88048 | 87950 | ** the argument. If the argument is NULL, the return value is the string |
| 88049 | 87951 | ** "NULL". Otherwise, the argument is enclosed in single quotes with |
| 88050 | 87952 | ** single-quote escapes. |
| | @@ -88229,11 +88131,11 @@ |
| 88229 | 88131 | } |
| 88230 | 88132 | |
| 88231 | 88133 | /* |
| 88232 | 88134 | ** The replace() function. Three arguments are all strings: call |
| 88233 | 88135 | ** them A, B, and C. The result is also a string which is derived |
| 88234 | | -** from A by replacing every occurance of B with C. The match |
| 88136 | +** from A by replacing every occurrence of B with C. The match |
| 88235 | 88137 | ** must be exact. Collating sequences are not used. |
| 88236 | 88138 | */ |
| 88237 | 88139 | static void replaceFunc( |
| 88238 | 88140 | sqlite3_context *context, |
| 88239 | 88141 | int argc, |
| | @@ -94147,15 +94049,19 @@ |
| 94147 | 94049 | sqlite3BtreeSetMmapLimit(db->aDb[ii].pBt, sz); |
| 94148 | 94050 | } |
| 94149 | 94051 | } |
| 94150 | 94052 | } |
| 94151 | 94053 | sz = -1; |
| 94152 | | - if( sqlite3_file_control(db,zDb,SQLITE_FCNTL_MMAP_SIZE,&sz)==SQLITE_OK ){ |
| 94054 | + rc = sqlite3_file_control(db, zDb, SQLITE_FCNTL_MMAP_SIZE, &sz); |
| 94153 | 94055 | #if SQLITE_MAX_MMAP_SIZE==0 |
| 94154 | | - sz = 0; |
| 94056 | + sz = 0; |
| 94155 | 94057 | #endif |
| 94058 | + if( rc==SQLITE_OK ){ |
| 94156 | 94059 | returnSingleInt(pParse, "mmap_size", sz); |
| 94060 | + }else if( rc!=SQLITE_NOTFOUND ){ |
| 94061 | + pParse->nErr++; |
| 94062 | + pParse->rc = rc; |
| 94157 | 94063 | } |
| 94158 | 94064 | }else |
| 94159 | 94065 | |
| 94160 | 94066 | /* |
| 94161 | 94067 | ** PRAGMA temp_store |
| | @@ -94682,11 +94588,11 @@ |
| 94682 | 94588 | #ifndef SQLITE_INTEGRITY_CHECK_ERROR_MAX |
| 94683 | 94589 | # define SQLITE_INTEGRITY_CHECK_ERROR_MAX 100 |
| 94684 | 94590 | #endif |
| 94685 | 94591 | |
| 94686 | 94592 | #ifndef SQLITE_OMIT_INTEGRITY_CHECK |
| 94687 | | - /* Pragma "quick_check" is an experimental reduced version of |
| 94593 | + /* Pragma "quick_check" is reduced version of |
| 94688 | 94594 | ** integrity_check designed to detect most database corruption |
| 94689 | 94595 | ** without most of the overhead of a full integrity-check. |
| 94690 | 94596 | */ |
| 94691 | 94597 | if( sqlite3StrICmp(zLeft, "integrity_check")==0 |
| 94692 | 94598 | || sqlite3StrICmp(zLeft, "quick_check")==0 |
| | @@ -95140,14 +95046,14 @@ |
| 95140 | 95046 | }else |
| 95141 | 95047 | #endif |
| 95142 | 95048 | |
| 95143 | 95049 | #ifdef SQLITE_HAS_CODEC |
| 95144 | 95050 | if( sqlite3StrICmp(zLeft, "key")==0 && zRight ){ |
| 95145 | | - sqlite3_key(db, zRight, sqlite3Strlen30(zRight)); |
| 95051 | + sqlite3_key_v2(db, zDb, zRight, sqlite3Strlen30(zRight)); |
| 95146 | 95052 | }else |
| 95147 | 95053 | if( sqlite3StrICmp(zLeft, "rekey")==0 && zRight ){ |
| 95148 | | - sqlite3_rekey(db, zRight, sqlite3Strlen30(zRight)); |
| 95054 | + sqlite3_rekey_v2(db, zDb, zRight, sqlite3Strlen30(zRight)); |
| 95149 | 95055 | }else |
| 95150 | 95056 | if( zRight && (sqlite3StrICmp(zLeft, "hexkey")==0 || |
| 95151 | 95057 | sqlite3StrICmp(zLeft, "hexrekey")==0) ){ |
| 95152 | 95058 | int i, h1, h2; |
| 95153 | 95059 | char zKey[40]; |
| | @@ -95155,13 +95061,13 @@ |
| 95155 | 95061 | h1 += 9*(1&(h1>>6)); |
| 95156 | 95062 | h2 += 9*(1&(h2>>6)); |
| 95157 | 95063 | zKey[i/2] = (h2 & 0x0f) | ((h1 & 0xf)<<4); |
| 95158 | 95064 | } |
| 95159 | 95065 | if( (zLeft[3] & 0xf)==0xb ){ |
| 95160 | | - sqlite3_key(db, zKey, i/2); |
| 95066 | + sqlite3_key_v2(db, zDb, zKey, i/2); |
| 95161 | 95067 | }else{ |
| 95162 | | - sqlite3_rekey(db, zKey, i/2); |
| 95068 | + sqlite3_rekey_v2(db, zDb, zKey, i/2); |
| 95163 | 95069 | } |
| 95164 | 95070 | }else |
| 95165 | 95071 | #endif |
| 95166 | 95072 | #if defined(SQLITE_HAS_CODEC) || defined(SQLITE_ENABLE_CEROD) |
| 95167 | 95073 | if( sqlite3StrICmp(zLeft, "activate_extensions")==0 && zRight ){ |
| | @@ -95792,11 +95698,11 @@ |
| 95792 | 95698 | } |
| 95793 | 95699 | |
| 95794 | 95700 | sqlite3VtabUnlockList(db); |
| 95795 | 95701 | |
| 95796 | 95702 | pParse->db = db; |
| 95797 | | - pParse->nQueryLoop = (double)1; |
| 95703 | + pParse->nQueryLoop = 0; /* Logarithmic, so 0 really means 1 */ |
| 95798 | 95704 | if( nBytes>=0 && (nBytes==0 || zSql[nBytes-1]!=0) ){ |
| 95799 | 95705 | char *zSqlCopy; |
| 95800 | 95706 | int mxLen = db->aLimit[SQLITE_LIMIT_SQL_LENGTH]; |
| 95801 | 95707 | testcase( nBytes==mxLen ); |
| 95802 | 95708 | testcase( nBytes==mxLen+1 ); |
| | @@ -95814,11 +95720,11 @@ |
| 95814 | 95720 | pParse->zTail = &zSql[nBytes]; |
| 95815 | 95721 | } |
| 95816 | 95722 | }else{ |
| 95817 | 95723 | sqlite3RunParser(pParse, zSql, &zErrMsg); |
| 95818 | 95724 | } |
| 95819 | | - assert( 1==(int)pParse->nQueryLoop ); |
| 95725 | + assert( 0==pParse->nQueryLoop ); |
| 95820 | 95726 | |
| 95821 | 95727 | if( db->mallocFailed ){ |
| 95822 | 95728 | pParse->rc = SQLITE_NOMEM; |
| 95823 | 95729 | } |
| 95824 | 95730 | if( pParse->rc==SQLITE_DONE ) pParse->rc = SQLITE_OK; |
| | @@ -96178,11 +96084,11 @@ |
| 96178 | 96084 | sqlite3DbFree(db, p); |
| 96179 | 96085 | } |
| 96180 | 96086 | } |
| 96181 | 96087 | |
| 96182 | 96088 | /* |
| 96183 | | -** Given 1 to 3 identifiers preceeding the JOIN keyword, determine the |
| 96089 | +** Given 1 to 3 identifiers preceding the JOIN keyword, determine the |
| 96184 | 96090 | ** type of join. Return an integer constant that expresses that type |
| 96185 | 96091 | ** in terms of the following bit values: |
| 96186 | 96092 | ** |
| 96187 | 96093 | ** JT_INNER |
| 96188 | 96094 | ** JT_CROSS |
| | @@ -97592,11 +97498,11 @@ |
| 97592 | 97498 | int addr1, n; |
| 97593 | 97499 | if( p->iLimit ) return; |
| 97594 | 97500 | |
| 97595 | 97501 | /* |
| 97596 | 97502 | ** "LIMIT -1" always shows all rows. There is some |
| 97597 | | - ** contraversy about what the correct behavior should be. |
| 97503 | + ** controversy about what the correct behavior should be. |
| 97598 | 97504 | ** The current implementation interprets "LIMIT 0" to mean |
| 97599 | 97505 | ** no rows. |
| 97600 | 97506 | */ |
| 97601 | 97507 | sqlite3ExprCacheClear(pParse); |
| 97602 | 97508 | assert( p->pOffset==0 || p->pLimit!=0 ); |
| | @@ -97607,12 +97513,12 @@ |
| 97607 | 97513 | if( sqlite3ExprIsInteger(p->pLimit, &n) ){ |
| 97608 | 97514 | sqlite3VdbeAddOp2(v, OP_Integer, n, iLimit); |
| 97609 | 97515 | VdbeComment((v, "LIMIT counter")); |
| 97610 | 97516 | if( n==0 ){ |
| 97611 | 97517 | sqlite3VdbeAddOp2(v, OP_Goto, 0, iBreak); |
| 97612 | | - }else{ |
| 97613 | | - if( p->nSelectRow > (double)n ) p->nSelectRow = (double)n; |
| 97518 | + }else if( n>=0 && p->nSelectRow>(u64)n ){ |
| 97519 | + p->nSelectRow = n; |
| 97614 | 97520 | } |
| 97615 | 97521 | }else{ |
| 97616 | 97522 | sqlite3ExprCode(pParse, p->pLimit, iLimit); |
| 97617 | 97523 | sqlite3VdbeAddOp1(v, OP_MustBeInt, iLimit); |
| 97618 | 97524 | VdbeComment((v, "LIMIT counter")); |
| | @@ -97802,13 +97708,13 @@ |
| 97802 | 97708 | pDelete = p->pPrior; |
| 97803 | 97709 | p->pPrior = pPrior; |
| 97804 | 97710 | p->nSelectRow += pPrior->nSelectRow; |
| 97805 | 97711 | if( pPrior->pLimit |
| 97806 | 97712 | && sqlite3ExprIsInteger(pPrior->pLimit, &nLimit) |
| 97807 | | - && p->nSelectRow > (double)nLimit |
| 97713 | + && nLimit>0 && p->nSelectRow > (u64)nLimit |
| 97808 | 97714 | ){ |
| 97809 | | - p->nSelectRow = (double)nLimit; |
| 97715 | + p->nSelectRow = nLimit; |
| 97810 | 97716 | } |
| 97811 | 97717 | if( addr ){ |
| 97812 | 97718 | sqlite3VdbeJumpHere(v, addr); |
| 97813 | 97719 | } |
| 97814 | 97720 | break; |
| | @@ -99953,15 +99859,14 @@ |
| 99953 | 99859 | Parse *pParse, /* Parse context */ |
| 99954 | 99860 | Table *pTab, /* Table being queried */ |
| 99955 | 99861 | Index *pIdx /* Index used to optimize scan, or NULL */ |
| 99956 | 99862 | ){ |
| 99957 | 99863 | if( pParse->explain==2 ){ |
| 99958 | | - char *zEqp = sqlite3MPrintf(pParse->db, "SCAN TABLE %s %s%s(~%d rows)", |
| 99864 | + char *zEqp = sqlite3MPrintf(pParse->db, "SCAN TABLE %s%s%s", |
| 99959 | 99865 | pTab->zName, |
| 99960 | | - pIdx ? "USING COVERING INDEX " : "", |
| 99961 | | - pIdx ? pIdx->zName : "", |
| 99962 | | - pTab->nRowEst |
| 99866 | + pIdx ? " USING COVERING INDEX " : "", |
| 99867 | + pIdx ? pIdx->zName : "" |
| 99963 | 99868 | ); |
| 99964 | 99869 | sqlite3VdbeAddOp4( |
| 99965 | 99870 | pParse->pVdbe, OP_Explain, pParse->iSelectId, 0, 0, zEqp, P4_DYNAMIC |
| 99966 | 99871 | ); |
| 99967 | 99872 | } |
| | @@ -100115,11 +100020,11 @@ |
| 100115 | 100020 | } |
| 100116 | 100021 | continue; |
| 100117 | 100022 | } |
| 100118 | 100023 | |
| 100119 | 100024 | /* Increment Parse.nHeight by the height of the largest expression |
| 100120 | | - ** tree refered to by this, the parent select. The child select |
| 100025 | + ** tree referred to by this, the parent select. The child select |
| 100121 | 100026 | ** may contain expression trees of at most |
| 100122 | 100027 | ** (SQLITE_MAX_EXPR_DEPTH-Parse.nHeight) height. This is a bit |
| 100123 | 100028 | ** more conservative than necessary, but much easier than enforcing |
| 100124 | 100029 | ** an exact limit. |
| 100125 | 100030 | */ |
| | @@ -100308,11 +100213,11 @@ |
| 100308 | 100213 | } |
| 100309 | 100214 | |
| 100310 | 100215 | /* Set the limiter. |
| 100311 | 100216 | */ |
| 100312 | 100217 | iEnd = sqlite3VdbeMakeLabel(v); |
| 100313 | | - p->nSelectRow = (double)LARGEST_INT64; |
| 100218 | + p->nSelectRow = LARGEST_INT64; |
| 100314 | 100219 | computeLimitRegisters(pParse, p, iEnd); |
| 100315 | 100220 | if( p->iLimit==0 && addrSortIndex>=0 ){ |
| 100316 | 100221 | sqlite3VdbeGetOp(v, addrSortIndex)->opcode = OP_SorterOpen; |
| 100317 | 100222 | p->selFlags |= SF_UseSorter; |
| 100318 | 100223 | } |
| | @@ -100336,13 +100241,17 @@ |
| 100336 | 100241 | ExprList *pDist = (sDistinct.isTnct ? p->pEList : 0); |
| 100337 | 100242 | |
| 100338 | 100243 | /* Begin the database scan. */ |
| 100339 | 100244 | pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, pOrderBy, pDist, 0,0); |
| 100340 | 100245 | if( pWInfo==0 ) goto select_end; |
| 100341 | | - if( pWInfo->nRowOut < p->nSelectRow ) p->nSelectRow = pWInfo->nRowOut; |
| 100342 | | - if( pWInfo->eDistinct ) sDistinct.eTnctType = pWInfo->eDistinct; |
| 100343 | | - if( pOrderBy && pWInfo->nOBSat==pOrderBy->nExpr ) pOrderBy = 0; |
| 100246 | + if( sqlite3WhereOutputRowCount(pWInfo) < p->nSelectRow ){ |
| 100247 | + p->nSelectRow = sqlite3WhereOutputRowCount(pWInfo); |
| 100248 | + } |
| 100249 | + if( sqlite3WhereIsDistinct(pWInfo) ){ |
| 100250 | + sDistinct.eTnctType = sqlite3WhereIsDistinct(pWInfo); |
| 100251 | + } |
| 100252 | + if( pOrderBy && sqlite3WhereIsOrdered(pWInfo) ) pOrderBy = 0; |
| 100344 | 100253 | |
| 100345 | 100254 | /* If sorting index that was created by a prior OP_OpenEphemeral |
| 100346 | 100255 | ** instruction ended up not being needed, then change the OP_OpenEphemeral |
| 100347 | 100256 | ** into an OP_Noop. |
| 100348 | 100257 | */ |
| | @@ -100351,11 +100260,12 @@ |
| 100351 | 100260 | p->addrOpenEphm[2] = -1; |
| 100352 | 100261 | } |
| 100353 | 100262 | |
| 100354 | 100263 | /* Use the standard inner loop. */ |
| 100355 | 100264 | selectInnerLoop(pParse, p, pEList, 0, 0, pOrderBy, &sDistinct, pDest, |
| 100356 | | - pWInfo->iContinue, pWInfo->iBreak); |
| 100265 | + sqlite3WhereContinueLabel(pWInfo), |
| 100266 | + sqlite3WhereBreakLabel(pWInfo)); |
| 100357 | 100267 | |
| 100358 | 100268 | /* End the database scan loop. |
| 100359 | 100269 | */ |
| 100360 | 100270 | sqlite3WhereEnd(pWInfo); |
| 100361 | 100271 | }else{ |
| | @@ -100384,13 +100294,13 @@ |
| 100384 | 100294 | pItem->iAlias = 0; |
| 100385 | 100295 | } |
| 100386 | 100296 | for(k=pGroupBy->nExpr, pItem=pGroupBy->a; k>0; k--, pItem++){ |
| 100387 | 100297 | pItem->iAlias = 0; |
| 100388 | 100298 | } |
| 100389 | | - if( p->nSelectRow>(double)100 ) p->nSelectRow = (double)100; |
| 100299 | + if( p->nSelectRow>100 ) p->nSelectRow = 100; |
| 100390 | 100300 | }else{ |
| 100391 | | - p->nSelectRow = (double)1; |
| 100301 | + p->nSelectRow = 1; |
| 100392 | 100302 | } |
| 100393 | 100303 | |
| 100394 | 100304 | |
| 100395 | 100305 | /* Create a label to jump to when we want to abort the query */ |
| 100396 | 100306 | addrEnd = sqlite3VdbeMakeLabel(v); |
| | @@ -100466,13 +100376,14 @@ |
| 100466 | 100376 | ** This might involve two separate loops with an OP_Sort in between, or |
| 100467 | 100377 | ** it might be a single loop that uses an index to extract information |
| 100468 | 100378 | ** in the right order to begin with. |
| 100469 | 100379 | */ |
| 100470 | 100380 | sqlite3VdbeAddOp2(v, OP_Gosub, regReset, addrReset); |
| 100471 | | - pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, pGroupBy, 0, 0, 0); |
| 100381 | + pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, pGroupBy, 0, |
| 100382 | + WHERE_GROUPBY, 0); |
| 100472 | 100383 | if( pWInfo==0 ) goto select_end; |
| 100473 | | - if( pWInfo->nOBSat==pGroupBy->nExpr ){ |
| 100384 | + if( sqlite3WhereIsOrdered(pWInfo) ){ |
| 100474 | 100385 | /* The optimizer is able to deliver rows in group by order so |
| 100475 | 100386 | ** we do not have to sort. The OP_OpenEphemeral table will be |
| 100476 | 100387 | ** cancelled later because we still need to use the pKeyInfo |
| 100477 | 100388 | */ |
| 100478 | 100389 | groupBySort = 0; |
| | @@ -100749,12 +100660,12 @@ |
| 100749 | 100660 | sqlite3ExprListDelete(db, pDel); |
| 100750 | 100661 | goto select_end; |
| 100751 | 100662 | } |
| 100752 | 100663 | updateAccumulator(pParse, &sAggInfo); |
| 100753 | 100664 | assert( pMinMax==0 || pMinMax->nExpr==1 ); |
| 100754 | | - if( pWInfo->nOBSat>0 ){ |
| 100755 | | - sqlite3VdbeAddOp2(v, OP_Goto, 0, pWInfo->iBreak); |
| 100665 | + if( sqlite3WhereIsOrdered(pWInfo) ){ |
| 100666 | + sqlite3VdbeAddOp2(v, OP_Goto, 0, sqlite3WhereBreakLabel(pWInfo)); |
| 100756 | 100667 | VdbeComment((v, "%s() by index", |
| 100757 | 100668 | (flag==WHERE_ORDERBY_MIN?"min":"max"))); |
| 100758 | 100669 | } |
| 100759 | 100670 | sqlite3WhereEnd(pWInfo); |
| 100760 | 100671 | finalizeAggFunctions(pParse, &sAggInfo); |
| | @@ -102109,11 +102020,11 @@ |
| 102109 | 102020 | } |
| 102110 | 102021 | |
| 102111 | 102022 | /* |
| 102112 | 102023 | ** This is called to code the required FOR EACH ROW triggers for an operation |
| 102113 | 102024 | ** on table pTab. The operation to code triggers for (INSERT, UPDATE or DELETE) |
| 102114 | | -** is given by the op paramater. The tr_tm parameter determines whether the |
| 102025 | +** is given by the op parameter. The tr_tm parameter determines whether the |
| 102115 | 102026 | ** BEFORE or AFTER triggers are coded. If the operation is an UPDATE, then |
| 102116 | 102027 | ** parameter pChanges is passed the list of columns being modified. |
| 102117 | 102028 | ** |
| 102118 | 102029 | ** If there are no triggers that fire at the specified time for the specified |
| 102119 | 102030 | ** operation on pTab, this function is a no-op. |
| | @@ -102560,11 +102471,11 @@ |
| 102560 | 102471 | sqlite3VdbeAddOp3(v, OP_Null, 0, regRowSet, regOldRowid); |
| 102561 | 102472 | pWInfo = sqlite3WhereBegin( |
| 102562 | 102473 | pParse, pTabList, pWhere, 0, 0, WHERE_ONEPASS_DESIRED, 0 |
| 102563 | 102474 | ); |
| 102564 | 102475 | if( pWInfo==0 ) goto update_cleanup; |
| 102565 | | - okOnePass = pWInfo->okOnePass; |
| 102476 | + okOnePass = sqlite3WhereOkOnePass(pWInfo); |
| 102566 | 102477 | |
| 102567 | 102478 | /* Remember the rowid of every item to be updated. |
| 102568 | 102479 | */ |
| 102569 | 102480 | sqlite3VdbeAddOp2(v, OP_Rowid, iCur, regOldRowid); |
| 102570 | 102481 | if( !okOnePass ){ |
| | @@ -104397,22 +104308,165 @@ |
| 104397 | 104308 | #if defined(SQLITE_TEST) || defined(SQLITE_DEBUG) |
| 104398 | 104309 | /***/ int sqlite3WhereTrace = 0; |
| 104399 | 104310 | #endif |
| 104400 | 104311 | #if defined(SQLITE_DEBUG) \ |
| 104401 | 104312 | && (defined(SQLITE_TEST) || defined(SQLITE_ENABLE_WHERETRACE)) |
| 104402 | | -# define WHERETRACE(X) if(sqlite3WhereTrace) sqlite3DebugPrintf X |
| 104313 | +# define WHERETRACE(K,X) if(sqlite3WhereTrace&(K)) sqlite3DebugPrintf X |
| 104314 | +# define WHERETRACE_ENABLED 1 |
| 104403 | 104315 | #else |
| 104404 | | -# define WHERETRACE(X) |
| 104316 | +# define WHERETRACE(K,X) |
| 104405 | 104317 | #endif |
| 104406 | 104318 | |
| 104407 | 104319 | /* Forward reference |
| 104408 | 104320 | */ |
| 104409 | 104321 | typedef struct WhereClause WhereClause; |
| 104410 | 104322 | typedef struct WhereMaskSet WhereMaskSet; |
| 104411 | 104323 | typedef struct WhereOrInfo WhereOrInfo; |
| 104412 | 104324 | typedef struct WhereAndInfo WhereAndInfo; |
| 104413 | | -typedef struct WhereCost WhereCost; |
| 104325 | +typedef struct WhereLevel WhereLevel; |
| 104326 | +typedef struct WhereLoop WhereLoop; |
| 104327 | +typedef struct WherePath WherePath; |
| 104328 | +typedef struct WhereTerm WhereTerm; |
| 104329 | +typedef struct WhereLoopBuilder WhereLoopBuilder; |
| 104330 | +typedef struct WhereScan WhereScan; |
| 104331 | + |
| 104332 | +/* |
| 104333 | +** Cost X is tracked as 10*log2(X) stored in a 16-bit integer. The |
| 104334 | +** maximum cost for ordinary tables is 64*(2**63) which becomes 6900. |
| 104335 | +** (Virtual tables can return a larger cost, but let's assume they do not.) |
| 104336 | +** So all costs can be stored in a 16-bit unsigned integer without risk |
| 104337 | +** of overflow. |
| 104338 | +** |
| 104339 | +** Costs are estimates, so don't go to the computational trouble to compute |
| 104340 | +** 10*log2(X) exactly. Instead, a close estimate is used. Any value of |
| 104341 | +** X<=1 is stored as 0. X=2 is 10. X=3 is 16. X=1000 is 99. etc. |
| 104342 | +** |
| 104343 | +** The tool/wherecosttest.c source file implements a command-line program |
| 104344 | +** that will convert between WhereCost to integers and do addition and |
| 104345 | +** multiplication on WhereCost values. That command-line program is a |
| 104346 | +** useful utility to have around when working with this module. |
| 104347 | +*/ |
| 104348 | +typedef unsigned short int WhereCost; |
| 104349 | + |
| 104350 | +/* |
| 104351 | +** This object contains information needed to implement a single nested |
| 104352 | +** loop in WHERE clause. |
| 104353 | +** |
| 104354 | +** Contrast this object with WhereLoop. This object describes the |
| 104355 | +** implementation of the loop. WhereLoop describes the algorithm. |
| 104356 | +** This object contains a pointer to the WhereLoop algorithm as one of |
| 104357 | +** its elements. |
| 104358 | +** |
| 104359 | +** The WhereInfo object contains a single instance of this object for |
| 104360 | +** each term in the FROM clause (which is to say, for each of the |
| 104361 | +** nested loops as implemented). The order of WhereLevel objects determines |
| 104362 | +** the loop nested order, with WhereInfo.a[0] being the outer loop and |
| 104363 | +** WhereInfo.a[WhereInfo.nLevel-1] being the inner loop. |
| 104364 | +*/ |
| 104365 | +struct WhereLevel { |
| 104366 | + int iLeftJoin; /* Memory cell used to implement LEFT OUTER JOIN */ |
| 104367 | + int iTabCur; /* The VDBE cursor used to access the table */ |
| 104368 | + int iIdxCur; /* The VDBE cursor used to access pIdx */ |
| 104369 | + int addrBrk; /* Jump here to break out of the loop */ |
| 104370 | + int addrNxt; /* Jump here to start the next IN combination */ |
| 104371 | + int addrCont; /* Jump here to continue with the next loop cycle */ |
| 104372 | + int addrFirst; /* First instruction of interior of the loop */ |
| 104373 | + u8 iFrom; /* Which entry in the FROM clause */ |
| 104374 | + u8 op, p5; /* Opcode and P5 of the opcode that ends the loop */ |
| 104375 | + int p1, p2; /* Operands of the opcode used to ends the loop */ |
| 104376 | + union { /* Information that depends on pWLoop->wsFlags */ |
| 104377 | + struct { |
| 104378 | + int nIn; /* Number of entries in aInLoop[] */ |
| 104379 | + struct InLoop { |
| 104380 | + int iCur; /* The VDBE cursor used by this IN operator */ |
| 104381 | + int addrInTop; /* Top of the IN loop */ |
| 104382 | + u8 eEndLoopOp; /* IN Loop terminator. OP_Next or OP_Prev */ |
| 104383 | + } *aInLoop; /* Information about each nested IN operator */ |
| 104384 | + } in; /* Used when pWLoop->wsFlags&WHERE_IN_ABLE */ |
| 104385 | + Index *pCovidx; /* Possible covering index for WHERE_MULTI_OR */ |
| 104386 | + } u; |
| 104387 | + struct WhereLoop *pWLoop; /* The selected WhereLoop object */ |
| 104388 | +}; |
| 104389 | + |
| 104390 | +/* |
| 104391 | +** Each instance of this object represents an algorithm for evaluating one |
| 104392 | +** term of a join. Every term of the FROM clause will have at least |
| 104393 | +** one corresponding WhereLoop object (unless INDEXED BY constraints |
| 104394 | +** prevent a query solution - which is an error) and many terms of the |
| 104395 | +** FROM clause will have multiple WhereLoop objects, each describing a |
| 104396 | +** potential way of implementing that FROM-clause term, together with |
| 104397 | +** dependencies and cost estimates for using the chosen algorithm. |
| 104398 | +** |
| 104399 | +** Query planning consists of building up a collection of these WhereLoop |
| 104400 | +** objects, then computing a particular sequence of WhereLoop objects, with |
| 104401 | +** one WhereLoop object per FROM clause term, that satisfy all dependencies |
| 104402 | +** and that minimize the overall cost. |
| 104403 | +*/ |
| 104404 | +struct WhereLoop { |
| 104405 | + Bitmask prereq; /* Bitmask of other loops that must run first */ |
| 104406 | + Bitmask maskSelf; /* Bitmask identifying table iTab */ |
| 104407 | +#ifdef SQLITE_DEBUG |
| 104408 | + char cId; /* Symbolic ID of this loop for debugging use */ |
| 104409 | +#endif |
| 104410 | + u8 iTab; /* Position in FROM clause of table for this loop */ |
| 104411 | + u8 iSortIdx; /* Sorting index number. 0==None */ |
| 104412 | + WhereCost rSetup; /* One-time setup cost (ex: create transient index) */ |
| 104413 | + WhereCost rRun; /* Cost of running each loop */ |
| 104414 | + WhereCost nOut; /* Estimated number of output rows */ |
| 104415 | + union { |
| 104416 | + struct { /* Information for internal btree tables */ |
| 104417 | + int nEq; /* Number of equality constraints */ |
| 104418 | + Index *pIndex; /* Index used, or NULL */ |
| 104419 | + } btree; |
| 104420 | + struct { /* Information for virtual tables */ |
| 104421 | + int idxNum; /* Index number */ |
| 104422 | + u8 needFree; /* True if sqlite3_free(idxStr) is needed */ |
| 104423 | + u8 isOrdered; /* True if satisfies ORDER BY */ |
| 104424 | + u16 omitMask; /* Terms that may be omitted */ |
| 104425 | + char *idxStr; /* Index identifier string */ |
| 104426 | + } vtab; |
| 104427 | + } u; |
| 104428 | + u32 wsFlags; /* WHERE_* flags describing the plan */ |
| 104429 | + u16 nLTerm; /* Number of entries in aLTerm[] */ |
| 104430 | + /**** whereLoopXfer() copies fields above ***********************/ |
| 104431 | +# define WHERE_LOOP_XFER_SZ offsetof(WhereLoop,nLSlot) |
| 104432 | + u16 nLSlot; /* Number of slots allocated for aLTerm[] */ |
| 104433 | + WhereTerm **aLTerm; /* WhereTerms used */ |
| 104434 | + WhereLoop *pNextLoop; /* Next WhereLoop object in the WhereClause */ |
| 104435 | + WhereTerm *aLTermSpace[4]; /* Initial aLTerm[] space */ |
| 104436 | +}; |
| 104437 | + |
| 104438 | +/* Forward declaration of methods */ |
| 104439 | +static int whereLoopResize(sqlite3*, WhereLoop*, int); |
| 104440 | + |
| 104441 | +/* |
| 104442 | +** Each instance of this object holds a sequence of WhereLoop objects |
| 104443 | +** that implement some or all of a query plan. |
| 104444 | +** |
| 104445 | +** Think of each WhereLoop objects as a node in a graph, which arcs |
| 104446 | +** showing dependences and costs for travelling between nodes. (That is |
| 104447 | +** not a completely accurate description because WhereLoop costs are a |
| 104448 | +** vector, not a scalar, and because dependences are many-to-one, not |
| 104449 | +** one-to-one as are graph nodes. But it is a useful visualization aid.) |
| 104450 | +** Then a WherePath object is a path through the graph that visits some |
| 104451 | +** or all of the WhereLoop objects once. |
| 104452 | +** |
| 104453 | +** The "solver" works by creating the N best WherePath objects of length |
| 104454 | +** 1. Then using those as a basis to compute the N best WherePath objects |
| 104455 | +** of length 2. And so forth until the length of WherePaths equals the |
| 104456 | +** number of nodes in the FROM clause. The best (lowest cost) WherePath |
| 104457 | +** at the end is the choosen query plan. |
| 104458 | +*/ |
| 104459 | +struct WherePath { |
| 104460 | + Bitmask maskLoop; /* Bitmask of all WhereLoop objects in this path */ |
| 104461 | + Bitmask revLoop; /* aLoop[]s that should be reversed for ORDER BY */ |
| 104462 | + WhereCost nRow; /* Estimated number of rows generated by this path */ |
| 104463 | + WhereCost rCost; /* Total cost of this path */ |
| 104464 | + u8 isOrdered; /* True if this path satisfies ORDER BY */ |
| 104465 | + u8 isOrderedValid; /* True if the isOrdered field is valid */ |
| 104466 | + WhereLoop **aLoop; /* Array of WhereLoop objects implementing this path */ |
| 104467 | +}; |
| 104414 | 104468 | |
| 104415 | 104469 | /* |
| 104416 | 104470 | ** The query generator uses an array of instances of this structure to |
| 104417 | 104471 | ** help it analyze the subexpressions of the WHERE clause. Each WHERE |
| 104418 | 104472 | ** clause subexpression is separated from the others by AND operators, |
| | @@ -104461,11 +104515,10 @@ |
| 104461 | 104515 | ** |
| 104462 | 104516 | ** The number of terms in a join is limited by the number of bits |
| 104463 | 104517 | ** in prereqRight and prereqAll. The default is 64 bits, hence SQLite |
| 104464 | 104518 | ** is only able to process joins with 64 or fewer tables. |
| 104465 | 104519 | */ |
| 104466 | | -typedef struct WhereTerm WhereTerm; |
| 104467 | 104520 | struct WhereTerm { |
| 104468 | 104521 | Expr *pExpr; /* Pointer to the subexpression that is this term */ |
| 104469 | 104522 | int iParent; /* Disable pWC->a[iParent] when this term disabled */ |
| 104470 | 104523 | int leftCursor; /* Cursor number of X in "X <op> <expr>" */ |
| 104471 | 104524 | union { |
| | @@ -104495,10 +104548,26 @@ |
| 104495 | 104548 | # define TERM_VNULL 0x80 /* Manufactured x>NULL or x<=NULL term */ |
| 104496 | 104549 | #else |
| 104497 | 104550 | # define TERM_VNULL 0x00 /* Disabled if not using stat3 */ |
| 104498 | 104551 | #endif |
| 104499 | 104552 | |
| 104553 | +/* |
| 104554 | +** An instance of the WhereScan object is used as an iterator for locating |
| 104555 | +** terms in the WHERE clause that are useful to the query planner. |
| 104556 | +*/ |
| 104557 | +struct WhereScan { |
| 104558 | + WhereClause *pOrigWC; /* Original, innermost WhereClause */ |
| 104559 | + WhereClause *pWC; /* WhereClause currently being scanned */ |
| 104560 | + char *zCollName; /* Required collating sequence, if not NULL */ |
| 104561 | + char idxaff; /* Must match this affinity, if zCollName!=NULL */ |
| 104562 | + unsigned char nEquiv; /* Number of entries in aEquiv[] */ |
| 104563 | + unsigned char iEquiv; /* Next unused slot in aEquiv[] */ |
| 104564 | + u32 opMask; /* Acceptable operators */ |
| 104565 | + int k; /* Resume scanning at this->pWC->a[this->k] */ |
| 104566 | + int aEquiv[22]; /* Cursor,Column pairs for equivalence classes */ |
| 104567 | +}; |
| 104568 | + |
| 104500 | 104569 | /* |
| 104501 | 104570 | ** An instance of the following structure holds all information about a |
| 104502 | 104571 | ** WHERE clause. Mostly this is a container for one or more WhereTerms. |
| 104503 | 104572 | ** |
| 104504 | 104573 | ** Explanation of pOuter: For a WHERE clause of the form |
| | @@ -104508,15 +104577,13 @@ |
| 104508 | 104577 | ** There are separate WhereClause objects for the whole clause and for |
| 104509 | 104578 | ** the subclauses "(b AND c)" and "(d AND e)". The pOuter field of the |
| 104510 | 104579 | ** subclauses points to the WhereClause object for the whole clause. |
| 104511 | 104580 | */ |
| 104512 | 104581 | struct WhereClause { |
| 104513 | | - Parse *pParse; /* The parser context */ |
| 104514 | | - WhereMaskSet *pMaskSet; /* Mapping of table cursor numbers to bitmasks */ |
| 104582 | + WhereInfo *pWInfo; /* WHERE clause processing context */ |
| 104515 | 104583 | WhereClause *pOuter; /* Outer conjunction */ |
| 104516 | 104584 | u8 op; /* Split operator. TK_AND or TK_OR */ |
| 104517 | | - u16 wctrlFlags; /* Might include WHERE_AND_ONLY */ |
| 104518 | 104585 | int nTerm; /* Number of terms */ |
| 104519 | 104586 | int nSlot; /* Number of entries in a[] */ |
| 104520 | 104587 | WhereTerm *a; /* Each a[] describes a term of the WHERE cluase */ |
| 104521 | 104588 | #if defined(SQLITE_SMALL_STACK) |
| 104522 | 104589 | WhereTerm aStatic[1]; /* Initial static space for a[] */ |
| | @@ -104572,23 +104639,59 @@ |
| 104572 | 104639 | int n; /* Number of assigned cursor values */ |
| 104573 | 104640 | int ix[BMS]; /* Cursor assigned to each bit */ |
| 104574 | 104641 | }; |
| 104575 | 104642 | |
| 104576 | 104643 | /* |
| 104577 | | -** A WhereCost object records a lookup strategy and the estimated |
| 104578 | | -** cost of pursuing that strategy. |
| 104644 | +** This object is a convenience wrapper holding all information needed |
| 104645 | +** to construct WhereLoop objects for a particular query. |
| 104579 | 104646 | */ |
| 104580 | | -struct WhereCost { |
| 104581 | | - WherePlan plan; /* The lookup strategy */ |
| 104582 | | - double rCost; /* Overall cost of pursuing this search strategy */ |
| 104583 | | - Bitmask used; /* Bitmask of cursors used by this plan */ |
| 104647 | +struct WhereLoopBuilder { |
| 104648 | + WhereInfo *pWInfo; /* Information about this WHERE */ |
| 104649 | + WhereClause *pWC; /* WHERE clause terms */ |
| 104650 | + ExprList *pOrderBy; /* ORDER BY clause */ |
| 104651 | + WhereLoop *pNew; /* Template WhereLoop */ |
| 104652 | + WhereLoop *pBest; /* If non-NULL, store single best loop here */ |
| 104584 | 104653 | }; |
| 104585 | 104654 | |
| 104586 | 104655 | /* |
| 104587 | | -** Bitmasks for the operators that indices are able to exploit. An |
| 104656 | +** The WHERE clause processing routine has two halves. The |
| 104657 | +** first part does the start of the WHERE loop and the second |
| 104658 | +** half does the tail of the WHERE loop. An instance of |
| 104659 | +** this structure is returned by the first half and passed |
| 104660 | +** into the second half to give some continuity. |
| 104661 | +** |
| 104662 | +** An instance of this object holds the complete state of the query |
| 104663 | +** planner. |
| 104664 | +*/ |
| 104665 | +struct WhereInfo { |
| 104666 | + Parse *pParse; /* Parsing and code generating context */ |
| 104667 | + SrcList *pTabList; /* List of tables in the join */ |
| 104668 | + ExprList *pOrderBy; /* The ORDER BY clause or NULL */ |
| 104669 | + ExprList *pDistinct; /* DISTINCT ON values, or NULL */ |
| 104670 | + WhereLoop *pLoops; /* List of all WhereLoop objects */ |
| 104671 | + Bitmask revMask; /* Mask of ORDER BY terms that need reversing */ |
| 104672 | + WhereCost nRowOut; /* Estimated number of output rows */ |
| 104673 | + u16 wctrlFlags; /* Flags originally passed to sqlite3WhereBegin() */ |
| 104674 | + u8 bOBSat; /* ORDER BY satisfied by indices */ |
| 104675 | + u8 okOnePass; /* Ok to use one-pass algorithm for UPDATE/DELETE */ |
| 104676 | + u8 untestedTerms; /* Not all WHERE terms resolved by outer loop */ |
| 104677 | + u8 eDistinct; /* One of the WHERE_DISTINCT_* values below */ |
| 104678 | + int iTop; /* The very beginning of the WHERE loop */ |
| 104679 | + int iContinue; /* Jump here to continue with next record */ |
| 104680 | + int iBreak; /* Jump here to break out of the loop */ |
| 104681 | + int nLevel; /* Number of nested loop */ |
| 104682 | + int savedNQueryLoop; /* pParse->nQueryLoop outside the WHERE loop */ |
| 104683 | + WhereMaskSet sMaskSet; /* Map cursor numbers to bitmasks */ |
| 104684 | + WhereClause sWC; /* Decomposition of the WHERE clause */ |
| 104685 | + WhereLevel a[1]; /* Information about each nest loop in WHERE */ |
| 104686 | +}; |
| 104687 | + |
| 104688 | +/* |
| 104689 | +** Bitmasks for the operators on WhereTerm objects. These are all |
| 104690 | +** operators that are of interest to the query planner. An |
| 104588 | 104691 | ** OR-ed combination of these values can be used when searching for |
| 104589 | | -** terms in the where clause. |
| 104692 | +** particular WhereTerms within a WhereClause. |
| 104590 | 104693 | */ |
| 104591 | 104694 | #define WO_IN 0x001 |
| 104592 | 104695 | #define WO_EQ 0x002 |
| 104593 | 104696 | #define WO_LT (WO_EQ<<(TK_LT-TK_EQ)) |
| 104594 | 104697 | #define WO_LE (WO_EQ<<(TK_LE-TK_EQ)) |
| | @@ -104603,96 +104706,106 @@ |
| 104603 | 104706 | |
| 104604 | 104707 | #define WO_ALL 0xfff /* Mask of all possible WO_* values */ |
| 104605 | 104708 | #define WO_SINGLE 0x0ff /* Mask of all non-compound WO_* values */ |
| 104606 | 104709 | |
| 104607 | 104710 | /* |
| 104608 | | -** Value for wsFlags returned by bestIndex() and stored in |
| 104609 | | -** WhereLevel.wsFlags. These flags determine which search |
| 104610 | | -** strategies are appropriate. |
| 104611 | | -** |
| 104612 | | -** The least significant 12 bits is reserved as a mask for WO_ values above. |
| 104613 | | -** The WhereLevel.wsFlags field is usually set to WO_IN|WO_EQ|WO_ISNULL. |
| 104614 | | -** But if the table is the right table of a left join, WhereLevel.wsFlags |
| 104615 | | -** is set to WO_IN|WO_EQ. The WhereLevel.wsFlags field can then be used as |
| 104616 | | -** the "op" parameter to findTerm when we are resolving equality constraints. |
| 104617 | | -** ISNULL constraints will then not be used on the right table of a left |
| 104618 | | -** join. Tickets #2177 and #2189. |
| 104619 | | -*/ |
| 104620 | | -#define WHERE_ROWID_EQ 0x00001000 /* rowid=EXPR or rowid IN (...) */ |
| 104621 | | -#define WHERE_ROWID_RANGE 0x00002000 /* rowid<EXPR and/or rowid>EXPR */ |
| 104622 | | -#define WHERE_COLUMN_EQ 0x00010000 /* x=EXPR or x IN (...) or x IS NULL */ |
| 104623 | | -#define WHERE_COLUMN_RANGE 0x00020000 /* x<EXPR and/or x>EXPR */ |
| 104624 | | -#define WHERE_COLUMN_IN 0x00040000 /* x IN (...) */ |
| 104625 | | -#define WHERE_COLUMN_NULL 0x00080000 /* x IS NULL */ |
| 104626 | | -#define WHERE_INDEXED 0x000f0000 /* Anything that uses an index */ |
| 104627 | | -#define WHERE_NOT_FULLSCAN 0x100f3000 /* Does not do a full table scan */ |
| 104628 | | -#define WHERE_IN_ABLE 0x080f1000 /* Able to support an IN operator */ |
| 104629 | | -#define WHERE_TOP_LIMIT 0x00100000 /* x<EXPR or x<=EXPR constraint */ |
| 104630 | | -#define WHERE_BTM_LIMIT 0x00200000 /* x>EXPR or x>=EXPR constraint */ |
| 104631 | | -#define WHERE_BOTH_LIMIT 0x00300000 /* Both x>EXPR and x<EXPR */ |
| 104632 | | -#define WHERE_IDX_ONLY 0x00400000 /* Use index only - omit table */ |
| 104633 | | -#define WHERE_ORDERED 0x00800000 /* Output will appear in correct order */ |
| 104634 | | -#define WHERE_REVERSE 0x01000000 /* Scan in reverse order */ |
| 104635 | | -#define WHERE_UNIQUE 0x02000000 /* Selects no more than one row */ |
| 104636 | | -#define WHERE_ALL_UNIQUE 0x04000000 /* This and all prior have one row */ |
| 104637 | | -#define WHERE_OB_UNIQUE 0x00004000 /* Values in ORDER BY columns are |
| 104638 | | - ** different for every output row */ |
| 104639 | | -#define WHERE_VIRTUALTABLE 0x08000000 /* Use virtual-table processing */ |
| 104640 | | -#define WHERE_MULTI_OR 0x10000000 /* OR using multiple indices */ |
| 104641 | | -#define WHERE_TEMP_INDEX 0x20000000 /* Uses an ephemeral index */ |
| 104642 | | -#define WHERE_DISTINCT 0x40000000 /* Correct order for DISTINCT */ |
| 104643 | | -#define WHERE_COVER_SCAN 0x80000000 /* Full scan of a covering index */ |
| 104644 | | - |
| 104645 | | -/* |
| 104646 | | -** This module contains many separate subroutines that work together to |
| 104647 | | -** find the best indices to use for accessing a particular table in a query. |
| 104648 | | -** An instance of the following structure holds context information about the |
| 104649 | | -** index search so that it can be more easily passed between the various |
| 104650 | | -** routines. |
| 104651 | | -*/ |
| 104652 | | -typedef struct WhereBestIdx WhereBestIdx; |
| 104653 | | -struct WhereBestIdx { |
| 104654 | | - Parse *pParse; /* Parser context */ |
| 104655 | | - WhereClause *pWC; /* The WHERE clause */ |
| 104656 | | - struct SrcList_item *pSrc; /* The FROM clause term to search */ |
| 104657 | | - Bitmask notReady; /* Mask of cursors not available */ |
| 104658 | | - Bitmask notValid; /* Cursors not available for any purpose */ |
| 104659 | | - ExprList *pOrderBy; /* The ORDER BY clause */ |
| 104660 | | - ExprList *pDistinct; /* The select-list if query is DISTINCT */ |
| 104661 | | - sqlite3_index_info **ppIdxInfo; /* Index information passed to xBestIndex */ |
| 104662 | | - int i, n; /* Which loop is being coded; # of loops */ |
| 104663 | | - WhereLevel *aLevel; /* Info about outer loops */ |
| 104664 | | - WhereCost cost; /* Lowest cost query plan */ |
| 104665 | | -}; |
| 104666 | | - |
| 104667 | | -/* |
| 104668 | | -** Return TRUE if the probe cost is less than the baseline cost |
| 104669 | | -*/ |
| 104670 | | -static int compareCost(const WhereCost *pProbe, const WhereCost *pBaseline){ |
| 104671 | | - if( pProbe->rCost<pBaseline->rCost ) return 1; |
| 104672 | | - if( pProbe->rCost>pBaseline->rCost ) return 0; |
| 104673 | | - if( pProbe->plan.nOBSat>pBaseline->plan.nOBSat ) return 1; |
| 104674 | | - if( pProbe->plan.nRow<pBaseline->plan.nRow ) return 1; |
| 104675 | | - return 0; |
| 104711 | +** These are definitions of bits in the WhereLoop.wsFlags field. |
| 104712 | +** The particular combination of bits in each WhereLoop help to |
| 104713 | +** determine the algorithm that WhereLoop represents. |
| 104714 | +*/ |
| 104715 | +#define WHERE_COLUMN_EQ 0x00000001 /* x=EXPR or x IN (...) or x IS NULL */ |
| 104716 | +#define WHERE_COLUMN_RANGE 0x00000002 /* x<EXPR and/or x>EXPR */ |
| 104717 | +#define WHERE_COLUMN_IN 0x00000004 /* x IN (...) */ |
| 104718 | +#define WHERE_COLUMN_NULL 0x00000008 /* x IS NULL */ |
| 104719 | +#define WHERE_CONSTRAINT 0x0000000f /* Any of the WHERE_COLUMN_xxx values */ |
| 104720 | +#define WHERE_TOP_LIMIT 0x00000010 /* x<EXPR or x<=EXPR constraint */ |
| 104721 | +#define WHERE_BTM_LIMIT 0x00000020 /* x>EXPR or x>=EXPR constraint */ |
| 104722 | +#define WHERE_BOTH_LIMIT 0x00000030 /* Both x>EXPR and x<EXPR */ |
| 104723 | +#define WHERE_IDX_ONLY 0x00000040 /* Use index only - omit table */ |
| 104724 | +#define WHERE_IPK 0x00000100 /* x is the INTEGER PRIMARY KEY */ |
| 104725 | +#define WHERE_INDEXED 0x00000200 /* WhereLoop.u.btree.pIndex is valid */ |
| 104726 | +#define WHERE_VIRTUALTABLE 0x00000400 /* WhereLoop.u.vtab is valid */ |
| 104727 | +#define WHERE_IN_ABLE 0x00000800 /* Able to support an IN operator */ |
| 104728 | +#define WHERE_ONEROW 0x00001000 /* Selects no more than one row */ |
| 104729 | +#define WHERE_MULTI_OR 0x00002000 /* OR using multiple indices */ |
| 104730 | +#define WHERE_TEMP_INDEX 0x00004000 /* Uses an ephemeral index */ |
| 104731 | + |
| 104732 | + |
| 104733 | +/* Convert a WhereCost value (10 times log2(X)) into its integer value X. |
| 104734 | +** A rough approximation is used. The value returned is not exact. |
| 104735 | +*/ |
| 104736 | +static u64 whereCostToInt(WhereCost x){ |
| 104737 | + u64 n; |
| 104738 | + if( x<10 ) return 1; |
| 104739 | + n = x%10; |
| 104740 | + x /= 10; |
| 104741 | + if( n>=5 ) n -= 2; |
| 104742 | + else if( n>=1 ) n -= 1; |
| 104743 | + if( x>=3 ) return (n+8)<<(x-3); |
| 104744 | + return (n+8)>>(3-x); |
| 104745 | +} |
| 104746 | + |
| 104747 | +/* |
| 104748 | +** Return the estimated number of output rows from a WHERE clause |
| 104749 | +*/ |
| 104750 | +SQLITE_PRIVATE u64 sqlite3WhereOutputRowCount(WhereInfo *pWInfo){ |
| 104751 | + return whereCostToInt(pWInfo->nRowOut); |
| 104752 | +} |
| 104753 | + |
| 104754 | +/* |
| 104755 | +** Return one of the WHERE_DISTINCT_xxxxx values to indicate how this |
| 104756 | +** WHERE clause returns outputs for DISTINCT processing. |
| 104757 | +*/ |
| 104758 | +SQLITE_PRIVATE int sqlite3WhereIsDistinct(WhereInfo *pWInfo){ |
| 104759 | + return pWInfo->eDistinct; |
| 104760 | +} |
| 104761 | + |
| 104762 | +/* |
| 104763 | +** Return TRUE if the WHERE clause returns rows in ORDER BY order. |
| 104764 | +** Return FALSE if the output needs to be sorted. |
| 104765 | +*/ |
| 104766 | +SQLITE_PRIVATE int sqlite3WhereIsOrdered(WhereInfo *pWInfo){ |
| 104767 | + return pWInfo->bOBSat!=0; |
| 104768 | +} |
| 104769 | + |
| 104770 | +/* |
| 104771 | +** Return the VDBE address or label to jump to in order to continue |
| 104772 | +** immediately with the next row of a WHERE clause. |
| 104773 | +*/ |
| 104774 | +SQLITE_PRIVATE int sqlite3WhereContinueLabel(WhereInfo *pWInfo){ |
| 104775 | + return pWInfo->iContinue; |
| 104776 | +} |
| 104777 | + |
| 104778 | +/* |
| 104779 | +** Return the VDBE address or label to jump to in order to break |
| 104780 | +** out of a WHERE loop. |
| 104781 | +*/ |
| 104782 | +SQLITE_PRIVATE int sqlite3WhereBreakLabel(WhereInfo *pWInfo){ |
| 104783 | + return pWInfo->iBreak; |
| 104784 | +} |
| 104785 | + |
| 104786 | +/* |
| 104787 | +** Return TRUE if an UPDATE or DELETE statement can operate directly on |
| 104788 | +** the rowids returned by a WHERE clause. Return FALSE if doing an |
| 104789 | +** UPDATE or DELETE might change subsequent WHERE clause results. |
| 104790 | +*/ |
| 104791 | +SQLITE_PRIVATE int sqlite3WhereOkOnePass(WhereInfo *pWInfo){ |
| 104792 | + return pWInfo->okOnePass; |
| 104676 | 104793 | } |
| 104677 | 104794 | |
| 104678 | 104795 | /* |
| 104679 | 104796 | ** Initialize a preallocated WhereClause structure. |
| 104680 | 104797 | */ |
| 104681 | 104798 | static void whereClauseInit( |
| 104682 | 104799 | WhereClause *pWC, /* The WhereClause to be initialized */ |
| 104683 | | - Parse *pParse, /* The parsing context */ |
| 104684 | | - WhereMaskSet *pMaskSet, /* Mapping from table cursor numbers to bitmasks */ |
| 104685 | | - u16 wctrlFlags /* Might include WHERE_AND_ONLY */ |
| 104800 | + WhereInfo *pWInfo /* The WHERE processing context */ |
| 104686 | 104801 | ){ |
| 104687 | | - pWC->pParse = pParse; |
| 104688 | | - pWC->pMaskSet = pMaskSet; |
| 104802 | + pWC->pWInfo = pWInfo; |
| 104689 | 104803 | pWC->pOuter = 0; |
| 104690 | 104804 | pWC->nTerm = 0; |
| 104691 | 104805 | pWC->nSlot = ArraySize(pWC->aStatic); |
| 104692 | 104806 | pWC->a = pWC->aStatic; |
| 104693 | | - pWC->wctrlFlags = wctrlFlags; |
| 104694 | 104807 | } |
| 104695 | 104808 | |
| 104696 | 104809 | /* Forward reference */ |
| 104697 | 104810 | static void whereClauseClear(WhereClause*); |
| 104698 | 104811 | |
| | @@ -104717,11 +104830,11 @@ |
| 104717 | 104830 | ** itself is not freed. This routine is the inverse of whereClauseInit(). |
| 104718 | 104831 | */ |
| 104719 | 104832 | static void whereClauseClear(WhereClause *pWC){ |
| 104720 | 104833 | int i; |
| 104721 | 104834 | WhereTerm *a; |
| 104722 | | - sqlite3 *db = pWC->pParse->db; |
| 104835 | + sqlite3 *db = pWC->pWInfo->pParse->db; |
| 104723 | 104836 | for(i=pWC->nTerm-1, a=pWC->a; i>=0; i--, a++){ |
| 104724 | 104837 | if( a->wtFlags & TERM_DYNAMIC ){ |
| 104725 | 104838 | sqlite3ExprDelete(db, a->pExpr); |
| 104726 | 104839 | } |
| 104727 | 104840 | if( a->wtFlags & TERM_ORINFO ){ |
| | @@ -104758,11 +104871,11 @@ |
| 104758 | 104871 | WhereTerm *pTerm; |
| 104759 | 104872 | int idx; |
| 104760 | 104873 | testcase( wtFlags & TERM_VIRTUAL ); /* EV: R-00211-15100 */ |
| 104761 | 104874 | if( pWC->nTerm>=pWC->nSlot ){ |
| 104762 | 104875 | WhereTerm *pOld = pWC->a; |
| 104763 | | - sqlite3 *db = pWC->pParse->db; |
| 104876 | + sqlite3 *db = pWC->pWInfo->pParse->db; |
| 104764 | 104877 | pWC->a = sqlite3DbMallocRaw(db, sizeof(pWC->a[0])*pWC->nSlot*2 ); |
| 104765 | 104878 | if( pWC->a==0 ){ |
| 104766 | 104879 | if( wtFlags & TERM_DYNAMIC ){ |
| 104767 | 104880 | sqlite3ExprDelete(db, p); |
| 104768 | 104881 | } |
| | @@ -104798,12 +104911,12 @@ |
| 104798 | 104911 | ** |
| 104799 | 104912 | ** In the previous sentence and in the diagram, "slot[]" refers to |
| 104800 | 104913 | ** the WhereClause.a[] array. The slot[] array grows as needed to contain |
| 104801 | 104914 | ** all terms of the WHERE clause. |
| 104802 | 104915 | */ |
| 104803 | | -static void whereSplit(WhereClause *pWC, Expr *pExpr, int op){ |
| 104804 | | - pWC->op = (u8)op; |
| 104916 | +static void whereSplit(WhereClause *pWC, Expr *pExpr, u8 op){ |
| 104917 | + pWC->op = op; |
| 104805 | 104918 | if( pExpr==0 ) return; |
| 104806 | 104919 | if( pExpr->op!=op ){ |
| 104807 | 104920 | whereClauseInsert(pWC, pExpr, 0); |
| 104808 | 104921 | }else{ |
| 104809 | 104922 | whereSplit(pWC, pExpr->pLeft, op); |
| | @@ -104810,13 +104923,13 @@ |
| 104810 | 104923 | whereSplit(pWC, pExpr->pRight, op); |
| 104811 | 104924 | } |
| 104812 | 104925 | } |
| 104813 | 104926 | |
| 104814 | 104927 | /* |
| 104815 | | -** Initialize an expression mask set (a WhereMaskSet object) |
| 104928 | +** Initialize a WhereMaskSet object |
| 104816 | 104929 | */ |
| 104817 | | -#define initMaskSet(P) memset(P, 0, sizeof(*P)) |
| 104930 | +#define initMaskSet(P) (P)->n=0 |
| 104818 | 104931 | |
| 104819 | 104932 | /* |
| 104820 | 104933 | ** Return the bitmask for the given cursor number. Return 0 if |
| 104821 | 104934 | ** iCursor is not in the set. |
| 104822 | 104935 | */ |
| | @@ -104823,11 +104936,11 @@ |
| 104823 | 104936 | static Bitmask getMask(WhereMaskSet *pMaskSet, int iCursor){ |
| 104824 | 104937 | int i; |
| 104825 | 104938 | assert( pMaskSet->n<=(int)sizeof(Bitmask)*8 ); |
| 104826 | 104939 | for(i=0; i<pMaskSet->n; i++){ |
| 104827 | 104940 | if( pMaskSet->ix[i]==iCursor ){ |
| 104828 | | - return ((Bitmask)1)<<i; |
| 104941 | + return MASKBIT(i); |
| 104829 | 104942 | } |
| 104830 | 104943 | } |
| 104831 | 104944 | return 0; |
| 104832 | 104945 | } |
| 104833 | 104946 | |
| | @@ -104843,22 +104956,13 @@ |
| 104843 | 104956 | assert( pMaskSet->n < ArraySize(pMaskSet->ix) ); |
| 104844 | 104957 | pMaskSet->ix[pMaskSet->n++] = iCursor; |
| 104845 | 104958 | } |
| 104846 | 104959 | |
| 104847 | 104960 | /* |
| 104848 | | -** This routine walks (recursively) an expression tree and generates |
| 104961 | +** These routine walk (recursively) an expression tree and generates |
| 104849 | 104962 | ** a bitmask indicating which tables are used in that expression |
| 104850 | 104963 | ** tree. |
| 104851 | | -** |
| 104852 | | -** In order for this routine to work, the calling function must have |
| 104853 | | -** previously invoked sqlite3ResolveExprNames() on the expression. See |
| 104854 | | -** the header comment on that routine for additional information. |
| 104855 | | -** The sqlite3ResolveExprNames() routines looks for column names and |
| 104856 | | -** sets their opcodes to TK_COLUMN and their Expr.iTable fields to |
| 104857 | | -** the VDBE cursor number of the table. This routine just has to |
| 104858 | | -** translate the cursor numbers into bitmask values and OR all |
| 104859 | | -** the bitmasks together. |
| 104860 | 104964 | */ |
| 104861 | 104965 | static Bitmask exprListTableUsage(WhereMaskSet*, ExprList*); |
| 104862 | 104966 | static Bitmask exprSelectTableUsage(WhereMaskSet*, Select*); |
| 104863 | 104967 | static Bitmask exprTableUsage(WhereMaskSet *pMaskSet, Expr *p){ |
| 104864 | 104968 | Bitmask mask = 0; |
| | @@ -104908,11 +105012,11 @@ |
| 104908 | 105012 | } |
| 104909 | 105013 | |
| 104910 | 105014 | /* |
| 104911 | 105015 | ** Return TRUE if the given operator is one of the operators that is |
| 104912 | 105016 | ** allowed for an indexable WHERE clause term. The allowed operators are |
| 104913 | | -** "=", "<", ">", "<=", ">=", and "IN". |
| 105017 | +** "=", "<", ">", "<=", ">=", "IN", and "IS NULL" |
| 104914 | 105018 | ** |
| 104915 | 105019 | ** IMPLEMENTATION-OF: R-59926-26393 To be usable by an index a term must be |
| 104916 | 105020 | ** of one of the following forms: column = expression column > expression |
| 104917 | 105021 | ** column >= expression column < expression column <= expression |
| 104918 | 105022 | ** expression = column expression > column expression >= column |
| | @@ -104935,14 +105039,13 @@ |
| 104935 | 105039 | /* |
| 104936 | 105040 | ** Commute a comparison operator. Expressions of the form "X op Y" |
| 104937 | 105041 | ** are converted into "Y op X". |
| 104938 | 105042 | ** |
| 104939 | 105043 | ** If left/right precedence rules come into play when determining the |
| 104940 | | -** collating |
| 104941 | | -** side of the comparison, it remains associated with the same side after |
| 104942 | | -** the commutation. So "Y collate NOCASE op X" becomes |
| 104943 | | -** "X op Y". This is because any collation sequence on |
| 105044 | +** collating sequence, then COLLATE operators are adjusted to ensure |
| 105045 | +** that the collating sequence does not change. For example: |
| 105046 | +** "Y collate NOCASE op X" becomes "X op Y" because any collation sequence on |
| 104944 | 105047 | ** the left hand side of a comparison overrides any collation sequence |
| 104945 | 105048 | ** attached to the right. For the same reason the EP_Collate flag |
| 104946 | 105049 | ** is not commuted. |
| 104947 | 105050 | */ |
| 104948 | 105051 | static void exprCommute(Parse *pParse, Expr *pExpr){ |
| | @@ -104994,10 +105097,134 @@ |
| 104994 | 105097 | assert( op!=TK_LE || c==WO_LE ); |
| 104995 | 105098 | assert( op!=TK_GT || c==WO_GT ); |
| 104996 | 105099 | assert( op!=TK_GE || c==WO_GE ); |
| 104997 | 105100 | return c; |
| 104998 | 105101 | } |
| 105102 | + |
| 105103 | +/* |
| 105104 | +** Advance to the next WhereTerm that matches according to the criteria |
| 105105 | +** established when the pScan object was initialized by whereScanInit(). |
| 105106 | +** Return NULL if there are no more matching WhereTerms. |
| 105107 | +*/ |
| 105108 | +WhereTerm *whereScanNext(WhereScan *pScan){ |
| 105109 | + int iCur; /* The cursor on the LHS of the term */ |
| 105110 | + int iColumn; /* The column on the LHS of the term. -1 for IPK */ |
| 105111 | + Expr *pX; /* An expression being tested */ |
| 105112 | + WhereClause *pWC; /* Shorthand for pScan->pWC */ |
| 105113 | + WhereTerm *pTerm; /* The term being tested */ |
| 105114 | + int k = pScan->k; /* Where to start scanning */ |
| 105115 | + |
| 105116 | + while( pScan->iEquiv<=pScan->nEquiv ){ |
| 105117 | + iCur = pScan->aEquiv[pScan->iEquiv-2]; |
| 105118 | + iColumn = pScan->aEquiv[pScan->iEquiv-1]; |
| 105119 | + while( (pWC = pScan->pWC)!=0 ){ |
| 105120 | + for(pTerm=pWC->a+k; k<pWC->nTerm; k++, pTerm++){ |
| 105121 | + if( pTerm->leftCursor==iCur && pTerm->u.leftColumn==iColumn ){ |
| 105122 | + if( (pTerm->eOperator & WO_EQUIV)!=0 |
| 105123 | + && pScan->nEquiv<ArraySize(pScan->aEquiv) |
| 105124 | + ){ |
| 105125 | + int j; |
| 105126 | + pX = sqlite3ExprSkipCollate(pTerm->pExpr->pRight); |
| 105127 | + assert( pX->op==TK_COLUMN ); |
| 105128 | + for(j=0; j<pScan->nEquiv; j+=2){ |
| 105129 | + if( pScan->aEquiv[j]==pX->iTable |
| 105130 | + && pScan->aEquiv[j+1]==pX->iColumn ){ |
| 105131 | + break; |
| 105132 | + } |
| 105133 | + } |
| 105134 | + if( j==pScan->nEquiv ){ |
| 105135 | + pScan->aEquiv[j] = pX->iTable; |
| 105136 | + pScan->aEquiv[j+1] = pX->iColumn; |
| 105137 | + pScan->nEquiv += 2; |
| 105138 | + } |
| 105139 | + } |
| 105140 | + if( (pTerm->eOperator & pScan->opMask)!=0 ){ |
| 105141 | + /* Verify the affinity and collating sequence match */ |
| 105142 | + if( pScan->zCollName && (pTerm->eOperator & WO_ISNULL)==0 ){ |
| 105143 | + CollSeq *pColl; |
| 105144 | + Parse *pParse = pWC->pWInfo->pParse; |
| 105145 | + pX = pTerm->pExpr; |
| 105146 | + if( !sqlite3IndexAffinityOk(pX, pScan->idxaff) ){ |
| 105147 | + continue; |
| 105148 | + } |
| 105149 | + assert(pX->pLeft); |
| 105150 | + pColl = sqlite3BinaryCompareCollSeq(pParse, |
| 105151 | + pX->pLeft, pX->pRight); |
| 105152 | + if( pColl==0 ) pColl = pParse->db->pDfltColl; |
| 105153 | + if( sqlite3StrICmp(pColl->zName, pScan->zCollName) ){ |
| 105154 | + continue; |
| 105155 | + } |
| 105156 | + } |
| 105157 | + if( (pTerm->eOperator & WO_EQ)!=0 |
| 105158 | + && (pX = pTerm->pExpr->pRight)->op==TK_COLUMN |
| 105159 | + && pX->iTable==pScan->aEquiv[0] |
| 105160 | + && pX->iColumn==pScan->aEquiv[1] |
| 105161 | + ){ |
| 105162 | + continue; |
| 105163 | + } |
| 105164 | + pScan->k = k+1; |
| 105165 | + return pTerm; |
| 105166 | + } |
| 105167 | + } |
| 105168 | + } |
| 105169 | + pScan->pWC = pScan->pWC->pOuter; |
| 105170 | + k = 0; |
| 105171 | + } |
| 105172 | + pScan->pWC = pScan->pOrigWC; |
| 105173 | + k = 0; |
| 105174 | + pScan->iEquiv += 2; |
| 105175 | + } |
| 105176 | + return 0; |
| 105177 | +} |
| 105178 | + |
| 105179 | +/* |
| 105180 | +** Initialize a WHERE clause scanner object. Return a pointer to the |
| 105181 | +** first match. Return NULL if there are no matches. |
| 105182 | +** |
| 105183 | +** The scanner will be searching the WHERE clause pWC. It will look |
| 105184 | +** for terms of the form "X <op> <expr>" where X is column iColumn of table |
| 105185 | +** iCur. The <op> must be one of the operators described by opMask. |
| 105186 | +** |
| 105187 | +** If the search is for X and the WHERE clause contains terms of the |
| 105188 | +** form X=Y then this routine might also return terms of the form |
| 105189 | +** "Y <op> <expr>". The number of levels of transitivity is limited, |
| 105190 | +** but is enough to handle most commonly occurring SQL statements. |
| 105191 | +** |
| 105192 | +** If X is not the INTEGER PRIMARY KEY then X must be compatible with |
| 105193 | +** index pIdx. |
| 105194 | +*/ |
| 105195 | +WhereTerm *whereScanInit( |
| 105196 | + WhereScan *pScan, /* The WhereScan object being initialized */ |
| 105197 | + WhereClause *pWC, /* The WHERE clause to be scanned */ |
| 105198 | + int iCur, /* Cursor to scan for */ |
| 105199 | + int iColumn, /* Column to scan for */ |
| 105200 | + u32 opMask, /* Operator(s) to scan for */ |
| 105201 | + Index *pIdx /* Must be compatible with this index */ |
| 105202 | +){ |
| 105203 | + int j; |
| 105204 | + |
| 105205 | + /* memset(pScan, 0, sizeof(*pScan)); */ |
| 105206 | + pScan->pOrigWC = pWC; |
| 105207 | + pScan->pWC = pWC; |
| 105208 | + if( pIdx && iColumn>=0 ){ |
| 105209 | + pScan->idxaff = pIdx->pTable->aCol[iColumn].affinity; |
| 105210 | + for(j=0; pIdx->aiColumn[j]!=iColumn; j++){ |
| 105211 | + if( NEVER(j>=pIdx->nColumn) ) return 0; |
| 105212 | + } |
| 105213 | + pScan->zCollName = pIdx->azColl[j]; |
| 105214 | + }else{ |
| 105215 | + pScan->idxaff = 0; |
| 105216 | + pScan->zCollName = 0; |
| 105217 | + } |
| 105218 | + pScan->opMask = opMask; |
| 105219 | + pScan->k = 0; |
| 105220 | + pScan->aEquiv[0] = iCur; |
| 105221 | + pScan->aEquiv[1] = iColumn; |
| 105222 | + pScan->nEquiv = 2; |
| 105223 | + pScan->iEquiv = 2; |
| 105224 | + return whereScanNext(pScan); |
| 105225 | +} |
| 104999 | 105226 | |
| 105000 | 105227 | /* |
| 105001 | 105228 | ** Search for a term in the WHERE clause that is of the form "X <op> <expr>" |
| 105002 | 105229 | ** where X is a reference to the iColumn of table iCur and <op> is one of |
| 105003 | 105230 | ** the WO_xx operator codes specified by the op parameter. |
| | @@ -105026,98 +105253,32 @@ |
| 105026 | 105253 | int iColumn, /* Column number of LHS */ |
| 105027 | 105254 | Bitmask notReady, /* RHS must not overlap with this mask */ |
| 105028 | 105255 | u32 op, /* Mask of WO_xx values describing operator */ |
| 105029 | 105256 | Index *pIdx /* Must be compatible with this index, if not NULL */ |
| 105030 | 105257 | ){ |
| 105031 | | - WhereTerm *pTerm; /* Term being examined as possible result */ |
| 105032 | | - WhereTerm *pResult = 0; /* The answer to return */ |
| 105033 | | - WhereClause *pWCOrig = pWC; /* Original pWC value */ |
| 105034 | | - int j, k; /* Loop counters */ |
| 105035 | | - Expr *pX; /* Pointer to an expression */ |
| 105036 | | - Parse *pParse; /* Parsing context */ |
| 105037 | | - int iOrigCol = iColumn; /* Original value of iColumn */ |
| 105038 | | - int nEquiv = 2; /* Number of entires in aEquiv[] */ |
| 105039 | | - int iEquiv = 2; /* Number of entries of aEquiv[] processed so far */ |
| 105040 | | - int aEquiv[22]; /* iCur,iColumn and up to 10 other equivalents */ |
| 105041 | | - |
| 105042 | | - assert( iCur>=0 ); |
| 105043 | | - aEquiv[0] = iCur; |
| 105044 | | - aEquiv[1] = iColumn; |
| 105045 | | - for(;;){ |
| 105046 | | - for(pWC=pWCOrig; pWC; pWC=pWC->pOuter){ |
| 105047 | | - for(pTerm=pWC->a, k=pWC->nTerm; k; k--, pTerm++){ |
| 105048 | | - if( pTerm->leftCursor==iCur |
| 105049 | | - && pTerm->u.leftColumn==iColumn |
| 105050 | | - ){ |
| 105051 | | - if( (pTerm->prereqRight & notReady)==0 |
| 105052 | | - && (pTerm->eOperator & op & WO_ALL)!=0 |
| 105053 | | - ){ |
| 105054 | | - if( iOrigCol>=0 && pIdx && (pTerm->eOperator & WO_ISNULL)==0 ){ |
| 105055 | | - CollSeq *pColl; |
| 105056 | | - char idxaff; |
| 105057 | | - |
| 105058 | | - pX = pTerm->pExpr; |
| 105059 | | - pParse = pWC->pParse; |
| 105060 | | - idxaff = pIdx->pTable->aCol[iOrigCol].affinity; |
| 105061 | | - if( !sqlite3IndexAffinityOk(pX, idxaff) ){ |
| 105062 | | - continue; |
| 105063 | | - } |
| 105064 | | - |
| 105065 | | - /* Figure out the collation sequence required from an index for |
| 105066 | | - ** it to be useful for optimising expression pX. Store this |
| 105067 | | - ** value in variable pColl. |
| 105068 | | - */ |
| 105069 | | - assert(pX->pLeft); |
| 105070 | | - pColl = sqlite3BinaryCompareCollSeq(pParse,pX->pLeft,pX->pRight); |
| 105071 | | - if( pColl==0 ) pColl = pParse->db->pDfltColl; |
| 105072 | | - |
| 105073 | | - for(j=0; pIdx->aiColumn[j]!=iOrigCol; j++){ |
| 105074 | | - if( NEVER(j>=pIdx->nColumn) ) return 0; |
| 105075 | | - } |
| 105076 | | - if( sqlite3StrICmp(pColl->zName, pIdx->azColl[j]) ){ |
| 105077 | | - continue; |
| 105078 | | - } |
| 105079 | | - } |
| 105080 | | - if( pTerm->prereqRight==0 && (pTerm->eOperator&WO_EQ)!=0 ){ |
| 105081 | | - pResult = pTerm; |
| 105082 | | - goto findTerm_success; |
| 105083 | | - }else if( pResult==0 ){ |
| 105084 | | - pResult = pTerm; |
| 105085 | | - } |
| 105086 | | - } |
| 105087 | | - if( (pTerm->eOperator & WO_EQUIV)!=0 |
| 105088 | | - && nEquiv<ArraySize(aEquiv) |
| 105089 | | - ){ |
| 105090 | | - pX = sqlite3ExprSkipCollate(pTerm->pExpr->pRight); |
| 105091 | | - assert( pX->op==TK_COLUMN ); |
| 105092 | | - for(j=0; j<nEquiv; j+=2){ |
| 105093 | | - if( aEquiv[j]==pX->iTable && aEquiv[j+1]==pX->iColumn ) break; |
| 105094 | | - } |
| 105095 | | - if( j==nEquiv ){ |
| 105096 | | - aEquiv[j] = pX->iTable; |
| 105097 | | - aEquiv[j+1] = pX->iColumn; |
| 105098 | | - nEquiv += 2; |
| 105099 | | - } |
| 105100 | | - } |
| 105101 | | - } |
| 105102 | | - } |
| 105103 | | - } |
| 105104 | | - if( iEquiv>=nEquiv ) break; |
| 105105 | | - iCur = aEquiv[iEquiv++]; |
| 105106 | | - iColumn = aEquiv[iEquiv++]; |
| 105107 | | - } |
| 105108 | | -findTerm_success: |
| 105258 | + WhereTerm *pResult = 0; |
| 105259 | + WhereTerm *p; |
| 105260 | + WhereScan scan; |
| 105261 | + |
| 105262 | + p = whereScanInit(&scan, pWC, iCur, iColumn, op, pIdx); |
| 105263 | + while( p ){ |
| 105264 | + if( (p->prereqRight & notReady)==0 ){ |
| 105265 | + if( p->prereqRight==0 && (p->eOperator&WO_EQ)!=0 ){ |
| 105266 | + return p; |
| 105267 | + } |
| 105268 | + if( pResult==0 ) pResult = p; |
| 105269 | + } |
| 105270 | + p = whereScanNext(&scan); |
| 105271 | + } |
| 105109 | 105272 | return pResult; |
| 105110 | 105273 | } |
| 105111 | 105274 | |
| 105112 | 105275 | /* Forward reference */ |
| 105113 | 105276 | static void exprAnalyze(SrcList*, WhereClause*, int); |
| 105114 | 105277 | |
| 105115 | 105278 | /* |
| 105116 | 105279 | ** Call exprAnalyze on all terms in a WHERE clause. |
| 105117 | | -** |
| 105118 | | -** |
| 105119 | 105280 | */ |
| 105120 | 105281 | static void exprAnalyzeAll( |
| 105121 | 105282 | SrcList *pTabList, /* the FROM clause */ |
| 105122 | 105283 | WhereClause *pWC /* the WHERE clause to be analyzed */ |
| 105123 | 105284 | ){ |
| | @@ -105345,15 +105506,15 @@ |
| 105345 | 105506 | static void exprAnalyzeOrTerm( |
| 105346 | 105507 | SrcList *pSrc, /* the FROM clause */ |
| 105347 | 105508 | WhereClause *pWC, /* the complete WHERE clause */ |
| 105348 | 105509 | int idxTerm /* Index of the OR-term to be analyzed */ |
| 105349 | 105510 | ){ |
| 105350 | | - Parse *pParse = pWC->pParse; /* Parser context */ |
| 105511 | + WhereInfo *pWInfo = pWC->pWInfo; /* WHERE clause processing context */ |
| 105512 | + Parse *pParse = pWInfo->pParse; /* Parser context */ |
| 105351 | 105513 | sqlite3 *db = pParse->db; /* Database connection */ |
| 105352 | 105514 | WhereTerm *pTerm = &pWC->a[idxTerm]; /* The term to be analyzed */ |
| 105353 | 105515 | Expr *pExpr = pTerm->pExpr; /* The expression of the term */ |
| 105354 | | - WhereMaskSet *pMaskSet = pWC->pMaskSet; /* Table use masks */ |
| 105355 | 105516 | int i; /* Loop counters */ |
| 105356 | 105517 | WhereClause *pOrWc; /* Breakup of pTerm into subterms */ |
| 105357 | 105518 | WhereTerm *pOrTerm; /* A Sub-term within the pOrWc */ |
| 105358 | 105519 | WhereOrInfo *pOrInfo; /* Additional information associated with pTerm */ |
| 105359 | 105520 | Bitmask chngToIN; /* Tables that might satisfy case 1 */ |
| | @@ -105368,11 +105529,11 @@ |
| 105368 | 105529 | assert( pExpr->op==TK_OR ); |
| 105369 | 105530 | pTerm->u.pOrInfo = pOrInfo = sqlite3DbMallocZero(db, sizeof(*pOrInfo)); |
| 105370 | 105531 | if( pOrInfo==0 ) return; |
| 105371 | 105532 | pTerm->wtFlags |= TERM_ORINFO; |
| 105372 | 105533 | pOrWc = &pOrInfo->wc; |
| 105373 | | - whereClauseInit(pOrWc, pWC->pParse, pMaskSet, pWC->wctrlFlags); |
| 105534 | + whereClauseInit(pOrWc, pWInfo); |
| 105374 | 105535 | whereSplit(pOrWc, pExpr, TK_OR); |
| 105375 | 105536 | exprAnalyzeAll(pSrc, pOrWc); |
| 105376 | 105537 | if( db->mallocFailed ) return; |
| 105377 | 105538 | assert( pOrWc->nTerm>=2 ); |
| 105378 | 105539 | |
| | @@ -105394,20 +105555,20 @@ |
| 105394 | 105555 | Bitmask b = 0; |
| 105395 | 105556 | pOrTerm->u.pAndInfo = pAndInfo; |
| 105396 | 105557 | pOrTerm->wtFlags |= TERM_ANDINFO; |
| 105397 | 105558 | pOrTerm->eOperator = WO_AND; |
| 105398 | 105559 | pAndWC = &pAndInfo->wc; |
| 105399 | | - whereClauseInit(pAndWC, pWC->pParse, pMaskSet, pWC->wctrlFlags); |
| 105560 | + whereClauseInit(pAndWC, pWC->pWInfo); |
| 105400 | 105561 | whereSplit(pAndWC, pOrTerm->pExpr, TK_AND); |
| 105401 | 105562 | exprAnalyzeAll(pSrc, pAndWC); |
| 105402 | 105563 | pAndWC->pOuter = pWC; |
| 105403 | 105564 | testcase( db->mallocFailed ); |
| 105404 | 105565 | if( !db->mallocFailed ){ |
| 105405 | 105566 | for(j=0, pAndTerm=pAndWC->a; j<pAndWC->nTerm; j++, pAndTerm++){ |
| 105406 | 105567 | assert( pAndTerm->pExpr ); |
| 105407 | 105568 | if( allowedOp(pAndTerm->pExpr->op) ){ |
| 105408 | | - b |= getMask(pMaskSet, pAndTerm->leftCursor); |
| 105569 | + b |= getMask(&pWInfo->sMaskSet, pAndTerm->leftCursor); |
| 105409 | 105570 | } |
| 105410 | 105571 | } |
| 105411 | 105572 | } |
| 105412 | 105573 | indexable &= b; |
| 105413 | 105574 | } |
| | @@ -105414,14 +105575,14 @@ |
| 105414 | 105575 | }else if( pOrTerm->wtFlags & TERM_COPIED ){ |
| 105415 | 105576 | /* Skip this term for now. We revisit it when we process the |
| 105416 | 105577 | ** corresponding TERM_VIRTUAL term */ |
| 105417 | 105578 | }else{ |
| 105418 | 105579 | Bitmask b; |
| 105419 | | - b = getMask(pMaskSet, pOrTerm->leftCursor); |
| 105580 | + b = getMask(&pWInfo->sMaskSet, pOrTerm->leftCursor); |
| 105420 | 105581 | if( pOrTerm->wtFlags & TERM_VIRTUAL ){ |
| 105421 | 105582 | WhereTerm *pOther = &pOrWc->a[pOrTerm->iParent]; |
| 105422 | | - b |= getMask(pMaskSet, pOther->leftCursor); |
| 105583 | + b |= getMask(&pWInfo->sMaskSet, pOther->leftCursor); |
| 105423 | 105584 | } |
| 105424 | 105585 | indexable &= b; |
| 105425 | 105586 | if( (pOrTerm->eOperator & WO_EQ)==0 ){ |
| 105426 | 105587 | chngToIN = 0; |
| 105427 | 105588 | }else{ |
| | @@ -105479,11 +105640,11 @@ |
| 105479 | 105640 | /* This is the 2-bit case and we are on the second iteration and |
| 105480 | 105641 | ** current term is from the first iteration. So skip this term. */ |
| 105481 | 105642 | assert( j==1 ); |
| 105482 | 105643 | continue; |
| 105483 | 105644 | } |
| 105484 | | - if( (chngToIN & getMask(pMaskSet, pOrTerm->leftCursor))==0 ){ |
| 105645 | + if( (chngToIN & getMask(&pWInfo->sMaskSet, pOrTerm->leftCursor))==0 ){ |
| 105485 | 105646 | /* This term must be of the form t1.a==t2.b where t2 is in the |
| 105486 | 105647 | ** chngToIN set but t1 is not. This term will be either preceeded |
| 105487 | 105648 | ** or follwed by an inverted copy (t2.b==t1.a). Skip this term |
| 105488 | 105649 | ** and use its inversion. */ |
| 105489 | 105650 | testcase( pOrTerm->wtFlags & TERM_COPIED ); |
| | @@ -105498,11 +105659,11 @@ |
| 105498 | 105659 | if( i<0 ){ |
| 105499 | 105660 | /* No candidate table+column was found. This can only occur |
| 105500 | 105661 | ** on the second iteration */ |
| 105501 | 105662 | assert( j==1 ); |
| 105502 | 105663 | assert( IsPowerOfTwo(chngToIN) ); |
| 105503 | | - assert( chngToIN==getMask(pMaskSet, iCursor) ); |
| 105664 | + assert( chngToIN==getMask(&pWInfo->sMaskSet, iCursor) ); |
| 105504 | 105665 | break; |
| 105505 | 105666 | } |
| 105506 | 105667 | testcase( j==1 ); |
| 105507 | 105668 | |
| 105508 | 105669 | /* We have found a candidate table and column. Check to see if that |
| | @@ -105547,11 +105708,11 @@ |
| 105547 | 105708 | if( (pOrTerm->wtFlags & TERM_OR_OK)==0 ) continue; |
| 105548 | 105709 | assert( pOrTerm->eOperator & WO_EQ ); |
| 105549 | 105710 | assert( pOrTerm->leftCursor==iCursor ); |
| 105550 | 105711 | assert( pOrTerm->u.leftColumn==iColumn ); |
| 105551 | 105712 | pDup = sqlite3ExprDup(db, pOrTerm->pExpr->pRight, 0); |
| 105552 | | - pList = sqlite3ExprListAppend(pWC->pParse, pList, pDup); |
| 105713 | + pList = sqlite3ExprListAppend(pWInfo->pParse, pList, pDup); |
| 105553 | 105714 | pLeft = pOrTerm->pExpr->pLeft; |
| 105554 | 105715 | } |
| 105555 | 105716 | assert( pLeft!=0 ); |
| 105556 | 105717 | pDup = sqlite3ExprDup(db, pLeft, 0); |
| 105557 | 105718 | pNew = sqlite3PExpr(pParse, TK_IN, pDup, 0, 0); |
| | @@ -105596,10 +105757,11 @@ |
| 105596 | 105757 | static void exprAnalyze( |
| 105597 | 105758 | SrcList *pSrc, /* the FROM clause */ |
| 105598 | 105759 | WhereClause *pWC, /* the WHERE clause */ |
| 105599 | 105760 | int idxTerm /* Index of the term to be analyzed */ |
| 105600 | 105761 | ){ |
| 105762 | + WhereInfo *pWInfo = pWC->pWInfo; /* WHERE clause processing context */ |
| 105601 | 105763 | WhereTerm *pTerm; /* The term to be analyzed */ |
| 105602 | 105764 | WhereMaskSet *pMaskSet; /* Set of table index masks */ |
| 105603 | 105765 | Expr *pExpr; /* The expression to be analyzed */ |
| 105604 | 105766 | Bitmask prereqLeft; /* Prerequesites of the pExpr->pLeft */ |
| 105605 | 105767 | Bitmask prereqAll; /* Prerequesites of pExpr */ |
| | @@ -105606,18 +105768,18 @@ |
| 105606 | 105768 | Bitmask extraRight = 0; /* Extra dependencies on LEFT JOIN */ |
| 105607 | 105769 | Expr *pStr1 = 0; /* RHS of LIKE/GLOB operator */ |
| 105608 | 105770 | int isComplete = 0; /* RHS of LIKE/GLOB ends with wildcard */ |
| 105609 | 105771 | int noCase = 0; /* LIKE/GLOB distinguishes case */ |
| 105610 | 105772 | int op; /* Top-level operator. pExpr->op */ |
| 105611 | | - Parse *pParse = pWC->pParse; /* Parsing context */ |
| 105773 | + Parse *pParse = pWInfo->pParse; /* Parsing context */ |
| 105612 | 105774 | sqlite3 *db = pParse->db; /* Database connection */ |
| 105613 | 105775 | |
| 105614 | 105776 | if( db->mallocFailed ){ |
| 105615 | 105777 | return; |
| 105616 | 105778 | } |
| 105617 | 105779 | pTerm = &pWC->a[idxTerm]; |
| 105618 | | - pMaskSet = pWC->pMaskSet; |
| 105780 | + pMaskSet = &pWInfo->sMaskSet; |
| 105619 | 105781 | pExpr = pTerm->pExpr; |
| 105620 | 105782 | assert( pExpr->op!=TK_AS && pExpr->op!=TK_COLLATE ); |
| 105621 | 105783 | prereqLeft = exprTableUsage(pMaskSet, pExpr->pLeft); |
| 105622 | 105784 | op = pExpr->op; |
| 105623 | 105785 | if( op==TK_IN ){ |
| | @@ -105891,15 +106053,12 @@ |
| 105891 | 106053 | */ |
| 105892 | 106054 | pTerm->prereqRight |= extraRight; |
| 105893 | 106055 | } |
| 105894 | 106056 | |
| 105895 | 106057 | /* |
| 105896 | | -** This function searches the expression list passed as the second argument |
| 105897 | | -** for an expression of type TK_COLUMN that refers to the same column and |
| 105898 | | -** uses the same collation sequence as the iCol'th column of index pIdx. |
| 105899 | | -** Argument iBase is the cursor number used for the table that pIdx refers |
| 105900 | | -** to. |
| 106058 | +** This function searches pList for a entry that matches the iCol-th column |
| 106059 | +** of index pIdx. |
| 105901 | 106060 | ** |
| 105902 | 106061 | ** If such an expression is found, its index in pList->a[] is returned. If |
| 105903 | 106062 | ** no expression is found, -1 is returned. |
| 105904 | 106063 | */ |
| 105905 | 106064 | static int findIndexCol( |
| | @@ -105925,82 +106084,23 @@ |
| 105925 | 106084 | } |
| 105926 | 106085 | } |
| 105927 | 106086 | |
| 105928 | 106087 | return -1; |
| 105929 | 106088 | } |
| 105930 | | - |
| 105931 | | -/* |
| 105932 | | -** This routine determines if pIdx can be used to assist in processing a |
| 105933 | | -** DISTINCT qualifier. In other words, it tests whether or not using this |
| 105934 | | -** index for the outer loop guarantees that rows with equal values for |
| 105935 | | -** all expressions in the pDistinct list are delivered grouped together. |
| 105936 | | -** |
| 105937 | | -** For example, the query |
| 105938 | | -** |
| 105939 | | -** SELECT DISTINCT a, b, c FROM tbl WHERE a = ? |
| 105940 | | -** |
| 105941 | | -** can benefit from any index on columns "b" and "c". |
| 105942 | | -*/ |
| 105943 | | -static int isDistinctIndex( |
| 105944 | | - Parse *pParse, /* Parsing context */ |
| 105945 | | - WhereClause *pWC, /* The WHERE clause */ |
| 105946 | | - Index *pIdx, /* The index being considered */ |
| 105947 | | - int base, /* Cursor number for the table pIdx is on */ |
| 105948 | | - ExprList *pDistinct, /* The DISTINCT expressions */ |
| 105949 | | - int nEqCol /* Number of index columns with == */ |
| 105950 | | -){ |
| 105951 | | - Bitmask mask = 0; /* Mask of unaccounted for pDistinct exprs */ |
| 105952 | | - int i; /* Iterator variable */ |
| 105953 | | - |
| 105954 | | - assert( pDistinct!=0 ); |
| 105955 | | - if( pIdx->zName==0 || pDistinct->nExpr>=BMS ) return 0; |
| 105956 | | - testcase( pDistinct->nExpr==BMS-1 ); |
| 105957 | | - |
| 105958 | | - /* Loop through all the expressions in the distinct list. If any of them |
| 105959 | | - ** are not simple column references, return early. Otherwise, test if the |
| 105960 | | - ** WHERE clause contains a "col=X" clause. If it does, the expression |
| 105961 | | - ** can be ignored. If it does not, and the column does not belong to the |
| 105962 | | - ** same table as index pIdx, return early. Finally, if there is no |
| 105963 | | - ** matching "col=X" expression and the column is on the same table as pIdx, |
| 105964 | | - ** set the corresponding bit in variable mask. |
| 105965 | | - */ |
| 105966 | | - for(i=0; i<pDistinct->nExpr; i++){ |
| 105967 | | - WhereTerm *pTerm; |
| 105968 | | - Expr *p = sqlite3ExprSkipCollate(pDistinct->a[i].pExpr); |
| 105969 | | - if( p->op!=TK_COLUMN ) return 0; |
| 105970 | | - pTerm = findTerm(pWC, p->iTable, p->iColumn, ~(Bitmask)0, WO_EQ, 0); |
| 105971 | | - if( pTerm ){ |
| 105972 | | - Expr *pX = pTerm->pExpr; |
| 105973 | | - CollSeq *p1 = sqlite3BinaryCompareCollSeq(pParse, pX->pLeft, pX->pRight); |
| 105974 | | - CollSeq *p2 = sqlite3ExprCollSeq(pParse, p); |
| 105975 | | - if( p1==p2 ) continue; |
| 105976 | | - } |
| 105977 | | - if( p->iTable!=base ) return 0; |
| 105978 | | - mask |= (((Bitmask)1) << i); |
| 105979 | | - } |
| 105980 | | - |
| 105981 | | - for(i=nEqCol; mask && i<pIdx->nColumn; i++){ |
| 105982 | | - int iExpr = findIndexCol(pParse, pDistinct, base, pIdx, i); |
| 105983 | | - if( iExpr<0 ) break; |
| 105984 | | - mask &= ~(((Bitmask)1) << iExpr); |
| 105985 | | - } |
| 105986 | | - |
| 105987 | | - return (mask==0); |
| 105988 | | -} |
| 105989 | | - |
| 105990 | 106089 | |
| 105991 | 106090 | /* |
| 105992 | 106091 | ** Return true if the DISTINCT expression-list passed as the third argument |
| 105993 | | -** is redundant. A DISTINCT list is redundant if the database contains a |
| 105994 | | -** UNIQUE index that guarantees that the result of the query will be distinct |
| 105995 | | -** anyway. |
| 106092 | +** is redundant. |
| 106093 | +** |
| 106094 | +** A DISTINCT list is redundant if the database contains some subset of |
| 106095 | +** columns that are unique and non-null. |
| 105996 | 106096 | */ |
| 105997 | 106097 | static int isDistinctRedundant( |
| 105998 | | - Parse *pParse, |
| 105999 | | - SrcList *pTabList, |
| 106000 | | - WhereClause *pWC, |
| 106001 | | - ExprList *pDistinct |
| 106098 | + Parse *pParse, /* Parsing context */ |
| 106099 | + SrcList *pTabList, /* The FROM clause */ |
| 106100 | + WhereClause *pWC, /* The WHERE clause */ |
| 106101 | + ExprList *pDistinct /* The result set that needs to be DISTINCT */ |
| 106002 | 106102 | ){ |
| 106003 | 106103 | Table *pTab; |
| 106004 | 106104 | Index *pIdx; |
| 106005 | 106105 | int i; |
| 106006 | 106106 | int iBase; |
| | @@ -106051,35 +106151,90 @@ |
| 106051 | 106151 | } |
| 106052 | 106152 | } |
| 106053 | 106153 | |
| 106054 | 106154 | return 0; |
| 106055 | 106155 | } |
| 106156 | + |
| 106157 | +/* |
| 106158 | +** The (an approximate) sum of two WhereCosts. This computation is |
| 106159 | +** not a simple "+" operator because WhereCost is stored as a logarithmic |
| 106160 | +** value. |
| 106161 | +** |
| 106162 | +*/ |
| 106163 | +static WhereCost whereCostAdd(WhereCost a, WhereCost b){ |
| 106164 | + static const unsigned char x[] = { |
| 106165 | + 10, 10, /* 0,1 */ |
| 106166 | + 9, 9, /* 2,3 */ |
| 106167 | + 8, 8, /* 4,5 */ |
| 106168 | + 7, 7, 7, /* 6,7,8 */ |
| 106169 | + 6, 6, 6, /* 9,10,11 */ |
| 106170 | + 5, 5, 5, /* 12-14 */ |
| 106171 | + 4, 4, 4, 4, /* 15-18 */ |
| 106172 | + 3, 3, 3, 3, 3, 3, /* 19-24 */ |
| 106173 | + 2, 2, 2, 2, 2, 2, 2, /* 25-31 */ |
| 106174 | + }; |
| 106175 | + if( a>=b ){ |
| 106176 | + if( a>b+49 ) return a; |
| 106177 | + if( a>b+31 ) return a+1; |
| 106178 | + return a+x[a-b]; |
| 106179 | + }else{ |
| 106180 | + if( b>a+49 ) return b; |
| 106181 | + if( b>a+31 ) return b+1; |
| 106182 | + return b+x[b-a]; |
| 106183 | + } |
| 106184 | +} |
| 106056 | 106185 | |
| 106057 | 106186 | /* |
| 106058 | | -** Prepare a crude estimate of the logarithm of the input value. |
| 106059 | | -** The results need not be exact. This is only used for estimating |
| 106060 | | -** the total cost of performing operations with O(logN) or O(NlogN) |
| 106061 | | -** complexity. Because N is just a guess, it is no great tragedy if |
| 106062 | | -** logN is a little off. |
| 106187 | +** Convert an integer into a WhereCost. In other words, compute a |
| 106188 | +** good approximatation for 10*log2(x). |
| 106063 | 106189 | */ |
| 106064 | | -static double estLog(double N){ |
| 106065 | | - double logN = 1; |
| 106066 | | - double x = 10; |
| 106067 | | - while( N>x ){ |
| 106068 | | - logN += 1; |
| 106069 | | - x *= 10; |
| 106070 | | - } |
| 106071 | | - return logN; |
| 106190 | +static WhereCost whereCost(tRowcnt x){ |
| 106191 | + static WhereCost a[] = { 0, 2, 3, 5, 6, 7, 8, 9 }; |
| 106192 | + WhereCost y = 40; |
| 106193 | + if( x<8 ){ |
| 106194 | + if( x<2 ) return 0; |
| 106195 | + while( x<8 ){ y -= 10; x <<= 1; } |
| 106196 | + }else{ |
| 106197 | + while( x>255 ){ y += 40; x >>= 4; } |
| 106198 | + while( x>15 ){ y += 10; x >>= 1; } |
| 106199 | + } |
| 106200 | + return a[x&7] + y - 10; |
| 106201 | +} |
| 106202 | + |
| 106203 | +#ifndef SQLITE_OMIT_VIRTUALTABLE |
| 106204 | +/* |
| 106205 | +** Convert a double (as received from xBestIndex of a virtual table) |
| 106206 | +** into a WhereCost. In other words, compute an approximation for |
| 106207 | +** 10*log2(x). |
| 106208 | +*/ |
| 106209 | +static WhereCost whereCostFromDouble(double x){ |
| 106210 | + u64 a; |
| 106211 | + WhereCost e; |
| 106212 | + assert( sizeof(x)==8 && sizeof(a)==8 ); |
| 106213 | + if( x<=1 ) return 0; |
| 106214 | + if( x<=2000000000 ) return whereCost((tRowcnt)x); |
| 106215 | + memcpy(&a, &x, 8); |
| 106216 | + e = (a>>52) - 1022; |
| 106217 | + return e*10; |
| 106218 | +} |
| 106219 | +#endif /* SQLITE_OMIT_VIRTUALTABLE */ |
| 106220 | + |
| 106221 | +/* |
| 106222 | +** Estimate the logarithm of the input value to base 2. |
| 106223 | +*/ |
| 106224 | +static WhereCost estLog(WhereCost N){ |
| 106225 | + WhereCost x = whereCost(N); |
| 106226 | + return x>33 ? x - 33 : 0; |
| 106072 | 106227 | } |
| 106073 | 106228 | |
| 106074 | 106229 | /* |
| 106075 | 106230 | ** Two routines for printing the content of an sqlite3_index_info |
| 106076 | 106231 | ** structure. Used for testing and debugging only. If neither |
| 106077 | 106232 | ** SQLITE_TEST or SQLITE_DEBUG are defined, then these routines |
| 106078 | 106233 | ** are no-ops. |
| 106079 | 106234 | */ |
| 106080 | | -#if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(SQLITE_DEBUG) |
| 106235 | +#if !defined(SQLITE_OMIT_VIRTUALTABLE) && defined(WHERETRACE_ENABLED) |
| 106081 | 106236 | static void TRACE_IDX_INPUTS(sqlite3_index_info *p){ |
| 106082 | 106237 | int i; |
| 106083 | 106238 | if( !sqlite3WhereTrace ) return; |
| 106084 | 106239 | for(i=0; i<p->nConstraint; i++){ |
| 106085 | 106240 | sqlite3DebugPrintf(" constraint[%d]: col=%d termid=%d op=%d usabled=%d\n", |
| | @@ -106113,111 +106268,10 @@ |
| 106113 | 106268 | #else |
| 106114 | 106269 | #define TRACE_IDX_INPUTS(A) |
| 106115 | 106270 | #define TRACE_IDX_OUTPUTS(A) |
| 106116 | 106271 | #endif |
| 106117 | 106272 | |
| 106118 | | -/* |
| 106119 | | -** Required because bestIndex() is called by bestOrClauseIndex() |
| 106120 | | -*/ |
| 106121 | | -static void bestIndex(WhereBestIdx*); |
| 106122 | | - |
| 106123 | | -/* |
| 106124 | | -** This routine attempts to find an scanning strategy that can be used |
| 106125 | | -** to optimize an 'OR' expression that is part of a WHERE clause. |
| 106126 | | -** |
| 106127 | | -** The table associated with FROM clause term pSrc may be either a |
| 106128 | | -** regular B-Tree table or a virtual table. |
| 106129 | | -*/ |
| 106130 | | -static void bestOrClauseIndex(WhereBestIdx *p){ |
| 106131 | | -#ifndef SQLITE_OMIT_OR_OPTIMIZATION |
| 106132 | | - WhereClause *pWC = p->pWC; /* The WHERE clause */ |
| 106133 | | - struct SrcList_item *pSrc = p->pSrc; /* The FROM clause term to search */ |
| 106134 | | - const int iCur = pSrc->iCursor; /* The cursor of the table */ |
| 106135 | | - const Bitmask maskSrc = getMask(pWC->pMaskSet, iCur); /* Bitmask for pSrc */ |
| 106136 | | - WhereTerm * const pWCEnd = &pWC->a[pWC->nTerm]; /* End of pWC->a[] */ |
| 106137 | | - WhereTerm *pTerm; /* A single term of the WHERE clause */ |
| 106138 | | - |
| 106139 | | - /* The OR-clause optimization is disallowed if the INDEXED BY or |
| 106140 | | - ** NOT INDEXED clauses are used or if the WHERE_AND_ONLY bit is set. */ |
| 106141 | | - if( pSrc->notIndexed || pSrc->pIndex!=0 ){ |
| 106142 | | - return; |
| 106143 | | - } |
| 106144 | | - if( pWC->wctrlFlags & WHERE_AND_ONLY ){ |
| 106145 | | - return; |
| 106146 | | - } |
| 106147 | | - |
| 106148 | | - /* Search the WHERE clause terms for a usable WO_OR term. */ |
| 106149 | | - for(pTerm=pWC->a; pTerm<pWCEnd; pTerm++){ |
| 106150 | | - if( (pTerm->eOperator & WO_OR)!=0 |
| 106151 | | - && ((pTerm->prereqAll & ~maskSrc) & p->notReady)==0 |
| 106152 | | - && (pTerm->u.pOrInfo->indexable & maskSrc)!=0 |
| 106153 | | - ){ |
| 106154 | | - WhereClause * const pOrWC = &pTerm->u.pOrInfo->wc; |
| 106155 | | - WhereTerm * const pOrWCEnd = &pOrWC->a[pOrWC->nTerm]; |
| 106156 | | - WhereTerm *pOrTerm; |
| 106157 | | - int flags = WHERE_MULTI_OR; |
| 106158 | | - double rTotal = 0; |
| 106159 | | - double nRow = 0; |
| 106160 | | - Bitmask used = 0; |
| 106161 | | - WhereBestIdx sBOI; |
| 106162 | | - |
| 106163 | | - sBOI = *p; |
| 106164 | | - sBOI.pOrderBy = 0; |
| 106165 | | - sBOI.pDistinct = 0; |
| 106166 | | - sBOI.ppIdxInfo = 0; |
| 106167 | | - for(pOrTerm=pOrWC->a; pOrTerm<pOrWCEnd; pOrTerm++){ |
| 106168 | | - WHERETRACE(("... Multi-index OR testing for term %d of %d....\n", |
| 106169 | | - (pOrTerm - pOrWC->a), (pTerm - pWC->a) |
| 106170 | | - )); |
| 106171 | | - if( (pOrTerm->eOperator& WO_AND)!=0 ){ |
| 106172 | | - sBOI.pWC = &pOrTerm->u.pAndInfo->wc; |
| 106173 | | - bestIndex(&sBOI); |
| 106174 | | - }else if( pOrTerm->leftCursor==iCur ){ |
| 106175 | | - WhereClause tempWC; |
| 106176 | | - tempWC.pParse = pWC->pParse; |
| 106177 | | - tempWC.pMaskSet = pWC->pMaskSet; |
| 106178 | | - tempWC.pOuter = pWC; |
| 106179 | | - tempWC.op = TK_AND; |
| 106180 | | - tempWC.a = pOrTerm; |
| 106181 | | - tempWC.wctrlFlags = 0; |
| 106182 | | - tempWC.nTerm = 1; |
| 106183 | | - sBOI.pWC = &tempWC; |
| 106184 | | - bestIndex(&sBOI); |
| 106185 | | - }else{ |
| 106186 | | - continue; |
| 106187 | | - } |
| 106188 | | - rTotal += sBOI.cost.rCost; |
| 106189 | | - nRow += sBOI.cost.plan.nRow; |
| 106190 | | - used |= sBOI.cost.used; |
| 106191 | | - if( rTotal>=p->cost.rCost ) break; |
| 106192 | | - } |
| 106193 | | - |
| 106194 | | - /* If there is an ORDER BY clause, increase the scan cost to account |
| 106195 | | - ** for the cost of the sort. */ |
| 106196 | | - if( p->pOrderBy!=0 ){ |
| 106197 | | - WHERETRACE(("... sorting increases OR cost %.9g to %.9g\n", |
| 106198 | | - rTotal, rTotal+nRow*estLog(nRow))); |
| 106199 | | - rTotal += nRow*estLog(nRow); |
| 106200 | | - } |
| 106201 | | - |
| 106202 | | - /* If the cost of scanning using this OR term for optimization is |
| 106203 | | - ** less than the current cost stored in pCost, replace the contents |
| 106204 | | - ** of pCost. */ |
| 106205 | | - WHERETRACE(("... multi-index OR cost=%.9g nrow=%.9g\n", rTotal, nRow)); |
| 106206 | | - if( rTotal<p->cost.rCost ){ |
| 106207 | | - p->cost.rCost = rTotal; |
| 106208 | | - p->cost.used = used; |
| 106209 | | - p->cost.plan.nRow = nRow; |
| 106210 | | - p->cost.plan.nOBSat = p->i ? p->aLevel[p->i-1].plan.nOBSat : 0; |
| 106211 | | - p->cost.plan.wsFlags = flags; |
| 106212 | | - p->cost.plan.u.pTerm = pTerm; |
| 106213 | | - } |
| 106214 | | - } |
| 106215 | | - } |
| 106216 | | -#endif /* SQLITE_OMIT_OR_OPTIMIZATION */ |
| 106217 | | -} |
| 106218 | | - |
| 106219 | 106273 | #ifndef SQLITE_OMIT_AUTOMATIC_INDEX |
| 106220 | 106274 | /* |
| 106221 | 106275 | ** Return TRUE if the WHERE clause term pTerm is of a form where it |
| 106222 | 106276 | ** could be used with an index to access pSrc, assuming an appropriate |
| 106223 | 106277 | ** index existed. |
| | @@ -106229,92 +106283,17 @@ |
| 106229 | 106283 | ){ |
| 106230 | 106284 | char aff; |
| 106231 | 106285 | if( pTerm->leftCursor!=pSrc->iCursor ) return 0; |
| 106232 | 106286 | if( (pTerm->eOperator & WO_EQ)==0 ) return 0; |
| 106233 | 106287 | if( (pTerm->prereqRight & notReady)!=0 ) return 0; |
| 106288 | + if( pTerm->u.leftColumn<0 ) return 0; |
| 106234 | 106289 | aff = pSrc->pTab->aCol[pTerm->u.leftColumn].affinity; |
| 106235 | 106290 | if( !sqlite3IndexAffinityOk(pTerm->pExpr, aff) ) return 0; |
| 106236 | 106291 | return 1; |
| 106237 | 106292 | } |
| 106238 | 106293 | #endif |
| 106239 | 106294 | |
| 106240 | | -#ifndef SQLITE_OMIT_AUTOMATIC_INDEX |
| 106241 | | -/* |
| 106242 | | -** If the query plan for pSrc specified in pCost is a full table scan |
| 106243 | | -** and indexing is allows (if there is no NOT INDEXED clause) and it |
| 106244 | | -** possible to construct a transient index that would perform better |
| 106245 | | -** than a full table scan even when the cost of constructing the index |
| 106246 | | -** is taken into account, then alter the query plan to use the |
| 106247 | | -** transient index. |
| 106248 | | -*/ |
| 106249 | | -static void bestAutomaticIndex(WhereBestIdx *p){ |
| 106250 | | - Parse *pParse = p->pParse; /* The parsing context */ |
| 106251 | | - WhereClause *pWC = p->pWC; /* The WHERE clause */ |
| 106252 | | - struct SrcList_item *pSrc = p->pSrc; /* The FROM clause term to search */ |
| 106253 | | - double nTableRow; /* Rows in the input table */ |
| 106254 | | - double logN; /* log(nTableRow) */ |
| 106255 | | - double costTempIdx; /* per-query cost of the transient index */ |
| 106256 | | - WhereTerm *pTerm; /* A single term of the WHERE clause */ |
| 106257 | | - WhereTerm *pWCEnd; /* End of pWC->a[] */ |
| 106258 | | - Table *pTable; /* Table tht might be indexed */ |
| 106259 | | - |
| 106260 | | - if( pParse->nQueryLoop<=(double)1 ){ |
| 106261 | | - /* There is no point in building an automatic index for a single scan */ |
| 106262 | | - return; |
| 106263 | | - } |
| 106264 | | - if( (pParse->db->flags & SQLITE_AutoIndex)==0 ){ |
| 106265 | | - /* Automatic indices are disabled at run-time */ |
| 106266 | | - return; |
| 106267 | | - } |
| 106268 | | - if( (p->cost.plan.wsFlags & WHERE_NOT_FULLSCAN)!=0 |
| 106269 | | - && (p->cost.plan.wsFlags & WHERE_COVER_SCAN)==0 |
| 106270 | | - ){ |
| 106271 | | - /* We already have some kind of index in use for this query. */ |
| 106272 | | - return; |
| 106273 | | - } |
| 106274 | | - if( pSrc->viaCoroutine ){ |
| 106275 | | - /* Cannot index a co-routine */ |
| 106276 | | - return; |
| 106277 | | - } |
| 106278 | | - if( pSrc->notIndexed ){ |
| 106279 | | - /* The NOT INDEXED clause appears in the SQL. */ |
| 106280 | | - return; |
| 106281 | | - } |
| 106282 | | - if( pSrc->isCorrelated ){ |
| 106283 | | - /* The source is a correlated sub-query. No point in indexing it. */ |
| 106284 | | - return; |
| 106285 | | - } |
| 106286 | | - |
| 106287 | | - assert( pParse->nQueryLoop >= (double)1 ); |
| 106288 | | - pTable = pSrc->pTab; |
| 106289 | | - nTableRow = pTable->nRowEst; |
| 106290 | | - logN = estLog(nTableRow); |
| 106291 | | - costTempIdx = 2*logN*(nTableRow/pParse->nQueryLoop + 1); |
| 106292 | | - if( costTempIdx>=p->cost.rCost ){ |
| 106293 | | - /* The cost of creating the transient table would be greater than |
| 106294 | | - ** doing the full table scan */ |
| 106295 | | - return; |
| 106296 | | - } |
| 106297 | | - |
| 106298 | | - /* Search for any equality comparison term */ |
| 106299 | | - pWCEnd = &pWC->a[pWC->nTerm]; |
| 106300 | | - for(pTerm=pWC->a; pTerm<pWCEnd; pTerm++){ |
| 106301 | | - if( termCanDriveIndex(pTerm, pSrc, p->notReady) ){ |
| 106302 | | - WHERETRACE(("auto-index reduces cost from %.1f to %.1f\n", |
| 106303 | | - p->cost.rCost, costTempIdx)); |
| 106304 | | - p->cost.rCost = costTempIdx; |
| 106305 | | - p->cost.plan.nRow = logN + 1; |
| 106306 | | - p->cost.plan.wsFlags = WHERE_TEMP_INDEX; |
| 106307 | | - p->cost.used = pTerm->prereqRight; |
| 106308 | | - break; |
| 106309 | | - } |
| 106310 | | - } |
| 106311 | | -} |
| 106312 | | -#else |
| 106313 | | -# define bestAutomaticIndex(A) /* no-op */ |
| 106314 | | -#endif /* SQLITE_OMIT_AUTOMATIC_INDEX */ |
| 106315 | | - |
| 106316 | 106295 | |
| 106317 | 106296 | #ifndef SQLITE_OMIT_AUTOMATIC_INDEX |
| 106318 | 106297 | /* |
| 106319 | 106298 | ** Generate code to construct the Index object for an automatic index |
| 106320 | 106299 | ** and to set up the WhereLevel object pLevel so that the code generator |
| | @@ -106340,10 +106319,11 @@ |
| 106340 | 106319 | int regRecord; /* Register holding an index record */ |
| 106341 | 106320 | int n; /* Column counter */ |
| 106342 | 106321 | int i; /* Loop counter */ |
| 106343 | 106322 | int mxBitCol; /* Maximum column in pSrc->colUsed */ |
| 106344 | 106323 | CollSeq *pColl; /* Collating sequence to on a column */ |
| 106324 | + WhereLoop *pLoop; /* The Loop object */ |
| 106345 | 106325 | Bitmask idxCols; /* Bitmap of columns used for indexing */ |
| 106346 | 106326 | Bitmask extraCols; /* Bitmap of additional columns */ |
| 106347 | 106327 | |
| 106348 | 106328 | /* Generate code to skip over the creation and initialization of the |
| 106349 | 106329 | ** transient index on 2nd and subsequent iterations of the loop. */ |
| | @@ -106354,54 +106334,58 @@ |
| 106354 | 106334 | /* Count the number of columns that will be added to the index |
| 106355 | 106335 | ** and used to match WHERE clause constraints */ |
| 106356 | 106336 | nColumn = 0; |
| 106357 | 106337 | pTable = pSrc->pTab; |
| 106358 | 106338 | pWCEnd = &pWC->a[pWC->nTerm]; |
| 106339 | + pLoop = pLevel->pWLoop; |
| 106359 | 106340 | idxCols = 0; |
| 106360 | 106341 | for(pTerm=pWC->a; pTerm<pWCEnd; pTerm++){ |
| 106361 | 106342 | if( termCanDriveIndex(pTerm, pSrc, notReady) ){ |
| 106362 | 106343 | int iCol = pTerm->u.leftColumn; |
| 106363 | | - Bitmask cMask = iCol>=BMS ? ((Bitmask)1)<<(BMS-1) : ((Bitmask)1)<<iCol; |
| 106344 | + Bitmask cMask = iCol>=BMS ? MASKBIT(BMS-1) : MASKBIT(iCol); |
| 106364 | 106345 | testcase( iCol==BMS ); |
| 106365 | 106346 | testcase( iCol==BMS-1 ); |
| 106366 | 106347 | if( (idxCols & cMask)==0 ){ |
| 106367 | | - nColumn++; |
| 106348 | + if( whereLoopResize(pParse->db, pLoop, nColumn+1) ) return; |
| 106349 | + pLoop->aLTerm[nColumn++] = pTerm; |
| 106368 | 106350 | idxCols |= cMask; |
| 106369 | 106351 | } |
| 106370 | 106352 | } |
| 106371 | 106353 | } |
| 106372 | 106354 | assert( nColumn>0 ); |
| 106373 | | - pLevel->plan.nEq = nColumn; |
| 106355 | + pLoop->u.btree.nEq = pLoop->nLTerm = nColumn; |
| 106356 | + pLoop->wsFlags = WHERE_COLUMN_EQ | WHERE_IDX_ONLY | WHERE_INDEXED |
| 106357 | + | WHERE_TEMP_INDEX; |
| 106374 | 106358 | |
| 106375 | 106359 | /* Count the number of additional columns needed to create a |
| 106376 | 106360 | ** covering index. A "covering index" is an index that contains all |
| 106377 | 106361 | ** columns that are needed by the query. With a covering index, the |
| 106378 | 106362 | ** original table never needs to be accessed. Automatic indices must |
| 106379 | 106363 | ** be a covering index because the index will not be updated if the |
| 106380 | 106364 | ** original table changes and the index and table cannot both be used |
| 106381 | 106365 | ** if they go out of sync. |
| 106382 | 106366 | */ |
| 106383 | | - extraCols = pSrc->colUsed & (~idxCols | (((Bitmask)1)<<(BMS-1))); |
| 106367 | + extraCols = pSrc->colUsed & (~idxCols | MASKBIT(BMS-1)); |
| 106384 | 106368 | mxBitCol = (pTable->nCol >= BMS-1) ? BMS-1 : pTable->nCol; |
| 106385 | 106369 | testcase( pTable->nCol==BMS-1 ); |
| 106386 | 106370 | testcase( pTable->nCol==BMS-2 ); |
| 106387 | 106371 | for(i=0; i<mxBitCol; i++){ |
| 106388 | | - if( extraCols & (((Bitmask)1)<<i) ) nColumn++; |
| 106372 | + if( extraCols & MASKBIT(i) ) nColumn++; |
| 106389 | 106373 | } |
| 106390 | | - if( pSrc->colUsed & (((Bitmask)1)<<(BMS-1)) ){ |
| 106374 | + if( pSrc->colUsed & MASKBIT(BMS-1) ){ |
| 106391 | 106375 | nColumn += pTable->nCol - BMS + 1; |
| 106392 | 106376 | } |
| 106393 | | - pLevel->plan.wsFlags |= WHERE_COLUMN_EQ | WHERE_IDX_ONLY | WO_EQ; |
| 106377 | + pLoop->wsFlags |= WHERE_COLUMN_EQ | WHERE_IDX_ONLY; |
| 106394 | 106378 | |
| 106395 | 106379 | /* Construct the Index object to describe this index */ |
| 106396 | 106380 | nByte = sizeof(Index); |
| 106397 | 106381 | nByte += nColumn*sizeof(int); /* Index.aiColumn */ |
| 106398 | 106382 | nByte += nColumn*sizeof(char*); /* Index.azColl */ |
| 106399 | 106383 | nByte += nColumn; /* Index.aSortOrder */ |
| 106400 | 106384 | pIdx = sqlite3DbMallocZero(pParse->db, nByte); |
| 106401 | 106385 | if( pIdx==0 ) return; |
| 106402 | | - pLevel->plan.u.pIdx = pIdx; |
| 106386 | + pLoop->u.btree.pIndex = pIdx; |
| 106403 | 106387 | pIdx->azColl = (char**)&pIdx[1]; |
| 106404 | 106388 | pIdx->aiColumn = (int*)&pIdx->azColl[nColumn]; |
| 106405 | 106389 | pIdx->aSortOrder = (u8*)&pIdx->aiColumn[nColumn]; |
| 106406 | 106390 | pIdx->zName = "auto-index"; |
| 106407 | 106391 | pIdx->nColumn = nColumn; |
| | @@ -106409,11 +106393,13 @@ |
| 106409 | 106393 | n = 0; |
| 106410 | 106394 | idxCols = 0; |
| 106411 | 106395 | for(pTerm=pWC->a; pTerm<pWCEnd; pTerm++){ |
| 106412 | 106396 | if( termCanDriveIndex(pTerm, pSrc, notReady) ){ |
| 106413 | 106397 | int iCol = pTerm->u.leftColumn; |
| 106414 | | - Bitmask cMask = iCol>=BMS ? ((Bitmask)1)<<(BMS-1) : ((Bitmask)1)<<iCol; |
| 106398 | + Bitmask cMask = iCol>=BMS ? MASKBIT(BMS-1) : MASKBIT(iCol); |
| 106399 | + testcase( iCol==BMS-1 ); |
| 106400 | + testcase( iCol==BMS ); |
| 106415 | 106401 | if( (idxCols & cMask)==0 ){ |
| 106416 | 106402 | Expr *pX = pTerm->pExpr; |
| 106417 | 106403 | idxCols |= cMask; |
| 106418 | 106404 | pIdx->aiColumn[n] = pTerm->u.leftColumn; |
| 106419 | 106405 | pColl = sqlite3BinaryCompareCollSeq(pParse, pX->pLeft, pX->pRight); |
| | @@ -106420,22 +106406,22 @@ |
| 106420 | 106406 | pIdx->azColl[n] = ALWAYS(pColl) ? pColl->zName : "BINARY"; |
| 106421 | 106407 | n++; |
| 106422 | 106408 | } |
| 106423 | 106409 | } |
| 106424 | 106410 | } |
| 106425 | | - assert( (u32)n==pLevel->plan.nEq ); |
| 106411 | + assert( (u32)n==pLoop->u.btree.nEq ); |
| 106426 | 106412 | |
| 106427 | 106413 | /* Add additional columns needed to make the automatic index into |
| 106428 | 106414 | ** a covering index */ |
| 106429 | 106415 | for(i=0; i<mxBitCol; i++){ |
| 106430 | | - if( extraCols & (((Bitmask)1)<<i) ){ |
| 106416 | + if( extraCols & MASKBIT(i) ){ |
| 106431 | 106417 | pIdx->aiColumn[n] = i; |
| 106432 | 106418 | pIdx->azColl[n] = "BINARY"; |
| 106433 | 106419 | n++; |
| 106434 | 106420 | } |
| 106435 | 106421 | } |
| 106436 | | - if( pSrc->colUsed & (((Bitmask)1)<<(BMS-1)) ){ |
| 106422 | + if( pSrc->colUsed & MASKBIT(BMS-1) ){ |
| 106437 | 106423 | for(i=BMS-1; i<pTable->nCol; i++){ |
| 106438 | 106424 | pIdx->aiColumn[n] = i; |
| 106439 | 106425 | pIdx->azColl[n] = "BINARY"; |
| 106440 | 106426 | n++; |
| 106441 | 106427 | } |
| | @@ -106443,10 +106429,11 @@ |
| 106443 | 106429 | assert( n==nColumn ); |
| 106444 | 106430 | |
| 106445 | 106431 | /* Create the automatic index */ |
| 106446 | 106432 | pKeyinfo = sqlite3IndexKeyinfo(pParse, pIdx); |
| 106447 | 106433 | assert( pLevel->iIdxCur>=0 ); |
| 106434 | + pLevel->iIdxCur = pParse->nTab++; |
| 106448 | 106435 | sqlite3VdbeAddOp4(v, OP_OpenAutoindex, pLevel->iIdxCur, nColumn+1, 0, |
| 106449 | 106436 | (char*)pKeyinfo, P4_KEYINFO_HANDOFF); |
| 106450 | 106437 | VdbeComment((v, "for %s", pTable->zName)); |
| 106451 | 106438 | |
| 106452 | 106439 | /* Fill the automatic index with content */ |
| | @@ -106469,26 +106456,25 @@ |
| 106469 | 106456 | /* |
| 106470 | 106457 | ** Allocate and populate an sqlite3_index_info structure. It is the |
| 106471 | 106458 | ** responsibility of the caller to eventually release the structure |
| 106472 | 106459 | ** by passing the pointer returned by this function to sqlite3_free(). |
| 106473 | 106460 | */ |
| 106474 | | -static sqlite3_index_info *allocateIndexInfo(WhereBestIdx *p){ |
| 106475 | | - Parse *pParse = p->pParse; |
| 106476 | | - WhereClause *pWC = p->pWC; |
| 106477 | | - struct SrcList_item *pSrc = p->pSrc; |
| 106478 | | - ExprList *pOrderBy = p->pOrderBy; |
| 106461 | +static sqlite3_index_info *allocateIndexInfo( |
| 106462 | + Parse *pParse, |
| 106463 | + WhereClause *pWC, |
| 106464 | + struct SrcList_item *pSrc, |
| 106465 | + ExprList *pOrderBy |
| 106466 | +){ |
| 106479 | 106467 | int i, j; |
| 106480 | 106468 | int nTerm; |
| 106481 | 106469 | struct sqlite3_index_constraint *pIdxCons; |
| 106482 | 106470 | struct sqlite3_index_orderby *pIdxOrderBy; |
| 106483 | 106471 | struct sqlite3_index_constraint_usage *pUsage; |
| 106484 | 106472 | WhereTerm *pTerm; |
| 106485 | 106473 | int nOrderBy; |
| 106486 | 106474 | sqlite3_index_info *pIdxInfo; |
| 106487 | 106475 | |
| 106488 | | - WHERETRACE(("Recomputing index info for %s...\n", pSrc->pTab->zName)); |
| 106489 | | - |
| 106490 | 106476 | /* Count the number of possible WHERE clause constraints referring |
| 106491 | 106477 | ** to this virtual table */ |
| 106492 | 106478 | for(i=nTerm=0, pTerm=pWC->a; i<pWC->nTerm; i++, pTerm++){ |
| 106493 | 106479 | if( pTerm->leftCursor != pSrc->iCursor ) continue; |
| 106494 | 106480 | assert( IsPowerOfTwo(pTerm->eOperator & ~WO_EQUIV) ); |
| | @@ -106520,11 +106506,10 @@ |
| 106520 | 106506 | pIdxInfo = sqlite3DbMallocZero(pParse->db, sizeof(*pIdxInfo) |
| 106521 | 106507 | + (sizeof(*pIdxCons) + sizeof(*pUsage))*nTerm |
| 106522 | 106508 | + sizeof(*pIdxOrderBy)*nOrderBy ); |
| 106523 | 106509 | if( pIdxInfo==0 ){ |
| 106524 | 106510 | sqlite3ErrorMsg(pParse, "out of memory"); |
| 106525 | | - /* (double)0 In case of SQLITE_OMIT_FLOATING_POINT... */ |
| 106526 | 106511 | return 0; |
| 106527 | 106512 | } |
| 106528 | 106513 | |
| 106529 | 106514 | /* Initialize the structure. The sqlite3_index_info structure contains |
| 106530 | 106515 | ** many fields that are declared "const" to prevent xBestIndex from |
| | @@ -106576,12 +106561,12 @@ |
| 106576 | 106561 | } |
| 106577 | 106562 | |
| 106578 | 106563 | /* |
| 106579 | 106564 | ** The table object reference passed as the second argument to this function |
| 106580 | 106565 | ** must represent a virtual table. This function invokes the xBestIndex() |
| 106581 | | -** method of the virtual table with the sqlite3_index_info pointer passed |
| 106582 | | -** as the argument. |
| 106566 | +** method of the virtual table with the sqlite3_index_info object that |
| 106567 | +** comes in as the 3rd argument to this function. |
| 106583 | 106568 | ** |
| 106584 | 106569 | ** If an error occurs, pParse is populated with an error message and a |
| 106585 | 106570 | ** non-zero value is returned. Otherwise, 0 is returned and the output |
| 106586 | 106571 | ** part of the sqlite3_index_info structure is left populated. |
| 106587 | 106572 | ** |
| | @@ -106592,11 +106577,10 @@ |
| 106592 | 106577 | static int vtabBestIndex(Parse *pParse, Table *pTab, sqlite3_index_info *p){ |
| 106593 | 106578 | sqlite3_vtab *pVtab = sqlite3GetVTable(pParse->db, pTab)->pVtab; |
| 106594 | 106579 | int i; |
| 106595 | 106580 | int rc; |
| 106596 | 106581 | |
| 106597 | | - WHERETRACE(("xBestIndex for %s\n", pTab->zName)); |
| 106598 | 106582 | TRACE_IDX_INPUTS(p); |
| 106599 | 106583 | rc = pVtab->pModule->xBestIndex(pVtab, p); |
| 106600 | 106584 | TRACE_IDX_OUTPUTS(p); |
| 106601 | 106585 | |
| 106602 | 106586 | if( rc!=SQLITE_OK ){ |
| | @@ -106618,211 +106602,12 @@ |
| 106618 | 106602 | } |
| 106619 | 106603 | } |
| 106620 | 106604 | |
| 106621 | 106605 | return pParse->nErr; |
| 106622 | 106606 | } |
| 106623 | | - |
| 106624 | | - |
| 106625 | | -/* |
| 106626 | | -** Compute the best index for a virtual table. |
| 106627 | | -** |
| 106628 | | -** The best index is computed by the xBestIndex method of the virtual |
| 106629 | | -** table module. This routine is really just a wrapper that sets up |
| 106630 | | -** the sqlite3_index_info structure that is used to communicate with |
| 106631 | | -** xBestIndex. |
| 106632 | | -** |
| 106633 | | -** In a join, this routine might be called multiple times for the |
| 106634 | | -** same virtual table. The sqlite3_index_info structure is created |
| 106635 | | -** and initialized on the first invocation and reused on all subsequent |
| 106636 | | -** invocations. The sqlite3_index_info structure is also used when |
| 106637 | | -** code is generated to access the virtual table. The whereInfoDelete() |
| 106638 | | -** routine takes care of freeing the sqlite3_index_info structure after |
| 106639 | | -** everybody has finished with it. |
| 106640 | | -*/ |
| 106641 | | -static void bestVirtualIndex(WhereBestIdx *p){ |
| 106642 | | - Parse *pParse = p->pParse; /* The parsing context */ |
| 106643 | | - WhereClause *pWC = p->pWC; /* The WHERE clause */ |
| 106644 | | - struct SrcList_item *pSrc = p->pSrc; /* The FROM clause term to search */ |
| 106645 | | - Table *pTab = pSrc->pTab; |
| 106646 | | - sqlite3_index_info *pIdxInfo; |
| 106647 | | - struct sqlite3_index_constraint *pIdxCons; |
| 106648 | | - struct sqlite3_index_constraint_usage *pUsage; |
| 106649 | | - WhereTerm *pTerm; |
| 106650 | | - int i, j; |
| 106651 | | - int nOrderBy; |
| 106652 | | - int bAllowIN; /* Allow IN optimizations */ |
| 106653 | | - double rCost; |
| 106654 | | - |
| 106655 | | - /* Make sure wsFlags is initialized to some sane value. Otherwise, if the |
| 106656 | | - ** malloc in allocateIndexInfo() fails and this function returns leaving |
| 106657 | | - ** wsFlags in an uninitialized state, the caller may behave unpredictably. |
| 106658 | | - */ |
| 106659 | | - memset(&p->cost, 0, sizeof(p->cost)); |
| 106660 | | - p->cost.plan.wsFlags = WHERE_VIRTUALTABLE; |
| 106661 | | - |
| 106662 | | - /* If the sqlite3_index_info structure has not been previously |
| 106663 | | - ** allocated and initialized, then allocate and initialize it now. |
| 106664 | | - */ |
| 106665 | | - pIdxInfo = *p->ppIdxInfo; |
| 106666 | | - if( pIdxInfo==0 ){ |
| 106667 | | - *p->ppIdxInfo = pIdxInfo = allocateIndexInfo(p); |
| 106668 | | - } |
| 106669 | | - if( pIdxInfo==0 ){ |
| 106670 | | - return; |
| 106671 | | - } |
| 106672 | | - |
| 106673 | | - /* At this point, the sqlite3_index_info structure that pIdxInfo points |
| 106674 | | - ** to will have been initialized, either during the current invocation or |
| 106675 | | - ** during some prior invocation. Now we just have to customize the |
| 106676 | | - ** details of pIdxInfo for the current invocation and pass it to |
| 106677 | | - ** xBestIndex. |
| 106678 | | - */ |
| 106679 | | - |
| 106680 | | - /* The module name must be defined. Also, by this point there must |
| 106681 | | - ** be a pointer to an sqlite3_vtab structure. Otherwise |
| 106682 | | - ** sqlite3ViewGetColumnNames() would have picked up the error. |
| 106683 | | - */ |
| 106684 | | - assert( pTab->azModuleArg && pTab->azModuleArg[0] ); |
| 106685 | | - assert( sqlite3GetVTable(pParse->db, pTab) ); |
| 106686 | | - |
| 106687 | | - /* Try once or twice. On the first attempt, allow IN optimizations. |
| 106688 | | - ** If an IN optimization is accepted by the virtual table xBestIndex |
| 106689 | | - ** method, but the pInfo->aConstrainUsage.omit flag is not set, then |
| 106690 | | - ** the query will not work because it might allow duplicate rows in |
| 106691 | | - ** output. In that case, run the xBestIndex method a second time |
| 106692 | | - ** without the IN constraints. Usually this loop only runs once. |
| 106693 | | - ** The loop will exit using a "break" statement. |
| 106694 | | - */ |
| 106695 | | - for(bAllowIN=1; 1; bAllowIN--){ |
| 106696 | | - assert( bAllowIN==0 || bAllowIN==1 ); |
| 106697 | | - |
| 106698 | | - /* Set the aConstraint[].usable fields and initialize all |
| 106699 | | - ** output variables to zero. |
| 106700 | | - ** |
| 106701 | | - ** aConstraint[].usable is true for constraints where the right-hand |
| 106702 | | - ** side contains only references to tables to the left of the current |
| 106703 | | - ** table. In other words, if the constraint is of the form: |
| 106704 | | - ** |
| 106705 | | - ** column = expr |
| 106706 | | - ** |
| 106707 | | - ** and we are evaluating a join, then the constraint on column is |
| 106708 | | - ** only valid if all tables referenced in expr occur to the left |
| 106709 | | - ** of the table containing column. |
| 106710 | | - ** |
| 106711 | | - ** The aConstraints[] array contains entries for all constraints |
| 106712 | | - ** on the current table. That way we only have to compute it once |
| 106713 | | - ** even though we might try to pick the best index multiple times. |
| 106714 | | - ** For each attempt at picking an index, the order of tables in the |
| 106715 | | - ** join might be different so we have to recompute the usable flag |
| 106716 | | - ** each time. |
| 106717 | | - */ |
| 106718 | | - pIdxCons = *(struct sqlite3_index_constraint**)&pIdxInfo->aConstraint; |
| 106719 | | - pUsage = pIdxInfo->aConstraintUsage; |
| 106720 | | - for(i=0; i<pIdxInfo->nConstraint; i++, pIdxCons++){ |
| 106721 | | - j = pIdxCons->iTermOffset; |
| 106722 | | - pTerm = &pWC->a[j]; |
| 106723 | | - if( (pTerm->prereqRight&p->notReady)==0 |
| 106724 | | - && (bAllowIN || (pTerm->eOperator & WO_IN)==0) |
| 106725 | | - ){ |
| 106726 | | - pIdxCons->usable = 1; |
| 106727 | | - }else{ |
| 106728 | | - pIdxCons->usable = 0; |
| 106729 | | - } |
| 106730 | | - } |
| 106731 | | - memset(pUsage, 0, sizeof(pUsage[0])*pIdxInfo->nConstraint); |
| 106732 | | - if( pIdxInfo->needToFreeIdxStr ){ |
| 106733 | | - sqlite3_free(pIdxInfo->idxStr); |
| 106734 | | - } |
| 106735 | | - pIdxInfo->idxStr = 0; |
| 106736 | | - pIdxInfo->idxNum = 0; |
| 106737 | | - pIdxInfo->needToFreeIdxStr = 0; |
| 106738 | | - pIdxInfo->orderByConsumed = 0; |
| 106739 | | - /* ((double)2) In case of SQLITE_OMIT_FLOATING_POINT... */ |
| 106740 | | - pIdxInfo->estimatedCost = SQLITE_BIG_DBL / ((double)2); |
| 106741 | | - nOrderBy = pIdxInfo->nOrderBy; |
| 106742 | | - if( !p->pOrderBy ){ |
| 106743 | | - pIdxInfo->nOrderBy = 0; |
| 106744 | | - } |
| 106745 | | - |
| 106746 | | - if( vtabBestIndex(pParse, pTab, pIdxInfo) ){ |
| 106747 | | - return; |
| 106748 | | - } |
| 106749 | | - |
| 106750 | | - pIdxCons = *(struct sqlite3_index_constraint**)&pIdxInfo->aConstraint; |
| 106751 | | - for(i=0; i<pIdxInfo->nConstraint; i++, pIdxCons++){ |
| 106752 | | - if( pUsage[i].argvIndex>0 ){ |
| 106753 | | - j = pIdxCons->iTermOffset; |
| 106754 | | - pTerm = &pWC->a[j]; |
| 106755 | | - p->cost.used |= pTerm->prereqRight; |
| 106756 | | - if( (pTerm->eOperator & WO_IN)!=0 ){ |
| 106757 | | - if( pUsage[i].omit==0 ){ |
| 106758 | | - /* Do not attempt to use an IN constraint if the virtual table |
| 106759 | | - ** says that the equivalent EQ constraint cannot be safely omitted. |
| 106760 | | - ** If we do attempt to use such a constraint, some rows might be |
| 106761 | | - ** repeated in the output. */ |
| 106762 | | - break; |
| 106763 | | - } |
| 106764 | | - /* A virtual table that is constrained by an IN clause may not |
| 106765 | | - ** consume the ORDER BY clause because (1) the order of IN terms |
| 106766 | | - ** is not necessarily related to the order of output terms and |
| 106767 | | - ** (2) Multiple outputs from a single IN value will not merge |
| 106768 | | - ** together. */ |
| 106769 | | - pIdxInfo->orderByConsumed = 0; |
| 106770 | | - } |
| 106771 | | - } |
| 106772 | | - } |
| 106773 | | - if( i>=pIdxInfo->nConstraint ) break; |
| 106774 | | - } |
| 106775 | | - |
| 106776 | | - /* The orderByConsumed signal is only valid if all outer loops collectively |
| 106777 | | - ** generate just a single row of output. |
| 106778 | | - */ |
| 106779 | | - if( pIdxInfo->orderByConsumed ){ |
| 106780 | | - for(i=0; i<p->i; i++){ |
| 106781 | | - if( (p->aLevel[i].plan.wsFlags & WHERE_UNIQUE)==0 ){ |
| 106782 | | - pIdxInfo->orderByConsumed = 0; |
| 106783 | | - } |
| 106784 | | - } |
| 106785 | | - } |
| 106786 | | - |
| 106787 | | - /* If there is an ORDER BY clause, and the selected virtual table index |
| 106788 | | - ** does not satisfy it, increase the cost of the scan accordingly. This |
| 106789 | | - ** matches the processing for non-virtual tables in bestBtreeIndex(). |
| 106790 | | - */ |
| 106791 | | - rCost = pIdxInfo->estimatedCost; |
| 106792 | | - if( p->pOrderBy && pIdxInfo->orderByConsumed==0 ){ |
| 106793 | | - rCost += estLog(rCost)*rCost; |
| 106794 | | - } |
| 106795 | | - |
| 106796 | | - /* The cost is not allowed to be larger than SQLITE_BIG_DBL (the |
| 106797 | | - ** inital value of lowestCost in this loop. If it is, then the |
| 106798 | | - ** (cost<lowestCost) test below will never be true. |
| 106799 | | - ** |
| 106800 | | - ** Use "(double)2" instead of "2.0" in case OMIT_FLOATING_POINT |
| 106801 | | - ** is defined. |
| 106802 | | - */ |
| 106803 | | - if( (SQLITE_BIG_DBL/((double)2))<rCost ){ |
| 106804 | | - p->cost.rCost = (SQLITE_BIG_DBL/((double)2)); |
| 106805 | | - }else{ |
| 106806 | | - p->cost.rCost = rCost; |
| 106807 | | - } |
| 106808 | | - p->cost.plan.u.pVtabIdx = pIdxInfo; |
| 106809 | | - if( pIdxInfo->orderByConsumed ){ |
| 106810 | | - p->cost.plan.wsFlags |= WHERE_ORDERED; |
| 106811 | | - p->cost.plan.nOBSat = nOrderBy; |
| 106812 | | - }else{ |
| 106813 | | - p->cost.plan.nOBSat = p->i ? p->aLevel[p->i-1].plan.nOBSat : 0; |
| 106814 | | - } |
| 106815 | | - p->cost.plan.nEq = 0; |
| 106816 | | - pIdxInfo->nOrderBy = nOrderBy; |
| 106817 | | - |
| 106818 | | - /* Try to find a more efficient access pattern by using multiple indexes |
| 106819 | | - ** to optimize an OR expression within the WHERE clause. |
| 106820 | | - */ |
| 106821 | | - bestOrClauseIndex(p); |
| 106822 | | -} |
| 106823 | | -#endif /* SQLITE_OMIT_VIRTUALTABLE */ |
| 106607 | +#endif /* !defined(SQLITE_OMIT_VIRTUALTABLE) */ |
| 106608 | + |
| 106824 | 106609 | |
| 106825 | 106610 | #ifdef SQLITE_ENABLE_STAT3 |
| 106826 | 106611 | /* |
| 106827 | 106612 | ** Estimate the location of a particular key among all keys in an |
| 106828 | 106613 | ** index. Store the results in aStat as follows: |
| | @@ -107060,11 +106845,11 @@ |
| 107060 | 106845 | Parse *pParse, /* Parsing & code generating context */ |
| 107061 | 106846 | Index *p, /* The index containing the range-compared column; "x" */ |
| 107062 | 106847 | int nEq, /* index into p->aCol[] of the range-compared column */ |
| 107063 | 106848 | WhereTerm *pLower, /* Lower bound on the range. ex: "x>123" Might be NULL */ |
| 107064 | 106849 | WhereTerm *pUpper, /* Upper bound on the range. ex: "x<455" Might be NULL */ |
| 107065 | | - double *pRangeDiv /* OUT: Reduce search space by this divisor */ |
| 106850 | + WhereCost *pRangeDiv /* OUT: Reduce search space by this divisor */ |
| 107066 | 106851 | ){ |
| 107067 | 106852 | int rc = SQLITE_OK; |
| 107068 | 106853 | |
| 107069 | 106854 | #ifdef SQLITE_ENABLE_STAT3 |
| 107070 | 106855 | |
| | @@ -107098,29 +106883,35 @@ |
| 107098 | 106883 | if( (pUpper->eOperator & WO_LE)!=0 ) iUpper += a[1]; |
| 107099 | 106884 | } |
| 107100 | 106885 | sqlite3ValueFree(pRangeVal); |
| 107101 | 106886 | } |
| 107102 | 106887 | if( rc==SQLITE_OK ){ |
| 107103 | | - if( iUpper<=iLower ){ |
| 107104 | | - *pRangeDiv = (double)p->aiRowEst[0]; |
| 107105 | | - }else{ |
| 107106 | | - *pRangeDiv = (double)p->aiRowEst[0]/(double)(iUpper - iLower); |
| 106888 | + WhereCost iBase = whereCost(p->aiRowEst[0]); |
| 106889 | + if( iUpper>iLower ){ |
| 106890 | + iBase -= whereCost(iUpper - iLower); |
| 107107 | 106891 | } |
| 107108 | | - WHERETRACE(("range scan regions: %u..%u div=%g\n", |
| 107109 | | - (u32)iLower, (u32)iUpper, *pRangeDiv)); |
| 106892 | + *pRangeDiv = iBase; |
| 106893 | + WHERETRACE(0x100, ("range scan regions: %u..%u div=%d\n", |
| 106894 | + (u32)iLower, (u32)iUpper, *pRangeDiv)); |
| 107110 | 106895 | return SQLITE_OK; |
| 107111 | 106896 | } |
| 107112 | 106897 | } |
| 107113 | 106898 | #else |
| 107114 | 106899 | UNUSED_PARAMETER(pParse); |
| 107115 | 106900 | UNUSED_PARAMETER(p); |
| 107116 | 106901 | UNUSED_PARAMETER(nEq); |
| 107117 | 106902 | #endif |
| 107118 | 106903 | assert( pLower || pUpper ); |
| 107119 | | - *pRangeDiv = (double)1; |
| 107120 | | - if( pLower && (pLower->wtFlags & TERM_VNULL)==0 ) *pRangeDiv *= (double)4; |
| 107121 | | - if( pUpper ) *pRangeDiv *= (double)4; |
| 106904 | + *pRangeDiv = 0; |
| 106905 | + /* TUNING: Each inequality constraint reduces the search space 4-fold. |
| 106906 | + ** A BETWEEN operator, therefore, reduces the search space 16-fold */ |
| 106907 | + if( pLower && (pLower->wtFlags & TERM_VNULL)==0 ){ |
| 106908 | + *pRangeDiv += 20; assert( 20==whereCost(4) ); |
| 106909 | + } |
| 106910 | + if( pUpper ){ |
| 106911 | + *pRangeDiv += 20; assert( 20==whereCost(4) ); |
| 106912 | + } |
| 107122 | 106913 | return rc; |
| 107123 | 106914 | } |
| 107124 | 106915 | |
| 107125 | 106916 | #ifdef SQLITE_ENABLE_STAT3 |
| 107126 | 106917 | /* |
| | @@ -107142,11 +106933,11 @@ |
| 107142 | 106933 | */ |
| 107143 | 106934 | static int whereEqualScanEst( |
| 107144 | 106935 | Parse *pParse, /* Parsing & code generating context */ |
| 107145 | 106936 | Index *p, /* The index whose left-most column is pTerm */ |
| 107146 | 106937 | Expr *pExpr, /* Expression for VALUE in the x=VALUE constraint */ |
| 107147 | | - double *pnRow /* Write the revised row estimate here */ |
| 106938 | + tRowcnt *pnRow /* Write the revised row estimate here */ |
| 107148 | 106939 | ){ |
| 107149 | 106940 | sqlite3_value *pRhs = 0; /* VALUE on right-hand side of pTerm */ |
| 107150 | 106941 | u8 aff; /* Column affinity */ |
| 107151 | 106942 | int rc; /* Subfunction return code */ |
| 107152 | 106943 | tRowcnt a[2]; /* Statistics */ |
| | @@ -107161,11 +106952,11 @@ |
| 107161 | 106952 | pRhs = sqlite3ValueNew(pParse->db); |
| 107162 | 106953 | } |
| 107163 | 106954 | if( pRhs==0 ) return SQLITE_NOTFOUND; |
| 107164 | 106955 | rc = whereKeyStats(pParse, p, pRhs, 0, a); |
| 107165 | 106956 | if( rc==SQLITE_OK ){ |
| 107166 | | - WHERETRACE(("equality scan regions: %d\n", (int)a[1])); |
| 106957 | + WHERETRACE(0x100,("equality scan regions: %d\n", (int)a[1])); |
| 107167 | 106958 | *pnRow = a[1]; |
| 107168 | 106959 | } |
| 107169 | 106960 | whereEqualScanEst_cancel: |
| 107170 | 106961 | sqlite3ValueFree(pRhs); |
| 107171 | 106962 | return rc; |
| | @@ -107191,16 +106982,16 @@ |
| 107191 | 106982 | */ |
| 107192 | 106983 | static int whereInScanEst( |
| 107193 | 106984 | Parse *pParse, /* Parsing & code generating context */ |
| 107194 | 106985 | Index *p, /* The index whose left-most column is pTerm */ |
| 107195 | 106986 | ExprList *pList, /* The value list on the RHS of "x IN (v1,v2,v3,...)" */ |
| 107196 | | - double *pnRow /* Write the revised row estimate here */ |
| 106987 | + tRowcnt *pnRow /* Write the revised row estimate here */ |
| 107197 | 106988 | ){ |
| 107198 | | - int rc = SQLITE_OK; /* Subfunction return code */ |
| 107199 | | - double nEst; /* Number of rows for a single term */ |
| 107200 | | - double nRowEst = (double)0; /* New estimate of the number of rows */ |
| 107201 | | - int i; /* Loop counter */ |
| 106989 | + int rc = SQLITE_OK; /* Subfunction return code */ |
| 106990 | + tRowcnt nEst; /* Number of rows for a single term */ |
| 106991 | + tRowcnt nRowEst = 0; /* New estimate of the number of rows */ |
| 106992 | + int i; /* Loop counter */ |
| 107202 | 106993 | |
| 107203 | 106994 | assert( p->aSample!=0 ); |
| 107204 | 106995 | for(i=0; rc==SQLITE_OK && i<pList->nExpr; i++){ |
| 107205 | 106996 | nEst = p->aiRowEst[0]; |
| 107206 | 106997 | rc = whereEqualScanEst(pParse, p, pList->a[i].pExpr, &nEst); |
| | @@ -107207,888 +106998,15 @@ |
| 107207 | 106998 | nRowEst += nEst; |
| 107208 | 106999 | } |
| 107209 | 107000 | if( rc==SQLITE_OK ){ |
| 107210 | 107001 | if( nRowEst > p->aiRowEst[0] ) nRowEst = p->aiRowEst[0]; |
| 107211 | 107002 | *pnRow = nRowEst; |
| 107212 | | - WHERETRACE(("IN row estimate: est=%g\n", nRowEst)); |
| 107213 | | - } |
| 107214 | | - return rc; |
| 107215 | | -} |
| 107216 | | -#endif /* defined(SQLITE_ENABLE_STAT3) */ |
| 107217 | | - |
| 107218 | | -/* |
| 107219 | | -** Check to see if column iCol of the table with cursor iTab will appear |
| 107220 | | -** in sorted order according to the current query plan. |
| 107221 | | -** |
| 107222 | | -** Return values: |
| 107223 | | -** |
| 107224 | | -** 0 iCol is not ordered |
| 107225 | | -** 1 iCol has only a single value |
| 107226 | | -** 2 iCol is in ASC order |
| 107227 | | -** 3 iCol is in DESC order |
| 107228 | | -*/ |
| 107229 | | -static int isOrderedColumn( |
| 107230 | | - WhereBestIdx *p, |
| 107231 | | - int iTab, |
| 107232 | | - int iCol |
| 107233 | | -){ |
| 107234 | | - int i, j; |
| 107235 | | - WhereLevel *pLevel = &p->aLevel[p->i-1]; |
| 107236 | | - Index *pIdx; |
| 107237 | | - u8 sortOrder; |
| 107238 | | - for(i=p->i-1; i>=0; i--, pLevel--){ |
| 107239 | | - if( pLevel->iTabCur!=iTab ) continue; |
| 107240 | | - if( (pLevel->plan.wsFlags & WHERE_ALL_UNIQUE)!=0 ){ |
| 107241 | | - return 1; |
| 107242 | | - } |
| 107243 | | - assert( (pLevel->plan.wsFlags & WHERE_ORDERED)!=0 ); |
| 107244 | | - if( (pIdx = pLevel->plan.u.pIdx)!=0 ){ |
| 107245 | | - if( iCol<0 ){ |
| 107246 | | - sortOrder = 0; |
| 107247 | | - testcase( (pLevel->plan.wsFlags & WHERE_REVERSE)!=0 ); |
| 107248 | | - }else{ |
| 107249 | | - int n = pIdx->nColumn; |
| 107250 | | - for(j=0; j<n; j++){ |
| 107251 | | - if( iCol==pIdx->aiColumn[j] ) break; |
| 107252 | | - } |
| 107253 | | - if( j>=n ) return 0; |
| 107254 | | - sortOrder = pIdx->aSortOrder[j]; |
| 107255 | | - testcase( (pLevel->plan.wsFlags & WHERE_REVERSE)!=0 ); |
| 107256 | | - } |
| 107257 | | - }else{ |
| 107258 | | - if( iCol!=(-1) ) return 0; |
| 107259 | | - sortOrder = 0; |
| 107260 | | - testcase( (pLevel->plan.wsFlags & WHERE_REVERSE)!=0 ); |
| 107261 | | - } |
| 107262 | | - if( (pLevel->plan.wsFlags & WHERE_REVERSE)!=0 ){ |
| 107263 | | - assert( sortOrder==0 || sortOrder==1 ); |
| 107264 | | - testcase( sortOrder==1 ); |
| 107265 | | - sortOrder = 1 - sortOrder; |
| 107266 | | - } |
| 107267 | | - return sortOrder+2; |
| 107268 | | - } |
| 107269 | | - return 0; |
| 107270 | | -} |
| 107271 | | - |
| 107272 | | -/* |
| 107273 | | -** This routine decides if pIdx can be used to satisfy the ORDER BY |
| 107274 | | -** clause, either in whole or in part. The return value is the |
| 107275 | | -** cumulative number of terms in the ORDER BY clause that are satisfied |
| 107276 | | -** by the index pIdx and other indices in outer loops. |
| 107277 | | -** |
| 107278 | | -** The table being queried has a cursor number of "base". pIdx is the |
| 107279 | | -** index that is postulated for use to access the table. |
| 107280 | | -** |
| 107281 | | -** The *pbRev value is set to 0 order 1 depending on whether or not |
| 107282 | | -** pIdx should be run in the forward order or in reverse order. |
| 107283 | | -*/ |
| 107284 | | -static int isSortingIndex( |
| 107285 | | - WhereBestIdx *p, /* Best index search context */ |
| 107286 | | - Index *pIdx, /* The index we are testing */ |
| 107287 | | - int base, /* Cursor number for the table to be sorted */ |
| 107288 | | - int *pbRev, /* Set to 1 for reverse-order scan of pIdx */ |
| 107289 | | - int *pbObUnique /* ORDER BY column values will different in every row */ |
| 107290 | | -){ |
| 107291 | | - int i; /* Number of pIdx terms used */ |
| 107292 | | - int j; /* Number of ORDER BY terms satisfied */ |
| 107293 | | - int sortOrder = 2; /* 0: forward. 1: backward. 2: unknown */ |
| 107294 | | - int nTerm; /* Number of ORDER BY terms */ |
| 107295 | | - struct ExprList_item *pOBItem;/* A term of the ORDER BY clause */ |
| 107296 | | - Table *pTab = pIdx->pTable; /* Table that owns index pIdx */ |
| 107297 | | - ExprList *pOrderBy; /* The ORDER BY clause */ |
| 107298 | | - Parse *pParse = p->pParse; /* Parser context */ |
| 107299 | | - sqlite3 *db = pParse->db; /* Database connection */ |
| 107300 | | - int nPriorSat; /* ORDER BY terms satisfied by outer loops */ |
| 107301 | | - int seenRowid = 0; /* True if an ORDER BY rowid term is seen */ |
| 107302 | | - int uniqueNotNull; /* pIdx is UNIQUE with all terms are NOT NULL */ |
| 107303 | | - int outerObUnique; /* Outer loops generate different values in |
| 107304 | | - ** every row for the ORDER BY columns */ |
| 107305 | | - |
| 107306 | | - if( p->i==0 ){ |
| 107307 | | - nPriorSat = 0; |
| 107308 | | - outerObUnique = 1; |
| 107309 | | - }else{ |
| 107310 | | - u32 wsFlags = p->aLevel[p->i-1].plan.wsFlags; |
| 107311 | | - nPriorSat = p->aLevel[p->i-1].plan.nOBSat; |
| 107312 | | - if( (wsFlags & WHERE_ORDERED)==0 ){ |
| 107313 | | - /* This loop cannot be ordered unless the next outer loop is |
| 107314 | | - ** also ordered */ |
| 107315 | | - return nPriorSat; |
| 107316 | | - } |
| 107317 | | - if( OptimizationDisabled(db, SQLITE_OrderByIdxJoin) ){ |
| 107318 | | - /* Only look at the outer-most loop if the OrderByIdxJoin |
| 107319 | | - ** optimization is disabled */ |
| 107320 | | - return nPriorSat; |
| 107321 | | - } |
| 107322 | | - testcase( wsFlags & WHERE_OB_UNIQUE ); |
| 107323 | | - testcase( wsFlags & WHERE_ALL_UNIQUE ); |
| 107324 | | - outerObUnique = (wsFlags & (WHERE_OB_UNIQUE|WHERE_ALL_UNIQUE))!=0; |
| 107325 | | - } |
| 107326 | | - pOrderBy = p->pOrderBy; |
| 107327 | | - assert( pOrderBy!=0 ); |
| 107328 | | - if( pIdx->bUnordered ){ |
| 107329 | | - /* Hash indices (indicated by the "unordered" tag on sqlite_stat1) cannot |
| 107330 | | - ** be used for sorting */ |
| 107331 | | - return nPriorSat; |
| 107332 | | - } |
| 107333 | | - nTerm = pOrderBy->nExpr; |
| 107334 | | - uniqueNotNull = pIdx->onError!=OE_None; |
| 107335 | | - assert( nTerm>0 ); |
| 107336 | | - |
| 107337 | | - /* Argument pIdx must either point to a 'real' named index structure, |
| 107338 | | - ** or an index structure allocated on the stack by bestBtreeIndex() to |
| 107339 | | - ** represent the rowid index that is part of every table. */ |
| 107340 | | - assert( pIdx->zName || (pIdx->nColumn==1 && pIdx->aiColumn[0]==-1) ); |
| 107341 | | - |
| 107342 | | - /* Match terms of the ORDER BY clause against columns of |
| 107343 | | - ** the index. |
| 107344 | | - ** |
| 107345 | | - ** Note that indices have pIdx->nColumn regular columns plus |
| 107346 | | - ** one additional column containing the rowid. The rowid column |
| 107347 | | - ** of the index is also allowed to match against the ORDER BY |
| 107348 | | - ** clause. |
| 107349 | | - */ |
| 107350 | | - j = nPriorSat; |
| 107351 | | - for(i=0,pOBItem=&pOrderBy->a[j]; j<nTerm && i<=pIdx->nColumn; i++){ |
| 107352 | | - Expr *pOBExpr; /* The expression of the ORDER BY pOBItem */ |
| 107353 | | - CollSeq *pColl; /* The collating sequence of pOBExpr */ |
| 107354 | | - int termSortOrder; /* Sort order for this term */ |
| 107355 | | - int iColumn; /* The i-th column of the index. -1 for rowid */ |
| 107356 | | - int iSortOrder; /* 1 for DESC, 0 for ASC on the i-th index term */ |
| 107357 | | - int isEq; /* Subject to an == or IS NULL constraint */ |
| 107358 | | - int isMatch; /* ORDER BY term matches the index term */ |
| 107359 | | - const char *zColl; /* Name of collating sequence for i-th index term */ |
| 107360 | | - WhereTerm *pConstraint; /* A constraint in the WHERE clause */ |
| 107361 | | - |
| 107362 | | - /* If the next term of the ORDER BY clause refers to anything other than |
| 107363 | | - ** a column in the "base" table, then this index will not be of any |
| 107364 | | - ** further use in handling the ORDER BY. */ |
| 107365 | | - pOBExpr = sqlite3ExprSkipCollate(pOBItem->pExpr); |
| 107366 | | - if( pOBExpr->op!=TK_COLUMN || pOBExpr->iTable!=base ){ |
| 107367 | | - break; |
| 107368 | | - } |
| 107369 | | - |
| 107370 | | - /* Find column number and collating sequence for the next entry |
| 107371 | | - ** in the index */ |
| 107372 | | - if( pIdx->zName && i<pIdx->nColumn ){ |
| 107373 | | - iColumn = pIdx->aiColumn[i]; |
| 107374 | | - if( iColumn==pIdx->pTable->iPKey ){ |
| 107375 | | - iColumn = -1; |
| 107376 | | - } |
| 107377 | | - iSortOrder = pIdx->aSortOrder[i]; |
| 107378 | | - zColl = pIdx->azColl[i]; |
| 107379 | | - assert( zColl!=0 ); |
| 107380 | | - }else{ |
| 107381 | | - iColumn = -1; |
| 107382 | | - iSortOrder = 0; |
| 107383 | | - zColl = 0; |
| 107384 | | - } |
| 107385 | | - |
| 107386 | | - /* Check to see if the column number and collating sequence of the |
| 107387 | | - ** index match the column number and collating sequence of the ORDER BY |
| 107388 | | - ** clause entry. Set isMatch to 1 if they both match. */ |
| 107389 | | - if( pOBExpr->iColumn==iColumn ){ |
| 107390 | | - if( zColl ){ |
| 107391 | | - pColl = sqlite3ExprCollSeq(pParse, pOBItem->pExpr); |
| 107392 | | - if( !pColl ) pColl = db->pDfltColl; |
| 107393 | | - isMatch = sqlite3StrICmp(pColl->zName, zColl)==0; |
| 107394 | | - }else{ |
| 107395 | | - isMatch = 1; |
| 107396 | | - } |
| 107397 | | - }else{ |
| 107398 | | - isMatch = 0; |
| 107399 | | - } |
| 107400 | | - |
| 107401 | | - /* termSortOrder is 0 or 1 for whether or not the access loop should |
| 107402 | | - ** run forward or backwards (respectively) in order to satisfy this |
| 107403 | | - ** term of the ORDER BY clause. */ |
| 107404 | | - assert( pOBItem->sortOrder==0 || pOBItem->sortOrder==1 ); |
| 107405 | | - assert( iSortOrder==0 || iSortOrder==1 ); |
| 107406 | | - termSortOrder = iSortOrder ^ pOBItem->sortOrder; |
| 107407 | | - |
| 107408 | | - /* If X is the column in the index and ORDER BY clause, check to see |
| 107409 | | - ** if there are any X= or X IS NULL constraints in the WHERE clause. */ |
| 107410 | | - pConstraint = findTerm(p->pWC, base, iColumn, p->notReady, |
| 107411 | | - WO_EQ|WO_ISNULL|WO_IN, pIdx); |
| 107412 | | - if( pConstraint==0 ){ |
| 107413 | | - isEq = 0; |
| 107414 | | - }else if( (pConstraint->eOperator & WO_IN)!=0 ){ |
| 107415 | | - isEq = 0; |
| 107416 | | - }else if( (pConstraint->eOperator & WO_ISNULL)!=0 ){ |
| 107417 | | - uniqueNotNull = 0; |
| 107418 | | - isEq = 1; /* "X IS NULL" means X has only a single value */ |
| 107419 | | - }else if( pConstraint->prereqRight==0 ){ |
| 107420 | | - isEq = 1; /* Constraint "X=constant" means X has only a single value */ |
| 107421 | | - }else{ |
| 107422 | | - Expr *pRight = pConstraint->pExpr->pRight; |
| 107423 | | - if( pRight->op==TK_COLUMN ){ |
| 107424 | | - WHERETRACE((" .. isOrderedColumn(tab=%d,col=%d)", |
| 107425 | | - pRight->iTable, pRight->iColumn)); |
| 107426 | | - isEq = isOrderedColumn(p, pRight->iTable, pRight->iColumn); |
| 107427 | | - WHERETRACE((" -> isEq=%d\n", isEq)); |
| 107428 | | - |
| 107429 | | - /* If the constraint is of the form X=Y where Y is an ordered value |
| 107430 | | - ** in an outer loop, then make sure the sort order of Y matches the |
| 107431 | | - ** sort order required for X. */ |
| 107432 | | - if( isMatch && isEq>=2 && isEq!=pOBItem->sortOrder+2 ){ |
| 107433 | | - testcase( isEq==2 ); |
| 107434 | | - testcase( isEq==3 ); |
| 107435 | | - break; |
| 107436 | | - } |
| 107437 | | - }else{ |
| 107438 | | - isEq = 0; /* "X=expr" places no ordering constraints on X */ |
| 107439 | | - } |
| 107440 | | - } |
| 107441 | | - if( !isMatch ){ |
| 107442 | | - if( isEq==0 ){ |
| 107443 | | - break; |
| 107444 | | - }else{ |
| 107445 | | - continue; |
| 107446 | | - } |
| 107447 | | - }else if( isEq!=1 ){ |
| 107448 | | - if( sortOrder==2 ){ |
| 107449 | | - sortOrder = termSortOrder; |
| 107450 | | - }else if( termSortOrder!=sortOrder ){ |
| 107451 | | - break; |
| 107452 | | - } |
| 107453 | | - } |
| 107454 | | - j++; |
| 107455 | | - pOBItem++; |
| 107456 | | - if( iColumn<0 ){ |
| 107457 | | - seenRowid = 1; |
| 107458 | | - break; |
| 107459 | | - }else if( pTab->aCol[iColumn].notNull==0 && isEq!=1 ){ |
| 107460 | | - testcase( isEq==0 ); |
| 107461 | | - testcase( isEq==2 ); |
| 107462 | | - testcase( isEq==3 ); |
| 107463 | | - uniqueNotNull = 0; |
| 107464 | | - } |
| 107465 | | - } |
| 107466 | | - if( seenRowid ){ |
| 107467 | | - uniqueNotNull = 1; |
| 107468 | | - }else if( uniqueNotNull==0 || i<pIdx->nColumn ){ |
| 107469 | | - uniqueNotNull = 0; |
| 107470 | | - } |
| 107471 | | - |
| 107472 | | - /* If we have not found at least one ORDER BY term that matches the |
| 107473 | | - ** index, then show no progress. */ |
| 107474 | | - if( pOBItem==&pOrderBy->a[nPriorSat] ) return nPriorSat; |
| 107475 | | - |
| 107476 | | - /* Either the outer queries must generate rows where there are no two |
| 107477 | | - ** rows with the same values in all ORDER BY columns, or else this |
| 107478 | | - ** loop must generate just a single row of output. Example: Suppose |
| 107479 | | - ** the outer loops generate A=1 and A=1, and this loop generates B=3 |
| 107480 | | - ** and B=4. Then without the following test, ORDER BY A,B would |
| 107481 | | - ** generate the wrong order output: 1,3 1,4 1,3 1,4 |
| 107482 | | - */ |
| 107483 | | - if( outerObUnique==0 && uniqueNotNull==0 ) return nPriorSat; |
| 107484 | | - *pbObUnique = uniqueNotNull; |
| 107485 | | - |
| 107486 | | - /* Return the necessary scan order back to the caller */ |
| 107487 | | - *pbRev = sortOrder & 1; |
| 107488 | | - |
| 107489 | | - /* If there was an "ORDER BY rowid" term that matched, or it is only |
| 107490 | | - ** possible for a single row from this table to match, then skip over |
| 107491 | | - ** any additional ORDER BY terms dealing with this table. |
| 107492 | | - */ |
| 107493 | | - if( uniqueNotNull ){ |
| 107494 | | - /* Advance j over additional ORDER BY terms associated with base */ |
| 107495 | | - WhereMaskSet *pMS = p->pWC->pMaskSet; |
| 107496 | | - Bitmask m = ~getMask(pMS, base); |
| 107497 | | - while( j<nTerm && (exprTableUsage(pMS, pOrderBy->a[j].pExpr)&m)==0 ){ |
| 107498 | | - j++; |
| 107499 | | - } |
| 107500 | | - } |
| 107501 | | - return j; |
| 107502 | | -} |
| 107503 | | - |
| 107504 | | -/* |
| 107505 | | -** Find the best query plan for accessing a particular table. Write the |
| 107506 | | -** best query plan and its cost into the p->cost. |
| 107507 | | -** |
| 107508 | | -** The lowest cost plan wins. The cost is an estimate of the amount of |
| 107509 | | -** CPU and disk I/O needed to process the requested result. |
| 107510 | | -** Factors that influence cost include: |
| 107511 | | -** |
| 107512 | | -** * The estimated number of rows that will be retrieved. (The |
| 107513 | | -** fewer the better.) |
| 107514 | | -** |
| 107515 | | -** * Whether or not sorting must occur. |
| 107516 | | -** |
| 107517 | | -** * Whether or not there must be separate lookups in the |
| 107518 | | -** index and in the main table. |
| 107519 | | -** |
| 107520 | | -** If there was an INDEXED BY clause (pSrc->pIndex) attached to the table in |
| 107521 | | -** the SQL statement, then this function only considers plans using the |
| 107522 | | -** named index. If no such plan is found, then the returned cost is |
| 107523 | | -** SQLITE_BIG_DBL. If a plan is found that uses the named index, |
| 107524 | | -** then the cost is calculated in the usual way. |
| 107525 | | -** |
| 107526 | | -** If a NOT INDEXED clause was attached to the table |
| 107527 | | -** in the SELECT statement, then no indexes are considered. However, the |
| 107528 | | -** selected plan may still take advantage of the built-in rowid primary key |
| 107529 | | -** index. |
| 107530 | | -*/ |
| 107531 | | -static void bestBtreeIndex(WhereBestIdx *p){ |
| 107532 | | - Parse *pParse = p->pParse; /* The parsing context */ |
| 107533 | | - WhereClause *pWC = p->pWC; /* The WHERE clause */ |
| 107534 | | - struct SrcList_item *pSrc = p->pSrc; /* The FROM clause term to search */ |
| 107535 | | - int iCur = pSrc->iCursor; /* The cursor of the table to be accessed */ |
| 107536 | | - Index *pProbe; /* An index we are evaluating */ |
| 107537 | | - Index *pIdx; /* Copy of pProbe, or zero for IPK index */ |
| 107538 | | - int eqTermMask; /* Current mask of valid equality operators */ |
| 107539 | | - int idxEqTermMask; /* Index mask of valid equality operators */ |
| 107540 | | - Index sPk; /* A fake index object for the primary key */ |
| 107541 | | - tRowcnt aiRowEstPk[2]; /* The aiRowEst[] value for the sPk index */ |
| 107542 | | - int aiColumnPk = -1; /* The aColumn[] value for the sPk index */ |
| 107543 | | - int wsFlagMask; /* Allowed flags in p->cost.plan.wsFlag */ |
| 107544 | | - int nPriorSat; /* ORDER BY terms satisfied by outer loops */ |
| 107545 | | - int nOrderBy; /* Number of ORDER BY terms */ |
| 107546 | | - char bSortInit; /* Initializer for bSort in inner loop */ |
| 107547 | | - char bDistInit; /* Initializer for bDist in inner loop */ |
| 107548 | | - |
| 107549 | | - |
| 107550 | | - /* Initialize the cost to a worst-case value */ |
| 107551 | | - memset(&p->cost, 0, sizeof(p->cost)); |
| 107552 | | - p->cost.rCost = SQLITE_BIG_DBL; |
| 107553 | | - |
| 107554 | | - /* If the pSrc table is the right table of a LEFT JOIN then we may not |
| 107555 | | - ** use an index to satisfy IS NULL constraints on that table. This is |
| 107556 | | - ** because columns might end up being NULL if the table does not match - |
| 107557 | | - ** a circumstance which the index cannot help us discover. Ticket #2177. |
| 107558 | | - */ |
| 107559 | | - if( pSrc->jointype & JT_LEFT ){ |
| 107560 | | - idxEqTermMask = WO_EQ|WO_IN; |
| 107561 | | - }else{ |
| 107562 | | - idxEqTermMask = WO_EQ|WO_IN|WO_ISNULL; |
| 107563 | | - } |
| 107564 | | - |
| 107565 | | - if( pSrc->pIndex ){ |
| 107566 | | - /* An INDEXED BY clause specifies a particular index to use */ |
| 107567 | | - pIdx = pProbe = pSrc->pIndex; |
| 107568 | | - wsFlagMask = ~(WHERE_ROWID_EQ|WHERE_ROWID_RANGE); |
| 107569 | | - eqTermMask = idxEqTermMask; |
| 107570 | | - }else{ |
| 107571 | | - /* There is no INDEXED BY clause. Create a fake Index object in local |
| 107572 | | - ** variable sPk to represent the rowid primary key index. Make this |
| 107573 | | - ** fake index the first in a chain of Index objects with all of the real |
| 107574 | | - ** indices to follow */ |
| 107575 | | - Index *pFirst; /* First of real indices on the table */ |
| 107576 | | - memset(&sPk, 0, sizeof(Index)); |
| 107577 | | - sPk.nColumn = 1; |
| 107578 | | - sPk.aiColumn = &aiColumnPk; |
| 107579 | | - sPk.aiRowEst = aiRowEstPk; |
| 107580 | | - sPk.onError = OE_Replace; |
| 107581 | | - sPk.pTable = pSrc->pTab; |
| 107582 | | - aiRowEstPk[0] = pSrc->pTab->nRowEst; |
| 107583 | | - aiRowEstPk[1] = 1; |
| 107584 | | - pFirst = pSrc->pTab->pIndex; |
| 107585 | | - if( pSrc->notIndexed==0 ){ |
| 107586 | | - /* The real indices of the table are only considered if the |
| 107587 | | - ** NOT INDEXED qualifier is omitted from the FROM clause */ |
| 107588 | | - sPk.pNext = pFirst; |
| 107589 | | - } |
| 107590 | | - pProbe = &sPk; |
| 107591 | | - wsFlagMask = ~( |
| 107592 | | - WHERE_COLUMN_IN|WHERE_COLUMN_EQ|WHERE_COLUMN_NULL|WHERE_COLUMN_RANGE |
| 107593 | | - ); |
| 107594 | | - eqTermMask = WO_EQ|WO_IN; |
| 107595 | | - pIdx = 0; |
| 107596 | | - } |
| 107597 | | - |
| 107598 | | - nOrderBy = p->pOrderBy ? p->pOrderBy->nExpr : 0; |
| 107599 | | - if( p->i ){ |
| 107600 | | - nPriorSat = p->aLevel[p->i-1].plan.nOBSat; |
| 107601 | | - bSortInit = nPriorSat<nOrderBy; |
| 107602 | | - bDistInit = 0; |
| 107603 | | - }else{ |
| 107604 | | - nPriorSat = 0; |
| 107605 | | - bSortInit = nOrderBy>0; |
| 107606 | | - bDistInit = p->pDistinct!=0; |
| 107607 | | - } |
| 107608 | | - |
| 107609 | | - /* Loop over all indices looking for the best one to use |
| 107610 | | - */ |
| 107611 | | - for(; pProbe; pIdx=pProbe=pProbe->pNext){ |
| 107612 | | - const tRowcnt * const aiRowEst = pProbe->aiRowEst; |
| 107613 | | - WhereCost pc; /* Cost of using pProbe */ |
| 107614 | | - double log10N = (double)1; /* base-10 logarithm of nRow (inexact) */ |
| 107615 | | - |
| 107616 | | - /* The following variables are populated based on the properties of |
| 107617 | | - ** index being evaluated. They are then used to determine the expected |
| 107618 | | - ** cost and number of rows returned. |
| 107619 | | - ** |
| 107620 | | - ** pc.plan.nEq: |
| 107621 | | - ** Number of equality terms that can be implemented using the index. |
| 107622 | | - ** In other words, the number of initial fields in the index that |
| 107623 | | - ** are used in == or IN or NOT NULL constraints of the WHERE clause. |
| 107624 | | - ** |
| 107625 | | - ** nInMul: |
| 107626 | | - ** The "in-multiplier". This is an estimate of how many seek operations |
| 107627 | | - ** SQLite must perform on the index in question. For example, if the |
| 107628 | | - ** WHERE clause is: |
| 107629 | | - ** |
| 107630 | | - ** WHERE a IN (1, 2, 3) AND b IN (4, 5, 6) |
| 107631 | | - ** |
| 107632 | | - ** SQLite must perform 9 lookups on an index on (a, b), so nInMul is |
| 107633 | | - ** set to 9. Given the same schema and either of the following WHERE |
| 107634 | | - ** clauses: |
| 107635 | | - ** |
| 107636 | | - ** WHERE a = 1 |
| 107637 | | - ** WHERE a >= 2 |
| 107638 | | - ** |
| 107639 | | - ** nInMul is set to 1. |
| 107640 | | - ** |
| 107641 | | - ** If there exists a WHERE term of the form "x IN (SELECT ...)", then |
| 107642 | | - ** the sub-select is assumed to return 25 rows for the purposes of |
| 107643 | | - ** determining nInMul. |
| 107644 | | - ** |
| 107645 | | - ** bInEst: |
| 107646 | | - ** Set to true if there was at least one "x IN (SELECT ...)" term used |
| 107647 | | - ** in determining the value of nInMul. Note that the RHS of the |
| 107648 | | - ** IN operator must be a SELECT, not a value list, for this variable |
| 107649 | | - ** to be true. |
| 107650 | | - ** |
| 107651 | | - ** rangeDiv: |
| 107652 | | - ** An estimate of a divisor by which to reduce the search space due |
| 107653 | | - ** to inequality constraints. In the absence of sqlite_stat3 ANALYZE |
| 107654 | | - ** data, a single inequality reduces the search space to 1/4rd its |
| 107655 | | - ** original size (rangeDiv==4). Two inequalities reduce the search |
| 107656 | | - ** space to 1/16th of its original size (rangeDiv==16). |
| 107657 | | - ** |
| 107658 | | - ** bSort: |
| 107659 | | - ** Boolean. True if there is an ORDER BY clause that will require an |
| 107660 | | - ** external sort (i.e. scanning the index being evaluated will not |
| 107661 | | - ** correctly order records). |
| 107662 | | - ** |
| 107663 | | - ** bDist: |
| 107664 | | - ** Boolean. True if there is a DISTINCT clause that will require an |
| 107665 | | - ** external btree. |
| 107666 | | - ** |
| 107667 | | - ** bLookup: |
| 107668 | | - ** Boolean. True if a table lookup is required for each index entry |
| 107669 | | - ** visited. In other words, true if this is not a covering index. |
| 107670 | | - ** This is always false for the rowid primary key index of a table. |
| 107671 | | - ** For other indexes, it is true unless all the columns of the table |
| 107672 | | - ** used by the SELECT statement are present in the index (such an |
| 107673 | | - ** index is sometimes described as a covering index). |
| 107674 | | - ** For example, given the index on (a, b), the second of the following |
| 107675 | | - ** two queries requires table b-tree lookups in order to find the value |
| 107676 | | - ** of column c, but the first does not because columns a and b are |
| 107677 | | - ** both available in the index. |
| 107678 | | - ** |
| 107679 | | - ** SELECT a, b FROM tbl WHERE a = 1; |
| 107680 | | - ** SELECT a, b, c FROM tbl WHERE a = 1; |
| 107681 | | - */ |
| 107682 | | - int bInEst = 0; /* True if "x IN (SELECT...)" seen */ |
| 107683 | | - int nInMul = 1; /* Number of distinct equalities to lookup */ |
| 107684 | | - double rangeDiv = (double)1; /* Estimated reduction in search space */ |
| 107685 | | - int nBound = 0; /* Number of range constraints seen */ |
| 107686 | | - char bSort = bSortInit; /* True if external sort required */ |
| 107687 | | - char bDist = bDistInit; /* True if index cannot help with DISTINCT */ |
| 107688 | | - char bLookup = 0; /* True if not a covering index */ |
| 107689 | | - WhereTerm *pTerm; /* A single term of the WHERE clause */ |
| 107690 | | -#ifdef SQLITE_ENABLE_STAT3 |
| 107691 | | - WhereTerm *pFirstTerm = 0; /* First term matching the index */ |
| 107692 | | -#endif |
| 107693 | | - |
| 107694 | | - WHERETRACE(( |
| 107695 | | - " %s(%s):\n", |
| 107696 | | - pSrc->pTab->zName, (pIdx ? pIdx->zName : "ipk") |
| 107697 | | - )); |
| 107698 | | - memset(&pc, 0, sizeof(pc)); |
| 107699 | | - pc.plan.nOBSat = nPriorSat; |
| 107700 | | - |
| 107701 | | - /* Determine the values of pc.plan.nEq and nInMul */ |
| 107702 | | - for(pc.plan.nEq=0; pc.plan.nEq<pProbe->nColumn; pc.plan.nEq++){ |
| 107703 | | - int j = pProbe->aiColumn[pc.plan.nEq]; |
| 107704 | | - pTerm = findTerm(pWC, iCur, j, p->notReady, eqTermMask, pIdx); |
| 107705 | | - if( pTerm==0 ) break; |
| 107706 | | - pc.plan.wsFlags |= (WHERE_COLUMN_EQ|WHERE_ROWID_EQ); |
| 107707 | | - testcase( pTerm->pWC!=pWC ); |
| 107708 | | - if( pTerm->eOperator & WO_IN ){ |
| 107709 | | - Expr *pExpr = pTerm->pExpr; |
| 107710 | | - pc.plan.wsFlags |= WHERE_COLUMN_IN; |
| 107711 | | - if( ExprHasProperty(pExpr, EP_xIsSelect) ){ |
| 107712 | | - /* "x IN (SELECT ...)": Assume the SELECT returns 25 rows */ |
| 107713 | | - nInMul *= 25; |
| 107714 | | - bInEst = 1; |
| 107715 | | - }else if( ALWAYS(pExpr->x.pList && pExpr->x.pList->nExpr) ){ |
| 107716 | | - /* "x IN (value, value, ...)" */ |
| 107717 | | - nInMul *= pExpr->x.pList->nExpr; |
| 107718 | | - } |
| 107719 | | - }else if( pTerm->eOperator & WO_ISNULL ){ |
| 107720 | | - pc.plan.wsFlags |= WHERE_COLUMN_NULL; |
| 107721 | | - } |
| 107722 | | -#ifdef SQLITE_ENABLE_STAT3 |
| 107723 | | - if( pc.plan.nEq==0 && pProbe->aSample ) pFirstTerm = pTerm; |
| 107724 | | -#endif |
| 107725 | | - pc.used |= pTerm->prereqRight; |
| 107726 | | - } |
| 107727 | | - |
| 107728 | | - /* If the index being considered is UNIQUE, and there is an equality |
| 107729 | | - ** constraint for all columns in the index, then this search will find |
| 107730 | | - ** at most a single row. In this case set the WHERE_UNIQUE flag to |
| 107731 | | - ** indicate this to the caller. |
| 107732 | | - ** |
| 107733 | | - ** Otherwise, if the search may find more than one row, test to see if |
| 107734 | | - ** there is a range constraint on indexed column (pc.plan.nEq+1) that |
| 107735 | | - ** can be optimized using the index. |
| 107736 | | - */ |
| 107737 | | - if( pc.plan.nEq==pProbe->nColumn && pProbe->onError!=OE_None ){ |
| 107738 | | - testcase( pc.plan.wsFlags & WHERE_COLUMN_IN ); |
| 107739 | | - testcase( pc.plan.wsFlags & WHERE_COLUMN_NULL ); |
| 107740 | | - if( (pc.plan.wsFlags & (WHERE_COLUMN_IN|WHERE_COLUMN_NULL))==0 ){ |
| 107741 | | - pc.plan.wsFlags |= WHERE_UNIQUE; |
| 107742 | | - if( p->i==0 || (p->aLevel[p->i-1].plan.wsFlags & WHERE_ALL_UNIQUE)!=0 ){ |
| 107743 | | - pc.plan.wsFlags |= WHERE_ALL_UNIQUE; |
| 107744 | | - } |
| 107745 | | - } |
| 107746 | | - }else if( pProbe->bUnordered==0 ){ |
| 107747 | | - int j; |
| 107748 | | - j = (pc.plan.nEq==pProbe->nColumn ? -1 : pProbe->aiColumn[pc.plan.nEq]); |
| 107749 | | - if( findTerm(pWC, iCur, j, p->notReady, WO_LT|WO_LE|WO_GT|WO_GE, pIdx) ){ |
| 107750 | | - WhereTerm *pTop, *pBtm; |
| 107751 | | - pTop = findTerm(pWC, iCur, j, p->notReady, WO_LT|WO_LE, pIdx); |
| 107752 | | - pBtm = findTerm(pWC, iCur, j, p->notReady, WO_GT|WO_GE, pIdx); |
| 107753 | | - whereRangeScanEst(pParse, pProbe, pc.plan.nEq, pBtm, pTop, &rangeDiv); |
| 107754 | | - if( pTop ){ |
| 107755 | | - nBound = 1; |
| 107756 | | - pc.plan.wsFlags |= WHERE_TOP_LIMIT; |
| 107757 | | - pc.used |= pTop->prereqRight; |
| 107758 | | - testcase( pTop->pWC!=pWC ); |
| 107759 | | - } |
| 107760 | | - if( pBtm ){ |
| 107761 | | - nBound++; |
| 107762 | | - pc.plan.wsFlags |= WHERE_BTM_LIMIT; |
| 107763 | | - pc.used |= pBtm->prereqRight; |
| 107764 | | - testcase( pBtm->pWC!=pWC ); |
| 107765 | | - } |
| 107766 | | - pc.plan.wsFlags |= (WHERE_COLUMN_RANGE|WHERE_ROWID_RANGE); |
| 107767 | | - } |
| 107768 | | - } |
| 107769 | | - |
| 107770 | | - /* If there is an ORDER BY clause and the index being considered will |
| 107771 | | - ** naturally scan rows in the required order, set the appropriate flags |
| 107772 | | - ** in pc.plan.wsFlags. Otherwise, if there is an ORDER BY clause but |
| 107773 | | - ** the index will scan rows in a different order, set the bSort |
| 107774 | | - ** variable. */ |
| 107775 | | - if( bSort && (pSrc->jointype & JT_LEFT)==0 ){ |
| 107776 | | - int bRev = 2; |
| 107777 | | - int bObUnique = 0; |
| 107778 | | - WHERETRACE((" --> before isSortIndex: nPriorSat=%d\n",nPriorSat)); |
| 107779 | | - pc.plan.nOBSat = isSortingIndex(p, pProbe, iCur, &bRev, &bObUnique); |
| 107780 | | - WHERETRACE((" --> after isSortIndex: bRev=%d bObU=%d nOBSat=%d\n", |
| 107781 | | - bRev, bObUnique, pc.plan.nOBSat)); |
| 107782 | | - if( nPriorSat<pc.plan.nOBSat || (pc.plan.wsFlags & WHERE_ALL_UNIQUE)!=0 ){ |
| 107783 | | - pc.plan.wsFlags |= WHERE_ORDERED; |
| 107784 | | - if( bObUnique ) pc.plan.wsFlags |= WHERE_OB_UNIQUE; |
| 107785 | | - } |
| 107786 | | - if( nOrderBy==pc.plan.nOBSat ){ |
| 107787 | | - bSort = 0; |
| 107788 | | - pc.plan.wsFlags |= WHERE_ROWID_RANGE|WHERE_COLUMN_RANGE; |
| 107789 | | - } |
| 107790 | | - if( bRev & 1 ) pc.plan.wsFlags |= WHERE_REVERSE; |
| 107791 | | - } |
| 107792 | | - |
| 107793 | | - /* If there is a DISTINCT qualifier and this index will scan rows in |
| 107794 | | - ** order of the DISTINCT expressions, clear bDist and set the appropriate |
| 107795 | | - ** flags in pc.plan.wsFlags. */ |
| 107796 | | - if( bDist |
| 107797 | | - && isDistinctIndex(pParse, pWC, pProbe, iCur, p->pDistinct, pc.plan.nEq) |
| 107798 | | - && (pc.plan.wsFlags & WHERE_COLUMN_IN)==0 |
| 107799 | | - ){ |
| 107800 | | - bDist = 0; |
| 107801 | | - pc.plan.wsFlags |= WHERE_ROWID_RANGE|WHERE_COLUMN_RANGE|WHERE_DISTINCT; |
| 107802 | | - } |
| 107803 | | - |
| 107804 | | - /* If currently calculating the cost of using an index (not the IPK |
| 107805 | | - ** index), determine if all required column data may be obtained without |
| 107806 | | - ** using the main table (i.e. if the index is a covering |
| 107807 | | - ** index for this query). If it is, set the WHERE_IDX_ONLY flag in |
| 107808 | | - ** pc.plan.wsFlags. Otherwise, set the bLookup variable to true. */ |
| 107809 | | - if( pIdx ){ |
| 107810 | | - Bitmask m = pSrc->colUsed; |
| 107811 | | - int j; |
| 107812 | | - for(j=0; j<pIdx->nColumn; j++){ |
| 107813 | | - int x = pIdx->aiColumn[j]; |
| 107814 | | - if( x<BMS-1 ){ |
| 107815 | | - m &= ~(((Bitmask)1)<<x); |
| 107816 | | - } |
| 107817 | | - } |
| 107818 | | - if( m==0 ){ |
| 107819 | | - pc.plan.wsFlags |= WHERE_IDX_ONLY; |
| 107820 | | - }else{ |
| 107821 | | - bLookup = 1; |
| 107822 | | - } |
| 107823 | | - } |
| 107824 | | - |
| 107825 | | - /* |
| 107826 | | - ** Estimate the number of rows of output. For an "x IN (SELECT...)" |
| 107827 | | - ** constraint, do not let the estimate exceed half the rows in the table. |
| 107828 | | - */ |
| 107829 | | - pc.plan.nRow = (double)(aiRowEst[pc.plan.nEq] * nInMul); |
| 107830 | | - if( bInEst && pc.plan.nRow*2>aiRowEst[0] ){ |
| 107831 | | - pc.plan.nRow = aiRowEst[0]/2; |
| 107832 | | - nInMul = (int)(pc.plan.nRow / aiRowEst[pc.plan.nEq]); |
| 107833 | | - } |
| 107834 | | - |
| 107835 | | -#ifdef SQLITE_ENABLE_STAT3 |
| 107836 | | - /* If the constraint is of the form x=VALUE or x IN (E1,E2,...) |
| 107837 | | - ** and we do not think that values of x are unique and if histogram |
| 107838 | | - ** data is available for column x, then it might be possible |
| 107839 | | - ** to get a better estimate on the number of rows based on |
| 107840 | | - ** VALUE and how common that value is according to the histogram. |
| 107841 | | - */ |
| 107842 | | - if( pc.plan.nRow>(double)1 && pc.plan.nEq==1 |
| 107843 | | - && pFirstTerm!=0 && aiRowEst[1]>1 ){ |
| 107844 | | - assert( (pFirstTerm->eOperator & (WO_EQ|WO_ISNULL|WO_IN))!=0 ); |
| 107845 | | - if( pFirstTerm->eOperator & (WO_EQ|WO_ISNULL) ){ |
| 107846 | | - testcase( pFirstTerm->eOperator & WO_EQ ); |
| 107847 | | - testcase( pFirstTerm->eOperator & WO_EQUIV ); |
| 107848 | | - testcase( pFirstTerm->eOperator & WO_ISNULL ); |
| 107849 | | - whereEqualScanEst(pParse, pProbe, pFirstTerm->pExpr->pRight, |
| 107850 | | - &pc.plan.nRow); |
| 107851 | | - }else if( bInEst==0 ){ |
| 107852 | | - assert( pFirstTerm->eOperator & WO_IN ); |
| 107853 | | - whereInScanEst(pParse, pProbe, pFirstTerm->pExpr->x.pList, |
| 107854 | | - &pc.plan.nRow); |
| 107855 | | - } |
| 107856 | | - } |
| 107857 | | -#endif /* SQLITE_ENABLE_STAT3 */ |
| 107858 | | - |
| 107859 | | - /* Adjust the number of output rows and downward to reflect rows |
| 107860 | | - ** that are excluded by range constraints. |
| 107861 | | - */ |
| 107862 | | - pc.plan.nRow = pc.plan.nRow/rangeDiv; |
| 107863 | | - if( pc.plan.nRow<1 ) pc.plan.nRow = 1; |
| 107864 | | - |
| 107865 | | - /* Experiments run on real SQLite databases show that the time needed |
| 107866 | | - ** to do a binary search to locate a row in a table or index is roughly |
| 107867 | | - ** log10(N) times the time to move from one row to the next row within |
| 107868 | | - ** a table or index. The actual times can vary, with the size of |
| 107869 | | - ** records being an important factor. Both moves and searches are |
| 107870 | | - ** slower with larger records, presumably because fewer records fit |
| 107871 | | - ** on one page and hence more pages have to be fetched. |
| 107872 | | - ** |
| 107873 | | - ** The ANALYZE command and the sqlite_stat1 and sqlite_stat3 tables do |
| 107874 | | - ** not give us data on the relative sizes of table and index records. |
| 107875 | | - ** So this computation assumes table records are about twice as big |
| 107876 | | - ** as index records |
| 107877 | | - */ |
| 107878 | | - if( (pc.plan.wsFlags&~(WHERE_REVERSE|WHERE_ORDERED|WHERE_OB_UNIQUE)) |
| 107879 | | - ==WHERE_IDX_ONLY |
| 107880 | | - && (pWC->wctrlFlags & WHERE_ONEPASS_DESIRED)==0 |
| 107881 | | - && sqlite3GlobalConfig.bUseCis |
| 107882 | | - && OptimizationEnabled(pParse->db, SQLITE_CoverIdxScan) |
| 107883 | | - ){ |
| 107884 | | - /* This index is not useful for indexing, but it is a covering index. |
| 107885 | | - ** A full-scan of the index might be a little faster than a full-scan |
| 107886 | | - ** of the table, so give this case a cost slightly less than a table |
| 107887 | | - ** scan. */ |
| 107888 | | - pc.rCost = aiRowEst[0]*3 + pProbe->nColumn; |
| 107889 | | - pc.plan.wsFlags |= WHERE_COVER_SCAN|WHERE_COLUMN_RANGE; |
| 107890 | | - }else if( (pc.plan.wsFlags & WHERE_NOT_FULLSCAN)==0 ){ |
| 107891 | | - /* The cost of a full table scan is a number of move operations equal |
| 107892 | | - ** to the number of rows in the table. |
| 107893 | | - ** |
| 107894 | | - ** We add an additional 4x penalty to full table scans. This causes |
| 107895 | | - ** the cost function to err on the side of choosing an index over |
| 107896 | | - ** choosing a full scan. This 4x full-scan penalty is an arguable |
| 107897 | | - ** decision and one which we expect to revisit in the future. But |
| 107898 | | - ** it seems to be working well enough at the moment. |
| 107899 | | - */ |
| 107900 | | - pc.rCost = aiRowEst[0]*4; |
| 107901 | | - pc.plan.wsFlags &= ~WHERE_IDX_ONLY; |
| 107902 | | - if( pIdx ){ |
| 107903 | | - pc.plan.wsFlags &= ~WHERE_ORDERED; |
| 107904 | | - pc.plan.nOBSat = nPriorSat; |
| 107905 | | - } |
| 107906 | | - }else{ |
| 107907 | | - log10N = estLog(aiRowEst[0]); |
| 107908 | | - pc.rCost = pc.plan.nRow; |
| 107909 | | - if( pIdx ){ |
| 107910 | | - if( bLookup ){ |
| 107911 | | - /* For an index lookup followed by a table lookup: |
| 107912 | | - ** nInMul index searches to find the start of each index range |
| 107913 | | - ** + nRow steps through the index |
| 107914 | | - ** + nRow table searches to lookup the table entry using the rowid |
| 107915 | | - */ |
| 107916 | | - pc.rCost += (nInMul + pc.plan.nRow)*log10N; |
| 107917 | | - }else{ |
| 107918 | | - /* For a covering index: |
| 107919 | | - ** nInMul index searches to find the initial entry |
| 107920 | | - ** + nRow steps through the index |
| 107921 | | - */ |
| 107922 | | - pc.rCost += nInMul*log10N; |
| 107923 | | - } |
| 107924 | | - }else{ |
| 107925 | | - /* For a rowid primary key lookup: |
| 107926 | | - ** nInMult table searches to find the initial entry for each range |
| 107927 | | - ** + nRow steps through the table |
| 107928 | | - */ |
| 107929 | | - pc.rCost += nInMul*log10N; |
| 107930 | | - } |
| 107931 | | - } |
| 107932 | | - |
| 107933 | | - /* Add in the estimated cost of sorting the result. Actual experimental |
| 107934 | | - ** measurements of sorting performance in SQLite show that sorting time |
| 107935 | | - ** adds C*N*log10(N) to the cost, where N is the number of rows to be |
| 107936 | | - ** sorted and C is a factor between 1.95 and 4.3. We will split the |
| 107937 | | - ** difference and select C of 3.0. |
| 107938 | | - */ |
| 107939 | | - if( bSort ){ |
| 107940 | | - double m = estLog(pc.plan.nRow*(nOrderBy - pc.plan.nOBSat)/nOrderBy); |
| 107941 | | - m *= (double)(pc.plan.nOBSat ? 2 : 3); |
| 107942 | | - pc.rCost += pc.plan.nRow*m; |
| 107943 | | - } |
| 107944 | | - if( bDist ){ |
| 107945 | | - pc.rCost += pc.plan.nRow*estLog(pc.plan.nRow)*3; |
| 107946 | | - } |
| 107947 | | - |
| 107948 | | - /**** Cost of using this index has now been computed ****/ |
| 107949 | | - |
| 107950 | | - /* If there are additional constraints on this table that cannot |
| 107951 | | - ** be used with the current index, but which might lower the number |
| 107952 | | - ** of output rows, adjust the nRow value accordingly. This only |
| 107953 | | - ** matters if the current index is the least costly, so do not bother |
| 107954 | | - ** with this step if we already know this index will not be chosen. |
| 107955 | | - ** Also, never reduce the output row count below 2 using this step. |
| 107956 | | - ** |
| 107957 | | - ** It is critical that the notValid mask be used here instead of |
| 107958 | | - ** the notReady mask. When computing an "optimal" index, the notReady |
| 107959 | | - ** mask will only have one bit set - the bit for the current table. |
| 107960 | | - ** The notValid mask, on the other hand, always has all bits set for |
| 107961 | | - ** tables that are not in outer loops. If notReady is used here instead |
| 107962 | | - ** of notValid, then a optimal index that depends on inner joins loops |
| 107963 | | - ** might be selected even when there exists an optimal index that has |
| 107964 | | - ** no such dependency. |
| 107965 | | - */ |
| 107966 | | - if( pc.plan.nRow>2 && pc.rCost<=p->cost.rCost ){ |
| 107967 | | - int k; /* Loop counter */ |
| 107968 | | - int nSkipEq = pc.plan.nEq; /* Number of == constraints to skip */ |
| 107969 | | - int nSkipRange = nBound; /* Number of < constraints to skip */ |
| 107970 | | - Bitmask thisTab; /* Bitmap for pSrc */ |
| 107971 | | - |
| 107972 | | - thisTab = getMask(pWC->pMaskSet, iCur); |
| 107973 | | - for(pTerm=pWC->a, k=pWC->nTerm; pc.plan.nRow>2 && k; k--, pTerm++){ |
| 107974 | | - if( pTerm->wtFlags & TERM_VIRTUAL ) continue; |
| 107975 | | - if( (pTerm->prereqAll & p->notValid)!=thisTab ) continue; |
| 107976 | | - if( pTerm->eOperator & (WO_EQ|WO_IN|WO_ISNULL) ){ |
| 107977 | | - if( nSkipEq ){ |
| 107978 | | - /* Ignore the first pc.plan.nEq equality matches since the index |
| 107979 | | - ** has already accounted for these */ |
| 107980 | | - nSkipEq--; |
| 107981 | | - }else{ |
| 107982 | | - /* Assume each additional equality match reduces the result |
| 107983 | | - ** set size by a factor of 10 */ |
| 107984 | | - pc.plan.nRow /= 10; |
| 107985 | | - } |
| 107986 | | - }else if( pTerm->eOperator & (WO_LT|WO_LE|WO_GT|WO_GE) ){ |
| 107987 | | - if( nSkipRange ){ |
| 107988 | | - /* Ignore the first nSkipRange range constraints since the index |
| 107989 | | - ** has already accounted for these */ |
| 107990 | | - nSkipRange--; |
| 107991 | | - }else{ |
| 107992 | | - /* Assume each additional range constraint reduces the result |
| 107993 | | - ** set size by a factor of 3. Indexed range constraints reduce |
| 107994 | | - ** the search space by a larger factor: 4. We make indexed range |
| 107995 | | - ** more selective intentionally because of the subjective |
| 107996 | | - ** observation that indexed range constraints really are more |
| 107997 | | - ** selective in practice, on average. */ |
| 107998 | | - pc.plan.nRow /= 3; |
| 107999 | | - } |
| 108000 | | - }else if( (pTerm->eOperator & WO_NOOP)==0 ){ |
| 108001 | | - /* Any other expression lowers the output row count by half */ |
| 108002 | | - pc.plan.nRow /= 2; |
| 108003 | | - } |
| 108004 | | - } |
| 108005 | | - if( pc.plan.nRow<2 ) pc.plan.nRow = 2; |
| 108006 | | - } |
| 108007 | | - |
| 108008 | | - |
| 108009 | | - WHERETRACE(( |
| 108010 | | - " nEq=%d nInMul=%d rangeDiv=%d bSort=%d bLookup=%d wsFlags=0x%08x\n" |
| 108011 | | - " notReady=0x%llx log10N=%.1f nRow=%.1f cost=%.1f\n" |
| 108012 | | - " used=0x%llx nOBSat=%d\n", |
| 108013 | | - pc.plan.nEq, nInMul, (int)rangeDiv, bSort, bLookup, pc.plan.wsFlags, |
| 108014 | | - p->notReady, log10N, pc.plan.nRow, pc.rCost, pc.used, |
| 108015 | | - pc.plan.nOBSat |
| 108016 | | - )); |
| 108017 | | - |
| 108018 | | - /* If this index is the best we have seen so far, then record this |
| 108019 | | - ** index and its cost in the p->cost structure. |
| 108020 | | - */ |
| 108021 | | - if( (!pIdx || pc.plan.wsFlags) && compareCost(&pc, &p->cost) ){ |
| 108022 | | - p->cost = pc; |
| 108023 | | - p->cost.plan.wsFlags &= wsFlagMask; |
| 108024 | | - p->cost.plan.u.pIdx = pIdx; |
| 108025 | | - } |
| 108026 | | - |
| 108027 | | - /* If there was an INDEXED BY clause, then only that one index is |
| 108028 | | - ** considered. */ |
| 108029 | | - if( pSrc->pIndex ) break; |
| 108030 | | - |
| 108031 | | - /* Reset masks for the next index in the loop */ |
| 108032 | | - wsFlagMask = ~(WHERE_ROWID_EQ|WHERE_ROWID_RANGE); |
| 108033 | | - eqTermMask = idxEqTermMask; |
| 108034 | | - } |
| 108035 | | - |
| 108036 | | - /* If there is no ORDER BY clause and the SQLITE_ReverseOrder flag |
| 108037 | | - ** is set, then reverse the order that the index will be scanned |
| 108038 | | - ** in. This is used for application testing, to help find cases |
| 108039 | | - ** where application behavior depends on the (undefined) order that |
| 108040 | | - ** SQLite outputs rows in in the absence of an ORDER BY clause. */ |
| 108041 | | - if( !p->pOrderBy && pParse->db->flags & SQLITE_ReverseOrder ){ |
| 108042 | | - p->cost.plan.wsFlags |= WHERE_REVERSE; |
| 108043 | | - } |
| 108044 | | - |
| 108045 | | - assert( p->pOrderBy || (p->cost.plan.wsFlags&WHERE_ORDERED)==0 ); |
| 108046 | | - assert( p->cost.plan.u.pIdx==0 || (p->cost.plan.wsFlags&WHERE_ROWID_EQ)==0 ); |
| 108047 | | - assert( pSrc->pIndex==0 |
| 108048 | | - || p->cost.plan.u.pIdx==0 |
| 108049 | | - || p->cost.plan.u.pIdx==pSrc->pIndex |
| 108050 | | - ); |
| 108051 | | - |
| 108052 | | - WHERETRACE((" best index is %s cost=%.1f\n", |
| 108053 | | - p->cost.plan.u.pIdx ? p->cost.plan.u.pIdx->zName : "ipk", |
| 108054 | | - p->cost.rCost)); |
| 108055 | | - |
| 108056 | | - bestOrClauseIndex(p); |
| 108057 | | - bestAutomaticIndex(p); |
| 108058 | | - p->cost.plan.wsFlags |= eqTermMask; |
| 108059 | | -} |
| 108060 | | - |
| 108061 | | -/* |
| 108062 | | -** Find the query plan for accessing table pSrc->pTab. Write the |
| 108063 | | -** best query plan and its cost into the WhereCost object supplied |
| 108064 | | -** as the last parameter. This function may calculate the cost of |
| 108065 | | -** both real and virtual table scans. |
| 108066 | | -** |
| 108067 | | -** This function does not take ORDER BY or DISTINCT into account. Nor |
| 108068 | | -** does it remember the virtual table query plan. All it does is compute |
| 108069 | | -** the cost while determining if an OR optimization is applicable. The |
| 108070 | | -** details will be reconsidered later if the optimization is found to be |
| 108071 | | -** applicable. |
| 108072 | | -*/ |
| 108073 | | -static void bestIndex(WhereBestIdx *p){ |
| 108074 | | -#ifndef SQLITE_OMIT_VIRTUALTABLE |
| 108075 | | - if( IsVirtual(p->pSrc->pTab) ){ |
| 108076 | | - sqlite3_index_info *pIdxInfo = 0; |
| 108077 | | - p->ppIdxInfo = &pIdxInfo; |
| 108078 | | - bestVirtualIndex(p); |
| 108079 | | - assert( pIdxInfo!=0 || p->pParse->db->mallocFailed ); |
| 108080 | | - if( pIdxInfo && pIdxInfo->needToFreeIdxStr ){ |
| 108081 | | - sqlite3_free(pIdxInfo->idxStr); |
| 108082 | | - } |
| 108083 | | - sqlite3DbFree(p->pParse->db, pIdxInfo); |
| 108084 | | - }else |
| 108085 | | -#endif |
| 108086 | | - { |
| 108087 | | - bestBtreeIndex(p); |
| 108088 | | - } |
| 108089 | | -} |
| 107003 | + WHERETRACE(0x100,("IN row estimate: est=%g\n", nRowEst)); |
| 107004 | + } |
| 107005 | + return rc; |
| 107006 | +} |
| 107007 | +#endif /* defined(SQLITE_ENABLE_STAT3) */ |
| 108090 | 107008 | |
| 108091 | 107009 | /* |
| 108092 | 107010 | ** Disable a term in the WHERE clause. Except, do not disable the term |
| 108093 | 107011 | ** if it controls a LEFT OUTER JOIN and it did not originate in the ON |
| 108094 | 107012 | ** or USING clause of that join. |
| | @@ -108183,10 +107101,11 @@ |
| 108183 | 107101 | static int codeEqualityTerm( |
| 108184 | 107102 | Parse *pParse, /* The parsing context */ |
| 108185 | 107103 | WhereTerm *pTerm, /* The term of the WHERE clause to be coded */ |
| 108186 | 107104 | WhereLevel *pLevel, /* The level of the FROM clause we are working on */ |
| 108187 | 107105 | int iEq, /* Index of the equality term within this level */ |
| 107106 | + int bRev, /* True for reverse-order IN operations */ |
| 108188 | 107107 | int iTarget /* Attempt to leave results in this register */ |
| 108189 | 107108 | ){ |
| 108190 | 107109 | Expr *pX = pTerm->pExpr; |
| 108191 | 107110 | Vdbe *v = pParse->pVdbe; |
| 108192 | 107111 | int iReg; /* Register holding results */ |
| | @@ -108200,18 +107119,17 @@ |
| 108200 | 107119 | #ifndef SQLITE_OMIT_SUBQUERY |
| 108201 | 107120 | }else{ |
| 108202 | 107121 | int eType; |
| 108203 | 107122 | int iTab; |
| 108204 | 107123 | struct InLoop *pIn; |
| 108205 | | - u8 bRev = (pLevel->plan.wsFlags & WHERE_REVERSE)!=0; |
| 107124 | + WhereLoop *pLoop = pLevel->pWLoop; |
| 108206 | 107125 | |
| 108207 | | - if( (pLevel->plan.wsFlags & WHERE_INDEXED)!=0 |
| 108208 | | - && pLevel->plan.u.pIdx->aSortOrder[iEq] |
| 107126 | + if( (pLoop->wsFlags & WHERE_VIRTUALTABLE)==0 |
| 107127 | + && pLoop->u.btree.pIndex!=0 |
| 107128 | + && pLoop->u.btree.pIndex->aSortOrder[iEq] |
| 108209 | 107129 | ){ |
| 108210 | 107130 | testcase( iEq==0 ); |
| 108211 | | - testcase( iEq==pLevel->plan.u.pIdx->nColumn-1 ); |
| 108212 | | - testcase( iEq>0 && iEq+1<pLevel->plan.u.pIdx->nColumn ); |
| 108213 | 107131 | testcase( bRev ); |
| 108214 | 107132 | bRev = !bRev; |
| 108215 | 107133 | } |
| 108216 | 107134 | assert( pX->op==TK_IN ); |
| 108217 | 107135 | iReg = iTarget; |
| | @@ -108220,11 +107138,12 @@ |
| 108220 | 107138 | testcase( bRev ); |
| 108221 | 107139 | bRev = !bRev; |
| 108222 | 107140 | } |
| 108223 | 107141 | iTab = pX->iTable; |
| 108224 | 107142 | sqlite3VdbeAddOp2(v, bRev ? OP_Last : OP_Rewind, iTab, 0); |
| 108225 | | - assert( pLevel->plan.wsFlags & WHERE_IN_ABLE ); |
| 107143 | + assert( (pLoop->wsFlags & WHERE_MULTI_OR)==0 ); |
| 107144 | + pLoop->wsFlags |= WHERE_IN_ABLE; |
| 108226 | 107145 | if( pLevel->u.in.nIn==0 ){ |
| 108227 | 107146 | pLevel->addrNxt = sqlite3VdbeMakeLabel(v); |
| 108228 | 107147 | } |
| 108229 | 107148 | pLevel->u.in.nIn++; |
| 108230 | 107149 | pLevel->u.in.aInLoop = |
| | @@ -108290,33 +107209,35 @@ |
| 108290 | 107209 | ** string in this example would be set to SQLITE_AFF_NONE. |
| 108291 | 107210 | */ |
| 108292 | 107211 | static int codeAllEqualityTerms( |
| 108293 | 107212 | Parse *pParse, /* Parsing context */ |
| 108294 | 107213 | WhereLevel *pLevel, /* Which nested loop of the FROM we are coding */ |
| 108295 | | - WhereClause *pWC, /* The WHERE clause */ |
| 108296 | | - Bitmask notReady, /* Which parts of FROM have not yet been coded */ |
| 107214 | + int bRev, /* Reverse the order of IN operators */ |
| 108297 | 107215 | int nExtraReg, /* Number of extra registers to allocate */ |
| 108298 | 107216 | char **pzAff /* OUT: Set to point to affinity string */ |
| 108299 | 107217 | ){ |
| 108300 | | - int nEq = pLevel->plan.nEq; /* The number of == or IN constraints to code */ |
| 107218 | + int nEq; /* The number of == or IN constraints to code */ |
| 108301 | 107219 | Vdbe *v = pParse->pVdbe; /* The vm under construction */ |
| 108302 | 107220 | Index *pIdx; /* The index being used for this loop */ |
| 108303 | | - int iCur = pLevel->iTabCur; /* The cursor of the table */ |
| 108304 | 107221 | WhereTerm *pTerm; /* A single constraint term */ |
| 107222 | + WhereLoop *pLoop; /* The WhereLoop object */ |
| 108305 | 107223 | int j; /* Loop counter */ |
| 108306 | 107224 | int regBase; /* Base register */ |
| 108307 | 107225 | int nReg; /* Number of registers to allocate */ |
| 108308 | 107226 | char *zAff; /* Affinity string to return */ |
| 108309 | 107227 | |
| 108310 | 107228 | /* This module is only called on query plans that use an index. */ |
| 108311 | | - assert( pLevel->plan.wsFlags & WHERE_INDEXED ); |
| 108312 | | - pIdx = pLevel->plan.u.pIdx; |
| 107229 | + pLoop = pLevel->pWLoop; |
| 107230 | + assert( (pLoop->wsFlags & WHERE_VIRTUALTABLE)==0 ); |
| 107231 | + nEq = pLoop->u.btree.nEq; |
| 107232 | + pIdx = pLoop->u.btree.pIndex; |
| 107233 | + assert( pIdx!=0 ); |
| 108313 | 107234 | |
| 108314 | 107235 | /* Figure out how many memory cells we will need then allocate them. |
| 108315 | 107236 | */ |
| 108316 | 107237 | regBase = pParse->nMem + 1; |
| 108317 | | - nReg = pLevel->plan.nEq + nExtraReg; |
| 107238 | + nReg = pLoop->u.btree.nEq + nExtraReg; |
| 108318 | 107239 | pParse->nMem += nReg; |
| 108319 | 107240 | |
| 108320 | 107241 | zAff = sqlite3DbStrDup(pParse->db, sqlite3IndexAffinityStr(v, pIdx)); |
| 108321 | 107242 | if( !zAff ){ |
| 108322 | 107243 | pParse->db->mallocFailed = 1; |
| | @@ -108325,18 +107246,17 @@ |
| 108325 | 107246 | /* Evaluate the equality constraints |
| 108326 | 107247 | */ |
| 108327 | 107248 | assert( pIdx->nColumn>=nEq ); |
| 108328 | 107249 | for(j=0; j<nEq; j++){ |
| 108329 | 107250 | int r1; |
| 108330 | | - int k = pIdx->aiColumn[j]; |
| 108331 | | - pTerm = findTerm(pWC, iCur, k, notReady, pLevel->plan.wsFlags, pIdx); |
| 108332 | | - if( pTerm==0 ) break; |
| 107251 | + pTerm = pLoop->aLTerm[j]; |
| 107252 | + assert( pTerm!=0 ); |
| 108333 | 107253 | /* The following true for indices with redundant columns. |
| 108334 | 107254 | ** Ex: CREATE INDEX i1 ON t1(a,b,a); SELECT * FROM t1 WHERE a=0 AND b=0; */ |
| 108335 | 107255 | testcase( (pTerm->wtFlags & TERM_CODED)!=0 ); |
| 108336 | 107256 | testcase( pTerm->wtFlags & TERM_VIRTUAL ); /* EV: R-30575-11662 */ |
| 108337 | | - r1 = codeEqualityTerm(pParse, pTerm, pLevel, j, regBase+j); |
| 107257 | + r1 = codeEqualityTerm(pParse, pTerm, pLevel, j, bRev, regBase+j); |
| 108338 | 107258 | if( r1!=regBase+j ){ |
| 108339 | 107259 | if( nReg==1 ){ |
| 108340 | 107260 | sqlite3ReleaseTempReg(pParse, regBase); |
| 108341 | 107261 | regBase = r1; |
| 108342 | 107262 | }else{ |
| | @@ -108400,20 +107320,19 @@ |
| 108400 | 107320 | ** |
| 108401 | 107321 | ** The returned pointer points to memory obtained from sqlite3DbMalloc(). |
| 108402 | 107322 | ** It is the responsibility of the caller to free the buffer when it is |
| 108403 | 107323 | ** no longer required. |
| 108404 | 107324 | */ |
| 108405 | | -static char *explainIndexRange(sqlite3 *db, WhereLevel *pLevel, Table *pTab){ |
| 108406 | | - WherePlan *pPlan = &pLevel->plan; |
| 108407 | | - Index *pIndex = pPlan->u.pIdx; |
| 108408 | | - int nEq = pPlan->nEq; |
| 107325 | +static char *explainIndexRange(sqlite3 *db, WhereLoop *pLoop, Table *pTab){ |
| 107326 | + Index *pIndex = pLoop->u.btree.pIndex; |
| 107327 | + int nEq = pLoop->u.btree.nEq; |
| 108409 | 107328 | int i, j; |
| 108410 | 107329 | Column *aCol = pTab->aCol; |
| 108411 | 107330 | int *aiColumn = pIndex->aiColumn; |
| 108412 | 107331 | StrAccum txt; |
| 108413 | 107332 | |
| 108414 | | - if( nEq==0 && (pPlan->wsFlags & (WHERE_BTM_LIMIT|WHERE_TOP_LIMIT))==0 ){ |
| 107333 | + if( nEq==0 && (pLoop->wsFlags & (WHERE_BTM_LIMIT|WHERE_TOP_LIMIT))==0 ){ |
| 108415 | 107334 | return 0; |
| 108416 | 107335 | } |
| 108417 | 107336 | sqlite3StrAccumInit(&txt, 0, 0, SQLITE_MAX_LENGTH); |
| 108418 | 107337 | txt.db = db; |
| 108419 | 107338 | sqlite3StrAccumAppend(&txt, " (", 2); |
| | @@ -108420,15 +107339,15 @@ |
| 108420 | 107339 | for(i=0; i<nEq; i++){ |
| 108421 | 107340 | explainAppendTerm(&txt, i, aCol[aiColumn[i]].zName, "="); |
| 108422 | 107341 | } |
| 108423 | 107342 | |
| 108424 | 107343 | j = i; |
| 108425 | | - if( pPlan->wsFlags&WHERE_BTM_LIMIT ){ |
| 107344 | + if( pLoop->wsFlags&WHERE_BTM_LIMIT ){ |
| 108426 | 107345 | char *z = (j==pIndex->nColumn ) ? "rowid" : aCol[aiColumn[j]].zName; |
| 108427 | 107346 | explainAppendTerm(&txt, i++, z, ">"); |
| 108428 | 107347 | } |
| 108429 | | - if( pPlan->wsFlags&WHERE_TOP_LIMIT ){ |
| 107348 | + if( pLoop->wsFlags&WHERE_TOP_LIMIT ){ |
| 108430 | 107349 | char *z = (j==pIndex->nColumn ) ? "rowid" : aCol[aiColumn[j]].zName; |
| 108431 | 107350 | explainAppendTerm(&txt, i, z, "<"); |
| 108432 | 107351 | } |
| 108433 | 107352 | sqlite3StrAccumAppend(&txt, ")", 1); |
| 108434 | 107353 | return sqlite3StrAccumFinish(&txt); |
| | @@ -108447,24 +107366,26 @@ |
| 108447 | 107366 | int iLevel, /* Value for "level" column of output */ |
| 108448 | 107367 | int iFrom, /* Value for "from" column of output */ |
| 108449 | 107368 | u16 wctrlFlags /* Flags passed to sqlite3WhereBegin() */ |
| 108450 | 107369 | ){ |
| 108451 | 107370 | if( pParse->explain==2 ){ |
| 108452 | | - u32 flags = pLevel->plan.wsFlags; |
| 108453 | 107371 | struct SrcList_item *pItem = &pTabList->a[pLevel->iFrom]; |
| 108454 | 107372 | Vdbe *v = pParse->pVdbe; /* VM being constructed */ |
| 108455 | 107373 | sqlite3 *db = pParse->db; /* Database handle */ |
| 108456 | 107374 | char *zMsg; /* Text to add to EQP output */ |
| 108457 | | - sqlite3_int64 nRow; /* Expected number of rows visited by scan */ |
| 108458 | 107375 | int iId = pParse->iSelectId; /* Select id (left-most output column) */ |
| 108459 | 107376 | int isSearch; /* True for a SEARCH. False for SCAN. */ |
| 107377 | + WhereLoop *pLoop; /* The controlling WhereLoop object */ |
| 107378 | + u32 flags; /* Flags that describe this loop */ |
| 108460 | 107379 | |
| 107380 | + pLoop = pLevel->pWLoop; |
| 107381 | + flags = pLoop->wsFlags; |
| 108461 | 107382 | if( (flags&WHERE_MULTI_OR) || (wctrlFlags&WHERE_ONETABLE_ONLY) ) return; |
| 108462 | 107383 | |
| 108463 | | - isSearch = (pLevel->plan.nEq>0) |
| 108464 | | - || (flags&(WHERE_BTM_LIMIT|WHERE_TOP_LIMIT))!=0 |
| 108465 | | - || (wctrlFlags&(WHERE_ORDERBY_MIN|WHERE_ORDERBY_MAX)); |
| 107384 | + isSearch = (flags&(WHERE_BTM_LIMIT|WHERE_TOP_LIMIT))!=0 |
| 107385 | + || ((flags&WHERE_VIRTUALTABLE)==0 && (pLoop->u.btree.nEq>0)) |
| 107386 | + || (wctrlFlags&(WHERE_ORDERBY_MIN|WHERE_ORDERBY_MAX)); |
| 108466 | 107387 | |
| 108467 | 107388 | zMsg = sqlite3MPrintf(db, "%s", isSearch?"SEARCH":"SCAN"); |
| 108468 | 107389 | if( pItem->pSelect ){ |
| 108469 | 107390 | zMsg = sqlite3MAppendf(db, zMsg, "%s SUBQUERY %d", zMsg,pItem->iSelectId); |
| 108470 | 107391 | }else{ |
| | @@ -108472,47 +107393,42 @@ |
| 108472 | 107393 | } |
| 108473 | 107394 | |
| 108474 | 107395 | if( pItem->zAlias ){ |
| 108475 | 107396 | zMsg = sqlite3MAppendf(db, zMsg, "%s AS %s", zMsg, pItem->zAlias); |
| 108476 | 107397 | } |
| 108477 | | - if( (flags & WHERE_INDEXED)!=0 ){ |
| 108478 | | - char *zWhere = explainIndexRange(db, pLevel, pItem->pTab); |
| 107398 | + if( (flags & (WHERE_IPK|WHERE_VIRTUALTABLE))==0 |
| 107399 | + && ALWAYS(pLoop->u.btree.pIndex!=0) |
| 107400 | + ){ |
| 107401 | + char *zWhere = explainIndexRange(db, pLoop, pItem->pTab); |
| 108479 | 107402 | zMsg = sqlite3MAppendf(db, zMsg, "%s USING %s%sINDEX%s%s%s", zMsg, |
| 108480 | 107403 | ((flags & WHERE_TEMP_INDEX)?"AUTOMATIC ":""), |
| 108481 | 107404 | ((flags & WHERE_IDX_ONLY)?"COVERING ":""), |
| 108482 | 107405 | ((flags & WHERE_TEMP_INDEX)?"":" "), |
| 108483 | | - ((flags & WHERE_TEMP_INDEX)?"": pLevel->plan.u.pIdx->zName), |
| 107406 | + ((flags & WHERE_TEMP_INDEX)?"": pLoop->u.btree.pIndex->zName), |
| 108484 | 107407 | zWhere |
| 108485 | 107408 | ); |
| 108486 | 107409 | sqlite3DbFree(db, zWhere); |
| 108487 | | - }else if( flags & (WHERE_ROWID_EQ|WHERE_ROWID_RANGE) ){ |
| 107410 | + }else if( (flags & WHERE_IPK)!=0 && (flags & WHERE_CONSTRAINT)!=0 ){ |
| 108488 | 107411 | zMsg = sqlite3MAppendf(db, zMsg, "%s USING INTEGER PRIMARY KEY", zMsg); |
| 108489 | 107412 | |
| 108490 | | - if( flags&WHERE_ROWID_EQ ){ |
| 107413 | + if( flags&(WHERE_COLUMN_EQ|WHERE_COLUMN_IN) ){ |
| 108491 | 107414 | zMsg = sqlite3MAppendf(db, zMsg, "%s (rowid=?)", zMsg); |
| 108492 | 107415 | }else if( (flags&WHERE_BOTH_LIMIT)==WHERE_BOTH_LIMIT ){ |
| 108493 | 107416 | zMsg = sqlite3MAppendf(db, zMsg, "%s (rowid>? AND rowid<?)", zMsg); |
| 108494 | 107417 | }else if( flags&WHERE_BTM_LIMIT ){ |
| 108495 | 107418 | zMsg = sqlite3MAppendf(db, zMsg, "%s (rowid>?)", zMsg); |
| 108496 | | - }else if( flags&WHERE_TOP_LIMIT ){ |
| 107419 | + }else if( ALWAYS(flags&WHERE_TOP_LIMIT) ){ |
| 108497 | 107420 | zMsg = sqlite3MAppendf(db, zMsg, "%s (rowid<?)", zMsg); |
| 108498 | 107421 | } |
| 108499 | 107422 | } |
| 108500 | 107423 | #ifndef SQLITE_OMIT_VIRTUALTABLE |
| 108501 | 107424 | else if( (flags & WHERE_VIRTUALTABLE)!=0 ){ |
| 108502 | | - sqlite3_index_info *pVtabIdx = pLevel->plan.u.pVtabIdx; |
| 108503 | 107425 | zMsg = sqlite3MAppendf(db, zMsg, "%s VIRTUAL TABLE INDEX %d:%s", zMsg, |
| 108504 | | - pVtabIdx->idxNum, pVtabIdx->idxStr); |
| 107426 | + pLoop->u.vtab.idxNum, pLoop->u.vtab.idxStr); |
| 108505 | 107427 | } |
| 108506 | 107428 | #endif |
| 108507 | | - if( wctrlFlags&(WHERE_ORDERBY_MIN|WHERE_ORDERBY_MAX) ){ |
| 108508 | | - testcase( wctrlFlags & WHERE_ORDERBY_MIN ); |
| 108509 | | - nRow = 1; |
| 108510 | | - }else{ |
| 108511 | | - nRow = (sqlite3_int64)pLevel->plan.nRow; |
| 108512 | | - } |
| 108513 | | - zMsg = sqlite3MAppendf(db, zMsg, "%s (~%lld rows)", zMsg, nRow); |
| 107429 | + zMsg = sqlite3MAppendf(db, zMsg, "%s", zMsg); |
| 108514 | 107430 | sqlite3VdbeAddOp4(v, OP_Explain, iId, iLevel, iFrom, zMsg, P4_DYNAMIC); |
| 108515 | 107431 | } |
| 108516 | 107432 | } |
| 108517 | 107433 | #else |
| 108518 | 107434 | # define explainOneScan(u,v,w,x,y,z) |
| | @@ -108524,19 +107440,19 @@ |
| 108524 | 107440 | ** implementation described by pWInfo. |
| 108525 | 107441 | */ |
| 108526 | 107442 | static Bitmask codeOneLoopStart( |
| 108527 | 107443 | WhereInfo *pWInfo, /* Complete information about the WHERE clause */ |
| 108528 | 107444 | int iLevel, /* Which level of pWInfo->a[] should be coded */ |
| 108529 | | - u16 wctrlFlags, /* One of the WHERE_* flags defined in sqliteInt.h */ |
| 108530 | 107445 | Bitmask notReady /* Which tables are currently available */ |
| 108531 | 107446 | ){ |
| 108532 | 107447 | int j, k; /* Loop counters */ |
| 108533 | 107448 | int iCur; /* The VDBE cursor for the table */ |
| 108534 | 107449 | int addrNxt; /* Where to jump to continue with the next IN case */ |
| 108535 | 107450 | int omitTable; /* True if we use the index only */ |
| 108536 | 107451 | int bRev; /* True if we need to scan in reverse order */ |
| 108537 | 107452 | WhereLevel *pLevel; /* The where level to be coded */ |
| 107453 | + WhereLoop *pLoop; /* The WhereLoop object being coded */ |
| 108538 | 107454 | WhereClause *pWC; /* Decomposition of the entire WHERE clause */ |
| 108539 | 107455 | WhereTerm *pTerm; /* A WHERE clause term */ |
| 108540 | 107456 | Parse *pParse; /* Parsing context */ |
| 108541 | 107457 | Vdbe *v; /* The prepared stmt under constructions */ |
| 108542 | 107458 | struct SrcList_item *pTabItem; /* FROM clause term being coded */ |
| | @@ -108546,17 +107462,18 @@ |
| 108546 | 107462 | int iReleaseReg = 0; /* Temp register to free before returning */ |
| 108547 | 107463 | Bitmask newNotReady; /* Return value */ |
| 108548 | 107464 | |
| 108549 | 107465 | pParse = pWInfo->pParse; |
| 108550 | 107466 | v = pParse->pVdbe; |
| 108551 | | - pWC = pWInfo->pWC; |
| 107467 | + pWC = &pWInfo->sWC; |
| 108552 | 107468 | pLevel = &pWInfo->a[iLevel]; |
| 107469 | + pLoop = pLevel->pWLoop; |
| 108553 | 107470 | pTabItem = &pWInfo->pTabList->a[pLevel->iFrom]; |
| 108554 | 107471 | iCur = pTabItem->iCursor; |
| 108555 | | - bRev = (pLevel->plan.wsFlags & WHERE_REVERSE)!=0; |
| 108556 | | - omitTable = (pLevel->plan.wsFlags & WHERE_IDX_ONLY)!=0 |
| 108557 | | - && (wctrlFlags & WHERE_FORCE_TABLE)==0; |
| 107472 | + bRev = (pWInfo->revMask>>iLevel)&1; |
| 107473 | + omitTable = (pLoop->wsFlags & WHERE_IDX_ONLY)!=0 |
| 107474 | + && (pWInfo->wctrlFlags & WHERE_FORCE_TABLE)==0; |
| 108558 | 107475 | VdbeNoopComment((v, "Begin Join Loop %d", iLevel)); |
| 108559 | 107476 | |
| 108560 | 107477 | /* Create labels for the "break" and "continue" instructions |
| 108561 | 107478 | ** for the current loop. Jump to addrBrk to break out of a loop. |
| 108562 | 107479 | ** Jump to cont to go immediately to the next iteration of the |
| | @@ -108589,51 +107506,41 @@ |
| 108589 | 107506 | sqlite3VdbeAddOp2(v, OP_If, regYield+1, addrBrk); |
| 108590 | 107507 | pLevel->op = OP_Goto; |
| 108591 | 107508 | }else |
| 108592 | 107509 | |
| 108593 | 107510 | #ifndef SQLITE_OMIT_VIRTUALTABLE |
| 108594 | | - if( (pLevel->plan.wsFlags & WHERE_VIRTUALTABLE)!=0 ){ |
| 108595 | | - /* Case 0: The table is a virtual-table. Use the VFilter and VNext |
| 107511 | + if( (pLoop->wsFlags & WHERE_VIRTUALTABLE)!=0 ){ |
| 107512 | + /* Case 1: The table is a virtual-table. Use the VFilter and VNext |
| 108596 | 107513 | ** to access the data. |
| 108597 | 107514 | */ |
| 108598 | 107515 | int iReg; /* P3 Value for OP_VFilter */ |
| 108599 | 107516 | int addrNotFound; |
| 108600 | | - sqlite3_index_info *pVtabIdx = pLevel->plan.u.pVtabIdx; |
| 108601 | | - int nConstraint = pVtabIdx->nConstraint; |
| 108602 | | - struct sqlite3_index_constraint_usage *aUsage = |
| 108603 | | - pVtabIdx->aConstraintUsage; |
| 108604 | | - const struct sqlite3_index_constraint *aConstraint = |
| 108605 | | - pVtabIdx->aConstraint; |
| 107517 | + int nConstraint = pLoop->nLTerm; |
| 108606 | 107518 | |
| 108607 | 107519 | sqlite3ExprCachePush(pParse); |
| 108608 | 107520 | iReg = sqlite3GetTempRange(pParse, nConstraint+2); |
| 108609 | 107521 | addrNotFound = pLevel->addrBrk; |
| 108610 | | - for(j=1; j<=nConstraint; j++){ |
| 108611 | | - for(k=0; k<nConstraint; k++){ |
| 108612 | | - if( aUsage[k].argvIndex==j ){ |
| 108613 | | - int iTarget = iReg+j+1; |
| 108614 | | - pTerm = &pWC->a[aConstraint[k].iTermOffset]; |
| 108615 | | - if( pTerm->eOperator & WO_IN ){ |
| 108616 | | - codeEqualityTerm(pParse, pTerm, pLevel, k, iTarget); |
| 108617 | | - addrNotFound = pLevel->addrNxt; |
| 108618 | | - }else{ |
| 108619 | | - sqlite3ExprCode(pParse, pTerm->pExpr->pRight, iTarget); |
| 108620 | | - } |
| 108621 | | - break; |
| 108622 | | - } |
| 108623 | | - } |
| 108624 | | - if( k==nConstraint ) break; |
| 108625 | | - } |
| 108626 | | - sqlite3VdbeAddOp2(v, OP_Integer, pVtabIdx->idxNum, iReg); |
| 108627 | | - sqlite3VdbeAddOp2(v, OP_Integer, j-1, iReg+1); |
| 108628 | | - sqlite3VdbeAddOp4(v, OP_VFilter, iCur, addrNotFound, iReg, pVtabIdx->idxStr, |
| 108629 | | - pVtabIdx->needToFreeIdxStr ? P4_MPRINTF : P4_STATIC); |
| 108630 | | - pVtabIdx->needToFreeIdxStr = 0; |
| 108631 | 107522 | for(j=0; j<nConstraint; j++){ |
| 108632 | | - if( aUsage[j].omit ){ |
| 108633 | | - int iTerm = aConstraint[j].iTermOffset; |
| 108634 | | - disableTerm(pLevel, &pWC->a[iTerm]); |
| 107523 | + int iTarget = iReg+j+2; |
| 107524 | + pTerm = pLoop->aLTerm[j]; |
| 107525 | + if( pTerm==0 ) continue; |
| 107526 | + if( pTerm->eOperator & WO_IN ){ |
| 107527 | + codeEqualityTerm(pParse, pTerm, pLevel, j, bRev, iTarget); |
| 107528 | + addrNotFound = pLevel->addrNxt; |
| 107529 | + }else{ |
| 107530 | + sqlite3ExprCode(pParse, pTerm->pExpr->pRight, iTarget); |
| 107531 | + } |
| 107532 | + } |
| 107533 | + sqlite3VdbeAddOp2(v, OP_Integer, pLoop->u.vtab.idxNum, iReg); |
| 107534 | + sqlite3VdbeAddOp2(v, OP_Integer, nConstraint, iReg+1); |
| 107535 | + sqlite3VdbeAddOp4(v, OP_VFilter, iCur, addrNotFound, iReg, |
| 107536 | + pLoop->u.vtab.idxStr, |
| 107537 | + pLoop->u.vtab.needFree ? P4_MPRINTF : P4_STATIC); |
| 107538 | + pLoop->u.vtab.needFree = 0; |
| 107539 | + for(j=0; j<nConstraint && j<16; j++){ |
| 107540 | + if( (pLoop->u.vtab.omitMask>>j)&1 ){ |
| 107541 | + disableTerm(pLevel, pLoop->aLTerm[j]); |
| 108635 | 107542 | } |
| 108636 | 107543 | } |
| 108637 | 107544 | pLevel->op = OP_VNext; |
| 108638 | 107545 | pLevel->p1 = iCur; |
| 108639 | 107546 | pLevel->p2 = sqlite3VdbeCurrentAddr(v); |
| | @@ -108640,41 +107547,49 @@ |
| 108640 | 107547 | sqlite3ReleaseTempRange(pParse, iReg, nConstraint+2); |
| 108641 | 107548 | sqlite3ExprCachePop(pParse, 1); |
| 108642 | 107549 | }else |
| 108643 | 107550 | #endif /* SQLITE_OMIT_VIRTUALTABLE */ |
| 108644 | 107551 | |
| 108645 | | - if( pLevel->plan.wsFlags & WHERE_ROWID_EQ ){ |
| 108646 | | - /* Case 1: We can directly reference a single row using an |
| 107552 | + if( (pLoop->wsFlags & WHERE_IPK)!=0 |
| 107553 | + && (pLoop->wsFlags & (WHERE_COLUMN_IN|WHERE_COLUMN_EQ))!=0 |
| 107554 | + ){ |
| 107555 | + /* Case 2: We can directly reference a single row using an |
| 108647 | 107556 | ** equality comparison against the ROWID field. Or |
| 108648 | 107557 | ** we reference multiple rows using a "rowid IN (...)" |
| 108649 | 107558 | ** construct. |
| 108650 | 107559 | */ |
| 107560 | + assert( pLoop->u.btree.nEq==1 ); |
| 108651 | 107561 | iReleaseReg = sqlite3GetTempReg(pParse); |
| 108652 | | - pTerm = findTerm(pWC, iCur, -1, notReady, WO_EQ|WO_IN, 0); |
| 107562 | + pTerm = pLoop->aLTerm[0]; |
| 108653 | 107563 | assert( pTerm!=0 ); |
| 108654 | 107564 | assert( pTerm->pExpr!=0 ); |
| 108655 | 107565 | assert( omitTable==0 ); |
| 108656 | 107566 | testcase( pTerm->wtFlags & TERM_VIRTUAL ); /* EV: R-30575-11662 */ |
| 108657 | | - iRowidReg = codeEqualityTerm(pParse, pTerm, pLevel, 0, iReleaseReg); |
| 107567 | + iRowidReg = codeEqualityTerm(pParse, pTerm, pLevel, 0, bRev, iReleaseReg); |
| 108658 | 107568 | addrNxt = pLevel->addrNxt; |
| 108659 | 107569 | sqlite3VdbeAddOp2(v, OP_MustBeInt, iRowidReg, addrNxt); |
| 108660 | 107570 | sqlite3VdbeAddOp3(v, OP_NotExists, iCur, addrNxt, iRowidReg); |
| 108661 | 107571 | sqlite3ExprCacheAffinityChange(pParse, iRowidReg, 1); |
| 108662 | 107572 | sqlite3ExprCacheStore(pParse, iCur, -1, iRowidReg); |
| 108663 | 107573 | VdbeComment((v, "pk")); |
| 108664 | 107574 | pLevel->op = OP_Noop; |
| 108665 | | - }else if( pLevel->plan.wsFlags & WHERE_ROWID_RANGE ){ |
| 108666 | | - /* Case 2: We have an inequality comparison against the ROWID field. |
| 107575 | + }else if( (pLoop->wsFlags & WHERE_IPK)!=0 |
| 107576 | + && (pLoop->wsFlags & WHERE_COLUMN_RANGE)!=0 |
| 107577 | + ){ |
| 107578 | + /* Case 3: We have an inequality comparison against the ROWID field. |
| 108667 | 107579 | */ |
| 108668 | 107580 | int testOp = OP_Noop; |
| 108669 | 107581 | int start; |
| 108670 | 107582 | int memEndValue = 0; |
| 108671 | 107583 | WhereTerm *pStart, *pEnd; |
| 108672 | 107584 | |
| 108673 | 107585 | assert( omitTable==0 ); |
| 108674 | | - pStart = findTerm(pWC, iCur, -1, notReady, WO_GT|WO_GE, 0); |
| 108675 | | - pEnd = findTerm(pWC, iCur, -1, notReady, WO_LT|WO_LE, 0); |
| 107586 | + j = 0; |
| 107587 | + pStart = pEnd = 0; |
| 107588 | + if( pLoop->wsFlags & WHERE_BTM_LIMIT ) pStart = pLoop->aLTerm[j++]; |
| 107589 | + if( pLoop->wsFlags & WHERE_TOP_LIMIT ) pEnd = pLoop->aLTerm[j++]; |
| 107590 | + assert( pStart!=0 || pEnd!=0 ); |
| 108676 | 107591 | if( bRev ){ |
| 108677 | 107592 | pTerm = pStart; |
| 108678 | 107593 | pStart = pEnd; |
| 108679 | 107594 | pEnd = pTerm; |
| 108680 | 107595 | } |
| | @@ -108725,24 +107640,20 @@ |
| 108725 | 107640 | } |
| 108726 | 107641 | start = sqlite3VdbeCurrentAddr(v); |
| 108727 | 107642 | pLevel->op = bRev ? OP_Prev : OP_Next; |
| 108728 | 107643 | pLevel->p1 = iCur; |
| 108729 | 107644 | pLevel->p2 = start; |
| 108730 | | - if( pStart==0 && pEnd==0 ){ |
| 108731 | | - pLevel->p5 = SQLITE_STMTSTATUS_FULLSCAN_STEP; |
| 108732 | | - }else{ |
| 108733 | | - assert( pLevel->p5==0 ); |
| 108734 | | - } |
| 107645 | + assert( pLevel->p5==0 ); |
| 108735 | 107646 | if( testOp!=OP_Noop ){ |
| 108736 | 107647 | iRowidReg = iReleaseReg = sqlite3GetTempReg(pParse); |
| 108737 | 107648 | sqlite3VdbeAddOp2(v, OP_Rowid, iCur, iRowidReg); |
| 108738 | 107649 | sqlite3ExprCacheStore(pParse, iCur, -1, iRowidReg); |
| 108739 | 107650 | sqlite3VdbeAddOp3(v, testOp, memEndValue, addrBrk, iRowidReg); |
| 108740 | 107651 | sqlite3VdbeChangeP5(v, SQLITE_AFF_NUMERIC | SQLITE_JUMPIFNULL); |
| 108741 | 107652 | } |
| 108742 | | - }else if( pLevel->plan.wsFlags & (WHERE_COLUMN_RANGE|WHERE_COLUMN_EQ) ){ |
| 108743 | | - /* Case 3: A scan using an index. |
| 107653 | + }else if( pLoop->wsFlags & WHERE_INDEXED ){ |
| 107654 | + /* Case 4: A scan using an index. |
| 108744 | 107655 | ** |
| 108745 | 107656 | ** The WHERE clause may contain zero or more equality |
| 108746 | 107657 | ** terms ("==" or "IN" operators) that refer to the N |
| 108747 | 107658 | ** left-most columns of the index. It may also contain |
| 108748 | 107659 | ** inequality constraints (>, <, >= or <=) on the indexed |
| | @@ -108784,12 +107695,12 @@ |
| 108784 | 107695 | static const u8 aEndOp[] = { |
| 108785 | 107696 | OP_Noop, /* 0: (!end_constraints) */ |
| 108786 | 107697 | OP_IdxGE, /* 1: (end_constraints && !bRev) */ |
| 108787 | 107698 | OP_IdxLT /* 2: (end_constraints && bRev) */ |
| 108788 | 107699 | }; |
| 108789 | | - int nEq = pLevel->plan.nEq; /* Number of == or IN terms */ |
| 108790 | | - int isMinQuery = 0; /* If this is an optimized SELECT min(x).. */ |
| 107700 | + int nEq = pLoop->u.btree.nEq; /* Number of == or IN terms */ |
| 107701 | + int isMinQuery = 0; /* If this is an optimized SELECT min(x).. */ |
| 108791 | 107702 | int regBase; /* Base register holding constraint values */ |
| 108792 | 107703 | int r1; /* Temp register */ |
| 108793 | 107704 | WhereTerm *pRangeStart = 0; /* Inequality constraint at range start */ |
| 108794 | 107705 | WhereTerm *pRangeEnd = 0; /* Inequality constraint at range end */ |
| 108795 | 107706 | int startEq; /* True if range start uses ==, >= or <= */ |
| | @@ -108801,24 +107712,23 @@ |
| 108801 | 107712 | int nExtraReg = 0; /* Number of extra registers needed */ |
| 108802 | 107713 | int op; /* Instruction opcode */ |
| 108803 | 107714 | char *zStartAff; /* Affinity for start of range constraint */ |
| 108804 | 107715 | char *zEndAff; /* Affinity for end of range constraint */ |
| 108805 | 107716 | |
| 108806 | | - pIdx = pLevel->plan.u.pIdx; |
| 107717 | + pIdx = pLoop->u.btree.pIndex; |
| 108807 | 107718 | iIdxCur = pLevel->iIdxCur; |
| 108808 | | - k = (nEq==pIdx->nColumn ? -1 : pIdx->aiColumn[nEq]); |
| 108809 | 107719 | |
| 108810 | 107720 | /* If this loop satisfies a sort order (pOrderBy) request that |
| 108811 | 107721 | ** was passed to this function to implement a "SELECT min(x) ..." |
| 108812 | 107722 | ** query, then the caller will only allow the loop to run for |
| 108813 | 107723 | ** a single iteration. This means that the first row returned |
| 108814 | 107724 | ** should not have a NULL value stored in 'x'. If column 'x' is |
| 108815 | 107725 | ** the first one after the nEq equality constraints in the index, |
| 108816 | 107726 | ** this requires some special handling. |
| 108817 | 107727 | */ |
| 108818 | | - if( (wctrlFlags&WHERE_ORDERBY_MIN)!=0 |
| 108819 | | - && (pLevel->plan.wsFlags&WHERE_ORDERED) |
| 107728 | + if( (pWInfo->wctrlFlags&WHERE_ORDERBY_MIN)!=0 |
| 107729 | + && (pWInfo->bOBSat!=0) |
| 108820 | 107730 | && (pIdx->nColumn>nEq) |
| 108821 | 107731 | ){ |
| 108822 | 107732 | /* assert( pOrderBy->nExpr==1 ); */ |
| 108823 | 107733 | /* assert( pOrderBy->a[0].pExpr->iColumn==pIdx->aiColumn[nEq] ); */ |
| 108824 | 107734 | isMinQuery = 1; |
| | @@ -108826,26 +107736,25 @@ |
| 108826 | 107736 | } |
| 108827 | 107737 | |
| 108828 | 107738 | /* Find any inequality constraint terms for the start and end |
| 108829 | 107739 | ** of the range. |
| 108830 | 107740 | */ |
| 108831 | | - if( pLevel->plan.wsFlags & WHERE_TOP_LIMIT ){ |
| 108832 | | - pRangeEnd = findTerm(pWC, iCur, k, notReady, (WO_LT|WO_LE), pIdx); |
| 107741 | + j = nEq; |
| 107742 | + if( pLoop->wsFlags & WHERE_BTM_LIMIT ){ |
| 107743 | + pRangeStart = pLoop->aLTerm[j++]; |
| 108833 | 107744 | nExtraReg = 1; |
| 108834 | 107745 | } |
| 108835 | | - if( pLevel->plan.wsFlags & WHERE_BTM_LIMIT ){ |
| 108836 | | - pRangeStart = findTerm(pWC, iCur, k, notReady, (WO_GT|WO_GE), pIdx); |
| 107746 | + if( pLoop->wsFlags & WHERE_TOP_LIMIT ){ |
| 107747 | + pRangeEnd = pLoop->aLTerm[j++]; |
| 108837 | 107748 | nExtraReg = 1; |
| 108838 | 107749 | } |
| 108839 | 107750 | |
| 108840 | 107751 | /* Generate code to evaluate all constraint terms using == or IN |
| 108841 | 107752 | ** and store the values of those terms in an array of registers |
| 108842 | 107753 | ** starting at regBase. |
| 108843 | 107754 | */ |
| 108844 | | - regBase = codeAllEqualityTerms( |
| 108845 | | - pParse, pLevel, pWC, notReady, nExtraReg, &zStartAff |
| 108846 | | - ); |
| 107755 | + regBase = codeAllEqualityTerms(pParse,pLevel,bRev,nExtraReg,&zStartAff); |
| 108847 | 107756 | zEndAff = sqlite3DbStrDup(pParse->db, zStartAff); |
| 108848 | 107757 | addrNxt = pLevel->addrNxt; |
| 108849 | 107758 | |
| 108850 | 107759 | /* If we are doing a reverse order scan on an ascending index, or |
| 108851 | 107760 | ** a forward order scan on a descending index, interchange the |
| | @@ -108855,14 +107764,14 @@ |
| 108855 | 107764 | || (bRev && pIdx->nColumn==nEq) |
| 108856 | 107765 | ){ |
| 108857 | 107766 | SWAP(WhereTerm *, pRangeEnd, pRangeStart); |
| 108858 | 107767 | } |
| 108859 | 107768 | |
| 108860 | | - testcase( pRangeStart && pRangeStart->eOperator & WO_LE ); |
| 108861 | | - testcase( pRangeStart && pRangeStart->eOperator & WO_GE ); |
| 108862 | | - testcase( pRangeEnd && pRangeEnd->eOperator & WO_LE ); |
| 108863 | | - testcase( pRangeEnd && pRangeEnd->eOperator & WO_GE ); |
| 107769 | + testcase( pRangeStart && (pRangeStart->eOperator & WO_LE)!=0 ); |
| 107770 | + testcase( pRangeStart && (pRangeStart->eOperator & WO_GE)!=0 ); |
| 107771 | + testcase( pRangeEnd && (pRangeEnd->eOperator & WO_LE)!=0 ); |
| 107772 | + testcase( pRangeEnd && (pRangeEnd->eOperator & WO_GE)!=0 ); |
| 108864 | 107773 | startEq = !pRangeStart || pRangeStart->eOperator & (WO_LE|WO_GE); |
| 108865 | 107774 | endEq = !pRangeEnd || pRangeEnd->eOperator & (WO_LE|WO_GE); |
| 108866 | 107775 | start_constraints = pRangeStart || nEq>0; |
| 108867 | 107776 | |
| 108868 | 107777 | /* Seek the index cursor to the start of the range. */ |
| | @@ -108948,13 +107857,13 @@ |
| 108948 | 107857 | /* If there are inequality constraints, check that the value |
| 108949 | 107858 | ** of the table column that the inequality contrains is not NULL. |
| 108950 | 107859 | ** If it is, jump to the next iteration of the loop. |
| 108951 | 107860 | */ |
| 108952 | 107861 | r1 = sqlite3GetTempReg(pParse); |
| 108953 | | - testcase( pLevel->plan.wsFlags & WHERE_BTM_LIMIT ); |
| 108954 | | - testcase( pLevel->plan.wsFlags & WHERE_TOP_LIMIT ); |
| 108955 | | - if( (pLevel->plan.wsFlags & (WHERE_BTM_LIMIT|WHERE_TOP_LIMIT))!=0 ){ |
| 107862 | + testcase( pLoop->wsFlags & WHERE_BTM_LIMIT ); |
| 107863 | + testcase( pLoop->wsFlags & WHERE_TOP_LIMIT ); |
| 107864 | + if( (pLoop->wsFlags & (WHERE_BTM_LIMIT|WHERE_TOP_LIMIT))!=0 ){ |
| 108956 | 107865 | sqlite3VdbeAddOp3(v, OP_Column, iIdxCur, nEq, r1); |
| 108957 | 107866 | sqlite3VdbeAddOp2(v, OP_IsNull, r1, addrCont); |
| 108958 | 107867 | } |
| 108959 | 107868 | sqlite3ReleaseTempReg(pParse, r1); |
| 108960 | 107869 | |
| | @@ -108969,28 +107878,28 @@ |
| 108969 | 107878 | } |
| 108970 | 107879 | |
| 108971 | 107880 | /* Record the instruction used to terminate the loop. Disable |
| 108972 | 107881 | ** WHERE clause terms made redundant by the index range scan. |
| 108973 | 107882 | */ |
| 108974 | | - if( pLevel->plan.wsFlags & WHERE_UNIQUE ){ |
| 107883 | + if( pLoop->wsFlags & WHERE_ONEROW ){ |
| 108975 | 107884 | pLevel->op = OP_Noop; |
| 108976 | 107885 | }else if( bRev ){ |
| 108977 | 107886 | pLevel->op = OP_Prev; |
| 108978 | 107887 | }else{ |
| 108979 | 107888 | pLevel->op = OP_Next; |
| 108980 | 107889 | } |
| 108981 | 107890 | pLevel->p1 = iIdxCur; |
| 108982 | | - if( pLevel->plan.wsFlags & WHERE_COVER_SCAN ){ |
| 107891 | + if( (pLoop->wsFlags & WHERE_CONSTRAINT)==0 ){ |
| 108983 | 107892 | pLevel->p5 = SQLITE_STMTSTATUS_FULLSCAN_STEP; |
| 108984 | 107893 | }else{ |
| 108985 | 107894 | assert( pLevel->p5==0 ); |
| 108986 | 107895 | } |
| 108987 | 107896 | }else |
| 108988 | 107897 | |
| 108989 | 107898 | #ifndef SQLITE_OMIT_OR_OPTIMIZATION |
| 108990 | | - if( pLevel->plan.wsFlags & WHERE_MULTI_OR ){ |
| 108991 | | - /* Case 4: Two or more separately indexed terms connected by OR |
| 107899 | + if( pLoop->wsFlags & WHERE_MULTI_OR ){ |
| 107900 | + /* Case 5: Two or more separately indexed terms connected by OR |
| 108992 | 107901 | ** |
| 108993 | 107902 | ** Example: |
| 108994 | 107903 | ** |
| 108995 | 107904 | ** CREATE TABLE t1(a,b,c,d); |
| 108996 | 107905 | ** CREATE INDEX i1 ON t1(a); |
| | @@ -109039,11 +107948,11 @@ |
| 109039 | 107948 | int iRetInit; /* Address of regReturn init */ |
| 109040 | 107949 | int untestedTerms = 0; /* Some terms not completely tested */ |
| 109041 | 107950 | int ii; /* Loop counter */ |
| 109042 | 107951 | Expr *pAndExpr = 0; /* An ".. AND (...)" expression */ |
| 109043 | 107952 | |
| 109044 | | - pTerm = pLevel->plan.u.pTerm; |
| 107953 | + pTerm = pLoop->aLTerm[0]; |
| 109045 | 107954 | assert( pTerm!=0 ); |
| 109046 | 107955 | assert( pTerm->eOperator & WO_OR ); |
| 109047 | 107956 | assert( (pTerm->wtFlags & TERM_ORINFO)!=0 ); |
| 109048 | 107957 | pOrWc = &pTerm->u.pOrInfo->wc; |
| 109049 | 107958 | pLevel->op = OP_Return; |
| | @@ -109058,11 +107967,11 @@ |
| 109058 | 107967 | struct SrcList_item *origSrc; /* Original list of tables */ |
| 109059 | 107968 | nNotReady = pWInfo->nLevel - iLevel - 1; |
| 109060 | 107969 | pOrTab = sqlite3StackAllocRaw(pParse->db, |
| 109061 | 107970 | sizeof(*pOrTab)+ nNotReady*sizeof(pOrTab->a[0])); |
| 109062 | 107971 | if( pOrTab==0 ) return notReady; |
| 109063 | | - pOrTab->nAlloc = (i16)(nNotReady + 1); |
| 107972 | + pOrTab->nAlloc = (u8)(nNotReady + 1); |
| 109064 | 107973 | pOrTab->nSrc = pOrTab->nAlloc; |
| 109065 | 107974 | memcpy(pOrTab->a, pTabItem, sizeof(*pTabItem)); |
| 109066 | 107975 | origSrc = pWInfo->pTabList->a; |
| 109067 | 107976 | for(k=1; k<=nNotReady; k++){ |
| 109068 | 107977 | memcpy(&pOrTab->a[k], &origSrc[pLevel[k].iFrom], sizeof(pOrTab->a[k])); |
| | @@ -109080,11 +107989,11 @@ |
| 109080 | 107989 | ** over the top of the loop into the body of it. In this case the |
| 109081 | 107990 | ** correct response for the end-of-loop code (the OP_Return) is to |
| 109082 | 107991 | ** fall through to the next instruction, just as an OP_Next does if |
| 109083 | 107992 | ** called on an uninitialized cursor. |
| 109084 | 107993 | */ |
| 109085 | | - if( (wctrlFlags & WHERE_DUPLICATES_OK)==0 ){ |
| 107994 | + if( (pWInfo->wctrlFlags & WHERE_DUPLICATES_OK)==0 ){ |
| 109086 | 107995 | regRowset = ++pParse->nMem; |
| 109087 | 107996 | regRowid = ++pParse->nMem; |
| 109088 | 107997 | sqlite3VdbeAddOp2(v, OP_Null, 0, regRowset); |
| 109089 | 107998 | } |
| 109090 | 107999 | iRetInit = sqlite3VdbeAddOp2(v, OP_Integer, 0, regReturn); |
| | @@ -109131,15 +108040,15 @@ |
| 109131 | 108040 | pSubWInfo = sqlite3WhereBegin(pParse, pOrTab, pOrExpr, 0, 0, |
| 109132 | 108041 | WHERE_OMIT_OPEN_CLOSE | WHERE_AND_ONLY | |
| 109133 | 108042 | WHERE_FORCE_TABLE | WHERE_ONETABLE_ONLY, iCovCur); |
| 109134 | 108043 | assert( pSubWInfo || pParse->nErr || pParse->db->mallocFailed ); |
| 109135 | 108044 | if( pSubWInfo ){ |
| 109136 | | - WhereLevel *pLvl; |
| 108045 | + WhereLoop *pSubLoop; |
| 109137 | 108046 | explainOneScan( |
| 109138 | 108047 | pParse, pOrTab, &pSubWInfo->a[0], iLevel, pLevel->iFrom, 0 |
| 109139 | 108048 | ); |
| 109140 | | - if( (wctrlFlags & WHERE_DUPLICATES_OK)==0 ){ |
| 108049 | + if( (pWInfo->wctrlFlags & WHERE_DUPLICATES_OK)==0 ){ |
| 109141 | 108050 | int iSet = ((ii==pOrWc->nTerm-1)?-1:ii); |
| 109142 | 108051 | int r; |
| 109143 | 108052 | r = sqlite3ExprCodeGetColumn(pParse, pTabItem->pTab, -1, iCur, |
| 109144 | 108053 | regRowid, 0); |
| 109145 | 108054 | sqlite3VdbeAddOp4Int(v, OP_RowSetTest, regRowset, |
| | @@ -109164,17 +108073,17 @@ |
| 109164 | 108073 | ** processed or the index is the same as that used by all previous |
| 109165 | 108074 | ** terms, set pCov to the candidate covering index. Otherwise, set |
| 109166 | 108075 | ** pCov to NULL to indicate that no candidate covering index will |
| 109167 | 108076 | ** be available. |
| 109168 | 108077 | */ |
| 109169 | | - pLvl = &pSubWInfo->a[0]; |
| 109170 | | - if( (pLvl->plan.wsFlags & WHERE_INDEXED)!=0 |
| 109171 | | - && (pLvl->plan.wsFlags & WHERE_TEMP_INDEX)==0 |
| 109172 | | - && (ii==0 || pLvl->plan.u.pIdx==pCov) |
| 108078 | + pSubLoop = pSubWInfo->a[0].pWLoop; |
| 108079 | + assert( (pSubLoop->wsFlags & WHERE_TEMP_INDEX)==0 ); |
| 108080 | + if( (pSubLoop->wsFlags & WHERE_INDEXED)!=0 |
| 108081 | + && (ii==0 || pSubLoop->u.btree.pIndex==pCov) |
| 109173 | 108082 | ){ |
| 109174 | | - assert( pLvl->iIdxCur==iCovCur ); |
| 109175 | | - pCov = pLvl->plan.u.pIdx; |
| 108083 | + assert( pSubWInfo->a[0].iIdxCur==iCovCur ); |
| 108084 | + pCov = pSubLoop->u.btree.pIndex; |
| 109176 | 108085 | }else{ |
| 109177 | 108086 | pCov = 0; |
| 109178 | 108087 | } |
| 109179 | 108088 | |
| 109180 | 108089 | /* Finish the loop through table entries that match term pOrTerm. */ |
| | @@ -109196,23 +108105,22 @@ |
| 109196 | 108105 | if( !untestedTerms ) disableTerm(pLevel, pTerm); |
| 109197 | 108106 | }else |
| 109198 | 108107 | #endif /* SQLITE_OMIT_OR_OPTIMIZATION */ |
| 109199 | 108108 | |
| 109200 | 108109 | { |
| 109201 | | - /* Case 5: There is no usable index. We must do a complete |
| 108110 | + /* Case 6: There is no usable index. We must do a complete |
| 109202 | 108111 | ** scan of the entire table. |
| 109203 | 108112 | */ |
| 109204 | 108113 | static const u8 aStep[] = { OP_Next, OP_Prev }; |
| 109205 | 108114 | static const u8 aStart[] = { OP_Rewind, OP_Last }; |
| 109206 | 108115 | assert( bRev==0 || bRev==1 ); |
| 109207 | | - assert( omitTable==0 ); |
| 109208 | 108116 | pLevel->op = aStep[bRev]; |
| 109209 | 108117 | pLevel->p1 = iCur; |
| 109210 | 108118 | pLevel->p2 = 1 + sqlite3VdbeAddOp2(v, aStart[bRev], iCur, addrBrk); |
| 109211 | 108119 | pLevel->p5 = SQLITE_STMTSTATUS_FULLSCAN_STEP; |
| 109212 | 108120 | } |
| 109213 | | - newNotReady = notReady & ~getMask(pWC->pMaskSet, iCur); |
| 108121 | + newNotReady = notReady & ~getMask(&pWInfo->sMaskSet, iCur); |
| 109214 | 108122 | |
| 109215 | 108123 | /* Insert code to test every subexpression that can be completely |
| 109216 | 108124 | ** computed using the current set of tables. |
| 109217 | 108125 | ** |
| 109218 | 108126 | ** IMPLEMENTATION-OF: R-49525-50935 Terms that cannot be satisfied through |
| | @@ -109258,10 +108166,12 @@ |
| 109258 | 108166 | assert( !ExprHasProperty(pE, EP_FromJoin) ); |
| 109259 | 108167 | assert( (pTerm->prereqRight & newNotReady)!=0 ); |
| 109260 | 108168 | pAlt = findTerm(pWC, iCur, pTerm->u.leftColumn, notReady, WO_EQ|WO_IN, 0); |
| 109261 | 108169 | if( pAlt==0 ) continue; |
| 109262 | 108170 | if( pAlt->wtFlags & (TERM_CODED) ) continue; |
| 108171 | + testcase( pAlt->eOperator & WO_EQ ); |
| 108172 | + testcase( pAlt->eOperator & WO_IN ); |
| 109263 | 108173 | VdbeNoopComment((v, "begin transitive constraint")); |
| 109264 | 108174 | sEq = *pAlt->pExpr; |
| 109265 | 108175 | sEq.pLeft = pE->pLeft; |
| 109266 | 108176 | sqlite3ExprIfFalse(pParse, &sEq, addrCont, SQLITE_JUMPIFNULL); |
| 109267 | 108177 | } |
| | @@ -109290,51 +108200,1562 @@ |
| 109290 | 108200 | sqlite3ReleaseTempReg(pParse, iReleaseReg); |
| 109291 | 108201 | |
| 109292 | 108202 | return newNotReady; |
| 109293 | 108203 | } |
| 109294 | 108204 | |
| 109295 | | -#if defined(SQLITE_TEST) |
| 108205 | +#ifdef WHERETRACE_ENABLED |
| 109296 | 108206 | /* |
| 109297 | | -** The following variable holds a text description of query plan generated |
| 109298 | | -** by the most recent call to sqlite3WhereBegin(). Each call to WhereBegin |
| 109299 | | -** overwrites the previous. This information is used for testing and |
| 109300 | | -** analysis only. |
| 108207 | +** Print a WhereLoop object for debugging purposes |
| 109301 | 108208 | */ |
| 109302 | | -SQLITE_API char sqlite3_query_plan[BMS*2*40]; /* Text of the join */ |
| 109303 | | -static int nQPlan = 0; /* Next free slow in _query_plan[] */ |
| 108209 | +static void whereLoopPrint(WhereLoop *p, SrcList *pTabList){ |
| 108210 | + int nb = 1+(pTabList->nSrc+7)/8; |
| 108211 | + struct SrcList_item *pItem = pTabList->a + p->iTab; |
| 108212 | + Table *pTab = pItem->pTab; |
| 108213 | + sqlite3DebugPrintf("%c %2d.%0*llx.%0*llx", p->cId, |
| 108214 | + p->iTab, nb, p->maskSelf, nb, p->prereq); |
| 108215 | + sqlite3DebugPrintf(" %8s", |
| 108216 | + pItem->zAlias ? pItem->zAlias : pTab->zName); |
| 108217 | + if( (p->wsFlags & WHERE_VIRTUALTABLE)==0 ){ |
| 108218 | + if( p->u.btree.pIndex ){ |
| 108219 | + const char *zName = p->u.btree.pIndex->zName; |
| 108220 | + if( zName==0 ) zName = "ipk"; |
| 108221 | + if( strncmp(zName, "sqlite_autoindex_", 17)==0 ){ |
| 108222 | + int i = sqlite3Strlen30(zName) - 1; |
| 108223 | + while( zName[i]!='_' ) i--; |
| 108224 | + zName += i; |
| 108225 | + } |
| 108226 | + sqlite3DebugPrintf(".%-12s %2d", zName, p->u.btree.nEq); |
| 108227 | + }else{ |
| 108228 | + sqlite3DebugPrintf("%16s",""); |
| 108229 | + } |
| 108230 | + }else{ |
| 108231 | + char *z; |
| 108232 | + if( p->u.vtab.idxStr ){ |
| 108233 | + z = sqlite3_mprintf("(%d,\"%s\",%x)", |
| 108234 | + p->u.vtab.idxNum, p->u.vtab.idxStr, p->u.vtab.omitMask); |
| 108235 | + }else{ |
| 108236 | + z = sqlite3_mprintf("(%d,%x)", p->u.vtab.idxNum, p->u.vtab.omitMask); |
| 108237 | + } |
| 108238 | + sqlite3DebugPrintf(" %-15s", z); |
| 108239 | + sqlite3_free(z); |
| 108240 | + } |
| 108241 | + sqlite3DebugPrintf(" fg %05x N %d", p->wsFlags, p->nLTerm); |
| 108242 | + sqlite3DebugPrintf(" cost %d,%d,%d\n", p->rSetup, p->rRun, p->nOut); |
| 108243 | +} |
| 108244 | +#endif |
| 109304 | 108245 | |
| 109305 | | -#endif /* SQLITE_TEST */ |
| 108246 | +/* |
| 108247 | +** Convert bulk memory into a valid WhereLoop that can be passed |
| 108248 | +** to whereLoopClear harmlessly. |
| 108249 | +*/ |
| 108250 | +static void whereLoopInit(WhereLoop *p){ |
| 108251 | + p->aLTerm = p->aLTermSpace; |
| 108252 | + p->nLTerm = 0; |
| 108253 | + p->nLSlot = ArraySize(p->aLTermSpace); |
| 108254 | + p->wsFlags = 0; |
| 108255 | +} |
| 109306 | 108256 | |
| 108257 | +/* |
| 108258 | +** Clear the WhereLoop.u union. Leave WhereLoop.pLTerm intact. |
| 108259 | +*/ |
| 108260 | +static void whereLoopClearUnion(sqlite3 *db, WhereLoop *p){ |
| 108261 | + if( p->wsFlags & (WHERE_VIRTUALTABLE|WHERE_TEMP_INDEX) ){ |
| 108262 | + if( (p->wsFlags & WHERE_VIRTUALTABLE)!=0 && p->u.vtab.needFree ){ |
| 108263 | + sqlite3_free(p->u.vtab.idxStr); |
| 108264 | + p->u.vtab.needFree = 0; |
| 108265 | + p->u.vtab.idxStr = 0; |
| 108266 | + }else if( (p->wsFlags & WHERE_TEMP_INDEX)!=0 && p->u.btree.pIndex!=0 ){ |
| 108267 | + sqlite3DbFree(db, p->u.btree.pIndex->zColAff); |
| 108268 | + sqlite3DbFree(db, p->u.btree.pIndex); |
| 108269 | + p->u.btree.pIndex = 0; |
| 108270 | + } |
| 108271 | + } |
| 108272 | +} |
| 108273 | + |
| 108274 | +/* |
| 108275 | +** Deallocate internal memory used by a WhereLoop object |
| 108276 | +*/ |
| 108277 | +static void whereLoopClear(sqlite3 *db, WhereLoop *p){ |
| 108278 | + if( p->aLTerm!=p->aLTermSpace ) sqlite3DbFree(db, p->aLTerm); |
| 108279 | + whereLoopClearUnion(db, p); |
| 108280 | + whereLoopInit(p); |
| 108281 | +} |
| 108282 | + |
| 108283 | +/* |
| 108284 | +** Increase the memory allocation for pLoop->aLTerm[] to be at least n. |
| 108285 | +*/ |
| 108286 | +static int whereLoopResize(sqlite3 *db, WhereLoop *p, int n){ |
| 108287 | + WhereTerm **paNew; |
| 108288 | + if( p->nLSlot>=n ) return SQLITE_OK; |
| 108289 | + n = (n+7)&~7; |
| 108290 | + paNew = sqlite3DbMallocRaw(db, sizeof(p->aLTerm[0])*n); |
| 108291 | + if( paNew==0 ) return SQLITE_NOMEM; |
| 108292 | + memcpy(paNew, p->aLTerm, sizeof(p->aLTerm[0])*p->nLSlot); |
| 108293 | + if( p->aLTerm!=p->aLTermSpace ) sqlite3DbFree(db, p->aLTerm); |
| 108294 | + p->aLTerm = paNew; |
| 108295 | + p->nLSlot = n; |
| 108296 | + return SQLITE_OK; |
| 108297 | +} |
| 108298 | + |
| 108299 | +/* |
| 108300 | +** Transfer content from the second pLoop into the first. |
| 108301 | +*/ |
| 108302 | +static int whereLoopXfer(sqlite3 *db, WhereLoop *pTo, WhereLoop *pFrom){ |
| 108303 | + if( whereLoopResize(db, pTo, pFrom->nLTerm) ) return SQLITE_NOMEM; |
| 108304 | + whereLoopClearUnion(db, pTo); |
| 108305 | + memcpy(pTo, pFrom, WHERE_LOOP_XFER_SZ); |
| 108306 | + memcpy(pTo->aLTerm, pFrom->aLTerm, pTo->nLTerm*sizeof(pTo->aLTerm[0])); |
| 108307 | + if( pFrom->wsFlags & WHERE_VIRTUALTABLE ){ |
| 108308 | + pFrom->u.vtab.needFree = 0; |
| 108309 | + }else if( (pFrom->wsFlags & WHERE_TEMP_INDEX)!=0 ){ |
| 108310 | + pFrom->u.btree.pIndex = 0; |
| 108311 | + } |
| 108312 | + return SQLITE_OK; |
| 108313 | +} |
| 108314 | + |
| 108315 | +/* |
| 108316 | +** Delete a WhereLoop object |
| 108317 | +*/ |
| 108318 | +static void whereLoopDelete(sqlite3 *db, WhereLoop *p){ |
| 108319 | + whereLoopClear(db, p); |
| 108320 | + sqlite3DbFree(db, p); |
| 108321 | +} |
| 109307 | 108322 | |
| 109308 | 108323 | /* |
| 109309 | 108324 | ** Free a WhereInfo structure |
| 109310 | 108325 | */ |
| 109311 | 108326 | static void whereInfoFree(sqlite3 *db, WhereInfo *pWInfo){ |
| 109312 | 108327 | if( ALWAYS(pWInfo) ){ |
| 109313 | | - int i; |
| 109314 | | - for(i=0; i<pWInfo->nLevel; i++){ |
| 109315 | | - sqlite3_index_info *pInfo = pWInfo->a[i].pIdxInfo; |
| 109316 | | - if( pInfo ){ |
| 109317 | | - /* assert( pInfo->needToFreeIdxStr==0 || db->mallocFailed ); */ |
| 109318 | | - if( pInfo->needToFreeIdxStr ){ |
| 109319 | | - sqlite3_free(pInfo->idxStr); |
| 109320 | | - } |
| 109321 | | - sqlite3DbFree(db, pInfo); |
| 109322 | | - } |
| 109323 | | - if( pWInfo->a[i].plan.wsFlags & WHERE_TEMP_INDEX ){ |
| 109324 | | - Index *pIdx = pWInfo->a[i].plan.u.pIdx; |
| 109325 | | - if( pIdx ){ |
| 109326 | | - sqlite3DbFree(db, pIdx->zColAff); |
| 109327 | | - sqlite3DbFree(db, pIdx); |
| 109328 | | - } |
| 109329 | | - } |
| 109330 | | - } |
| 109331 | | - whereClauseClear(pWInfo->pWC); |
| 108328 | + whereClauseClear(&pWInfo->sWC); |
| 108329 | + while( pWInfo->pLoops ){ |
| 108330 | + WhereLoop *p = pWInfo->pLoops; |
| 108331 | + pWInfo->pLoops = p->pNextLoop; |
| 108332 | + whereLoopDelete(db, p); |
| 108333 | + } |
| 109332 | 108334 | sqlite3DbFree(db, pWInfo); |
| 109333 | 108335 | } |
| 109334 | 108336 | } |
| 109335 | 108337 | |
| 108338 | +/* |
| 108339 | +** Insert or replace a WhereLoop entry using the template supplied. |
| 108340 | +** |
| 108341 | +** An existing WhereLoop entry might be overwritten if the new template |
| 108342 | +** is better and has fewer dependencies. Or the template will be ignored |
| 108343 | +** and no insert will occur if an existing WhereLoop is faster and has |
| 108344 | +** fewer dependencies than the template. Otherwise a new WhereLoop is |
| 108345 | +** added based on the template. |
| 108346 | +** |
| 108347 | +** If pBuilder->pBest is not NULL then we only care about the very |
| 108348 | +** best template and that template should be stored in pBuilder->pBest. |
| 108349 | +** If pBuilder->pBest is NULL then a list of the best templates are stored |
| 108350 | +** in pBuilder->pWInfo->pLoops. |
| 108351 | +** |
| 108352 | +** When accumulating multiple loops (when pBuilder->pBest is NULL) we |
| 108353 | +** still might overwrite similar loops with the new template if the |
| 108354 | +** template is better. Loops may be overwritten if the following |
| 108355 | +** conditions are met: |
| 108356 | +** |
| 108357 | +** (1) They have the same iTab. |
| 108358 | +** (2) They have the same iSortIdx. |
| 108359 | +** (3) The template has same or fewer dependencies than the current loop |
| 108360 | +** (4) The template has the same or lower cost than the current loop |
| 108361 | +** (5) The template uses more terms of the same index but has no additional |
| 108362 | +** dependencies |
| 108363 | +*/ |
| 108364 | +static int whereLoopInsert(WhereLoopBuilder *pBuilder, WhereLoop *pTemplate){ |
| 108365 | + WhereLoop **ppPrev, *p, *pNext = 0; |
| 108366 | + WhereInfo *pWInfo = pBuilder->pWInfo; |
| 108367 | + sqlite3 *db = pWInfo->pParse->db; |
| 108368 | + |
| 108369 | + /* If pBuilder->pBest is defined, then only keep track of the single |
| 108370 | + ** best WhereLoop. pBuilder->pBest->maskSelf==0 indicates that no |
| 108371 | + ** prior WhereLoops have been evaluated and that the current pTemplate |
| 108372 | + ** is therefore the first and hence the best and should be retained. |
| 108373 | + */ |
| 108374 | + if( (p = pBuilder->pBest)!=0 ){ |
| 108375 | + if( p->maskSelf!=0 ){ |
| 108376 | + WhereCost rCost = whereCostAdd(p->rRun,p->rSetup); |
| 108377 | + WhereCost rTemplate = whereCostAdd(pTemplate->rRun,pTemplate->rSetup); |
| 108378 | + if( rCost < rTemplate ){ |
| 108379 | + testcase( rCost==rTemplate-1 ); |
| 108380 | + goto whereLoopInsert_noop; |
| 108381 | + } |
| 108382 | + if( rCost==rTemplate && (p->prereq & pTemplate->prereq)==p->prereq ){ |
| 108383 | + goto whereLoopInsert_noop; |
| 108384 | + } |
| 108385 | + } |
| 108386 | +#if WHERETRACE_ENABLED |
| 108387 | + if( sqlite3WhereTrace & 0x8 ){ |
| 108388 | + sqlite3DebugPrintf(p->maskSelf==0 ? "ins-init: " : "ins-best: "); |
| 108389 | + whereLoopPrint(pTemplate, pWInfo->pTabList); |
| 108390 | + } |
| 108391 | +#endif |
| 108392 | + whereLoopXfer(db, p, pTemplate); |
| 108393 | + return SQLITE_OK; |
| 108394 | + } |
| 108395 | + |
| 108396 | + /* Search for an existing WhereLoop to overwrite, or which takes |
| 108397 | + ** priority over pTemplate. |
| 108398 | + */ |
| 108399 | + for(ppPrev=&pWInfo->pLoops, p=*ppPrev; p; ppPrev=&p->pNextLoop, p=*ppPrev){ |
| 108400 | + if( p->iTab!=pTemplate->iTab || p->iSortIdx!=pTemplate->iSortIdx ){ |
| 108401 | + /* If either the iTab or iSortIdx values for two WhereLoop are different |
| 108402 | + ** then those WhereLoops need to be considered separately. Neither is |
| 108403 | + ** a candidate to replace the other. */ |
| 108404 | + continue; |
| 108405 | + } |
| 108406 | + /* In the current implementation, the rSetup value is either zero |
| 108407 | + ** or the cost of building an automatic index (NlogN) and the NlogN |
| 108408 | + ** is the same for compatible WhereLoops. */ |
| 108409 | + assert( p->rSetup==0 || pTemplate->rSetup==0 |
| 108410 | + || p->rSetup==pTemplate->rSetup ); |
| 108411 | + |
| 108412 | + /* whereLoopAddBtree() always generates and inserts the automatic index |
| 108413 | + ** case first. Hence compatible candidate WhereLoops never have a larger |
| 108414 | + ** rSetup. Call this SETUP-INVARIANT */ |
| 108415 | + assert( p->rSetup>=pTemplate->rSetup ); |
| 108416 | + |
| 108417 | + if( (p->prereq & pTemplate->prereq)==p->prereq |
| 108418 | + && p->rSetup<=pTemplate->rSetup |
| 108419 | + && p->rRun<=pTemplate->rRun |
| 108420 | + ){ |
| 108421 | + /* This branch taken when p is equal or better than pTemplate in |
| 108422 | + ** all of (1) dependences (2) setup-cost, and (3) run-cost. */ |
| 108423 | + assert( p->rSetup==pTemplate->rSetup ); |
| 108424 | + if( p->nLTerm<pTemplate->nLTerm |
| 108425 | + && (p->wsFlags & WHERE_INDEXED)!=0 |
| 108426 | + && (pTemplate->wsFlags & WHERE_INDEXED)!=0 |
| 108427 | + && p->u.btree.pIndex==pTemplate->u.btree.pIndex |
| 108428 | + && p->prereq==pTemplate->prereq |
| 108429 | + ){ |
| 108430 | + /* Overwrite an existing WhereLoop with an similar one that uses |
| 108431 | + ** more terms of the index */ |
| 108432 | + pNext = p->pNextLoop; |
| 108433 | + break; |
| 108434 | + }else{ |
| 108435 | + /* pTemplate is not helpful. |
| 108436 | + ** Return without changing or adding anything */ |
| 108437 | + goto whereLoopInsert_noop; |
| 108438 | + } |
| 108439 | + } |
| 108440 | + if( (p->prereq & pTemplate->prereq)==pTemplate->prereq |
| 108441 | + && p->rRun>=pTemplate->rRun |
| 108442 | + && ALWAYS(p->rSetup>=pTemplate->rSetup) /* See SETUP-INVARIANT above */ |
| 108443 | + ){ |
| 108444 | + /* Overwrite an existing WhereLoop with a better one: one that is |
| 108445 | + ** better at one of (1) dependences, (2) setup-cost, or (3) run-cost |
| 108446 | + ** and is no worse in any of those categories. */ |
| 108447 | + pNext = p->pNextLoop; |
| 108448 | + break; |
| 108449 | + } |
| 108450 | + } |
| 108451 | + |
| 108452 | + /* If we reach this point it means that either p[] should be overwritten |
| 108453 | + ** with pTemplate[] if p[] exists, or if p==NULL then allocate a new |
| 108454 | + ** WhereLoop and insert it. |
| 108455 | + */ |
| 108456 | +#if WHERETRACE_ENABLED |
| 108457 | + if( sqlite3WhereTrace & 0x8 ){ |
| 108458 | + if( p!=0 ){ |
| 108459 | + sqlite3DebugPrintf("ins-del: "); |
| 108460 | + whereLoopPrint(p, pWInfo->pTabList); |
| 108461 | + } |
| 108462 | + sqlite3DebugPrintf("ins-new: "); |
| 108463 | + whereLoopPrint(pTemplate, pWInfo->pTabList); |
| 108464 | + } |
| 108465 | +#endif |
| 108466 | + if( p==0 ){ |
| 108467 | + p = sqlite3DbMallocRaw(db, sizeof(WhereLoop)); |
| 108468 | + if( p==0 ) return SQLITE_NOMEM; |
| 108469 | + whereLoopInit(p); |
| 108470 | + } |
| 108471 | + whereLoopXfer(db, p, pTemplate); |
| 108472 | + p->pNextLoop = pNext; |
| 108473 | + *ppPrev = p; |
| 108474 | + if( (p->wsFlags & WHERE_VIRTUALTABLE)==0 ){ |
| 108475 | + Index *pIndex = p->u.btree.pIndex; |
| 108476 | + if( pIndex && pIndex->tnum==0 ){ |
| 108477 | + p->u.btree.pIndex = 0; |
| 108478 | + } |
| 108479 | + } |
| 108480 | + return SQLITE_OK; |
| 108481 | + |
| 108482 | + /* Jump here if the insert is a no-op */ |
| 108483 | +whereLoopInsert_noop: |
| 108484 | +#if WHERETRACE_ENABLED |
| 108485 | + if( sqlite3WhereTrace & 0x8 ){ |
| 108486 | + sqlite3DebugPrintf(pBuilder->pBest ? "ins-skip: " : "ins-noop: "); |
| 108487 | + whereLoopPrint(pTemplate, pWInfo->pTabList); |
| 108488 | + } |
| 108489 | +#endif |
| 108490 | + return SQLITE_OK; |
| 108491 | +} |
| 108492 | + |
| 108493 | +/* |
| 108494 | +** We have so far matched pBuilder->pNew->u.btree.nEq terms of the index pIndex. |
| 108495 | +** Try to match one more. |
| 108496 | +** |
| 108497 | +** If pProbe->tnum==0, that means pIndex is a fake index used for the |
| 108498 | +** INTEGER PRIMARY KEY. |
| 108499 | +*/ |
| 108500 | +static int whereLoopAddBtreeIndex( |
| 108501 | + WhereLoopBuilder *pBuilder, /* The WhereLoop factory */ |
| 108502 | + struct SrcList_item *pSrc, /* FROM clause term being analyzed */ |
| 108503 | + Index *pProbe, /* An index on pSrc */ |
| 108504 | + WhereCost nInMul /* log(Number of iterations due to IN) */ |
| 108505 | +){ |
| 108506 | + WhereInfo *pWInfo = pBuilder->pWInfo; /* WHERE analyse context */ |
| 108507 | + Parse *pParse = pWInfo->pParse; /* Parsing context */ |
| 108508 | + sqlite3 *db = pParse->db; /* Database connection malloc context */ |
| 108509 | + WhereLoop *pNew; /* Template WhereLoop under construction */ |
| 108510 | + WhereTerm *pTerm; /* A WhereTerm under consideration */ |
| 108511 | + int opMask; /* Valid operators for constraints */ |
| 108512 | + WhereScan scan; /* Iterator for WHERE terms */ |
| 108513 | + Bitmask saved_prereq; /* Original value of pNew->prereq */ |
| 108514 | + u16 saved_nLTerm; /* Original value of pNew->nLTerm */ |
| 108515 | + int saved_nEq; /* Original value of pNew->u.btree.nEq */ |
| 108516 | + u32 saved_wsFlags; /* Original value of pNew->wsFlags */ |
| 108517 | + WhereCost saved_nOut; /* Original value of pNew->nOut */ |
| 108518 | + int iCol; /* Index of the column in the table */ |
| 108519 | + int rc = SQLITE_OK; /* Return code */ |
| 108520 | + WhereCost nRowEst; /* Estimated index selectivity */ |
| 108521 | + WhereCost rLogSize; /* Logarithm of table size */ |
| 108522 | + WhereTerm *pTop = 0, *pBtm = 0; /* Top and bottom range constraints */ |
| 108523 | + |
| 108524 | + pNew = pBuilder->pNew; |
| 108525 | + if( db->mallocFailed ) return SQLITE_NOMEM; |
| 108526 | + |
| 108527 | + assert( (pNew->wsFlags & WHERE_VIRTUALTABLE)==0 ); |
| 108528 | + assert( (pNew->wsFlags & WHERE_TOP_LIMIT)==0 ); |
| 108529 | + if( pNew->wsFlags & WHERE_BTM_LIMIT ){ |
| 108530 | + opMask = WO_LT|WO_LE; |
| 108531 | + }else if( pProbe->tnum<=0 || (pSrc->jointype & JT_LEFT)!=0 ){ |
| 108532 | + opMask = WO_EQ|WO_IN|WO_GT|WO_GE|WO_LT|WO_LE; |
| 108533 | + }else{ |
| 108534 | + opMask = WO_EQ|WO_IN|WO_ISNULL|WO_GT|WO_GE|WO_LT|WO_LE; |
| 108535 | + } |
| 108536 | + if( pProbe->bUnordered ) opMask &= ~(WO_GT|WO_GE|WO_LT|WO_LE); |
| 108537 | + |
| 108538 | + assert( pNew->u.btree.nEq<=pProbe->nColumn ); |
| 108539 | + if( pNew->u.btree.nEq < pProbe->nColumn ){ |
| 108540 | + iCol = pProbe->aiColumn[pNew->u.btree.nEq]; |
| 108541 | + nRowEst = whereCost(pProbe->aiRowEst[pNew->u.btree.nEq+1]); |
| 108542 | + if( nRowEst==0 && pProbe->onError==OE_None ) nRowEst = 1; |
| 108543 | + }else{ |
| 108544 | + iCol = -1; |
| 108545 | + nRowEst = 0; |
| 108546 | + } |
| 108547 | + pTerm = whereScanInit(&scan, pBuilder->pWC, pSrc->iCursor, iCol, |
| 108548 | + opMask, pProbe); |
| 108549 | + saved_nEq = pNew->u.btree.nEq; |
| 108550 | + saved_nLTerm = pNew->nLTerm; |
| 108551 | + saved_wsFlags = pNew->wsFlags; |
| 108552 | + saved_prereq = pNew->prereq; |
| 108553 | + saved_nOut = pNew->nOut; |
| 108554 | + pNew->rSetup = 0; |
| 108555 | + rLogSize = estLog(whereCost(pProbe->aiRowEst[0])); |
| 108556 | + for(; rc==SQLITE_OK && pTerm!=0; pTerm = whereScanNext(&scan)){ |
| 108557 | + int nIn = 0; |
| 108558 | + if( pTerm->prereqRight & pNew->maskSelf ) continue; |
| 108559 | + pNew->wsFlags = saved_wsFlags; |
| 108560 | + pNew->u.btree.nEq = saved_nEq; |
| 108561 | + pNew->nLTerm = saved_nLTerm; |
| 108562 | + if( whereLoopResize(db, pNew, pNew->nLTerm+1) ) break; /* OOM */ |
| 108563 | + pNew->aLTerm[pNew->nLTerm++] = pTerm; |
| 108564 | + pNew->prereq = (saved_prereq | pTerm->prereqRight) & ~pNew->maskSelf; |
| 108565 | + pNew->rRun = rLogSize; /* Baseline cost is log2(N). Adjustments below */ |
| 108566 | + if( pTerm->eOperator & WO_IN ){ |
| 108567 | + Expr *pExpr = pTerm->pExpr; |
| 108568 | + pNew->wsFlags |= WHERE_COLUMN_IN; |
| 108569 | + if( ExprHasProperty(pExpr, EP_xIsSelect) ){ |
| 108570 | + /* "x IN (SELECT ...)": TUNING: the SELECT returns 25 rows */ |
| 108571 | + nIn = 46; assert( 46==whereCost(25) ); |
| 108572 | + }else if( ALWAYS(pExpr->x.pList && pExpr->x.pList->nExpr) ){ |
| 108573 | + /* "x IN (value, value, ...)" */ |
| 108574 | + nIn = whereCost(pExpr->x.pList->nExpr); |
| 108575 | + } |
| 108576 | + pNew->rRun += nIn; |
| 108577 | + pNew->u.btree.nEq++; |
| 108578 | + pNew->nOut = nRowEst + nInMul + nIn; |
| 108579 | + }else if( pTerm->eOperator & (WO_EQ) ){ |
| 108580 | + assert( (pNew->wsFlags & (WHERE_COLUMN_NULL|WHERE_COLUMN_IN))!=0 |
| 108581 | + || nInMul==0 ); |
| 108582 | + pNew->wsFlags |= WHERE_COLUMN_EQ; |
| 108583 | + if( iCol<0 |
| 108584 | + || (pProbe->onError!=OE_None && nInMul==0 |
| 108585 | + && pNew->u.btree.nEq==pProbe->nColumn-1) |
| 108586 | + ){ |
| 108587 | + assert( (pNew->wsFlags & WHERE_COLUMN_IN)==0 || iCol<0 ); |
| 108588 | + pNew->wsFlags |= WHERE_ONEROW; |
| 108589 | + } |
| 108590 | + pNew->u.btree.nEq++; |
| 108591 | + pNew->nOut = nRowEst + nInMul; |
| 108592 | + }else if( pTerm->eOperator & (WO_ISNULL) ){ |
| 108593 | + pNew->wsFlags |= WHERE_COLUMN_NULL; |
| 108594 | + pNew->u.btree.nEq++; |
| 108595 | + /* TUNING: IS NULL selects 2 rows */ |
| 108596 | + nIn = 10; assert( 10==whereCost(2) ); |
| 108597 | + pNew->nOut = nRowEst + nInMul + nIn; |
| 108598 | + }else if( pTerm->eOperator & (WO_GT|WO_GE) ){ |
| 108599 | + testcase( pTerm->eOperator & WO_GT ); |
| 108600 | + testcase( pTerm->eOperator & WO_GE ); |
| 108601 | + pNew->wsFlags |= WHERE_COLUMN_RANGE|WHERE_BTM_LIMIT; |
| 108602 | + pBtm = pTerm; |
| 108603 | + pTop = 0; |
| 108604 | + }else{ |
| 108605 | + assert( pTerm->eOperator & (WO_LT|WO_LE) ); |
| 108606 | + testcase( pTerm->eOperator & WO_LT ); |
| 108607 | + testcase( pTerm->eOperator & WO_LE ); |
| 108608 | + pNew->wsFlags |= WHERE_COLUMN_RANGE|WHERE_TOP_LIMIT; |
| 108609 | + pTop = pTerm; |
| 108610 | + pBtm = (pNew->wsFlags & WHERE_BTM_LIMIT)!=0 ? |
| 108611 | + pNew->aLTerm[pNew->nLTerm-2] : 0; |
| 108612 | + } |
| 108613 | + if( pNew->wsFlags & WHERE_COLUMN_RANGE ){ |
| 108614 | + /* Adjust nOut and rRun for STAT3 range values */ |
| 108615 | + WhereCost rDiv; |
| 108616 | + whereRangeScanEst(pParse, pProbe, pNew->u.btree.nEq, |
| 108617 | + pBtm, pTop, &rDiv); |
| 108618 | + pNew->nOut = saved_nOut>rDiv+10 ? saved_nOut - rDiv : 10; |
| 108619 | + } |
| 108620 | +#ifdef SQLITE_ENABLE_STAT3 |
| 108621 | + if( pNew->u.btree.nEq==1 && pProbe->nSample ){ |
| 108622 | + tRowcnt nOut = 0; |
| 108623 | + if( (pTerm->eOperator & (WO_EQ|WO_ISNULL))!=0 ){ |
| 108624 | + testcase( pTerm->eOperator & WO_EQ ); |
| 108625 | + testcase( pTerm->eOperator & WO_ISNULL ); |
| 108626 | + rc = whereEqualScanEst(pParse, pProbe, pTerm->pExpr->pRight, &nOut); |
| 108627 | + }else if( (pTerm->eOperator & WO_IN) |
| 108628 | + && !ExprHasProperty(pTerm->pExpr, EP_xIsSelect) ){ |
| 108629 | + rc = whereInScanEst(pParse, pProbe, pTerm->pExpr->x.pList, &nOut); |
| 108630 | + } |
| 108631 | + if( rc==SQLITE_OK ) pNew->nOut = whereCost(nOut); |
| 108632 | + } |
| 108633 | +#endif |
| 108634 | + if( (pNew->wsFlags & (WHERE_IDX_ONLY|WHERE_IPK))==0 ){ |
| 108635 | + /* Each row involves a step of the index, then a binary search of |
| 108636 | + ** the main table */ |
| 108637 | + pNew->rRun = whereCostAdd(pNew->rRun, rLogSize>27 ? rLogSize-17 : 10); |
| 108638 | + } |
| 108639 | + /* Step cost for each output row */ |
| 108640 | + pNew->rRun = whereCostAdd(pNew->rRun, pNew->nOut); |
| 108641 | + /* TBD: Adjust nOut for additional constraints */ |
| 108642 | + rc = whereLoopInsert(pBuilder, pNew); |
| 108643 | + if( (pNew->wsFlags & WHERE_TOP_LIMIT)==0 |
| 108644 | + && pNew->u.btree.nEq<(pProbe->nColumn + (pProbe->zName!=0)) |
| 108645 | + ){ |
| 108646 | + whereLoopAddBtreeIndex(pBuilder, pSrc, pProbe, nInMul+nIn); |
| 108647 | + } |
| 108648 | + } |
| 108649 | + pNew->prereq = saved_prereq; |
| 108650 | + pNew->u.btree.nEq = saved_nEq; |
| 108651 | + pNew->wsFlags = saved_wsFlags; |
| 108652 | + pNew->nOut = saved_nOut; |
| 108653 | + pNew->nLTerm = saved_nLTerm; |
| 108654 | + return rc; |
| 108655 | +} |
| 108656 | + |
| 108657 | +/* |
| 108658 | +** Return True if it is possible that pIndex might be useful in |
| 108659 | +** implementing the ORDER BY clause in pBuilder. |
| 108660 | +** |
| 108661 | +** Return False if pBuilder does not contain an ORDER BY clause or |
| 108662 | +** if there is no way for pIndex to be useful in implementing that |
| 108663 | +** ORDER BY clause. |
| 108664 | +*/ |
| 108665 | +static int indexMightHelpWithOrderBy( |
| 108666 | + WhereLoopBuilder *pBuilder, |
| 108667 | + Index *pIndex, |
| 108668 | + int iCursor |
| 108669 | +){ |
| 108670 | + ExprList *pOB; |
| 108671 | + int ii, jj; |
| 108672 | + |
| 108673 | + if( pIndex->bUnordered ) return 0; |
| 108674 | + if( (pOB = pBuilder->pWInfo->pOrderBy)==0 ) return 0; |
| 108675 | + for(ii=0; ii<pOB->nExpr; ii++){ |
| 108676 | + Expr *pExpr = sqlite3ExprSkipCollate(pOB->a[ii].pExpr); |
| 108677 | + if( pExpr->op!=TK_COLUMN ) return 0; |
| 108678 | + if( pExpr->iTable==iCursor ){ |
| 108679 | + for(jj=0; jj<pIndex->nColumn; jj++){ |
| 108680 | + if( pExpr->iColumn==pIndex->aiColumn[jj] ) return 1; |
| 108681 | + } |
| 108682 | + } |
| 108683 | + } |
| 108684 | + return 0; |
| 108685 | +} |
| 108686 | + |
| 108687 | +/* |
| 108688 | +** Return a bitmask where 1s indicate that the corresponding column of |
| 108689 | +** the table is used by an index. Only the first 63 columns are considered. |
| 108690 | +*/ |
| 108691 | +static Bitmask columnsInIndex(Index *pIdx){ |
| 108692 | + Bitmask m = 0; |
| 108693 | + int j; |
| 108694 | + for(j=pIdx->nColumn-1; j>=0; j--){ |
| 108695 | + int x = pIdx->aiColumn[j]; |
| 108696 | + testcase( x==BMS-1 ); |
| 108697 | + testcase( x==BMS-2 ); |
| 108698 | + if( x<BMS-1 ) m |= MASKBIT(x); |
| 108699 | + } |
| 108700 | + return m; |
| 108701 | +} |
| 108702 | + |
| 108703 | + |
| 108704 | +/* |
| 108705 | +** Add all WhereLoop objects a single table of the join were the table |
| 108706 | +** is idenfied by pBuilder->pNew->iTab. That table is guaranteed to be |
| 108707 | +** a b-tree table, not a virtual table. |
| 108708 | +*/ |
| 108709 | +static int whereLoopAddBtree( |
| 108710 | + WhereLoopBuilder *pBuilder, /* WHERE clause information */ |
| 108711 | + Bitmask mExtra /* Extra prerequesites for using this table */ |
| 108712 | +){ |
| 108713 | + WhereInfo *pWInfo; /* WHERE analysis context */ |
| 108714 | + Index *pProbe; /* An index we are evaluating */ |
| 108715 | + Index sPk; /* A fake index object for the primary key */ |
| 108716 | + tRowcnt aiRowEstPk[2]; /* The aiRowEst[] value for the sPk index */ |
| 108717 | + int aiColumnPk = -1; /* The aColumn[] value for the sPk index */ |
| 108718 | + SrcList *pTabList; /* The FROM clause */ |
| 108719 | + struct SrcList_item *pSrc; /* The FROM clause btree term to add */ |
| 108720 | + WhereLoop *pNew; /* Template WhereLoop object */ |
| 108721 | + int rc = SQLITE_OK; /* Return code */ |
| 108722 | + int iSortIdx = 1; /* Index number */ |
| 108723 | + int b; /* A boolean value */ |
| 108724 | + WhereCost rSize; /* number of rows in the table */ |
| 108725 | + WhereCost rLogSize; /* Logarithm of the number of rows in the table */ |
| 108726 | + |
| 108727 | + pNew = pBuilder->pNew; |
| 108728 | + pWInfo = pBuilder->pWInfo; |
| 108729 | + pTabList = pWInfo->pTabList; |
| 108730 | + pSrc = pTabList->a + pNew->iTab; |
| 108731 | + assert( !IsVirtual(pSrc->pTab) ); |
| 108732 | + |
| 108733 | + if( pSrc->pIndex ){ |
| 108734 | + /* An INDEXED BY clause specifies a particular index to use */ |
| 108735 | + pProbe = pSrc->pIndex; |
| 108736 | + }else{ |
| 108737 | + /* There is no INDEXED BY clause. Create a fake Index object in local |
| 108738 | + ** variable sPk to represent the rowid primary key index. Make this |
| 108739 | + ** fake index the first in a chain of Index objects with all of the real |
| 108740 | + ** indices to follow */ |
| 108741 | + Index *pFirst; /* First of real indices on the table */ |
| 108742 | + memset(&sPk, 0, sizeof(Index)); |
| 108743 | + sPk.nColumn = 1; |
| 108744 | + sPk.aiColumn = &aiColumnPk; |
| 108745 | + sPk.aiRowEst = aiRowEstPk; |
| 108746 | + sPk.onError = OE_Replace; |
| 108747 | + sPk.pTable = pSrc->pTab; |
| 108748 | + aiRowEstPk[0] = pSrc->pTab->nRowEst; |
| 108749 | + aiRowEstPk[1] = 1; |
| 108750 | + pFirst = pSrc->pTab->pIndex; |
| 108751 | + if( pSrc->notIndexed==0 ){ |
| 108752 | + /* The real indices of the table are only considered if the |
| 108753 | + ** NOT INDEXED qualifier is omitted from the FROM clause */ |
| 108754 | + sPk.pNext = pFirst; |
| 108755 | + } |
| 108756 | + pProbe = &sPk; |
| 108757 | + } |
| 108758 | + rSize = whereCost(pSrc->pTab->nRowEst); |
| 108759 | + rLogSize = estLog(rSize); |
| 108760 | + |
| 108761 | + /* Automatic indexes */ |
| 108762 | + if( !pBuilder->pBest |
| 108763 | + && (pWInfo->pParse->db->flags & SQLITE_AutoIndex)!=0 |
| 108764 | + && pSrc->pIndex==0 |
| 108765 | + && !pSrc->viaCoroutine |
| 108766 | + && !pSrc->notIndexed |
| 108767 | + && !pSrc->isCorrelated |
| 108768 | + ){ |
| 108769 | + /* Generate auto-index WhereLoops */ |
| 108770 | + WhereClause *pWC = pBuilder->pWC; |
| 108771 | + WhereTerm *pTerm; |
| 108772 | + WhereTerm *pWCEnd = pWC->a + pWC->nTerm; |
| 108773 | + for(pTerm=pWC->a; rc==SQLITE_OK && pTerm<pWCEnd; pTerm++){ |
| 108774 | + if( pTerm->prereqRight & pNew->maskSelf ) continue; |
| 108775 | + if( termCanDriveIndex(pTerm, pSrc, 0) ){ |
| 108776 | + pNew->u.btree.nEq = 1; |
| 108777 | + pNew->u.btree.pIndex = 0; |
| 108778 | + pNew->nLTerm = 1; |
| 108779 | + pNew->aLTerm[0] = pTerm; |
| 108780 | + /* TUNING: One-time cost for computing the automatic index is |
| 108781 | + ** approximately 6*N*log2(N) where N is the number of rows in |
| 108782 | + ** the table being indexed. */ |
| 108783 | + pNew->rSetup = rLogSize + rSize + 26; assert( 26==whereCost(6) ); |
| 108784 | + /* TUNING: Each index lookup yields 10 rows in the table */ |
| 108785 | + pNew->nOut = 33; assert( 33==whereCost(10) ); |
| 108786 | + pNew->rRun = whereCostAdd(rLogSize,pNew->nOut); |
| 108787 | + pNew->wsFlags = WHERE_TEMP_INDEX; |
| 108788 | + pNew->prereq = mExtra | pTerm->prereqRight; |
| 108789 | + rc = whereLoopInsert(pBuilder, pNew); |
| 108790 | + } |
| 108791 | + } |
| 108792 | + } |
| 108793 | + |
| 108794 | + /* Loop over all indices |
| 108795 | + */ |
| 108796 | + for(; rc==SQLITE_OK && pProbe; pProbe=pProbe->pNext, iSortIdx++){ |
| 108797 | + pNew->u.btree.nEq = 0; |
| 108798 | + pNew->nLTerm = 0; |
| 108799 | + pNew->iSortIdx = 0; |
| 108800 | + pNew->rSetup = 0; |
| 108801 | + pNew->prereq = mExtra; |
| 108802 | + pNew->nOut = rSize; |
| 108803 | + pNew->u.btree.pIndex = pProbe; |
| 108804 | + b = indexMightHelpWithOrderBy(pBuilder, pProbe, pSrc->iCursor); |
| 108805 | + /* The ONEPASS_DESIRED flags never occurs together with ORDER BY */ |
| 108806 | + assert( (pWInfo->wctrlFlags & WHERE_ONEPASS_DESIRED)==0 || b==0 ); |
| 108807 | + if( pProbe->tnum<=0 ){ |
| 108808 | + /* Integer primary key index */ |
| 108809 | + pNew->wsFlags = WHERE_IPK; |
| 108810 | + |
| 108811 | + /* Full table scan */ |
| 108812 | + pNew->iSortIdx = b ? iSortIdx : 0; |
| 108813 | + /* TUNING: Cost of full table scan is 3*(N + log2(N)). |
| 108814 | + ** + The extra 3 factor is to encourage the use of indexed lookups |
| 108815 | + ** over full scans. A smaller constant 2 is used for covering |
| 108816 | + ** index scans so that a covering index scan will be favored over |
| 108817 | + ** a table scan. */ |
| 108818 | + pNew->rRun = whereCostAdd(rSize,rLogSize) + 16; |
| 108819 | + rc = whereLoopInsert(pBuilder, pNew); |
| 108820 | + if( rc ) break; |
| 108821 | + }else{ |
| 108822 | + Bitmask m = pSrc->colUsed & ~columnsInIndex(pProbe); |
| 108823 | + pNew->wsFlags = (m==0) ? (WHERE_IDX_ONLY|WHERE_INDEXED) : WHERE_INDEXED; |
| 108824 | + |
| 108825 | + /* Full scan via index */ |
| 108826 | + if( b |
| 108827 | + || ( m==0 |
| 108828 | + && pProbe->bUnordered==0 |
| 108829 | + && (pWInfo->wctrlFlags & WHERE_ONEPASS_DESIRED)==0 |
| 108830 | + && sqlite3GlobalConfig.bUseCis |
| 108831 | + && OptimizationEnabled(pWInfo->pParse->db, SQLITE_CoverIdxScan) |
| 108832 | + ) |
| 108833 | + ){ |
| 108834 | + pNew->iSortIdx = b ? iSortIdx : 0; |
| 108835 | + if( m==0 ){ |
| 108836 | + /* TUNING: Cost of a covering index scan is 2*(N + log2(N)). |
| 108837 | + ** + The extra 2 factor is to encourage the use of indexed lookups |
| 108838 | + ** over index scans. A table scan uses a factor of 3 so that |
| 108839 | + ** index scans are favored over table scans. |
| 108840 | + ** + If this covering index might also help satisfy the ORDER BY |
| 108841 | + ** clause, then the cost is fudged down slightly so that this |
| 108842 | + ** index is favored above other indices that have no hope of |
| 108843 | + ** helping with the ORDER BY. */ |
| 108844 | + pNew->rRun = 10 + whereCostAdd(rSize,rLogSize) - b; |
| 108845 | + }else{ |
| 108846 | + assert( b!=0 ); |
| 108847 | + /* TUNING: Cost of scanning a non-covering index is (N+1)*log2(N) |
| 108848 | + ** which we will simplify to just N*log2(N) */ |
| 108849 | + pNew->rRun = rSize + rLogSize; |
| 108850 | + } |
| 108851 | + rc = whereLoopInsert(pBuilder, pNew); |
| 108852 | + if( rc ) break; |
| 108853 | + } |
| 108854 | + } |
| 108855 | + rc = whereLoopAddBtreeIndex(pBuilder, pSrc, pProbe, 0); |
| 108856 | + |
| 108857 | + /* If there was an INDEXED BY clause, then only that one index is |
| 108858 | + ** considered. */ |
| 108859 | + if( pSrc->pIndex ) break; |
| 108860 | + } |
| 108861 | + return rc; |
| 108862 | +} |
| 108863 | + |
| 108864 | +#ifndef SQLITE_OMIT_VIRTUALTABLE |
| 108865 | +/* |
| 108866 | +** Add all WhereLoop objects for a table of the join identified by |
| 108867 | +** pBuilder->pNew->iTab. That table is guaranteed to be a virtual table. |
| 108868 | +*/ |
| 108869 | +static int whereLoopAddVirtual( |
| 108870 | + WhereLoopBuilder *pBuilder /* WHERE clause information */ |
| 108871 | +){ |
| 108872 | + WhereInfo *pWInfo; /* WHERE analysis context */ |
| 108873 | + Parse *pParse; /* The parsing context */ |
| 108874 | + WhereClause *pWC; /* The WHERE clause */ |
| 108875 | + struct SrcList_item *pSrc; /* The FROM clause term to search */ |
| 108876 | + Table *pTab; |
| 108877 | + sqlite3 *db; |
| 108878 | + sqlite3_index_info *pIdxInfo; |
| 108879 | + struct sqlite3_index_constraint *pIdxCons; |
| 108880 | + struct sqlite3_index_constraint_usage *pUsage; |
| 108881 | + WhereTerm *pTerm; |
| 108882 | + int i, j; |
| 108883 | + int iTerm, mxTerm; |
| 108884 | + int nConstraint; |
| 108885 | + int seenIn = 0; /* True if an IN operator is seen */ |
| 108886 | + int seenVar = 0; /* True if a non-constant constraint is seen */ |
| 108887 | + int iPhase; /* 0: const w/o IN, 1: const, 2: no IN, 2: IN */ |
| 108888 | + WhereLoop *pNew; |
| 108889 | + int rc = SQLITE_OK; |
| 108890 | + |
| 108891 | + pWInfo = pBuilder->pWInfo; |
| 108892 | + pParse = pWInfo->pParse; |
| 108893 | + db = pParse->db; |
| 108894 | + pWC = pBuilder->pWC; |
| 108895 | + pNew = pBuilder->pNew; |
| 108896 | + pSrc = &pWInfo->pTabList->a[pNew->iTab]; |
| 108897 | + pTab = pSrc->pTab; |
| 108898 | + assert( IsVirtual(pTab) ); |
| 108899 | + pIdxInfo = allocateIndexInfo(pParse, pWC, pSrc, pBuilder->pOrderBy); |
| 108900 | + if( pIdxInfo==0 ) return SQLITE_NOMEM; |
| 108901 | + pNew->prereq = 0; |
| 108902 | + pNew->rSetup = 0; |
| 108903 | + pNew->wsFlags = WHERE_VIRTUALTABLE; |
| 108904 | + pNew->nLTerm = 0; |
| 108905 | + pNew->u.vtab.needFree = 0; |
| 108906 | + pUsage = pIdxInfo->aConstraintUsage; |
| 108907 | + nConstraint = pIdxInfo->nConstraint; |
| 108908 | + if( whereLoopResize(db, pNew, nConstraint) ){ |
| 108909 | + sqlite3DbFree(db, pIdxInfo); |
| 108910 | + return SQLITE_NOMEM; |
| 108911 | + } |
| 108912 | + |
| 108913 | + for(iPhase=0; iPhase<=3; iPhase++){ |
| 108914 | + if( !seenIn && (iPhase&1)!=0 ){ |
| 108915 | + iPhase++; |
| 108916 | + if( iPhase>3 ) break; |
| 108917 | + } |
| 108918 | + if( !seenVar && iPhase>1 ) break; |
| 108919 | + pIdxCons = *(struct sqlite3_index_constraint**)&pIdxInfo->aConstraint; |
| 108920 | + for(i=0; i<pIdxInfo->nConstraint; i++, pIdxCons++){ |
| 108921 | + j = pIdxCons->iTermOffset; |
| 108922 | + pTerm = &pWC->a[j]; |
| 108923 | + switch( iPhase ){ |
| 108924 | + case 0: /* Constants without IN operator */ |
| 108925 | + pIdxCons->usable = 0; |
| 108926 | + if( (pTerm->eOperator & WO_IN)!=0 ){ |
| 108927 | + seenIn = 1; |
| 108928 | + } |
| 108929 | + if( pTerm->prereqRight!=0 ){ |
| 108930 | + seenVar = 1; |
| 108931 | + }else if( (pTerm->eOperator & WO_IN)==0 ){ |
| 108932 | + pIdxCons->usable = 1; |
| 108933 | + } |
| 108934 | + break; |
| 108935 | + case 1: /* Constants with IN operators */ |
| 108936 | + assert( seenIn ); |
| 108937 | + pIdxCons->usable = (pTerm->prereqRight==0); |
| 108938 | + break; |
| 108939 | + case 2: /* Variables without IN */ |
| 108940 | + assert( seenVar ); |
| 108941 | + pIdxCons->usable = (pTerm->eOperator & WO_IN)==0; |
| 108942 | + break; |
| 108943 | + default: /* Variables with IN */ |
| 108944 | + assert( seenVar && seenIn ); |
| 108945 | + pIdxCons->usable = 1; |
| 108946 | + break; |
| 108947 | + } |
| 108948 | + } |
| 108949 | + memset(pUsage, 0, sizeof(pUsage[0])*pIdxInfo->nConstraint); |
| 108950 | + if( pIdxInfo->needToFreeIdxStr ) sqlite3_free(pIdxInfo->idxStr); |
| 108951 | + pIdxInfo->idxStr = 0; |
| 108952 | + pIdxInfo->idxNum = 0; |
| 108953 | + pIdxInfo->needToFreeIdxStr = 0; |
| 108954 | + pIdxInfo->orderByConsumed = 0; |
| 108955 | + pIdxInfo->estimatedCost = SQLITE_BIG_DBL / (double)2; |
| 108956 | + rc = vtabBestIndex(pParse, pTab, pIdxInfo); |
| 108957 | + if( rc ) goto whereLoopAddVtab_exit; |
| 108958 | + pIdxCons = *(struct sqlite3_index_constraint**)&pIdxInfo->aConstraint; |
| 108959 | + pNew->prereq = 0; |
| 108960 | + mxTerm = -1; |
| 108961 | + assert( pNew->nLSlot>=nConstraint ); |
| 108962 | + for(i=0; i<nConstraint; i++) pNew->aLTerm[i] = 0; |
| 108963 | + pNew->u.vtab.omitMask = 0; |
| 108964 | + for(i=0; i<nConstraint; i++, pIdxCons++){ |
| 108965 | + if( (iTerm = pUsage[i].argvIndex - 1)>=0 ){ |
| 108966 | + j = pIdxCons->iTermOffset; |
| 108967 | + if( iTerm>=nConstraint |
| 108968 | + || j<0 |
| 108969 | + || j>=pWC->nTerm |
| 108970 | + || pNew->aLTerm[iTerm]!=0 |
| 108971 | + ){ |
| 108972 | + rc = SQLITE_ERROR; |
| 108973 | + sqlite3ErrorMsg(pParse, "%s.xBestIndex() malfunction", pTab->zName); |
| 108974 | + goto whereLoopAddVtab_exit; |
| 108975 | + } |
| 108976 | + testcase( iTerm==nConstraint-1 ); |
| 108977 | + testcase( j==0 ); |
| 108978 | + testcase( j==pWC->nTerm-1 ); |
| 108979 | + pTerm = &pWC->a[j]; |
| 108980 | + pNew->prereq |= pTerm->prereqRight; |
| 108981 | + assert( iTerm<pNew->nLSlot ); |
| 108982 | + pNew->aLTerm[iTerm] = pTerm; |
| 108983 | + if( iTerm>mxTerm ) mxTerm = iTerm; |
| 108984 | + testcase( iTerm==15 ); |
| 108985 | + testcase( iTerm==16 ); |
| 108986 | + if( iTerm<16 && pUsage[i].omit ) pNew->u.vtab.omitMask |= 1<<iTerm; |
| 108987 | + if( (pTerm->eOperator & WO_IN)!=0 ){ |
| 108988 | + if( pUsage[i].omit==0 ){ |
| 108989 | + /* Do not attempt to use an IN constraint if the virtual table |
| 108990 | + ** says that the equivalent EQ constraint cannot be safely omitted. |
| 108991 | + ** If we do attempt to use such a constraint, some rows might be |
| 108992 | + ** repeated in the output. */ |
| 108993 | + break; |
| 108994 | + } |
| 108995 | + /* A virtual table that is constrained by an IN clause may not |
| 108996 | + ** consume the ORDER BY clause because (1) the order of IN terms |
| 108997 | + ** is not necessarily related to the order of output terms and |
| 108998 | + ** (2) Multiple outputs from a single IN value will not merge |
| 108999 | + ** together. */ |
| 109000 | + pIdxInfo->orderByConsumed = 0; |
| 109001 | + } |
| 109002 | + } |
| 109003 | + } |
| 109004 | + if( i>=nConstraint ){ |
| 109005 | + pNew->nLTerm = mxTerm+1; |
| 109006 | + assert( pNew->nLTerm<=pNew->nLSlot ); |
| 109007 | + pNew->u.vtab.idxNum = pIdxInfo->idxNum; |
| 109008 | + pNew->u.vtab.needFree = pIdxInfo->needToFreeIdxStr; |
| 109009 | + pIdxInfo->needToFreeIdxStr = 0; |
| 109010 | + pNew->u.vtab.idxStr = pIdxInfo->idxStr; |
| 109011 | + pNew->u.vtab.isOrdered = (u8)((pIdxInfo->nOrderBy!=0) |
| 109012 | + && pIdxInfo->orderByConsumed); |
| 109013 | + pNew->rSetup = 0; |
| 109014 | + pNew->rRun = whereCostFromDouble(pIdxInfo->estimatedCost); |
| 109015 | + /* TUNING: Every virtual table query returns 25 rows */ |
| 109016 | + pNew->nOut = 46; assert( 46==whereCost(25) ); |
| 109017 | + whereLoopInsert(pBuilder, pNew); |
| 109018 | + if( pNew->u.vtab.needFree ){ |
| 109019 | + sqlite3_free(pNew->u.vtab.idxStr); |
| 109020 | + pNew->u.vtab.needFree = 0; |
| 109021 | + } |
| 109022 | + } |
| 109023 | + } |
| 109024 | + |
| 109025 | +whereLoopAddVtab_exit: |
| 109026 | + if( pIdxInfo->needToFreeIdxStr ) sqlite3_free(pIdxInfo->idxStr); |
| 109027 | + sqlite3DbFree(db, pIdxInfo); |
| 109028 | + return rc; |
| 109029 | +} |
| 109030 | +#endif /* SQLITE_OMIT_VIRTUALTABLE */ |
| 109031 | + |
| 109032 | +/* |
| 109033 | +** Add WhereLoop entries to handle OR terms. This works for either |
| 109034 | +** btrees or virtual tables. |
| 109035 | +*/ |
| 109036 | +static int whereLoopAddOr(WhereLoopBuilder *pBuilder, Bitmask mExtra){ |
| 109037 | + WhereInfo *pWInfo = pBuilder->pWInfo; |
| 109038 | + WhereClause *pWC; |
| 109039 | + WhereLoop *pNew; |
| 109040 | + WhereTerm *pTerm, *pWCEnd; |
| 109041 | + int rc = SQLITE_OK; |
| 109042 | + int iCur; |
| 109043 | + WhereClause tempWC; |
| 109044 | + WhereLoopBuilder sSubBuild; |
| 109045 | + WhereLoop sBest; |
| 109046 | + struct SrcList_item *pItem; |
| 109047 | + |
| 109048 | + pWC = pBuilder->pWC; |
| 109049 | + if( pWInfo->wctrlFlags & WHERE_AND_ONLY ) return SQLITE_OK; |
| 109050 | + pWCEnd = pWC->a + pWC->nTerm; |
| 109051 | + pNew = pBuilder->pNew; |
| 109052 | + |
| 109053 | + for(pTerm=pWC->a; pTerm<pWCEnd && rc==SQLITE_OK; pTerm++){ |
| 109054 | + if( (pTerm->eOperator & WO_OR)!=0 |
| 109055 | + && (pTerm->u.pOrInfo->indexable & pNew->maskSelf)!=0 |
| 109056 | + ){ |
| 109057 | + WhereClause * const pOrWC = &pTerm->u.pOrInfo->wc; |
| 109058 | + WhereTerm * const pOrWCEnd = &pOrWC->a[pOrWC->nTerm]; |
| 109059 | + WhereTerm *pOrTerm; |
| 109060 | + WhereCost rTotal = 0; |
| 109061 | + WhereCost nRow = 0; |
| 109062 | + Bitmask prereq = mExtra; |
| 109063 | + |
| 109064 | + whereLoopInit(&sBest); |
| 109065 | + pItem = pWInfo->pTabList->a + pNew->iTab; |
| 109066 | + iCur = pItem->iCursor; |
| 109067 | + sSubBuild = *pBuilder; |
| 109068 | + sSubBuild.pOrderBy = 0; |
| 109069 | + sSubBuild.pBest = &sBest; |
| 109070 | + |
| 109071 | + for(pOrTerm=pOrWC->a; pOrTerm<pOrWCEnd; pOrTerm++){ |
| 109072 | + if( (pOrTerm->eOperator & WO_AND)!=0 ){ |
| 109073 | + sSubBuild.pWC = &pOrTerm->u.pAndInfo->wc; |
| 109074 | + }else if( pOrTerm->leftCursor==iCur ){ |
| 109075 | + tempWC.pWInfo = pWC->pWInfo; |
| 109076 | + tempWC.pOuter = pWC; |
| 109077 | + tempWC.op = TK_AND; |
| 109078 | + tempWC.nTerm = 1; |
| 109079 | + tempWC.a = pOrTerm; |
| 109080 | + sSubBuild.pWC = &tempWC; |
| 109081 | + }else{ |
| 109082 | + continue; |
| 109083 | + } |
| 109084 | + sBest.maskSelf = 0; |
| 109085 | + sBest.rSetup = 0; |
| 109086 | + sBest.rRun = 0; |
| 109087 | +#ifndef SQLITE_OMIT_VIRTUALTABLE |
| 109088 | + if( IsVirtual(pItem->pTab) ){ |
| 109089 | + rc = whereLoopAddVirtual(&sSubBuild); |
| 109090 | + }else |
| 109091 | +#endif |
| 109092 | + { |
| 109093 | + rc = whereLoopAddBtree(&sSubBuild, mExtra); |
| 109094 | + } |
| 109095 | + /* sBest.maskSelf is always zero if an error occurs */ |
| 109096 | + assert( rc==SQLITE_OK || sBest.maskSelf==0 ); |
| 109097 | + if( sBest.maskSelf==0 ) break; |
| 109098 | + assert( sBest.rSetup==0 ); |
| 109099 | + rTotal = whereCostAdd(rTotal, sBest.rRun); |
| 109100 | + nRow = whereCostAdd(nRow, sBest.nOut); |
| 109101 | + prereq |= sBest.prereq; |
| 109102 | + } |
| 109103 | + assert( pNew->nLSlot>=1 ); |
| 109104 | + if( sBest.maskSelf ){ |
| 109105 | + pNew->nLTerm = 1; |
| 109106 | + pNew->aLTerm[0] = pTerm; |
| 109107 | + pNew->wsFlags = WHERE_MULTI_OR; |
| 109108 | + pNew->rSetup = 0; |
| 109109 | + /* TUNING: Multiple by 3.5 for the secondary table lookup */ |
| 109110 | + pNew->rRun = rTotal + 18; assert( 18==whereCost(7)-whereCost(2) ); |
| 109111 | + pNew->nOut = nRow; |
| 109112 | + pNew->prereq = prereq; |
| 109113 | + memset(&pNew->u, 0, sizeof(pNew->u)); |
| 109114 | + rc = whereLoopInsert(pBuilder, pNew); |
| 109115 | + } |
| 109116 | + whereLoopClear(pWInfo->pParse->db, &sBest); |
| 109117 | + } |
| 109118 | + } |
| 109119 | + return rc; |
| 109120 | +} |
| 109121 | + |
| 109122 | +/* |
| 109123 | +** Add all WhereLoop objects for all tables |
| 109124 | +*/ |
| 109125 | +static int whereLoopAddAll(WhereLoopBuilder *pBuilder){ |
| 109126 | + WhereInfo *pWInfo = pBuilder->pWInfo; |
| 109127 | + Bitmask mExtra = 0; |
| 109128 | + Bitmask mPrior = 0; |
| 109129 | + int iTab; |
| 109130 | + SrcList *pTabList = pWInfo->pTabList; |
| 109131 | + struct SrcList_item *pItem; |
| 109132 | + sqlite3 *db = pWInfo->pParse->db; |
| 109133 | + int nTabList = pWInfo->nLevel; |
| 109134 | + int rc = SQLITE_OK; |
| 109135 | + u8 priorJoinType = 0; |
| 109136 | + WhereLoop *pNew; |
| 109137 | + |
| 109138 | + /* Loop over the tables in the join, from left to right */ |
| 109139 | + pNew = pBuilder->pNew; |
| 109140 | + whereLoopInit(pNew); |
| 109141 | + for(iTab=0, pItem=pTabList->a; iTab<nTabList; iTab++, pItem++){ |
| 109142 | + pNew->iTab = iTab; |
| 109143 | + pNew->maskSelf = getMask(&pWInfo->sMaskSet, pItem->iCursor); |
| 109144 | + if( ((pItem->jointype|priorJoinType) & (JT_LEFT|JT_CROSS))!=0 ){ |
| 109145 | + mExtra = mPrior; |
| 109146 | + } |
| 109147 | + priorJoinType = pItem->jointype; |
| 109148 | + if( IsVirtual(pItem->pTab) ){ |
| 109149 | + rc = whereLoopAddVirtual(pBuilder); |
| 109150 | + }else{ |
| 109151 | + rc = whereLoopAddBtree(pBuilder, mExtra); |
| 109152 | + } |
| 109153 | + if( rc==SQLITE_OK ){ |
| 109154 | + rc = whereLoopAddOr(pBuilder, mExtra); |
| 109155 | + } |
| 109156 | + mPrior |= pNew->maskSelf; |
| 109157 | + if( rc || db->mallocFailed ) break; |
| 109158 | + } |
| 109159 | + whereLoopClear(db, pNew); |
| 109160 | + return rc; |
| 109161 | +} |
| 109162 | + |
| 109163 | +/* |
| 109164 | +** Examine a WherePath (with the addition of the extra WhereLoop of the 5th |
| 109165 | +** parameters) to see if it outputs rows in the requested ORDER BY |
| 109166 | +** (or GROUP BY) without requiring a separate source operation. Return: |
| 109167 | +** |
| 109168 | +** 0: ORDER BY is not satisfied. Sorting required |
| 109169 | +** 1: ORDER BY is satisfied. Omit sorting |
| 109170 | +** -1: Unknown at this time |
| 109171 | +** |
| 109172 | +*/ |
| 109173 | +static int wherePathSatisfiesOrderBy( |
| 109174 | + WhereInfo *pWInfo, /* The WHERE clause */ |
| 109175 | + ExprList *pOrderBy, /* ORDER BY or GROUP BY or DISTINCT clause to check */ |
| 109176 | + WherePath *pPath, /* The WherePath to check */ |
| 109177 | + u16 wctrlFlags, /* Might contain WHERE_GROUPBY or WHERE_DISTINCTBY */ |
| 109178 | + u16 nLoop, /* Number of entries in pPath->aLoop[] */ |
| 109179 | + WhereLoop *pLast, /* Add this WhereLoop to the end of pPath->aLoop[] */ |
| 109180 | + Bitmask *pRevMask /* OUT: Mask of WhereLoops to run in reverse order */ |
| 109181 | +){ |
| 109182 | + u8 revSet; /* True if rev is known */ |
| 109183 | + u8 rev; /* Composite sort order */ |
| 109184 | + u8 revIdx; /* Index sort order */ |
| 109185 | + u8 isOrderDistinct; /* All prior WhereLoops are order-distinct */ |
| 109186 | + u8 distinctColumns; /* True if the loop has UNIQUE NOT NULL columns */ |
| 109187 | + u8 isMatch; /* iColumn matches a term of the ORDER BY clause */ |
| 109188 | + u16 nColumn; /* Number of columns in pIndex */ |
| 109189 | + u16 nOrderBy; /* Number terms in the ORDER BY clause */ |
| 109190 | + int iLoop; /* Index of WhereLoop in pPath being processed */ |
| 109191 | + int i, j; /* Loop counters */ |
| 109192 | + int iCur; /* Cursor number for current WhereLoop */ |
| 109193 | + int iColumn; /* A column number within table iCur */ |
| 109194 | + WhereLoop *pLoop = 0; /* Current WhereLoop being processed. */ |
| 109195 | + WhereTerm *pTerm; /* A single term of the WHERE clause */ |
| 109196 | + Expr *pOBExpr; /* An expression from the ORDER BY clause */ |
| 109197 | + CollSeq *pColl; /* COLLATE function from an ORDER BY clause term */ |
| 109198 | + Index *pIndex; /* The index associated with pLoop */ |
| 109199 | + sqlite3 *db = pWInfo->pParse->db; /* Database connection */ |
| 109200 | + Bitmask obSat = 0; /* Mask of ORDER BY terms satisfied so far */ |
| 109201 | + Bitmask obDone; /* Mask of all ORDER BY terms */ |
| 109202 | + Bitmask orderDistinctMask; /* Mask of all well-ordered loops */ |
| 109203 | + Bitmask ready; /* Mask of inner loops */ |
| 109204 | + |
| 109205 | + /* |
| 109206 | + ** We say the WhereLoop is "one-row" if it generates no more than one |
| 109207 | + ** row of output. A WhereLoop is one-row if all of the following are true: |
| 109208 | + ** (a) All index columns match with WHERE_COLUMN_EQ. |
| 109209 | + ** (b) The index is unique |
| 109210 | + ** Any WhereLoop with an WHERE_COLUMN_EQ constraint on the rowid is one-row. |
| 109211 | + ** Every one-row WhereLoop will have the WHERE_ONEROW bit set in wsFlags. |
| 109212 | + ** |
| 109213 | + ** We say the WhereLoop is "order-distinct" if the set of columns from |
| 109214 | + ** that WhereLoop that are in the ORDER BY clause are different for every |
| 109215 | + ** row of the WhereLoop. Every one-row WhereLoop is automatically |
| 109216 | + ** order-distinct. A WhereLoop that has no columns in the ORDER BY clause |
| 109217 | + ** is not order-distinct. To be order-distinct is not quite the same as being |
| 109218 | + ** UNIQUE since a UNIQUE column or index can have multiple rows that |
| 109219 | + ** are NULL and NULL values are equivalent for the purpose of order-distinct. |
| 109220 | + ** To be order-distinct, the columns must be UNIQUE and NOT NULL. |
| 109221 | + ** |
| 109222 | + ** The rowid for a table is always UNIQUE and NOT NULL so whenever the |
| 109223 | + ** rowid appears in the ORDER BY clause, the corresponding WhereLoop is |
| 109224 | + ** automatically order-distinct. |
| 109225 | + */ |
| 109226 | + |
| 109227 | + assert( pOrderBy!=0 ); |
| 109228 | + |
| 109229 | + /* Sortability of virtual tables is determined by the xBestIndex method |
| 109230 | + ** of the virtual table itself */ |
| 109231 | + if( pLast->wsFlags & WHERE_VIRTUALTABLE ){ |
| 109232 | + testcase( nLoop>0 ); /* True when outer loops are one-row and match |
| 109233 | + ** no ORDER BY terms */ |
| 109234 | + return pLast->u.vtab.isOrdered; |
| 109235 | + } |
| 109236 | + if( nLoop && OptimizationDisabled(db, SQLITE_OrderByIdxJoin) ) return 0; |
| 109237 | + |
| 109238 | + nOrderBy = pOrderBy->nExpr; |
| 109239 | + testcase( nOrderBy==BMS-1 ); |
| 109240 | + if( nOrderBy>BMS-1 ) return 0; /* Cannot optimize overly large ORDER BYs */ |
| 109241 | + isOrderDistinct = 1; |
| 109242 | + obDone = MASKBIT(nOrderBy)-1; |
| 109243 | + orderDistinctMask = 0; |
| 109244 | + ready = 0; |
| 109245 | + for(iLoop=0; isOrderDistinct && obSat<obDone && iLoop<=nLoop; iLoop++){ |
| 109246 | + if( iLoop>0 ) ready |= pLoop->maskSelf; |
| 109247 | + pLoop = iLoop<nLoop ? pPath->aLoop[iLoop] : pLast; |
| 109248 | + assert( (pLoop->wsFlags & WHERE_VIRTUALTABLE)==0 ); |
| 109249 | + iCur = pWInfo->pTabList->a[pLoop->iTab].iCursor; |
| 109250 | + |
| 109251 | + /* Mark off any ORDER BY term X that is a column in the table of |
| 109252 | + ** the current loop for which there is term in the WHERE |
| 109253 | + ** clause of the form X IS NULL or X=? that reference only outer |
| 109254 | + ** loops. |
| 109255 | + */ |
| 109256 | + for(i=0; i<nOrderBy; i++){ |
| 109257 | + if( MASKBIT(i) & obSat ) continue; |
| 109258 | + pOBExpr = sqlite3ExprSkipCollate(pOrderBy->a[i].pExpr); |
| 109259 | + if( pOBExpr->op!=TK_COLUMN ) continue; |
| 109260 | + if( pOBExpr->iTable!=iCur ) continue; |
| 109261 | + pTerm = findTerm(&pWInfo->sWC, iCur, pOBExpr->iColumn, |
| 109262 | + ~ready, WO_EQ|WO_ISNULL, 0); |
| 109263 | + if( pTerm==0 ) continue; |
| 109264 | + if( (pTerm->eOperator&WO_EQ)!=0 && pOBExpr->iColumn>=0 ){ |
| 109265 | + const char *z1, *z2; |
| 109266 | + pColl = sqlite3ExprCollSeq(pWInfo->pParse, pOrderBy->a[i].pExpr); |
| 109267 | + if( !pColl ) pColl = db->pDfltColl; |
| 109268 | + z1 = pColl->zName; |
| 109269 | + pColl = sqlite3ExprCollSeq(pWInfo->pParse, pTerm->pExpr); |
| 109270 | + if( !pColl ) pColl = db->pDfltColl; |
| 109271 | + z2 = pColl->zName; |
| 109272 | + if( sqlite3StrICmp(z1, z2)!=0 ) continue; |
| 109273 | + } |
| 109274 | + obSat |= MASKBIT(i); |
| 109275 | + } |
| 109276 | + |
| 109277 | + if( (pLoop->wsFlags & WHERE_ONEROW)==0 ){ |
| 109278 | + if( pLoop->wsFlags & WHERE_IPK ){ |
| 109279 | + pIndex = 0; |
| 109280 | + nColumn = 0; |
| 109281 | + }else if( (pIndex = pLoop->u.btree.pIndex)==0 || pIndex->bUnordered ){ |
| 109282 | + return 0; |
| 109283 | + }else{ |
| 109284 | + nColumn = pIndex->nColumn; |
| 109285 | + isOrderDistinct = pIndex->onError!=OE_None; |
| 109286 | + } |
| 109287 | + |
| 109288 | + /* Loop through all columns of the index and deal with the ones |
| 109289 | + ** that are not constrained by == or IN. |
| 109290 | + */ |
| 109291 | + rev = revSet = 0; |
| 109292 | + distinctColumns = 0; |
| 109293 | + for(j=0; j<=nColumn; j++){ |
| 109294 | + u8 bOnce; /* True to run the ORDER BY search loop */ |
| 109295 | + |
| 109296 | + /* Skip over == and IS NULL terms */ |
| 109297 | + if( j<pLoop->u.btree.nEq |
| 109298 | + && ((i = pLoop->aLTerm[j]->eOperator) & (WO_EQ|WO_ISNULL))!=0 |
| 109299 | + ){ |
| 109300 | + if( i & WO_ISNULL ){ |
| 109301 | + testcase( isOrderDistinct ); |
| 109302 | + isOrderDistinct = 0; |
| 109303 | + } |
| 109304 | + continue; |
| 109305 | + } |
| 109306 | + |
| 109307 | + /* Get the column number in the table (iColumn) and sort order |
| 109308 | + ** (revIdx) for the j-th column of the index. |
| 109309 | + */ |
| 109310 | + if( j<nColumn ){ |
| 109311 | + /* Normal index columns */ |
| 109312 | + iColumn = pIndex->aiColumn[j]; |
| 109313 | + revIdx = pIndex->aSortOrder[j]; |
| 109314 | + if( iColumn==pIndex->pTable->iPKey ) iColumn = -1; |
| 109315 | + }else{ |
| 109316 | + /* The ROWID column at the end */ |
| 109317 | + assert( j==nColumn ); |
| 109318 | + iColumn = -1; |
| 109319 | + revIdx = 0; |
| 109320 | + } |
| 109321 | + |
| 109322 | + /* An unconstrained column that might be NULL means that this |
| 109323 | + ** WhereLoop is not well-ordered |
| 109324 | + */ |
| 109325 | + if( isOrderDistinct |
| 109326 | + && iColumn>=0 |
| 109327 | + && j>=pLoop->u.btree.nEq |
| 109328 | + && pIndex->pTable->aCol[iColumn].notNull==0 |
| 109329 | + ){ |
| 109330 | + isOrderDistinct = 0; |
| 109331 | + } |
| 109332 | + |
| 109333 | + /* Find the ORDER BY term that corresponds to the j-th column |
| 109334 | + ** of the index and and mark that ORDER BY term off |
| 109335 | + */ |
| 109336 | + bOnce = 1; |
| 109337 | + isMatch = 0; |
| 109338 | + for(i=0; bOnce && i<nOrderBy; i++){ |
| 109339 | + if( MASKBIT(i) & obSat ) continue; |
| 109340 | + pOBExpr = sqlite3ExprSkipCollate(pOrderBy->a[i].pExpr); |
| 109341 | + testcase( wctrlFlags & WHERE_GROUPBY ); |
| 109342 | + testcase( wctrlFlags & WHERE_DISTINCTBY ); |
| 109343 | + if( (wctrlFlags & (WHERE_GROUPBY|WHERE_DISTINCTBY))==0 ) bOnce = 0; |
| 109344 | + if( pOBExpr->op!=TK_COLUMN ) continue; |
| 109345 | + if( pOBExpr->iTable!=iCur ) continue; |
| 109346 | + if( pOBExpr->iColumn!=iColumn ) continue; |
| 109347 | + if( iColumn>=0 ){ |
| 109348 | + pColl = sqlite3ExprCollSeq(pWInfo->pParse, pOrderBy->a[i].pExpr); |
| 109349 | + if( !pColl ) pColl = db->pDfltColl; |
| 109350 | + if( sqlite3StrICmp(pColl->zName, pIndex->azColl[j])!=0 ) continue; |
| 109351 | + } |
| 109352 | + isMatch = 1; |
| 109353 | + break; |
| 109354 | + } |
| 109355 | + if( isMatch ){ |
| 109356 | + if( iColumn<0 ){ |
| 109357 | + testcase( distinctColumns==0 ); |
| 109358 | + distinctColumns = 1; |
| 109359 | + } |
| 109360 | + obSat |= MASKBIT(i); |
| 109361 | + if( (pWInfo->wctrlFlags & WHERE_GROUPBY)==0 ){ |
| 109362 | + /* Make sure the sort order is compatible in an ORDER BY clause. |
| 109363 | + ** Sort order is irrelevant for a GROUP BY clause. */ |
| 109364 | + if( revSet ){ |
| 109365 | + if( (rev ^ revIdx)!=pOrderBy->a[i].sortOrder ) return 0; |
| 109366 | + }else{ |
| 109367 | + rev = revIdx ^ pOrderBy->a[i].sortOrder; |
| 109368 | + if( rev ) *pRevMask |= MASKBIT(iLoop); |
| 109369 | + revSet = 1; |
| 109370 | + } |
| 109371 | + } |
| 109372 | + }else{ |
| 109373 | + /* No match found */ |
| 109374 | + if( j==0 || j<nColumn ){ |
| 109375 | + testcase( isOrderDistinct!=0 ); |
| 109376 | + isOrderDistinct = 0; |
| 109377 | + } |
| 109378 | + break; |
| 109379 | + } |
| 109380 | + } /* end Loop over all index columns */ |
| 109381 | + if( distinctColumns ){ |
| 109382 | + testcase( isOrderDistinct==0 ); |
| 109383 | + isOrderDistinct = 1; |
| 109384 | + } |
| 109385 | + } /* end-if not one-row */ |
| 109386 | + |
| 109387 | + /* Mark off any other ORDER BY terms that reference pLoop */ |
| 109388 | + if( isOrderDistinct ){ |
| 109389 | + orderDistinctMask |= pLoop->maskSelf; |
| 109390 | + for(i=0; i<nOrderBy; i++){ |
| 109391 | + Expr *p; |
| 109392 | + if( MASKBIT(i) & obSat ) continue; |
| 109393 | + p = pOrderBy->a[i].pExpr; |
| 109394 | + if( (exprTableUsage(&pWInfo->sMaskSet, p)&~orderDistinctMask)==0 ){ |
| 109395 | + obSat |= MASKBIT(i); |
| 109396 | + } |
| 109397 | + } |
| 109398 | + } |
| 109399 | + } /* End the loop over all WhereLoops from outer-most down to inner-most */ |
| 109400 | + if( obSat==obDone ) return 1; |
| 109401 | + if( !isOrderDistinct ) return 0; |
| 109402 | + return -1; |
| 109403 | +} |
| 109404 | + |
| 109405 | +#ifdef WHERETRACE_ENABLED |
| 109406 | +/* For debugging use only: */ |
| 109407 | +static const char *wherePathName(WherePath *pPath, int nLoop, WhereLoop *pLast){ |
| 109408 | + static char zName[65]; |
| 109409 | + int i; |
| 109410 | + for(i=0; i<nLoop; i++){ zName[i] = pPath->aLoop[i]->cId; } |
| 109411 | + if( pLast ) zName[i++] = pLast->cId; |
| 109412 | + zName[i] = 0; |
| 109413 | + return zName; |
| 109414 | +} |
| 109415 | +#endif |
| 109416 | + |
| 109417 | + |
| 109418 | +/* |
| 109419 | +** Given the list of WhereLoop objects on pWInfo->pLoops, this routine |
| 109420 | +** attempts to find the lowest cost path that visits each WhereLoop |
| 109421 | +** once. This path is then loaded into the pWInfo->a[].pWLoop fields. |
| 109422 | +** |
| 109423 | +** Assume that the total number of output rows that will need to be sorted |
| 109424 | +** will be nRowEst (in the 10*log2 representation). Or, ignore sorting |
| 109425 | +** costs if nRowEst==0. |
| 109426 | +** |
| 109427 | +** Return SQLITE_OK on success or SQLITE_NOMEM of a memory allocation |
| 109428 | +** error occurs. |
| 109429 | +*/ |
| 109430 | +static int wherePathSolver(WhereInfo *pWInfo, WhereCost nRowEst){ |
| 109431 | + int mxChoice; /* Maximum number of simultaneous paths tracked */ |
| 109432 | + int nLoop; /* Number of terms in the join */ |
| 109433 | + Parse *pParse; /* Parsing context */ |
| 109434 | + sqlite3 *db; /* The database connection */ |
| 109435 | + int iLoop; /* Loop counter over the terms of the join */ |
| 109436 | + int ii, jj; /* Loop counters */ |
| 109437 | + WhereCost rCost; /* Cost of a path */ |
| 109438 | + WhereCost mxCost = 0; /* Maximum cost of a set of paths */ |
| 109439 | + WhereCost rSortCost; /* Cost to do a sort */ |
| 109440 | + int nTo, nFrom; /* Number of valid entries in aTo[] and aFrom[] */ |
| 109441 | + WherePath *aFrom; /* All nFrom paths at the previous level */ |
| 109442 | + WherePath *aTo; /* The nTo best paths at the current level */ |
| 109443 | + WherePath *pFrom; /* An element of aFrom[] that we are working on */ |
| 109444 | + WherePath *pTo; /* An element of aTo[] that we are working on */ |
| 109445 | + WhereLoop *pWLoop; /* One of the WhereLoop objects */ |
| 109446 | + WhereLoop **pX; /* Used to divy up the pSpace memory */ |
| 109447 | + char *pSpace; /* Temporary memory used by this routine */ |
| 109448 | + |
| 109449 | + pParse = pWInfo->pParse; |
| 109450 | + db = pParse->db; |
| 109451 | + nLoop = pWInfo->nLevel; |
| 109452 | + /* TUNING: For simple queries, only the best path is tracked. |
| 109453 | + ** For 2-way joins, the 5 best paths are followed. |
| 109454 | + ** For joins of 3 or more tables, track the 10 best paths */ |
| 109455 | + mxChoice = (nLoop==1) ? 1 : (nLoop==2 ? 5 : 10); |
| 109456 | + assert( nLoop<=pWInfo->pTabList->nSrc ); |
| 109457 | + WHERETRACE(0x002, ("---- begin solver\n")); |
| 109458 | + |
| 109459 | + /* Allocate and initialize space for aTo and aFrom */ |
| 109460 | + ii = (sizeof(WherePath)+sizeof(WhereLoop*)*nLoop)*mxChoice*2; |
| 109461 | + pSpace = sqlite3DbMallocRaw(db, ii); |
| 109462 | + if( pSpace==0 ) return SQLITE_NOMEM; |
| 109463 | + aTo = (WherePath*)pSpace; |
| 109464 | + aFrom = aTo+mxChoice; |
| 109465 | + memset(aFrom, 0, sizeof(aFrom[0])); |
| 109466 | + pX = (WhereLoop**)(aFrom+mxChoice); |
| 109467 | + for(ii=mxChoice*2, pFrom=aTo; ii>0; ii--, pFrom++, pX += nLoop){ |
| 109468 | + pFrom->aLoop = pX; |
| 109469 | + } |
| 109470 | + |
| 109471 | + /* Seed the search with a single WherePath containing zero WhereLoops. |
| 109472 | + ** |
| 109473 | + ** TUNING: Do not let the number of iterations go above 25. If the cost |
| 109474 | + ** of computing an automatic index is not paid back within the first 25 |
| 109475 | + ** rows, then do not use the automatic index. */ |
| 109476 | + aFrom[0].nRow = MIN(pParse->nQueryLoop, 46); assert( 46==whereCost(25) ); |
| 109477 | + nFrom = 1; |
| 109478 | + |
| 109479 | + /* Precompute the cost of sorting the final result set, if the caller |
| 109480 | + ** to sqlite3WhereBegin() was concerned about sorting */ |
| 109481 | + rSortCost = 0; |
| 109482 | + if( pWInfo->pOrderBy==0 || nRowEst==0 ){ |
| 109483 | + aFrom[0].isOrderedValid = 1; |
| 109484 | + }else{ |
| 109485 | + /* TUNING: Estimated cost of sorting is N*log2(N) where N is the |
| 109486 | + ** number of output rows. */ |
| 109487 | + rSortCost = nRowEst + estLog(nRowEst); |
| 109488 | + WHERETRACE(0x002,("---- sort cost=%-3d\n", rSortCost)); |
| 109489 | + } |
| 109490 | + |
| 109491 | + /* Compute successively longer WherePaths using the previous generation |
| 109492 | + ** of WherePaths as the basis for the next. Keep track of the mxChoice |
| 109493 | + ** best paths at each generation */ |
| 109494 | + for(iLoop=0; iLoop<nLoop; iLoop++){ |
| 109495 | + nTo = 0; |
| 109496 | + for(ii=0, pFrom=aFrom; ii<nFrom; ii++, pFrom++){ |
| 109497 | + for(pWLoop=pWInfo->pLoops; pWLoop; pWLoop=pWLoop->pNextLoop){ |
| 109498 | + Bitmask maskNew; |
| 109499 | + Bitmask revMask = 0; |
| 109500 | + u8 isOrderedValid = pFrom->isOrderedValid; |
| 109501 | + u8 isOrdered = pFrom->isOrdered; |
| 109502 | + if( (pWLoop->prereq & ~pFrom->maskLoop)!=0 ) continue; |
| 109503 | + if( (pWLoop->maskSelf & pFrom->maskLoop)!=0 ) continue; |
| 109504 | + /* At this point, pWLoop is a candidate to be the next loop. |
| 109505 | + ** Compute its cost */ |
| 109506 | + rCost = whereCostAdd(pWLoop->rSetup,pWLoop->rRun + pFrom->nRow); |
| 109507 | + rCost = whereCostAdd(rCost, pFrom->rCost); |
| 109508 | + maskNew = pFrom->maskLoop | pWLoop->maskSelf; |
| 109509 | + if( !isOrderedValid ){ |
| 109510 | + switch( wherePathSatisfiesOrderBy(pWInfo, |
| 109511 | + pWInfo->pOrderBy, pFrom, pWInfo->wctrlFlags, |
| 109512 | + iLoop, pWLoop, &revMask) ){ |
| 109513 | + case 1: /* Yes. pFrom+pWLoop does satisfy the ORDER BY clause */ |
| 109514 | + isOrdered = 1; |
| 109515 | + isOrderedValid = 1; |
| 109516 | + break; |
| 109517 | + case 0: /* No. pFrom+pWLoop will require a separate sort */ |
| 109518 | + isOrdered = 0; |
| 109519 | + isOrderedValid = 1; |
| 109520 | + rCost = whereCostAdd(rCost, rSortCost); |
| 109521 | + break; |
| 109522 | + default: /* Cannot tell yet. Try again on the next iteration */ |
| 109523 | + break; |
| 109524 | + } |
| 109525 | + }else{ |
| 109526 | + revMask = pFrom->revLoop; |
| 109527 | + } |
| 109528 | + /* Check to see if pWLoop should be added to the mxChoice best so far */ |
| 109529 | + for(jj=0, pTo=aTo; jj<nTo; jj++, pTo++){ |
| 109530 | + if( pTo->maskLoop==maskNew && pTo->isOrderedValid==isOrderedValid ){ |
| 109531 | + testcase( jj==nTo-1 ); |
| 109532 | + break; |
| 109533 | + } |
| 109534 | + } |
| 109535 | + if( jj>=nTo ){ |
| 109536 | + if( nTo>=mxChoice && rCost>=mxCost ){ |
| 109537 | +#ifdef WHERETRACE_ENABLED |
| 109538 | + if( sqlite3WhereTrace&0x4 ){ |
| 109539 | + sqlite3DebugPrintf("Skip %s cost=%3d order=%c\n", |
| 109540 | + wherePathName(pFrom, iLoop, pWLoop), rCost, |
| 109541 | + isOrderedValid ? (isOrdered ? 'Y' : 'N') : '?'); |
| 109542 | + } |
| 109543 | +#endif |
| 109544 | + continue; |
| 109545 | + } |
| 109546 | + /* Add a new Path to the aTo[] set */ |
| 109547 | + if( nTo<mxChoice ){ |
| 109548 | + /* Increase the size of the aTo set by one */ |
| 109549 | + jj = nTo++; |
| 109550 | + }else{ |
| 109551 | + /* New path replaces the prior worst to keep count below mxChoice */ |
| 109552 | + for(jj=nTo-1; aTo[jj].rCost<mxCost; jj--){ assert(jj>0); } |
| 109553 | + } |
| 109554 | + pTo = &aTo[jj]; |
| 109555 | +#ifdef WHERETRACE_ENABLED |
| 109556 | + if( sqlite3WhereTrace&0x4 ){ |
| 109557 | + sqlite3DebugPrintf("New %s cost=%-3d order=%c\n", |
| 109558 | + wherePathName(pFrom, iLoop, pWLoop), rCost, |
| 109559 | + isOrderedValid ? (isOrdered ? 'Y' : 'N') : '?'); |
| 109560 | + } |
| 109561 | +#endif |
| 109562 | + }else{ |
| 109563 | + if( pTo->rCost<=rCost ){ |
| 109564 | +#ifdef WHERETRACE_ENABLED |
| 109565 | + if( sqlite3WhereTrace&0x4 ){ |
| 109566 | + sqlite3DebugPrintf( |
| 109567 | + "Skip %s cost=%-3d order=%c", |
| 109568 | + wherePathName(pFrom, iLoop, pWLoop), rCost, |
| 109569 | + isOrderedValid ? (isOrdered ? 'Y' : 'N') : '?'); |
| 109570 | + sqlite3DebugPrintf(" vs %s cost=%-3d order=%c\n", |
| 109571 | + wherePathName(pTo, iLoop+1, 0), pTo->rCost, |
| 109572 | + pTo->isOrderedValid ? (pTo->isOrdered ? 'Y' : 'N') : '?'); |
| 109573 | + } |
| 109574 | +#endif |
| 109575 | + testcase( pTo->rCost==rCost ); |
| 109576 | + continue; |
| 109577 | + } |
| 109578 | + testcase( pTo->rCost==rCost+1 ); |
| 109579 | + /* A new and better score for a previously created equivalent path */ |
| 109580 | +#ifdef WHERETRACE_ENABLED |
| 109581 | + if( sqlite3WhereTrace&0x4 ){ |
| 109582 | + sqlite3DebugPrintf( |
| 109583 | + "Update %s cost=%-3d order=%c", |
| 109584 | + wherePathName(pFrom, iLoop, pWLoop), rCost, |
| 109585 | + isOrderedValid ? (isOrdered ? 'Y' : 'N') : '?'); |
| 109586 | + sqlite3DebugPrintf(" was %s cost=%-3d order=%c\n", |
| 109587 | + wherePathName(pTo, iLoop+1, 0), pTo->rCost, |
| 109588 | + pTo->isOrderedValid ? (pTo->isOrdered ? 'Y' : 'N') : '?'); |
| 109589 | + } |
| 109590 | +#endif |
| 109591 | + } |
| 109592 | + /* pWLoop is a winner. Add it to the set of best so far */ |
| 109593 | + pTo->maskLoop = pFrom->maskLoop | pWLoop->maskSelf; |
| 109594 | + pTo->revLoop = revMask; |
| 109595 | + pTo->nRow = pFrom->nRow + pWLoop->nOut; |
| 109596 | + pTo->rCost = rCost; |
| 109597 | + pTo->isOrderedValid = isOrderedValid; |
| 109598 | + pTo->isOrdered = isOrdered; |
| 109599 | + memcpy(pTo->aLoop, pFrom->aLoop, sizeof(WhereLoop*)*iLoop); |
| 109600 | + pTo->aLoop[iLoop] = pWLoop; |
| 109601 | + if( nTo>=mxChoice ){ |
| 109602 | + mxCost = aTo[0].rCost; |
| 109603 | + for(jj=1, pTo=&aTo[1]; jj<mxChoice; jj++, pTo++){ |
| 109604 | + if( pTo->rCost>mxCost ) mxCost = pTo->rCost; |
| 109605 | + } |
| 109606 | + } |
| 109607 | + } |
| 109608 | + } |
| 109609 | + |
| 109610 | +#ifdef WHERETRACE_ENABLED |
| 109611 | + if( sqlite3WhereTrace>=2 ){ |
| 109612 | + sqlite3DebugPrintf("---- after round %d ----\n", iLoop); |
| 109613 | + for(ii=0, pTo=aTo; ii<nTo; ii++, pTo++){ |
| 109614 | + sqlite3DebugPrintf(" %s cost=%-3d nrow=%-3d order=%c", |
| 109615 | + wherePathName(pTo, iLoop+1, 0), pTo->rCost, pTo->nRow, |
| 109616 | + pTo->isOrderedValid ? (pTo->isOrdered ? 'Y' : 'N') : '?'); |
| 109617 | + if( pTo->isOrderedValid && pTo->isOrdered ){ |
| 109618 | + sqlite3DebugPrintf(" rev=0x%llx\n", pTo->revLoop); |
| 109619 | + }else{ |
| 109620 | + sqlite3DebugPrintf("\n"); |
| 109621 | + } |
| 109622 | + } |
| 109623 | + } |
| 109624 | +#endif |
| 109625 | + |
| 109626 | + /* Swap the roles of aFrom and aTo for the next generation */ |
| 109627 | + pFrom = aTo; |
| 109628 | + aTo = aFrom; |
| 109629 | + aFrom = pFrom; |
| 109630 | + nFrom = nTo; |
| 109631 | + } |
| 109632 | + |
| 109633 | + if( nFrom==0 ){ |
| 109634 | + sqlite3ErrorMsg(pParse, "no query solution"); |
| 109635 | + sqlite3DbFree(db, pSpace); |
| 109636 | + return SQLITE_ERROR; |
| 109637 | + } |
| 109638 | + |
| 109639 | + /* Find the lowest cost path. pFrom will be left pointing to that path */ |
| 109640 | + pFrom = aFrom; |
| 109641 | + assert( nFrom==1 ); |
| 109642 | +#if 0 /* The following is needed if nFrom is ever more than 1 */ |
| 109643 | + for(ii=1; ii<nFrom; ii++){ |
| 109644 | + if( pFrom->rCost>aFrom[ii].rCost ) pFrom = &aFrom[ii]; |
| 109645 | + } |
| 109646 | +#endif |
| 109647 | + assert( pWInfo->nLevel==nLoop ); |
| 109648 | + /* Load the lowest cost path into pWInfo */ |
| 109649 | + for(iLoop=0; iLoop<nLoop; iLoop++){ |
| 109650 | + WhereLevel *pLevel = pWInfo->a + iLoop; |
| 109651 | + pLevel->pWLoop = pWLoop = pFrom->aLoop[iLoop]; |
| 109652 | + pLevel->iFrom = pWLoop->iTab; |
| 109653 | + pLevel->iTabCur = pWInfo->pTabList->a[pLevel->iFrom].iCursor; |
| 109654 | + } |
| 109655 | + if( (pWInfo->wctrlFlags & WHERE_DISTINCTBY)==0 |
| 109656 | + && pWInfo->pDistinct |
| 109657 | + && nRowEst |
| 109658 | + ){ |
| 109659 | + Bitmask notUsed; |
| 109660 | + int rc = wherePathSatisfiesOrderBy(pWInfo, pWInfo->pDistinct, pFrom, |
| 109661 | + WHERE_DISTINCTBY, nLoop-1, pFrom->aLoop[nLoop-1], ¬Used); |
| 109662 | + if( rc==1 ) pWInfo->eDistinct = WHERE_DISTINCT_ORDERED; |
| 109663 | + } |
| 109664 | + if( pFrom->isOrdered ){ |
| 109665 | + if( pWInfo->wctrlFlags & WHERE_DISTINCTBY ){ |
| 109666 | + pWInfo->eDistinct = WHERE_DISTINCT_ORDERED; |
| 109667 | + }else{ |
| 109668 | + pWInfo->bOBSat = 1; |
| 109669 | + pWInfo->revMask = pFrom->revLoop; |
| 109670 | + } |
| 109671 | + } |
| 109672 | + pWInfo->nRowOut = pFrom->nRow; |
| 109673 | + |
| 109674 | + /* Free temporary memory and return success */ |
| 109675 | + sqlite3DbFree(db, pSpace); |
| 109676 | + return SQLITE_OK; |
| 109677 | +} |
| 109678 | + |
| 109679 | +/* |
| 109680 | +** Most queries use only a single table (they are not joins) and have |
| 109681 | +** simple == constraints against indexed fields. This routine attempts |
| 109682 | +** to plan those simple cases using much less ceremony than the |
| 109683 | +** general-purpose query planner, and thereby yield faster sqlite3_prepare() |
| 109684 | +** times for the common case. |
| 109685 | +** |
| 109686 | +** Return non-zero on success, if this query can be handled by this |
| 109687 | +** no-frills query planner. Return zero if this query needs the |
| 109688 | +** general-purpose query planner. |
| 109689 | +*/ |
| 109690 | +static int whereShortCut(WhereLoopBuilder *pBuilder){ |
| 109691 | + WhereInfo *pWInfo; |
| 109692 | + struct SrcList_item *pItem; |
| 109693 | + WhereClause *pWC; |
| 109694 | + WhereTerm *pTerm; |
| 109695 | + WhereLoop *pLoop; |
| 109696 | + int iCur; |
| 109697 | + int j; |
| 109698 | + Table *pTab; |
| 109699 | + Index *pIdx; |
| 109700 | + |
| 109701 | + pWInfo = pBuilder->pWInfo; |
| 109702 | + if( pWInfo->wctrlFlags & WHERE_FORCE_TABLE ) return 0; |
| 109703 | + assert( pWInfo->pTabList->nSrc>=1 ); |
| 109704 | + pItem = pWInfo->pTabList->a; |
| 109705 | + pTab = pItem->pTab; |
| 109706 | + if( IsVirtual(pTab) ) return 0; |
| 109707 | + if( pItem->zIndex ) return 0; |
| 109708 | + iCur = pItem->iCursor; |
| 109709 | + pWC = &pWInfo->sWC; |
| 109710 | + pLoop = pBuilder->pNew; |
| 109711 | + pLoop->wsFlags = 0; |
| 109712 | + pTerm = findTerm(pWC, iCur, -1, 0, WO_EQ, 0); |
| 109713 | + if( pTerm ){ |
| 109714 | + pLoop->wsFlags = WHERE_COLUMN_EQ|WHERE_IPK|WHERE_ONEROW; |
| 109715 | + pLoop->aLTerm[0] = pTerm; |
| 109716 | + pLoop->nLTerm = 1; |
| 109717 | + pLoop->u.btree.nEq = 1; |
| 109718 | + /* TUNING: Cost of a rowid lookup is 10 */ |
| 109719 | + pLoop->rRun = 33; /* 33==whereCost(10) */ |
| 109720 | + }else{ |
| 109721 | + for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){ |
| 109722 | + if( pIdx->onError==OE_None ) continue; |
| 109723 | + for(j=0; j<pIdx->nColumn; j++){ |
| 109724 | + pTerm = findTerm(pWC, iCur, pIdx->aiColumn[j], 0, WO_EQ, pIdx); |
| 109725 | + if( pTerm==0 ) break; |
| 109726 | + whereLoopResize(pWInfo->pParse->db, pLoop, j); |
| 109727 | + pLoop->aLTerm[j] = pTerm; |
| 109728 | + } |
| 109729 | + if( j!=pIdx->nColumn ) continue; |
| 109730 | + pLoop->wsFlags = WHERE_COLUMN_EQ|WHERE_ONEROW|WHERE_INDEXED; |
| 109731 | + if( (pItem->colUsed & ~columnsInIndex(pIdx))==0 ){ |
| 109732 | + pLoop->wsFlags |= WHERE_IDX_ONLY; |
| 109733 | + } |
| 109734 | + pLoop->nLTerm = j; |
| 109735 | + pLoop->u.btree.nEq = j; |
| 109736 | + pLoop->u.btree.pIndex = pIdx; |
| 109737 | + /* TUNING: Cost of a unique index lookup is 15 */ |
| 109738 | + pLoop->rRun = 39; /* 39==whereCost(15) */ |
| 109739 | + break; |
| 109740 | + } |
| 109741 | + } |
| 109742 | + if( pLoop->wsFlags ){ |
| 109743 | + pLoop->nOut = (WhereCost)1; |
| 109744 | + pWInfo->a[0].pWLoop = pLoop; |
| 109745 | + pLoop->maskSelf = getMask(&pWInfo->sMaskSet, iCur); |
| 109746 | + pWInfo->a[0].iTabCur = iCur; |
| 109747 | + pWInfo->nRowOut = 1; |
| 109748 | + if( pWInfo->pOrderBy ) pWInfo->bOBSat = 1; |
| 109749 | + if( pWInfo->pDistinct ) pWInfo->eDistinct = WHERE_DISTINCT_UNIQUE; |
| 109750 | +#ifdef SQLITE_DEBUG |
| 109751 | + pLoop->cId = '0'; |
| 109752 | +#endif |
| 109753 | + return 1; |
| 109754 | + } |
| 109755 | + return 0; |
| 109756 | +} |
| 109336 | 109757 | |
| 109337 | 109758 | /* |
| 109338 | 109759 | ** Generate the beginning of the loop used for WHERE clause processing. |
| 109339 | 109760 | ** The return value is a pointer to an opaque structure that contains |
| 109340 | 109761 | ** information needed to terminate the loop. Later, the calling routine |
| | @@ -109410,19 +109831,10 @@ |
| 109410 | 109831 | ** ORDER BY CLAUSE PROCESSING |
| 109411 | 109832 | ** |
| 109412 | 109833 | ** pOrderBy is a pointer to the ORDER BY clause of a SELECT statement, |
| 109413 | 109834 | ** if there is one. If there is no ORDER BY clause or if this routine |
| 109414 | 109835 | ** is called from an UPDATE or DELETE statement, then pOrderBy is NULL. |
| 109415 | | -** |
| 109416 | | -** If an index can be used so that the natural output order of the table |
| 109417 | | -** scan is correct for the ORDER BY clause, then that index is used and |
| 109418 | | -** the returned WhereInfo.nOBSat field is set to pOrderBy->nExpr. This |
| 109419 | | -** is an optimization that prevents an unnecessary sort of the result set |
| 109420 | | -** if an index appropriate for the ORDER BY clause already exists. |
| 109421 | | -** |
| 109422 | | -** If the where clause loops cannot be arranged to provide the correct |
| 109423 | | -** output order, then WhereInfo.nOBSat is 0. |
| 109424 | 109836 | */ |
| 109425 | 109837 | SQLITE_PRIVATE WhereInfo *sqlite3WhereBegin( |
| 109426 | 109838 | Parse *pParse, /* The parser context */ |
| 109427 | 109839 | SrcList *pTabList, /* A list of all tables to be scanned */ |
| 109428 | 109840 | Expr *pWhere, /* The WHERE clause */ |
| | @@ -109434,22 +109846,21 @@ |
| 109434 | 109846 | int nByteWInfo; /* Num. bytes allocated for WhereInfo struct */ |
| 109435 | 109847 | int nTabList; /* Number of elements in pTabList */ |
| 109436 | 109848 | WhereInfo *pWInfo; /* Will become the return value of this function */ |
| 109437 | 109849 | Vdbe *v = pParse->pVdbe; /* The virtual database engine */ |
| 109438 | 109850 | Bitmask notReady; /* Cursors that are not yet positioned */ |
| 109439 | | - WhereBestIdx sWBI; /* Best index search context */ |
| 109851 | + WhereLoopBuilder sWLB; /* The WhereLoop builder */ |
| 109440 | 109852 | WhereMaskSet *pMaskSet; /* The expression mask set */ |
| 109441 | 109853 | WhereLevel *pLevel; /* A single level in pWInfo->a[] */ |
| 109442 | | - int iFrom; /* First unused FROM clause element */ |
| 109443 | | - int andFlags; /* AND-ed combination of all pWC->a[].wtFlags */ |
| 109444 | 109854 | int ii; /* Loop counter */ |
| 109445 | 109855 | sqlite3 *db; /* Database connection */ |
| 109856 | + int rc; /* Return code */ |
| 109446 | 109857 | |
| 109447 | 109858 | |
| 109448 | 109859 | /* Variable initialization */ |
| 109449 | | - memset(&sWBI, 0, sizeof(sWBI)); |
| 109450 | | - sWBI.pParse = pParse; |
| 109860 | + memset(&sWLB, 0, sizeof(sWLB)); |
| 109861 | + sWLB.pOrderBy = pOrderBy; |
| 109451 | 109862 | |
| 109452 | 109863 | /* The number of tables in the FROM clause is limited by the number of |
| 109453 | 109864 | ** bits in a Bitmask |
| 109454 | 109865 | */ |
| 109455 | 109866 | testcase( pTabList->nSrc==BMS ); |
| | @@ -109472,49 +109883,59 @@ |
| 109472 | 109883 | ** field (type Bitmask) it must be aligned on an 8-byte boundary on |
| 109473 | 109884 | ** some architectures. Hence the ROUND8() below. |
| 109474 | 109885 | */ |
| 109475 | 109886 | db = pParse->db; |
| 109476 | 109887 | nByteWInfo = ROUND8(sizeof(WhereInfo)+(nTabList-1)*sizeof(WhereLevel)); |
| 109477 | | - pWInfo = sqlite3DbMallocZero(db, |
| 109478 | | - nByteWInfo + |
| 109479 | | - sizeof(WhereClause) + |
| 109480 | | - sizeof(WhereMaskSet) |
| 109481 | | - ); |
| 109888 | + pWInfo = sqlite3DbMallocZero(db, nByteWInfo + sizeof(WhereLoop)); |
| 109482 | 109889 | if( db->mallocFailed ){ |
| 109483 | 109890 | sqlite3DbFree(db, pWInfo); |
| 109484 | 109891 | pWInfo = 0; |
| 109485 | 109892 | goto whereBeginError; |
| 109486 | 109893 | } |
| 109487 | 109894 | pWInfo->nLevel = nTabList; |
| 109488 | 109895 | pWInfo->pParse = pParse; |
| 109489 | 109896 | pWInfo->pTabList = pTabList; |
| 109897 | + pWInfo->pOrderBy = pOrderBy; |
| 109898 | + pWInfo->pDistinct = pDistinct; |
| 109490 | 109899 | pWInfo->iBreak = sqlite3VdbeMakeLabel(v); |
| 109491 | | - pWInfo->pWC = sWBI.pWC = (WhereClause *)&((u8 *)pWInfo)[nByteWInfo]; |
| 109492 | 109900 | pWInfo->wctrlFlags = wctrlFlags; |
| 109493 | 109901 | pWInfo->savedNQueryLoop = pParse->nQueryLoop; |
| 109494 | | - pMaskSet = (WhereMaskSet*)&sWBI.pWC[1]; |
| 109495 | | - sWBI.aLevel = pWInfo->a; |
| 109902 | + pMaskSet = &pWInfo->sMaskSet; |
| 109903 | + sWLB.pWInfo = pWInfo; |
| 109904 | + sWLB.pWC = &pWInfo->sWC; |
| 109905 | + sWLB.pNew = (WhereLoop*)&pWInfo->a[nTabList]; |
| 109906 | + whereLoopInit(sWLB.pNew); |
| 109907 | +#ifdef SQLITE_DEBUG |
| 109908 | + sWLB.pNew->cId = '*'; |
| 109909 | +#endif |
| 109496 | 109910 | |
| 109497 | 109911 | /* Disable the DISTINCT optimization if SQLITE_DistinctOpt is set via |
| 109498 | 109912 | ** sqlite3_test_ctrl(SQLITE_TESTCTRL_OPTIMIZATIONS,...) */ |
| 109499 | 109913 | if( OptimizationDisabled(db, SQLITE_DistinctOpt) ) pDistinct = 0; |
| 109500 | 109914 | |
| 109501 | 109915 | /* Split the WHERE clause into separate subexpressions where each |
| 109502 | 109916 | ** subexpression is separated by an AND operator. |
| 109503 | 109917 | */ |
| 109504 | 109918 | initMaskSet(pMaskSet); |
| 109505 | | - whereClauseInit(sWBI.pWC, pParse, pMaskSet, wctrlFlags); |
| 109919 | + whereClauseInit(&pWInfo->sWC, pWInfo); |
| 109506 | 109920 | sqlite3ExprCodeConstants(pParse, pWhere); |
| 109507 | | - whereSplit(sWBI.pWC, pWhere, TK_AND); /* IMP: R-15842-53296 */ |
| 109921 | + whereSplit(&pWInfo->sWC, pWhere, TK_AND); /* IMP: R-15842-53296 */ |
| 109508 | 109922 | |
| 109509 | 109923 | /* Special case: a WHERE clause that is constant. Evaluate the |
| 109510 | 109924 | ** expression and either jump over all of the code or fall thru. |
| 109511 | 109925 | */ |
| 109512 | 109926 | if( pWhere && (nTabList==0 || sqlite3ExprIsConstantNotJoin(pWhere)) ){ |
| 109513 | 109927 | sqlite3ExprIfFalse(pParse, pWhere, pWInfo->iBreak, SQLITE_JUMPIFNULL); |
| 109514 | 109928 | pWhere = 0; |
| 109515 | 109929 | } |
| 109930 | + |
| 109931 | + /* Special case: No FROM clause |
| 109932 | + */ |
| 109933 | + if( nTabList==0 ){ |
| 109934 | + if( pOrderBy ) pWInfo->bOBSat = 1; |
| 109935 | + if( pDistinct ) pWInfo->eDistinct = WHERE_DISTINCT_UNIQUE; |
| 109936 | + } |
| 109516 | 109937 | |
| 109517 | 109938 | /* Assign a bit from the bitmask to every term in the FROM clause. |
| 109518 | 109939 | ** |
| 109519 | 109940 | ** When assigning bitmask values to FROM clause cursors, it must be |
| 109520 | 109941 | ** the case that if X is the bitmask for the N-th FROM clause term then |
| | @@ -109547,337 +109968,153 @@ |
| 109547 | 109968 | /* Analyze all of the subexpressions. Note that exprAnalyze() might |
| 109548 | 109969 | ** add new virtual terms onto the end of the WHERE clause. We do not |
| 109549 | 109970 | ** want to analyze these virtual terms, so start analyzing at the end |
| 109550 | 109971 | ** and work forward so that the added virtual terms are never processed. |
| 109551 | 109972 | */ |
| 109552 | | - exprAnalyzeAll(pTabList, sWBI.pWC); |
| 109973 | + exprAnalyzeAll(pTabList, &pWInfo->sWC); |
| 109553 | 109974 | if( db->mallocFailed ){ |
| 109554 | 109975 | goto whereBeginError; |
| 109555 | 109976 | } |
| 109977 | + |
| 109978 | + /* If the ORDER BY (or GROUP BY) clause contains references to general |
| 109979 | + ** expressions, then we won't be able to satisfy it using indices, so |
| 109980 | + ** go ahead and disable it now. |
| 109981 | + */ |
| 109982 | + if( pOrderBy && pDistinct ){ |
| 109983 | + for(ii=0; ii<pOrderBy->nExpr; ii++){ |
| 109984 | + Expr *pExpr = sqlite3ExprSkipCollate(pOrderBy->a[ii].pExpr); |
| 109985 | + if( pExpr->op!=TK_COLUMN ){ |
| 109986 | + pWInfo->pOrderBy = pOrderBy = 0; |
| 109987 | + break; |
| 109988 | + }else if( pExpr->iColumn<0 ){ |
| 109989 | + break; |
| 109990 | + } |
| 109991 | + } |
| 109992 | + } |
| 109556 | 109993 | |
| 109557 | 109994 | /* Check if the DISTINCT qualifier, if there is one, is redundant. |
| 109558 | 109995 | ** If it is, then set pDistinct to NULL and WhereInfo.eDistinct to |
| 109559 | 109996 | ** WHERE_DISTINCT_UNIQUE to tell the caller to ignore the DISTINCT. |
| 109560 | 109997 | */ |
| 109561 | | - if( pDistinct && isDistinctRedundant(pParse, pTabList, sWBI.pWC, pDistinct) ){ |
| 109562 | | - pDistinct = 0; |
| 109563 | | - pWInfo->eDistinct = WHERE_DISTINCT_UNIQUE; |
| 109564 | | - } |
| 109565 | | - |
| 109566 | | - /* Chose the best index to use for each table in the FROM clause. |
| 109567 | | - ** |
| 109568 | | - ** This loop fills in the following fields: |
| 109569 | | - ** |
| 109570 | | - ** pWInfo->a[].pIdx The index to use for this level of the loop. |
| 109571 | | - ** pWInfo->a[].wsFlags WHERE_xxx flags associated with pIdx |
| 109572 | | - ** pWInfo->a[].nEq The number of == and IN constraints |
| 109573 | | - ** pWInfo->a[].iFrom Which term of the FROM clause is being coded |
| 109574 | | - ** pWInfo->a[].iTabCur The VDBE cursor for the database table |
| 109575 | | - ** pWInfo->a[].iIdxCur The VDBE cursor for the index |
| 109576 | | - ** pWInfo->a[].pTerm When wsFlags==WO_OR, the OR-clause term |
| 109577 | | - ** |
| 109578 | | - ** This loop also figures out the nesting order of tables in the FROM |
| 109579 | | - ** clause. |
| 109580 | | - */ |
| 109581 | | - sWBI.notValid = ~(Bitmask)0; |
| 109582 | | - sWBI.pOrderBy = pOrderBy; |
| 109583 | | - sWBI.n = nTabList; |
| 109584 | | - sWBI.pDistinct = pDistinct; |
| 109585 | | - andFlags = ~0; |
| 109586 | | - WHERETRACE(("*** Optimizer Start ***\n")); |
| 109587 | | - for(sWBI.i=iFrom=0, pLevel=pWInfo->a; sWBI.i<nTabList; sWBI.i++, pLevel++){ |
| 109588 | | - WhereCost bestPlan; /* Most efficient plan seen so far */ |
| 109589 | | - Index *pIdx; /* Index for FROM table at pTabItem */ |
| 109590 | | - int j; /* For looping over FROM tables */ |
| 109591 | | - int bestJ = -1; /* The value of j */ |
| 109592 | | - Bitmask m; /* Bitmask value for j or bestJ */ |
| 109593 | | - int isOptimal; /* Iterator for optimal/non-optimal search */ |
| 109594 | | - int ckOptimal; /* Do the optimal scan check */ |
| 109595 | | - int nUnconstrained; /* Number tables without INDEXED BY */ |
| 109596 | | - Bitmask notIndexed; /* Mask of tables that cannot use an index */ |
| 109597 | | - |
| 109598 | | - memset(&bestPlan, 0, sizeof(bestPlan)); |
| 109599 | | - bestPlan.rCost = SQLITE_BIG_DBL; |
| 109600 | | - WHERETRACE(("*** Begin search for loop %d ***\n", sWBI.i)); |
| 109601 | | - |
| 109602 | | - /* Loop through the remaining entries in the FROM clause to find the |
| 109603 | | - ** next nested loop. The loop tests all FROM clause entries |
| 109604 | | - ** either once or twice. |
| 109605 | | - ** |
| 109606 | | - ** The first test is always performed if there are two or more entries |
| 109607 | | - ** remaining and never performed if there is only one FROM clause entry |
| 109608 | | - ** to choose from. The first test looks for an "optimal" scan. In |
| 109609 | | - ** this context an optimal scan is one that uses the same strategy |
| 109610 | | - ** for the given FROM clause entry as would be selected if the entry |
| 109611 | | - ** were used as the innermost nested loop. In other words, a table |
| 109612 | | - ** is chosen such that the cost of running that table cannot be reduced |
| 109613 | | - ** by waiting for other tables to run first. This "optimal" test works |
| 109614 | | - ** by first assuming that the FROM clause is on the inner loop and finding |
| 109615 | | - ** its query plan, then checking to see if that query plan uses any |
| 109616 | | - ** other FROM clause terms that are sWBI.notValid. If no notValid terms |
| 109617 | | - ** are used then the "optimal" query plan works. |
| 109618 | | - ** |
| 109619 | | - ** Note that the WhereCost.nRow parameter for an optimal scan might |
| 109620 | | - ** not be as small as it would be if the table really were the innermost |
| 109621 | | - ** join. The nRow value can be reduced by WHERE clause constraints |
| 109622 | | - ** that do not use indices. But this nRow reduction only happens if the |
| 109623 | | - ** table really is the innermost join. |
| 109624 | | - ** |
| 109625 | | - ** The second loop iteration is only performed if no optimal scan |
| 109626 | | - ** strategies were found by the first iteration. This second iteration |
| 109627 | | - ** is used to search for the lowest cost scan overall. |
| 109628 | | - ** |
| 109629 | | - ** Without the optimal scan step (the first iteration) a suboptimal |
| 109630 | | - ** plan might be chosen for queries like this: |
| 109631 | | - ** |
| 109632 | | - ** CREATE TABLE t1(a, b); |
| 109633 | | - ** CREATE TABLE t2(c, d); |
| 109634 | | - ** SELECT * FROM t2, t1 WHERE t2.rowid = t1.a; |
| 109635 | | - ** |
| 109636 | | - ** The best strategy is to iterate through table t1 first. However it |
| 109637 | | - ** is not possible to determine this with a simple greedy algorithm. |
| 109638 | | - ** Since the cost of a linear scan through table t2 is the same |
| 109639 | | - ** as the cost of a linear scan through table t1, a simple greedy |
| 109640 | | - ** algorithm may choose to use t2 for the outer loop, which is a much |
| 109641 | | - ** costlier approach. |
| 109642 | | - */ |
| 109643 | | - nUnconstrained = 0; |
| 109644 | | - notIndexed = 0; |
| 109645 | | - |
| 109646 | | - /* The optimal scan check only occurs if there are two or more tables |
| 109647 | | - ** available to be reordered */ |
| 109648 | | - if( iFrom==nTabList-1 ){ |
| 109649 | | - ckOptimal = 0; /* Common case of just one table in the FROM clause */ |
| 109650 | | - }else{ |
| 109651 | | - ckOptimal = -1; |
| 109652 | | - for(j=iFrom, sWBI.pSrc=&pTabList->a[j]; j<nTabList; j++, sWBI.pSrc++){ |
| 109653 | | - m = getMask(pMaskSet, sWBI.pSrc->iCursor); |
| 109654 | | - if( (m & sWBI.notValid)==0 ){ |
| 109655 | | - if( j==iFrom ) iFrom++; |
| 109656 | | - continue; |
| 109657 | | - } |
| 109658 | | - if( j>iFrom && (sWBI.pSrc->jointype & (JT_LEFT|JT_CROSS))!=0 ) break; |
| 109659 | | - if( ++ckOptimal ) break; |
| 109660 | | - if( (sWBI.pSrc->jointype & JT_LEFT)!=0 ) break; |
| 109661 | | - } |
| 109662 | | - } |
| 109663 | | - assert( ckOptimal==0 || ckOptimal==1 ); |
| 109664 | | - |
| 109665 | | - for(isOptimal=ckOptimal; isOptimal>=0 && bestJ<0; isOptimal--){ |
| 109666 | | - for(j=iFrom, sWBI.pSrc=&pTabList->a[j]; j<nTabList; j++, sWBI.pSrc++){ |
| 109667 | | - if( j>iFrom && (sWBI.pSrc->jointype & (JT_LEFT|JT_CROSS))!=0 ){ |
| 109668 | | - /* This break and one like it in the ckOptimal computation loop |
| 109669 | | - ** above prevent table reordering across LEFT and CROSS JOINs. |
| 109670 | | - ** The LEFT JOIN case is necessary for correctness. The prohibition |
| 109671 | | - ** against reordering across a CROSS JOIN is an SQLite feature that |
| 109672 | | - ** allows the developer to control table reordering */ |
| 109673 | | - break; |
| 109674 | | - } |
| 109675 | | - m = getMask(pMaskSet, sWBI.pSrc->iCursor); |
| 109676 | | - if( (m & sWBI.notValid)==0 ){ |
| 109677 | | - assert( j>iFrom ); |
| 109678 | | - continue; |
| 109679 | | - } |
| 109680 | | - sWBI.notReady = (isOptimal ? m : sWBI.notValid); |
| 109681 | | - if( sWBI.pSrc->pIndex==0 ) nUnconstrained++; |
| 109682 | | - |
| 109683 | | - WHERETRACE((" === trying table %d (%s) with isOptimal=%d ===\n", |
| 109684 | | - j, sWBI.pSrc->pTab->zName, isOptimal)); |
| 109685 | | - assert( sWBI.pSrc->pTab ); |
| 109686 | | -#ifndef SQLITE_OMIT_VIRTUALTABLE |
| 109687 | | - if( IsVirtual(sWBI.pSrc->pTab) ){ |
| 109688 | | - sWBI.ppIdxInfo = &pWInfo->a[j].pIdxInfo; |
| 109689 | | - bestVirtualIndex(&sWBI); |
| 109690 | | - }else |
| 109691 | | -#endif |
| 109692 | | - { |
| 109693 | | - bestBtreeIndex(&sWBI); |
| 109694 | | - } |
| 109695 | | - assert( isOptimal || (sWBI.cost.used&sWBI.notValid)==0 ); |
| 109696 | | - |
| 109697 | | - /* If an INDEXED BY clause is present, then the plan must use that |
| 109698 | | - ** index if it uses any index at all */ |
| 109699 | | - assert( sWBI.pSrc->pIndex==0 |
| 109700 | | - || (sWBI.cost.plan.wsFlags & WHERE_NOT_FULLSCAN)==0 |
| 109701 | | - || sWBI.cost.plan.u.pIdx==sWBI.pSrc->pIndex ); |
| 109702 | | - |
| 109703 | | - if( isOptimal && (sWBI.cost.plan.wsFlags & WHERE_NOT_FULLSCAN)==0 ){ |
| 109704 | | - notIndexed |= m; |
| 109705 | | - } |
| 109706 | | - if( isOptimal ){ |
| 109707 | | - pWInfo->a[j].rOptCost = sWBI.cost.rCost; |
| 109708 | | - }else if( ckOptimal ){ |
| 109709 | | - /* If two or more tables have nearly the same outer loop cost, but |
| 109710 | | - ** very different inner loop (optimal) cost, we want to choose |
| 109711 | | - ** for the outer loop that table which benefits the least from |
| 109712 | | - ** being in the inner loop. The following code scales the |
| 109713 | | - ** outer loop cost estimate to accomplish that. */ |
| 109714 | | - WHERETRACE((" scaling cost from %.1f to %.1f\n", |
| 109715 | | - sWBI.cost.rCost, |
| 109716 | | - sWBI.cost.rCost/pWInfo->a[j].rOptCost)); |
| 109717 | | - sWBI.cost.rCost /= pWInfo->a[j].rOptCost; |
| 109718 | | - } |
| 109719 | | - |
| 109720 | | - /* Conditions under which this table becomes the best so far: |
| 109721 | | - ** |
| 109722 | | - ** (1) The table must not depend on other tables that have not |
| 109723 | | - ** yet run. (In other words, it must not depend on tables |
| 109724 | | - ** in inner loops.) |
| 109725 | | - ** |
| 109726 | | - ** (2) (This rule was removed on 2012-11-09. The scaling of the |
| 109727 | | - ** cost using the optimal scan cost made this rule obsolete.) |
| 109728 | | - ** |
| 109729 | | - ** (3) All tables have an INDEXED BY clause or this table lacks an |
| 109730 | | - ** INDEXED BY clause or this table uses the specific |
| 109731 | | - ** index specified by its INDEXED BY clause. This rule ensures |
| 109732 | | - ** that a best-so-far is always selected even if an impossible |
| 109733 | | - ** combination of INDEXED BY clauses are given. The error |
| 109734 | | - ** will be detected and relayed back to the application later. |
| 109735 | | - ** The NEVER() comes about because rule (2) above prevents |
| 109736 | | - ** An indexable full-table-scan from reaching rule (3). |
| 109737 | | - ** |
| 109738 | | - ** (4) The plan cost must be lower than prior plans, where "cost" |
| 109739 | | - ** is defined by the compareCost() function above. |
| 109740 | | - */ |
| 109741 | | - if( (sWBI.cost.used&sWBI.notValid)==0 /* (1) */ |
| 109742 | | - && (nUnconstrained==0 || sWBI.pSrc->pIndex==0 /* (3) */ |
| 109743 | | - || NEVER((sWBI.cost.plan.wsFlags & WHERE_NOT_FULLSCAN)!=0)) |
| 109744 | | - && (bestJ<0 || compareCost(&sWBI.cost, &bestPlan)) /* (4) */ |
| 109745 | | - ){ |
| 109746 | | - WHERETRACE((" === table %d (%s) is best so far\n" |
| 109747 | | - " cost=%.1f, nRow=%.1f, nOBSat=%d, wsFlags=%08x\n", |
| 109748 | | - j, sWBI.pSrc->pTab->zName, |
| 109749 | | - sWBI.cost.rCost, sWBI.cost.plan.nRow, |
| 109750 | | - sWBI.cost.plan.nOBSat, sWBI.cost.plan.wsFlags)); |
| 109751 | | - bestPlan = sWBI.cost; |
| 109752 | | - bestJ = j; |
| 109753 | | - } |
| 109754 | | - |
| 109755 | | - /* In a join like "w JOIN x LEFT JOIN y JOIN z" make sure that |
| 109756 | | - ** table y (and not table z) is always the next inner loop inside |
| 109757 | | - ** of table x. */ |
| 109758 | | - if( (sWBI.pSrc->jointype & JT_LEFT)!=0 ) break; |
| 109759 | | - } |
| 109760 | | - } |
| 109761 | | - assert( bestJ>=0 ); |
| 109762 | | - assert( sWBI.notValid & getMask(pMaskSet, pTabList->a[bestJ].iCursor) ); |
| 109763 | | - assert( bestJ==iFrom || (pTabList->a[iFrom].jointype & JT_LEFT)==0 ); |
| 109764 | | - testcase( bestJ>iFrom && (pTabList->a[iFrom].jointype & JT_CROSS)!=0 ); |
| 109765 | | - testcase( bestJ>iFrom && bestJ<nTabList-1 |
| 109766 | | - && (pTabList->a[bestJ+1].jointype & JT_LEFT)!=0 ); |
| 109767 | | - WHERETRACE(("*** Optimizer selects table %d (%s) for loop %d with:\n" |
| 109768 | | - " cost=%.1f, nRow=%.1f, nOBSat=%d, wsFlags=0x%08x\n", |
| 109769 | | - bestJ, pTabList->a[bestJ].pTab->zName, |
| 109770 | | - pLevel-pWInfo->a, bestPlan.rCost, bestPlan.plan.nRow, |
| 109771 | | - bestPlan.plan.nOBSat, bestPlan.plan.wsFlags)); |
| 109772 | | - if( (bestPlan.plan.wsFlags & WHERE_DISTINCT)!=0 ){ |
| 109773 | | - assert( pWInfo->eDistinct==0 ); |
| 109774 | | - pWInfo->eDistinct = WHERE_DISTINCT_ORDERED; |
| 109775 | | - } |
| 109776 | | - andFlags &= bestPlan.plan.wsFlags; |
| 109777 | | - pLevel->plan = bestPlan.plan; |
| 109778 | | - pLevel->iTabCur = pTabList->a[bestJ].iCursor; |
| 109779 | | - testcase( bestPlan.plan.wsFlags & WHERE_INDEXED ); |
| 109780 | | - testcase( bestPlan.plan.wsFlags & WHERE_TEMP_INDEX ); |
| 109781 | | - if( bestPlan.plan.wsFlags & (WHERE_INDEXED|WHERE_TEMP_INDEX) ){ |
| 109782 | | - if( (wctrlFlags & WHERE_ONETABLE_ONLY) |
| 109783 | | - && (bestPlan.plan.wsFlags & WHERE_TEMP_INDEX)==0 |
| 109784 | | - ){ |
| 109785 | | - pLevel->iIdxCur = iIdxCur; |
| 109786 | | - }else{ |
| 109787 | | - pLevel->iIdxCur = pParse->nTab++; |
| 109788 | | - } |
| 109789 | | - }else{ |
| 109790 | | - pLevel->iIdxCur = -1; |
| 109791 | | - } |
| 109792 | | - sWBI.notValid &= ~getMask(pMaskSet, pTabList->a[bestJ].iCursor); |
| 109793 | | - pLevel->iFrom = (u8)bestJ; |
| 109794 | | - if( bestPlan.plan.nRow>=(double)1 ){ |
| 109795 | | - pParse->nQueryLoop *= bestPlan.plan.nRow; |
| 109796 | | - } |
| 109797 | | - |
| 109798 | | - /* Check that if the table scanned by this loop iteration had an |
| 109799 | | - ** INDEXED BY clause attached to it, that the named index is being |
| 109800 | | - ** used for the scan. If not, then query compilation has failed. |
| 109801 | | - ** Return an error. |
| 109802 | | - */ |
| 109803 | | - pIdx = pTabList->a[bestJ].pIndex; |
| 109804 | | - if( pIdx ){ |
| 109805 | | - if( (bestPlan.plan.wsFlags & WHERE_INDEXED)==0 ){ |
| 109806 | | - sqlite3ErrorMsg(pParse, "cannot use index: %s", pIdx->zName); |
| 109807 | | - goto whereBeginError; |
| 109808 | | - }else{ |
| 109809 | | - /* If an INDEXED BY clause is used, the bestIndex() function is |
| 109810 | | - ** guaranteed to find the index specified in the INDEXED BY clause |
| 109811 | | - ** if it find an index at all. */ |
| 109812 | | - assert( bestPlan.plan.u.pIdx==pIdx ); |
| 109813 | | - } |
| 109814 | | - } |
| 109815 | | - } |
| 109816 | | - WHERETRACE(("*** Optimizer Finished ***\n")); |
| 109817 | | - if( pParse->nErr || db->mallocFailed ){ |
| 109818 | | - goto whereBeginError; |
| 109819 | | - } |
| 109820 | | - if( nTabList ){ |
| 109821 | | - pLevel--; |
| 109822 | | - pWInfo->nOBSat = pLevel->plan.nOBSat; |
| 109823 | | - }else{ |
| 109824 | | - pWInfo->nOBSat = 0; |
| 109825 | | - } |
| 109826 | | - |
| 109827 | | - /* If the total query only selects a single row, then the ORDER BY |
| 109828 | | - ** clause is irrelevant. |
| 109829 | | - */ |
| 109830 | | - if( (andFlags & WHERE_UNIQUE)!=0 && pOrderBy ){ |
| 109831 | | - assert( nTabList==0 || (pLevel->plan.wsFlags & WHERE_ALL_UNIQUE)!=0 ); |
| 109832 | | - pWInfo->nOBSat = pOrderBy->nExpr; |
| 109833 | | - } |
| 109998 | + if( pDistinct ){ |
| 109999 | + if( isDistinctRedundant(pParse,pTabList,&pWInfo->sWC,pDistinct) ){ |
| 110000 | + pDistinct = 0; |
| 110001 | + pWInfo->eDistinct = WHERE_DISTINCT_UNIQUE; |
| 110002 | + }else if( pOrderBy==0 ){ |
| 110003 | + pWInfo->wctrlFlags |= WHERE_DISTINCTBY; |
| 110004 | + pWInfo->pOrderBy = pDistinct; |
| 110005 | + } |
| 110006 | + } |
| 110007 | + |
| 110008 | + /* Construct the WhereLoop objects */ |
| 110009 | + WHERETRACE(0xffff,("*** Optimizer Start ***\n")); |
| 110010 | + if( nTabList!=1 || whereShortCut(&sWLB)==0 ){ |
| 110011 | + rc = whereLoopAddAll(&sWLB); |
| 110012 | + if( rc ) goto whereBeginError; |
| 110013 | + |
| 110014 | + /* Display all of the WhereLoop objects if wheretrace is enabled */ |
| 110015 | +#ifdef WHERETRACE_ENABLED |
| 110016 | + if( sqlite3WhereTrace ){ |
| 110017 | + WhereLoop *p; |
| 110018 | + int i = 0; |
| 110019 | + static char zLabel[] = "0123456789abcdefghijklmnopqrstuvwyxz" |
| 110020 | + "ABCDEFGHIJKLMNOPQRSTUVWYXZ"; |
| 110021 | + for(p=pWInfo->pLoops; p; p=p->pNextLoop){ |
| 110022 | + p->cId = zLabel[(i++)%sizeof(zLabel)]; |
| 110023 | + whereLoopPrint(p, pTabList); |
| 110024 | + } |
| 110025 | + } |
| 110026 | +#endif |
| 110027 | + |
| 110028 | + wherePathSolver(pWInfo, 0); |
| 110029 | + if( db->mallocFailed ) goto whereBeginError; |
| 110030 | + if( pWInfo->pOrderBy ){ |
| 110031 | + wherePathSolver(pWInfo, pWInfo->nRowOut+1); |
| 110032 | + if( db->mallocFailed ) goto whereBeginError; |
| 110033 | + } |
| 110034 | + } |
| 110035 | + if( pWInfo->pOrderBy==0 && (db->flags & SQLITE_ReverseOrder)!=0 ){ |
| 110036 | + pWInfo->revMask = (Bitmask)(-1); |
| 110037 | + } |
| 110038 | + if( pParse->nErr || NEVER(db->mallocFailed) ){ |
| 110039 | + goto whereBeginError; |
| 110040 | + } |
| 110041 | +#ifdef WHERETRACE_ENABLED |
| 110042 | + if( sqlite3WhereTrace ){ |
| 110043 | + int ii; |
| 110044 | + sqlite3DebugPrintf("---- Solution nRow=%d", pWInfo->nRowOut); |
| 110045 | + if( pWInfo->bOBSat ){ |
| 110046 | + sqlite3DebugPrintf(" ORDERBY=0x%llx", pWInfo->revMask); |
| 110047 | + } |
| 110048 | + switch( pWInfo->eDistinct ){ |
| 110049 | + case WHERE_DISTINCT_UNIQUE: { |
| 110050 | + sqlite3DebugPrintf(" DISTINCT=unique"); |
| 110051 | + break; |
| 110052 | + } |
| 110053 | + case WHERE_DISTINCT_ORDERED: { |
| 110054 | + sqlite3DebugPrintf(" DISTINCT=ordered"); |
| 110055 | + break; |
| 110056 | + } |
| 110057 | + case WHERE_DISTINCT_UNORDERED: { |
| 110058 | + sqlite3DebugPrintf(" DISTINCT=unordered"); |
| 110059 | + break; |
| 110060 | + } |
| 110061 | + } |
| 110062 | + sqlite3DebugPrintf("\n"); |
| 110063 | + for(ii=0; ii<nTabList; ii++){ |
| 110064 | + whereLoopPrint(pWInfo->a[ii].pWLoop, pTabList); |
| 110065 | + } |
| 110066 | + } |
| 110067 | +#endif |
| 110068 | + WHERETRACE(0xffff,("*** Optimizer Finished ***\n")); |
| 110069 | + pWInfo->pParse->nQueryLoop += pWInfo->nRowOut; |
| 109834 | 110070 | |
| 109835 | 110071 | /* If the caller is an UPDATE or DELETE statement that is requesting |
| 109836 | 110072 | ** to use a one-pass algorithm, determine if this is appropriate. |
| 109837 | 110073 | ** The one-pass algorithm only works if the WHERE clause constraints |
| 109838 | 110074 | ** the statement to update a single row. |
| 109839 | 110075 | */ |
| 109840 | 110076 | assert( (wctrlFlags & WHERE_ONEPASS_DESIRED)==0 || pWInfo->nLevel==1 ); |
| 109841 | | - if( (wctrlFlags & WHERE_ONEPASS_DESIRED)!=0 && (andFlags & WHERE_UNIQUE)!=0 ){ |
| 110077 | + if( (wctrlFlags & WHERE_ONEPASS_DESIRED)!=0 |
| 110078 | + && (pWInfo->a[0].pWLoop->wsFlags & WHERE_ONEROW)!=0 ){ |
| 109842 | 110079 | pWInfo->okOnePass = 1; |
| 109843 | | - pWInfo->a[0].plan.wsFlags &= ~WHERE_IDX_ONLY; |
| 110080 | + pWInfo->a[0].pWLoop->wsFlags &= ~WHERE_IDX_ONLY; |
| 109844 | 110081 | } |
| 109845 | 110082 | |
| 109846 | 110083 | /* Open all tables in the pTabList and any indices selected for |
| 109847 | 110084 | ** searching those tables. |
| 109848 | 110085 | */ |
| 109849 | 110086 | sqlite3CodeVerifySchema(pParse, -1); /* Insert the cookie verifier Goto */ |
| 109850 | 110087 | notReady = ~(Bitmask)0; |
| 109851 | | - pWInfo->nRowOut = (double)1; |
| 109852 | 110088 | for(ii=0, pLevel=pWInfo->a; ii<nTabList; ii++, pLevel++){ |
| 109853 | 110089 | Table *pTab; /* Table to open */ |
| 109854 | 110090 | int iDb; /* Index of database containing table/index */ |
| 109855 | 110091 | struct SrcList_item *pTabItem; |
| 110092 | + WhereLoop *pLoop; |
| 109856 | 110093 | |
| 109857 | 110094 | pTabItem = &pTabList->a[pLevel->iFrom]; |
| 109858 | 110095 | pTab = pTabItem->pTab; |
| 109859 | | - pWInfo->nRowOut *= pLevel->plan.nRow; |
| 109860 | 110096 | iDb = sqlite3SchemaToIndex(db, pTab->pSchema); |
| 110097 | + pLoop = pLevel->pWLoop; |
| 109861 | 110098 | if( (pTab->tabFlags & TF_Ephemeral)!=0 || pTab->pSelect ){ |
| 109862 | 110099 | /* Do nothing */ |
| 109863 | 110100 | }else |
| 109864 | 110101 | #ifndef SQLITE_OMIT_VIRTUALTABLE |
| 109865 | | - if( (pLevel->plan.wsFlags & WHERE_VIRTUALTABLE)!=0 ){ |
| 110102 | + if( (pLoop->wsFlags & WHERE_VIRTUALTABLE)!=0 ){ |
| 109866 | 110103 | const char *pVTab = (const char *)sqlite3GetVTable(db, pTab); |
| 109867 | 110104 | int iCur = pTabItem->iCursor; |
| 109868 | 110105 | sqlite3VdbeAddOp4(v, OP_VOpen, iCur, 0, 0, pVTab, P4_VTAB); |
| 109869 | 110106 | }else if( IsVirtual(pTab) ){ |
| 109870 | 110107 | /* noop */ |
| 109871 | 110108 | }else |
| 109872 | 110109 | #endif |
| 109873 | | - if( (pLevel->plan.wsFlags & WHERE_IDX_ONLY)==0 |
| 110110 | + if( (pLoop->wsFlags & WHERE_IDX_ONLY)==0 |
| 109874 | 110111 | && (wctrlFlags & WHERE_OMIT_OPEN_CLOSE)==0 ){ |
| 109875 | 110112 | int op = pWInfo->okOnePass ? OP_OpenWrite : OP_OpenRead; |
| 109876 | 110113 | sqlite3OpenTable(pParse, pTabItem->iCursor, iDb, pTab, op); |
| 109877 | | - testcase( pTab->nCol==BMS-1 ); |
| 109878 | | - testcase( pTab->nCol==BMS ); |
| 110114 | + testcase( !pWInfo->okOnePass && pTab->nCol==BMS-1 ); |
| 110115 | + testcase( !pWInfo->okOnePass && pTab->nCol==BMS ); |
| 109879 | 110116 | if( !pWInfo->okOnePass && pTab->nCol<BMS ){ |
| 109880 | 110117 | Bitmask b = pTabItem->colUsed; |
| 109881 | 110118 | int n = 0; |
| 109882 | 110119 | for(; b; b=b>>1, n++){} |
| 109883 | 110120 | sqlite3VdbeChangeP4(v, sqlite3VdbeCurrentAddr(v)-1, |
| | @@ -109886,26 +110123,27 @@ |
| 109886 | 110123 | } |
| 109887 | 110124 | }else{ |
| 109888 | 110125 | sqlite3TableLock(pParse, iDb, pTab->tnum, 0, pTab->zName); |
| 109889 | 110126 | } |
| 109890 | 110127 | #ifndef SQLITE_OMIT_AUTOMATIC_INDEX |
| 109891 | | - if( (pLevel->plan.wsFlags & WHERE_TEMP_INDEX)!=0 ){ |
| 109892 | | - constructAutomaticIndex(pParse, sWBI.pWC, pTabItem, notReady, pLevel); |
| 110128 | + if( (pLoop->wsFlags & WHERE_TEMP_INDEX)!=0 ){ |
| 110129 | + constructAutomaticIndex(pParse, &pWInfo->sWC, pTabItem, notReady, pLevel); |
| 109893 | 110130 | }else |
| 109894 | 110131 | #endif |
| 109895 | | - if( (pLevel->plan.wsFlags & WHERE_INDEXED)!=0 ){ |
| 109896 | | - Index *pIx = pLevel->plan.u.pIdx; |
| 110132 | + if( pLoop->wsFlags & WHERE_INDEXED ){ |
| 110133 | + Index *pIx = pLoop->u.btree.pIndex; |
| 109897 | 110134 | KeyInfo *pKey = sqlite3IndexKeyinfo(pParse, pIx); |
| 109898 | | - int iIndexCur = pLevel->iIdxCur; |
| 110135 | + /* FIXME: As an optimization use pTabItem->iCursor if WHERE_IDX_ONLY */ |
| 110136 | + int iIndexCur = pLevel->iIdxCur = iIdxCur ? iIdxCur : pParse->nTab++; |
| 109899 | 110137 | assert( pIx->pSchema==pTab->pSchema ); |
| 109900 | 110138 | assert( iIndexCur>=0 ); |
| 109901 | 110139 | sqlite3VdbeAddOp4(v, OP_OpenRead, iIndexCur, pIx->tnum, iDb, |
| 109902 | 110140 | (char*)pKey, P4_KEYINFO_HANDOFF); |
| 109903 | 110141 | VdbeComment((v, "%s", pIx->zName)); |
| 109904 | 110142 | } |
| 109905 | 110143 | sqlite3CodeVerifySchema(pParse, iDb); |
| 109906 | | - notReady &= ~getMask(sWBI.pWC->pMaskSet, pTabItem->iCursor); |
| 110144 | + notReady &= ~getMask(&pWInfo->sMaskSet, pTabItem->iCursor); |
| 109907 | 110145 | } |
| 109908 | 110146 | pWInfo->iTop = sqlite3VdbeCurrentAddr(v); |
| 109909 | 110147 | if( db->mallocFailed ) goto whereBeginError; |
| 109910 | 110148 | |
| 109911 | 110149 | /* Generate the code to do the search. Each iteration of the for |
| | @@ -109914,70 +110152,15 @@ |
| 109914 | 110152 | */ |
| 109915 | 110153 | notReady = ~(Bitmask)0; |
| 109916 | 110154 | for(ii=0; ii<nTabList; ii++){ |
| 109917 | 110155 | pLevel = &pWInfo->a[ii]; |
| 109918 | 110156 | explainOneScan(pParse, pTabList, pLevel, ii, pLevel->iFrom, wctrlFlags); |
| 109919 | | - notReady = codeOneLoopStart(pWInfo, ii, wctrlFlags, notReady); |
| 110157 | + notReady = codeOneLoopStart(pWInfo, ii, notReady); |
| 109920 | 110158 | pWInfo->iContinue = pLevel->addrCont; |
| 109921 | 110159 | } |
| 109922 | 110160 | |
| 109923 | | -#ifdef SQLITE_TEST /* For testing and debugging use only */ |
| 109924 | | - /* Record in the query plan information about the current table |
| 109925 | | - ** and the index used to access it (if any). If the table itself |
| 109926 | | - ** is not used, its name is just '{}'. If no index is used |
| 109927 | | - ** the index is listed as "{}". If the primary key is used the |
| 109928 | | - ** index name is '*'. |
| 109929 | | - */ |
| 109930 | | - for(ii=0; ii<nTabList; ii++){ |
| 109931 | | - char *z; |
| 109932 | | - int n; |
| 109933 | | - int w; |
| 109934 | | - struct SrcList_item *pTabItem; |
| 109935 | | - |
| 109936 | | - pLevel = &pWInfo->a[ii]; |
| 109937 | | - w = pLevel->plan.wsFlags; |
| 109938 | | - pTabItem = &pTabList->a[pLevel->iFrom]; |
| 109939 | | - z = pTabItem->zAlias; |
| 109940 | | - if( z==0 ) z = pTabItem->pTab->zName; |
| 109941 | | - n = sqlite3Strlen30(z); |
| 109942 | | - if( n+nQPlan < sizeof(sqlite3_query_plan)-10 ){ |
| 109943 | | - if( (w & WHERE_IDX_ONLY)!=0 && (w & WHERE_COVER_SCAN)==0 ){ |
| 109944 | | - memcpy(&sqlite3_query_plan[nQPlan], "{}", 2); |
| 109945 | | - nQPlan += 2; |
| 109946 | | - }else{ |
| 109947 | | - memcpy(&sqlite3_query_plan[nQPlan], z, n); |
| 109948 | | - nQPlan += n; |
| 109949 | | - } |
| 109950 | | - sqlite3_query_plan[nQPlan++] = ' '; |
| 109951 | | - } |
| 109952 | | - testcase( w & WHERE_ROWID_EQ ); |
| 109953 | | - testcase( w & WHERE_ROWID_RANGE ); |
| 109954 | | - if( w & (WHERE_ROWID_EQ|WHERE_ROWID_RANGE) ){ |
| 109955 | | - memcpy(&sqlite3_query_plan[nQPlan], "* ", 2); |
| 109956 | | - nQPlan += 2; |
| 109957 | | - }else if( (w & WHERE_INDEXED)!=0 && (w & WHERE_COVER_SCAN)==0 ){ |
| 109958 | | - n = sqlite3Strlen30(pLevel->plan.u.pIdx->zName); |
| 109959 | | - if( n+nQPlan < sizeof(sqlite3_query_plan)-2 ){ |
| 109960 | | - memcpy(&sqlite3_query_plan[nQPlan], pLevel->plan.u.pIdx->zName, n); |
| 109961 | | - nQPlan += n; |
| 109962 | | - sqlite3_query_plan[nQPlan++] = ' '; |
| 109963 | | - } |
| 109964 | | - }else{ |
| 109965 | | - memcpy(&sqlite3_query_plan[nQPlan], "{} ", 3); |
| 109966 | | - nQPlan += 3; |
| 109967 | | - } |
| 109968 | | - } |
| 109969 | | - while( nQPlan>0 && sqlite3_query_plan[nQPlan-1]==' ' ){ |
| 109970 | | - sqlite3_query_plan[--nQPlan] = 0; |
| 109971 | | - } |
| 109972 | | - sqlite3_query_plan[nQPlan] = 0; |
| 109973 | | - nQPlan = 0; |
| 109974 | | -#endif /* SQLITE_TEST // Testing and debugging use only */ |
| 109975 | | - |
| 109976 | | - /* Record the continuation address in the WhereInfo structure. Then |
| 109977 | | - ** clean up and return. |
| 109978 | | - */ |
| 110161 | + /* Done. */ |
| 109979 | 110162 | return pWInfo; |
| 109980 | 110163 | |
| 109981 | 110164 | /* Jump here if malloc fails */ |
| 109982 | 110165 | whereBeginError: |
| 109983 | 110166 | if( pWInfo ){ |
| | @@ -109994,24 +110177,26 @@ |
| 109994 | 110177 | SQLITE_PRIVATE void sqlite3WhereEnd(WhereInfo *pWInfo){ |
| 109995 | 110178 | Parse *pParse = pWInfo->pParse; |
| 109996 | 110179 | Vdbe *v = pParse->pVdbe; |
| 109997 | 110180 | int i; |
| 109998 | 110181 | WhereLevel *pLevel; |
| 110182 | + WhereLoop *pLoop; |
| 109999 | 110183 | SrcList *pTabList = pWInfo->pTabList; |
| 110000 | 110184 | sqlite3 *db = pParse->db; |
| 110001 | 110185 | |
| 110002 | 110186 | /* Generate loop termination code. |
| 110003 | 110187 | */ |
| 110004 | 110188 | sqlite3ExprCacheClear(pParse); |
| 110005 | 110189 | for(i=pWInfo->nLevel-1; i>=0; i--){ |
| 110006 | 110190 | pLevel = &pWInfo->a[i]; |
| 110191 | + pLoop = pLevel->pWLoop; |
| 110007 | 110192 | sqlite3VdbeResolveLabel(v, pLevel->addrCont); |
| 110008 | 110193 | if( pLevel->op!=OP_Noop ){ |
| 110009 | 110194 | sqlite3VdbeAddOp2(v, pLevel->op, pLevel->p1, pLevel->p2); |
| 110010 | 110195 | sqlite3VdbeChangeP5(v, pLevel->p5); |
| 110011 | 110196 | } |
| 110012 | | - if( pLevel->plan.wsFlags & WHERE_IN_ABLE && pLevel->u.in.nIn>0 ){ |
| 110197 | + if( pLoop->wsFlags & WHERE_IN_ABLE && pLevel->u.in.nIn>0 ){ |
| 110013 | 110198 | struct InLoop *pIn; |
| 110014 | 110199 | int j; |
| 110015 | 110200 | sqlite3VdbeResolveLabel(v, pLevel->addrNxt); |
| 110016 | 110201 | for(j=pLevel->u.in.nIn, pIn=&pLevel->u.in.aInLoop[j-1]; j>0; j--, pIn--){ |
| 110017 | 110202 | sqlite3VdbeJumpHere(v, pIn->addrInTop+1); |
| | @@ -110022,16 +110207,16 @@ |
| 110022 | 110207 | } |
| 110023 | 110208 | sqlite3VdbeResolveLabel(v, pLevel->addrBrk); |
| 110024 | 110209 | if( pLevel->iLeftJoin ){ |
| 110025 | 110210 | int addr; |
| 110026 | 110211 | addr = sqlite3VdbeAddOp1(v, OP_IfPos, pLevel->iLeftJoin); |
| 110027 | | - assert( (pLevel->plan.wsFlags & WHERE_IDX_ONLY)==0 |
| 110028 | | - || (pLevel->plan.wsFlags & WHERE_INDEXED)!=0 ); |
| 110029 | | - if( (pLevel->plan.wsFlags & WHERE_IDX_ONLY)==0 ){ |
| 110212 | + assert( (pLoop->wsFlags & WHERE_IDX_ONLY)==0 |
| 110213 | + || (pLoop->wsFlags & WHERE_INDEXED)!=0 ); |
| 110214 | + if( (pLoop->wsFlags & WHERE_IDX_ONLY)==0 ){ |
| 110030 | 110215 | sqlite3VdbeAddOp1(v, OP_NullRow, pTabList->a[i].iCursor); |
| 110031 | 110216 | } |
| 110032 | | - if( pLevel->iIdxCur>=0 ){ |
| 110217 | + if( pLoop->wsFlags & WHERE_INDEXED ){ |
| 110033 | 110218 | sqlite3VdbeAddOp1(v, OP_NullRow, pLevel->iIdxCur); |
| 110034 | 110219 | } |
| 110035 | 110220 | if( pLevel->op==OP_Return ){ |
| 110036 | 110221 | sqlite3VdbeAddOp2(v, OP_Gosub, pLevel->p1, pLevel->addrFirst); |
| 110037 | 110222 | }else{ |
| | @@ -110052,42 +110237,41 @@ |
| 110052 | 110237 | for(i=0, pLevel=pWInfo->a; i<pWInfo->nLevel; i++, pLevel++){ |
| 110053 | 110238 | Index *pIdx = 0; |
| 110054 | 110239 | struct SrcList_item *pTabItem = &pTabList->a[pLevel->iFrom]; |
| 110055 | 110240 | Table *pTab = pTabItem->pTab; |
| 110056 | 110241 | assert( pTab!=0 ); |
| 110242 | + pLoop = pLevel->pWLoop; |
| 110057 | 110243 | if( (pTab->tabFlags & TF_Ephemeral)==0 |
| 110058 | 110244 | && pTab->pSelect==0 |
| 110059 | 110245 | && (pWInfo->wctrlFlags & WHERE_OMIT_OPEN_CLOSE)==0 |
| 110060 | 110246 | ){ |
| 110061 | | - int ws = pLevel->plan.wsFlags; |
| 110247 | + int ws = pLoop->wsFlags; |
| 110062 | 110248 | if( !pWInfo->okOnePass && (ws & WHERE_IDX_ONLY)==0 ){ |
| 110063 | 110249 | sqlite3VdbeAddOp1(v, OP_Close, pTabItem->iCursor); |
| 110064 | 110250 | } |
| 110065 | | - if( (ws & WHERE_INDEXED)!=0 && (ws & WHERE_TEMP_INDEX)==0 ){ |
| 110251 | + if( (ws & WHERE_INDEXED)!=0 && (ws & (WHERE_IPK|WHERE_TEMP_INDEX))==0 ){ |
| 110066 | 110252 | sqlite3VdbeAddOp1(v, OP_Close, pLevel->iIdxCur); |
| 110067 | 110253 | } |
| 110068 | 110254 | } |
| 110069 | 110255 | |
| 110070 | | - /* If this scan uses an index, make code substitutions to read data |
| 110071 | | - ** from the index in preference to the table. Sometimes, this means |
| 110072 | | - ** the table need never be read from. This is a performance boost, |
| 110073 | | - ** as the vdbe level waits until the table is read before actually |
| 110074 | | - ** seeking the table cursor to the record corresponding to the current |
| 110075 | | - ** position in the index. |
| 110256 | + /* If this scan uses an index, make VDBE code substitutions to read data |
| 110257 | + ** from the index instead of from the table where possible. In some cases |
| 110258 | + ** this optimization prevents the table from ever being read, which can |
| 110259 | + ** yield a significant performance boost. |
| 110076 | 110260 | ** |
| 110077 | 110261 | ** Calls to the code generator in between sqlite3WhereBegin and |
| 110078 | 110262 | ** sqlite3WhereEnd will have created code that references the table |
| 110079 | 110263 | ** directly. This loop scans all that code looking for opcodes |
| 110080 | 110264 | ** that reference the table and converts them into opcodes that |
| 110081 | 110265 | ** reference the index. |
| 110082 | 110266 | */ |
| 110083 | | - if( pLevel->plan.wsFlags & WHERE_INDEXED ){ |
| 110084 | | - pIdx = pLevel->plan.u.pIdx; |
| 110085 | | - }else if( pLevel->plan.wsFlags & WHERE_MULTI_OR ){ |
| 110267 | + if( pLoop->wsFlags & (WHERE_INDEXED|WHERE_IDX_ONLY) ){ |
| 110268 | + pIdx = pLoop->u.btree.pIndex; |
| 110269 | + }else if( pLoop->wsFlags & WHERE_MULTI_OR ){ |
| 110086 | 110270 | pIdx = pLevel->u.pCovidx; |
| 110087 | 110271 | } |
| 110088 | | - if( pIdx && !db->mallocFailed){ |
| 110272 | + if( pIdx && !db->mallocFailed ){ |
| 110089 | 110273 | int k, j, last; |
| 110090 | 110274 | VdbeOp *pOp; |
| 110091 | 110275 | |
| 110092 | 110276 | pOp = sqlite3VdbeGetOp(v, pWInfo->iTop); |
| 110093 | 110277 | last = sqlite3VdbeCurrentAddr(v); |
| | @@ -110099,12 +110283,11 @@ |
| 110099 | 110283 | pOp->p2 = j; |
| 110100 | 110284 | pOp->p1 = pLevel->iIdxCur; |
| 110101 | 110285 | break; |
| 110102 | 110286 | } |
| 110103 | 110287 | } |
| 110104 | | - assert( (pLevel->plan.wsFlags & WHERE_IDX_ONLY)==0 |
| 110105 | | - || j<pIdx->nColumn ); |
| 110288 | + assert( (pLoop->wsFlags & WHERE_IDX_ONLY)==0 || j<pIdx->nColumn ); |
| 110106 | 110289 | }else if( pOp->opcode==OP_Rowid ){ |
| 110107 | 110290 | pOp->p1 = pLevel->iIdxCur; |
| 110108 | 110291 | pOp->opcode = OP_IdxRowid; |
| 110109 | 110292 | } |
| 110110 | 110293 | } |
| | @@ -115480,11 +115663,11 @@ |
| 115480 | 115663 | } |
| 115481 | 115664 | |
| 115482 | 115665 | /* |
| 115483 | 115666 | ** Another built-in collating sequence: NOCASE. |
| 115484 | 115667 | ** |
| 115485 | | -** This collating sequence is intended to be used for "case independant |
| 115668 | +** This collating sequence is intended to be used for "case independent |
| 115486 | 115669 | ** comparison". SQLite's knowledge of upper and lower case equivalents |
| 115487 | 115670 | ** extends only to the 26 characters used in the English language. |
| 115488 | 115671 | ** |
| 115489 | 115672 | ** At the moment there is only a UTF-8 implementation. |
| 115490 | 115673 | */ |
| | @@ -115627,16 +115810,10 @@ |
| 115627 | 115810 | "statements or unfinished backups"); |
| 115628 | 115811 | sqlite3_mutex_leave(db->mutex); |
| 115629 | 115812 | return SQLITE_BUSY; |
| 115630 | 115813 | } |
| 115631 | 115814 | |
| 115632 | | - /* If a transaction is open, roll it back. This also ensures that if |
| 115633 | | - ** any database schemas have been modified by the current transaction |
| 115634 | | - ** they are reset. And that the required b-tree mutex is held to make |
| 115635 | | - ** the the pager rollback and schema reset an atomic operation. */ |
| 115636 | | - sqlite3RollbackAll(db, SQLITE_OK); |
| 115637 | | - |
| 115638 | 115815 | #ifdef SQLITE_ENABLE_SQLLOG |
| 115639 | 115816 | if( sqlite3GlobalConfig.xSqllog ){ |
| 115640 | 115817 | /* Closing the handle. Fourth parameter is passed the value 2. */ |
| 115641 | 115818 | sqlite3GlobalConfig.xSqllog(sqlite3GlobalConfig.pSqllogArg, db, 0, 2); |
| 115642 | 115819 | } |
| | @@ -115686,10 +115863,16 @@ |
| 115686 | 115863 | /* If we reach this point, it means that the database connection has |
| 115687 | 115864 | ** closed all sqlite3_stmt and sqlite3_backup objects and has been |
| 115688 | 115865 | ** passed to sqlite3_close (meaning that it is a zombie). Therefore, |
| 115689 | 115866 | ** go ahead and free all resources. |
| 115690 | 115867 | */ |
| 115868 | + |
| 115869 | + /* If a transaction is open, roll it back. This also ensures that if |
| 115870 | + ** any database schemas have been modified by an uncommitted transaction |
| 115871 | + ** they are reset. And that the required b-tree mutex is held to make |
| 115872 | + ** the pager rollback and schema reset an atomic operation. */ |
| 115873 | + sqlite3RollbackAll(db, SQLITE_OK); |
| 115691 | 115874 | |
| 115692 | 115875 | /* Free any outstanding Savepoint structures. */ |
| 115693 | 115876 | sqlite3CloseSavepoints(db); |
| 115694 | 115877 | |
| 115695 | 115878 | /* Close all database connections */ |
| | @@ -115787,19 +115970,26 @@ |
| 115787 | 115970 | SQLITE_PRIVATE void sqlite3RollbackAll(sqlite3 *db, int tripCode){ |
| 115788 | 115971 | int i; |
| 115789 | 115972 | int inTrans = 0; |
| 115790 | 115973 | assert( sqlite3_mutex_held(db->mutex) ); |
| 115791 | 115974 | sqlite3BeginBenignMalloc(); |
| 115975 | + |
| 115976 | + /* Obtain all b-tree mutexes before making any calls to BtreeRollback(). |
| 115977 | + ** This is important in case the transaction being rolled back has |
| 115978 | + ** modified the database schema. If the b-tree mutexes are not taken |
| 115979 | + ** here, then another shared-cache connection might sneak in between |
| 115980 | + ** the database rollback and schema reset, which can cause false |
| 115981 | + ** corruption reports in some cases. */ |
| 115792 | 115982 | sqlite3BtreeEnterAll(db); |
| 115983 | + |
| 115793 | 115984 | for(i=0; i<db->nDb; i++){ |
| 115794 | 115985 | Btree *p = db->aDb[i].pBt; |
| 115795 | 115986 | if( p ){ |
| 115796 | 115987 | if( sqlite3BtreeIsInTrans(p) ){ |
| 115797 | 115988 | inTrans = 1; |
| 115798 | 115989 | } |
| 115799 | 115990 | sqlite3BtreeRollback(p, tripCode); |
| 115800 | | - db->aDb[i].inTrans = 0; |
| 115801 | 115991 | } |
| 115802 | 115992 | } |
| 115803 | 115993 | sqlite3VtabRollback(db); |
| 115804 | 115994 | sqlite3EndBenignMalloc(); |
| 115805 | 115995 | |
| | @@ -117562,12 +117752,10 @@ |
| 117562 | 117752 | /* |
| 117563 | 117753 | ** Test to see whether or not the database connection is in autocommit |
| 117564 | 117754 | ** mode. Return TRUE if it is and FALSE if not. Autocommit mode is on |
| 117565 | 117755 | ** by default. Autocommit is disabled by a BEGIN statement and reenabled |
| 117566 | 117756 | ** by the next COMMIT or ROLLBACK. |
| 117567 | | -** |
| 117568 | | -******* THIS IS AN EXPERIMENTAL API AND IS SUBJECT TO CHANGE ****** |
| 117569 | 117757 | */ |
| 117570 | 117758 | SQLITE_API int sqlite3_get_autocommit(sqlite3 *db){ |
| 117571 | 117759 | return db->autoCommit; |
| 117572 | 117760 | } |
| 117573 | 117761 | |
| | @@ -119051,10 +119239,22 @@ |
| 119051 | 119239 | |
| 119052 | 119240 | #endif /* _FTS3_HASH_H_ */ |
| 119053 | 119241 | |
| 119054 | 119242 | /************** End of fts3_hash.h *******************************************/ |
| 119055 | 119243 | /************** Continuing where we left off in fts3Int.h ********************/ |
| 119244 | + |
| 119245 | +/* |
| 119246 | +** This constant determines the maximum depth of an FTS expression tree |
| 119247 | +** that the library will create and use. FTS uses recursion to perform |
| 119248 | +** various operations on the query tree, so the disadvantage of a large |
| 119249 | +** limit is that it may allow very large queries to use large amounts |
| 119250 | +** of stack space (perhaps causing a stack overflow). |
| 119251 | +*/ |
| 119252 | +#ifndef SQLITE_FTS3_MAX_EXPR_DEPTH |
| 119253 | +# define SQLITE_FTS3_MAX_EXPR_DEPTH 12 |
| 119254 | +#endif |
| 119255 | + |
| 119056 | 119256 | |
| 119057 | 119257 | /* |
| 119058 | 119258 | ** This constant controls how often segments are merged. Once there are |
| 119059 | 119259 | ** FTS3_MERGE_COUNT segments of level N, they are merged into a single |
| 119060 | 119260 | ** segment of level N+1. |
| | @@ -120709,11 +120909,11 @@ |
| 120709 | 120909 | /* By default use a full table scan. This is an expensive option, |
| 120710 | 120910 | ** so search through the constraints to see if a more efficient |
| 120711 | 120911 | ** strategy is possible. |
| 120712 | 120912 | */ |
| 120713 | 120913 | pInfo->idxNum = FTS3_FULLSCAN_SEARCH; |
| 120714 | | - pInfo->estimatedCost = 500000; |
| 120914 | + pInfo->estimatedCost = 5000000; |
| 120715 | 120915 | for(i=0; i<pInfo->nConstraint; i++){ |
| 120716 | 120916 | struct sqlite3_index_constraint *pCons = &pInfo->aConstraint[i]; |
| 120717 | 120917 | if( pCons->usable==0 ) continue; |
| 120718 | 120918 | |
| 120719 | 120919 | /* A direct lookup on the rowid or docid column. Assign a cost of 1.0. */ |
| | @@ -122270,15 +122470,11 @@ |
| 122270 | 122470 | ); |
| 122271 | 122471 | if( rc!=SQLITE_OK ){ |
| 122272 | 122472 | return rc; |
| 122273 | 122473 | } |
| 122274 | 122474 | |
| 122275 | | - rc = sqlite3Fts3ReadLock(p); |
| 122276 | | - if( rc!=SQLITE_OK ) return rc; |
| 122277 | | - |
| 122278 | 122475 | rc = fts3EvalStart(pCsr); |
| 122279 | | - |
| 122280 | 122476 | sqlite3Fts3SegmentsClose(p); |
| 122281 | 122477 | if( rc!=SQLITE_OK ) return rc; |
| 122282 | 122478 | pCsr->pNextId = pCsr->aDoclist; |
| 122283 | 122479 | pCsr->iPrevId = 0; |
| 122284 | 122480 | } |
| | @@ -126129,30 +126325,30 @@ |
| 126129 | 126325 | int iDefaultCol, /* Default column to query */ |
| 126130 | 126326 | const char *z, int n, /* Text of MATCH query */ |
| 126131 | 126327 | Fts3Expr **ppExpr, /* OUT: Parsed query structure */ |
| 126132 | 126328 | char **pzErr /* OUT: Error message (sqlite3_malloc) */ |
| 126133 | 126329 | ){ |
| 126134 | | - static const int MAX_EXPR_DEPTH = 12; |
| 126135 | 126330 | int rc = fts3ExprParseUnbalanced( |
| 126136 | 126331 | pTokenizer, iLangid, azCol, bFts4, nCol, iDefaultCol, z, n, ppExpr |
| 126137 | 126332 | ); |
| 126138 | 126333 | |
| 126139 | 126334 | /* Rebalance the expression. And check that its depth does not exceed |
| 126140 | | - ** MAX_EXPR_DEPTH. */ |
| 126335 | + ** SQLITE_FTS3_MAX_EXPR_DEPTH. */ |
| 126141 | 126336 | if( rc==SQLITE_OK && *ppExpr ){ |
| 126142 | | - rc = fts3ExprBalance(ppExpr, MAX_EXPR_DEPTH); |
| 126337 | + rc = fts3ExprBalance(ppExpr, SQLITE_FTS3_MAX_EXPR_DEPTH); |
| 126143 | 126338 | if( rc==SQLITE_OK ){ |
| 126144 | | - rc = fts3ExprCheckDepth(*ppExpr, MAX_EXPR_DEPTH); |
| 126339 | + rc = fts3ExprCheckDepth(*ppExpr, SQLITE_FTS3_MAX_EXPR_DEPTH); |
| 126145 | 126340 | } |
| 126146 | 126341 | } |
| 126147 | 126342 | |
| 126148 | 126343 | if( rc!=SQLITE_OK ){ |
| 126149 | 126344 | sqlite3Fts3ExprFree(*ppExpr); |
| 126150 | 126345 | *ppExpr = 0; |
| 126151 | 126346 | if( rc==SQLITE_TOOBIG ){ |
| 126152 | 126347 | *pzErr = sqlite3_mprintf( |
| 126153 | | - "FTS expression tree is too large (maximum depth %d)", MAX_EXPR_DEPTH |
| 126348 | + "FTS expression tree is too large (maximum depth %d)", |
| 126349 | + SQLITE_FTS3_MAX_EXPR_DEPTH |
| 126154 | 126350 | ); |
| 126155 | 126351 | rc = SQLITE_ERROR; |
| 126156 | 126352 | }else if( rc==SQLITE_ERROR ){ |
| 126157 | 126353 | *pzErr = sqlite3_mprintf("malformed MATCH expression: [%s]", z); |
| 126158 | 126354 | } |
| | @@ -129110,41 +129306,34 @@ |
| 129110 | 129306 | *pRC = rc; |
| 129111 | 129307 | } |
| 129112 | 129308 | |
| 129113 | 129309 | |
| 129114 | 129310 | /* |
| 129115 | | -** This function ensures that the caller has obtained a shared-cache |
| 129116 | | -** table-lock on the %_content table. This is required before reading |
| 129117 | | -** data from the fts3 table. If this lock is not acquired first, then |
| 129118 | | -** the caller may end up holding read-locks on the %_segments and %_segdir |
| 129119 | | -** tables, but no read-lock on the %_content table. If this happens |
| 129120 | | -** a second connection will be able to write to the fts3 table, but |
| 129121 | | -** attempting to commit those writes might return SQLITE_LOCKED or |
| 129122 | | -** SQLITE_LOCKED_SHAREDCACHE (because the commit attempts to obtain |
| 129123 | | -** write-locks on the %_segments and %_segdir ** tables). |
| 129124 | | -** |
| 129125 | | -** We try to avoid this because if FTS3 returns any error when committing |
| 129126 | | -** a transaction, the whole transaction will be rolled back. And this is |
| 129127 | | -** not what users expect when they get SQLITE_LOCKED_SHAREDCACHE. It can |
| 129128 | | -** still happen if the user reads data directly from the %_segments or |
| 129129 | | -** %_segdir tables instead of going through FTS3 though. |
| 129130 | | -** |
| 129131 | | -** This reasoning does not apply to a content=xxx table. |
| 129132 | | -*/ |
| 129133 | | -SQLITE_PRIVATE int sqlite3Fts3ReadLock(Fts3Table *p){ |
| 129134 | | - int rc; /* Return code */ |
| 129135 | | - sqlite3_stmt *pStmt; /* Statement used to obtain lock */ |
| 129136 | | - |
| 129137 | | - if( p->zContentTbl==0 ){ |
| 129138 | | - rc = fts3SqlStmt(p, SQL_SELECT_CONTENT_BY_ROWID, &pStmt, 0); |
| 129311 | +** This function ensures that the caller has obtained an exclusive |
| 129312 | +** shared-cache table-lock on the %_segdir table. This is required before |
| 129313 | +** writing data to the fts3 table. If this lock is not acquired first, then |
| 129314 | +** the caller may end up attempting to take this lock as part of committing |
| 129315 | +** a transaction, causing SQLite to return SQLITE_LOCKED or |
| 129316 | +** LOCKED_SHAREDCACHEto a COMMIT command. |
| 129317 | +** |
| 129318 | +** It is best to avoid this because if FTS3 returns any error when |
| 129319 | +** committing a transaction, the whole transaction will be rolled back. |
| 129320 | +** And this is not what users expect when they get SQLITE_LOCKED_SHAREDCACHE. |
| 129321 | +** It can still happen if the user locks the underlying tables directly |
| 129322 | +** instead of accessing them via FTS. |
| 129323 | +*/ |
| 129324 | +static int fts3Writelock(Fts3Table *p){ |
| 129325 | + int rc = SQLITE_OK; |
| 129326 | + |
| 129327 | + if( p->nPendingData==0 ){ |
| 129328 | + sqlite3_stmt *pStmt; |
| 129329 | + rc = fts3SqlStmt(p, SQL_DELETE_SEGDIR_LEVEL, &pStmt, 0); |
| 129139 | 129330 | if( rc==SQLITE_OK ){ |
| 129140 | 129331 | sqlite3_bind_null(pStmt, 1); |
| 129141 | 129332 | sqlite3_step(pStmt); |
| 129142 | 129333 | rc = sqlite3_reset(pStmt); |
| 129143 | 129334 | } |
| 129144 | | - }else{ |
| 129145 | | - rc = SQLITE_OK; |
| 129146 | 129335 | } |
| 129147 | 129336 | |
| 129148 | 129337 | return rc; |
| 129149 | 129338 | } |
| 129150 | 129339 | |
| | @@ -133918,10 +134107,13 @@ |
| 133918 | 134107 | goto update_out; |
| 133919 | 134108 | } |
| 133920 | 134109 | aSzIns = &aSzDel[p->nColumn+1]; |
| 133921 | 134110 | memset(aSzDel, 0, sizeof(aSzDel[0])*(p->nColumn+1)*2); |
| 133922 | 134111 | |
| 134112 | + rc = fts3Writelock(p); |
| 134113 | + if( rc!=SQLITE_OK ) goto update_out; |
| 134114 | + |
| 133923 | 134115 | /* If this is an INSERT operation, or an UPDATE that modifies the rowid |
| 133924 | 134116 | ** value, then this operation requires constraint handling. |
| 133925 | 134117 | ** |
| 133926 | 134118 | ** If the on-conflict mode is REPLACE, this means that the existing row |
| 133927 | 134119 | ** should be deleted from the database before inserting the new row. Or, |
| | @@ -136051,32 +136243,31 @@ |
| 136051 | 136243 | 0x02A3E003, 0x02A4980A, 0x02A51C0D, 0x02A57C01, 0x02A60004, |
| 136052 | 136244 | 0x02A6CC1B, 0x02A77802, 0x02A8A40E, 0x02A90C01, 0x02A93002, |
| 136053 | 136245 | 0x02A97004, 0x02A9DC03, 0x02A9EC01, 0x02AAC001, 0x02AAC803, |
| 136054 | 136246 | 0x02AADC02, 0x02AAF802, 0x02AB0401, 0x02AB7802, 0x02ABAC07, |
| 136055 | 136247 | 0x02ABD402, 0x02AF8C0B, 0x03600001, 0x036DFC02, 0x036FFC02, |
| 136056 | | - 0x037FFC02, 0x03E3FC01, 0x03EC7801, 0x03ECA401, 0x03EEC810, |
| 136057 | | - 0x03F4F802, 0x03F7F002, 0x03F8001A, 0x03F88007, 0x03F8C023, |
| 136058 | | - 0x03F95013, 0x03F9A004, 0x03FBFC01, 0x03FC040F, 0x03FC6807, |
| 136059 | | - 0x03FCEC06, 0x03FD6C0B, 0x03FF8007, 0x03FFA007, 0x03FFE405, |
| 136060 | | - 0x04040003, 0x0404DC09, 0x0405E411, 0x0406400C, 0x0407402E, |
| 136061 | | - 0x040E7C01, 0x040F4001, 0x04215C01, 0x04247C01, 0x0424FC01, |
| 136062 | | - 0x04280403, 0x04281402, 0x04283004, 0x0428E003, 0x0428FC01, |
| 136063 | | - 0x04294009, 0x0429FC01, 0x042CE407, 0x04400003, 0x0440E016, |
| 136064 | | - 0x04420003, 0x0442C012, 0x04440003, 0x04449C0E, 0x04450004, |
| 136065 | | - 0x04460003, 0x0446CC0E, 0x04471404, 0x045AAC0D, 0x0491C004, |
| 136066 | | - 0x05BD442E, 0x05BE3C04, 0x074000F6, 0x07440027, 0x0744A4B5, |
| 136067 | | - 0x07480046, 0x074C0057, 0x075B0401, 0x075B6C01, 0x075BEC01, |
| 136068 | | - 0x075C5401, 0x075CD401, 0x075D3C01, 0x075DBC01, 0x075E2401, |
| 136069 | | - 0x075EA401, 0x075F0C01, 0x07BBC002, 0x07C0002C, 0x07C0C064, |
| 136070 | | - 0x07C2800F, 0x07C2C40E, 0x07C3040F, 0x07C3440F, 0x07C4401F, |
| 136071 | | - 0x07C4C03C, 0x07C5C02B, 0x07C7981D, 0x07C8402B, 0x07C90009, |
| 136072 | | - 0x07C94002, 0x07CC0021, 0x07CCC006, 0x07CCDC46, 0x07CE0014, |
| 136073 | | - 0x07CE8025, 0x07CF1805, 0x07CF8011, 0x07D0003F, 0x07D10001, |
| 136074 | | - 0x07D108B6, 0x07D3E404, 0x07D4003E, 0x07D50004, 0x07D54018, |
| 136075 | | - 0x07D7EC46, 0x07D9140B, 0x07DA0046, 0x07DC0074, 0x38000401, |
| 136076 | | - 0x38008060, 0x380400F0, 0x3C000001, 0x3FFFF401, 0x40000001, |
| 136077 | | - 0x43FFF401, |
| 136248 | + 0x037FFC01, 0x03EC7801, 0x03ECA401, 0x03EEC810, 0x03F4F802, |
| 136249 | + 0x03F7F002, 0x03F8001A, 0x03F88007, 0x03F8C023, 0x03F95013, |
| 136250 | + 0x03F9A004, 0x03FBFC01, 0x03FC040F, 0x03FC6807, 0x03FCEC06, |
| 136251 | + 0x03FD6C0B, 0x03FF8007, 0x03FFA007, 0x03FFE405, 0x04040003, |
| 136252 | + 0x0404DC09, 0x0405E411, 0x0406400C, 0x0407402E, 0x040E7C01, |
| 136253 | + 0x040F4001, 0x04215C01, 0x04247C01, 0x0424FC01, 0x04280403, |
| 136254 | + 0x04281402, 0x04283004, 0x0428E003, 0x0428FC01, 0x04294009, |
| 136255 | + 0x0429FC01, 0x042CE407, 0x04400003, 0x0440E016, 0x04420003, |
| 136256 | + 0x0442C012, 0x04440003, 0x04449C0E, 0x04450004, 0x04460003, |
| 136257 | + 0x0446CC0E, 0x04471404, 0x045AAC0D, 0x0491C004, 0x05BD442E, |
| 136258 | + 0x05BE3C04, 0x074000F6, 0x07440027, 0x0744A4B5, 0x07480046, |
| 136259 | + 0x074C0057, 0x075B0401, 0x075B6C01, 0x075BEC01, 0x075C5401, |
| 136260 | + 0x075CD401, 0x075D3C01, 0x075DBC01, 0x075E2401, 0x075EA401, |
| 136261 | + 0x075F0C01, 0x07BBC002, 0x07C0002C, 0x07C0C064, 0x07C2800F, |
| 136262 | + 0x07C2C40E, 0x07C3040F, 0x07C3440F, 0x07C4401F, 0x07C4C03C, |
| 136263 | + 0x07C5C02B, 0x07C7981D, 0x07C8402B, 0x07C90009, 0x07C94002, |
| 136264 | + 0x07CC0021, 0x07CCC006, 0x07CCDC46, 0x07CE0014, 0x07CE8025, |
| 136265 | + 0x07CF1805, 0x07CF8011, 0x07D0003F, 0x07D10001, 0x07D108B6, |
| 136266 | + 0x07D3E404, 0x07D4003E, 0x07D50004, 0x07D54018, 0x07D7EC46, |
| 136267 | + 0x07D9140B, 0x07DA0046, 0x07DC0074, 0x38000401, 0x38008060, |
| 136268 | + 0x380400F0, |
| 136078 | 136269 | }; |
| 136079 | 136270 | static const unsigned int aAscii[4] = { |
| 136080 | 136271 | 0xFFFFFFFF, 0xFC00FFFF, 0xF8000001, 0xF8000001, |
| 136081 | 136272 | }; |
| 136082 | 136273 | |
| | @@ -139705,11 +139896,11 @@ |
| 139705 | 139896 | ** operator) using the ICU uregex_XX() APIs. |
| 139706 | 139897 | ** |
| 139707 | 139898 | ** * Implementations of the SQL scalar upper() and lower() functions |
| 139708 | 139899 | ** for case mapping. |
| 139709 | 139900 | ** |
| 139710 | | -** * Integration of ICU and SQLite collation seqences. |
| 139901 | +** * Integration of ICU and SQLite collation sequences. |
| 139711 | 139902 | ** |
| 139712 | 139903 | ** * An implementation of the LIKE operator that uses ICU to |
| 139713 | 139904 | ** provide case-independent matching. |
| 139714 | 139905 | */ |
| 139715 | 139906 | |
| 139716 | 139907 | |