From 53cd10afcd77c4ff2296999a9fe5116c51333688 Mon Sep 17 00:00:00 2001 From: drh Date: Mon, 31 Mar 2014 18:24:18 +0000 Subject: [PATCH] Make sure that an index that covers a proper superset of the WHERE clause terms of some other index has a lower cost than the other index. FossilOrigin-Name: ea8b0910040198751551b0b960e6b783913607df --- manifest | 15 ++++---- manifest.uuid | 2 +- src/where.c | 99 ++++++++++++++++++++++++++++++++++----------------- 3 files changed, 74 insertions(+), 42 deletions(-) diff --git a/manifest b/manifest index 9ef65fa6b9..ac1faf182f 100644 --- a/manifest +++ b/manifest @@ -1,5 +1,5 @@ -C Experiments\sin\spicking\sbetter\squery\splans,\sespecially\swhen\sthe\susage\sof\sone\nindex\sis\sa\ssubset\sof\sanother. -D 2014-03-29T21:16:07.103 +C Make\ssure\sthat\san\sindex\sthat\scovers\sa\sproper\ssuperset\sof\sthe\sWHERE\sclause\nterms\sof\ssome\sother\sindex\shas\sa\slower\scost\sthan\sthe\sother\sindex. +D 2014-03-31T18:24:18.867 F Makefile.arm-wince-mingw32ce-gcc d6df77f1f48d690bd73162294bbba7f59507c72f F Makefile.in 2ef13430cd359f7b361bb863504e227b25cc7f81 F Makefile.linux-gcc 91d710bdc4998cb015f39edf3cb314ec4f4d7e23 @@ -291,7 +291,7 @@ F src/vtab.c 21b932841e51ebd7d075e2d0ad1415dce8d2d5fd F src/wal.c 76e7fc6de229bea8b30bb2539110f03a494dc3a8 F src/wal.h df01efe09c5cb8c8e391ff1715cca294f89668a4 F src/walker.c 11edb74d587bc87b33ca96a5173e3ec1b8389e45 -F src/where.c 26c6f6260b0cc2b0038dcc68ace0d7db20c7dcee +F src/where.c 50ac3154473b5c8df15c7b8dbd19da385fa859e1 F src/whereInt.h 2564055b440e44ebec8b47f237bbccae6719b7af F test/8_3_names.test ebbb5cd36741350040fd28b432ceadf495be25b2 F test/aggerror.test a867e273ef9e3d7919f03ef4f0e8c0d2767944f2 @@ -1159,10 +1159,7 @@ F tool/vdbe_profile.tcl 67746953071a9f8f2f668b73fe899074e2c6d8c1 F tool/warnings-clang.sh f6aa929dc20ef1f856af04a730772f59283631d4 F tool/warnings.sh d1a6de74685f360ab718efda6265994b99bbea01 F tool/win/sqlite.vsix 030f3eeaf2cb811a3692ab9c14d021a75ce41fff -P 27deb6e49bcc76714dbdc61b34748603155ac770 -R 1df7985395668b26c614cc4e641f29c8 -T *branch * query-plan-experiments -T *sym-query-plan-experiments * -T -sym-trunk * +P 8f869ca7a6eaa9ca7a08102290e6c606735f9090 +R 76b8d8088ba83ec014dc8bf476fa6749 U drh -Z 1c5ff3f986da6bbe350c60cf72c963dd +Z ecebe13d1c9f7ea1da970c5f6118dc52 diff --git a/manifest.uuid b/manifest.uuid index 05916c40aa..649fc9530b 100644 --- a/manifest.uuid +++ b/manifest.uuid @@ -1 +1 @@ -8f869ca7a6eaa9ca7a08102290e6c606735f9090 \ No newline at end of file +ea8b0910040198751551b0b960e6b783913607df \ No newline at end of file diff --git a/src/where.c b/src/where.c index c2b2cf2111..38c3712977 100644 --- a/src/where.c +++ b/src/where.c @@ -3711,6 +3711,51 @@ static void whereInfoFree(sqlite3 *db, WhereInfo *pWInfo){ } } +/* +** Compare every WhereLoop X on the list p against pTemplate. If: +** +** (1) both X and pTemplate refer to the same table, and +** (2) both X and pTemplate use a single index, and +** (3) pTemplate uses all the same WHERE clause terms as X plus +** at least one more term, +** +** then make sure the cost pTemplate is less than the cost of X, adjusting +** the cost of pTemplate downward if necessary. +** +** Example: When computing the query plan for the SELECT below: +** +** CREATE TABLE t1(a,b,c,d); +** CREATE INDEX t1abc ON t1(a,b,c); +** CREATE INDEX t1bc ON t1(b,c); +** SELECT d FROM t1 WHERE a=? AND b=? AND c>=? ORDER BY c; +** +** Make sure the cost of using three three columns of index t1abc is less +** than the cost of using both columns of t1bc. +*/ +static void whereLoopAdjustCost(const WhereLoop *p, WhereLoop *pTemplate){ + if( (pTemplate->wsFlags & WHERE_INDEXED)==0 ) return; + if( pTemplate->nLTerm==0 ) return; + for(; p; p=p->pNextLoop){ + if( p->iTab==pTemplate->iTab + && (p->wsFlags & WHERE_INDEXED)!=0 + && p->nLTermnLTerm + && (p->rRunrRun || (p->rRun==pTemplate->rRun && + p->nOut<=pTemplate->nOut)) + ){ + int i, j; + for(j=0, i=p->nLTerm-1; i>=0 && j>=0; i--){ + for(j=pTemplate->nLTerm-1; j>=0; j--){ + if( pTemplate->aLTerm[j]==p->aLTerm[i] ) break; + } + } + if( j>=0 ){ + pTemplate->rRun = p->rRun; + pTemplate->nOut = p->nOut - 1; + } + } + } +} + /* ** Search the list of WhereLoops in *ppPrev looking for one that can be ** supplanted by pTemplate. @@ -3747,39 +3792,30 @@ static WhereLoop **whereLoopFindLesser( ** rSetup. Call this SETUP-INVARIANT */ assert( p->rSetup>=pTemplate->rSetup ); - if( (p->prereq & pTemplate->prereq)==p->prereq - && p->rSetup<=pTemplate->rSetup - && p->rRun<=pTemplate->rRun - && p->nOut<=pTemplate->nOut + /* If existing WhereLoop p is better than pTemplate, pTemplate can be + ** discarded. WhereLoop p is better if: + ** (1) p has no more dependencies than pTemplate, and + ** (2) p has an equal or lower cost than pTemplate + */ + if( (p->prereq & pTemplate->prereq)==p->prereq /* (1) */ + && p->rSetup<=pTemplate->rSetup /* (2a) */ + && p->rRun<=pTemplate->rRun /* (2b) */ + && p->nOut<=pTemplate->nOut /* (2c) */ ){ - /* This branch taken when p is equal or better than pTemplate in - ** all of (1) dependencies (2) setup-cost, (3) run-cost, and - ** (4) number of output rows. */ - assert( p->rSetup==pTemplate->rSetup ); - if( p->prereq==pTemplate->prereq - && p->nLTermnLTerm - && (p->wsFlags & pTemplate->wsFlags & WHERE_INDEXED)!=0 - && (p->u.btree.pIndex==pTemplate->u.btree.pIndex - || pTemplate->rRun+p->nLTerm<=p->rRun+pTemplate->nLTerm) - ){ - /* Overwrite an existing WhereLoop with an similar one that uses - ** more terms of the index */ - break; - }else{ - /* There is an existing WhereLoop that is better than pTemplate */ - return 0; - } + return 0; /* Discard pTemplate */ } - if( (p->prereq & pTemplate->prereq)==pTemplate->prereq - && p->rRun>=pTemplate->rRun - && p->nOut>=pTemplate->nOut + + /* If pTemplate is always better than p, then cause p to be overwritten + ** with pTemplate. pTemplate is better than p if: + ** (1) pTemplate has no more dependences than p, and + ** (2) pTemplate has an equal or lower cost than p. + */ + if( (p->prereq & pTemplate->prereq)==pTemplate->prereq /* (1) */ + && p->rRun>=pTemplate->rRun /* (2a) */ + && p->nOut>=pTemplate->nOut /* (2b) */ ){ - /* Overwrite an existing WhereLoop with a better one: one that is - ** better at one of (1) dependencies, (2) setup-cost, (3) run-cost - ** or (4) number of output rows, and is no worse in any of those - ** categories. */ assert( p->rSetup>=pTemplate->rSetup ); /* SETUP-INVARIANT above */ - break; + break; /* Cause p to be overwritten by pTemplate */ } } return ppPrev; @@ -3801,15 +3837,13 @@ static WhereLoop **whereLoopFindLesser( ** ** When accumulating multiple loops (when pBuilder->pOrSet is NULL) we ** still might overwrite similar loops with the new template if the -** template is better. Loops may be overwritten if the following +** new template is better. Loops may be overwritten if the following ** conditions are met: ** ** (1) They have the same iTab. ** (2) They have the same iSortIdx. ** (3) The template has same or fewer dependencies than the current loop ** (4) The template has the same or lower cost than the current loop -** (5) The template uses more terms of the same index but has no additional -** dependencies */ static int whereLoopInsert(WhereLoopBuilder *pBuilder, WhereLoop *pTemplate){ WhereLoop **ppPrev, *p; @@ -3837,6 +3871,7 @@ static int whereLoopInsert(WhereLoopBuilder *pBuilder, WhereLoop *pTemplate){ /* Look for an existing WhereLoop to replace with pTemplate */ + whereLoopAdjustCost(pWInfo->pLoops, pTemplate); ppPrev = whereLoopFindLesser(&pWInfo->pLoops, pTemplate); if( ppPrev==0 ){