From: drh <drh@noemail.net>
Date: Sat, 21 Jan 2006 22:19:54 +0000 (+0000)
Subject: Do not flatten subqueries in a join where the subquery includes a LIMIT.
X-Git-Tag: version-3.6.10~3180
X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=ac83963afa044a004390974e5b17a6e4dc1f6583;p=thirdparty%2Fsqlite.git

Do not flatten subqueries in a join where the subquery includes a LIMIT.
Ticket #1634.  This is just an initial fix.  Many test cases need to be
added prior to closing the ticket. (CVS 2987)

FossilOrigin-Name: af18c0f431a1a6349e40249009f2ac222f8c8114
---

diff --git a/manifest b/manifest
index 9af1a7d543..e5e0c6b0cb 100644
--- a/manifest
+++ b/manifest
@@ -1,5 +1,5 @@
-C Fix\sa\sbug\sin\sos.h.\s\sHow\sdid\sthis\sslip\sby\sbefore\snow?\s(CVS\s2986)
-D 2006-01-21T19:57:51
+C Do\snot\sflatten\ssubqueries\sin\sa\sjoin\swhere\sthe\ssubquery\sincludes\sa\sLIMIT.\nTicket\s#1634.\s\sThis\sis\sjust\san\sinitial\sfix.\s\sMany\stest\scases\sneed\sto\sbe\nadded\sprior\sto\sclosing\sthe\sticket.\s(CVS\s2987)
+D 2006-01-21T22:19:55
 F Makefile.in ab3ffd8d469cef4477257169b82810030a6bb967
 F Makefile.linux-gcc aee18d8a05546dcf1888bd4547e442008a49a092
 F README 9c4e2d6706bdcc3efdd773ce752a8cdab4f90028
@@ -66,7 +66,7 @@ F src/pragma.c 4496cc77dc35824e1c978c3d1413b8a5a4c777d3
 F src/prepare.c 5d6f5b7194ee72cecd66cab49d15159e55d63f28
 F src/printf.c f47a2f4b5387cd2ebb12e9117a1a5d6bd9a2b812
 F src/random.c d40f8d356cecbd351ccfab6eaedd7ec1b54f5261
-F src/select.c 7a7f4f73a120fbd42e4f5708f5da7a57721bfc7f
+F src/select.c 4e9072092ddba113acf3c8192152ae9e75a23702
 F src/server.c 087b92a39d883e3fa113cae259d64e4c7438bc96
 F src/shell.c 66b073375efbdee19045e7e0cd38b85f9aff71da
 F src/sqlite.h.in 492580f7e3ff71eb43193eb7bb98e2d549889ce3
@@ -344,7 +344,7 @@ F www/tclsqlite.tcl bb0d1357328a42b1993d78573e587c6dcbc964b9
 F www/vdbe.tcl 87a31ace769f20d3627a64fa1fade7fed47b90d0
 F www/version3.tcl a99cf5f6d8bd4d5537584a2b342f0fb9fa601d8b
 F www/whentouse.tcl 97e2b5cd296f7d8057e11f44427dea8a4c2db513
-P 29281dea81c909b70b2d914d7061a6df8f388195
-R 2cfc41c8ea1cc80b34434b2ac4a057da
+P 29725de474f9aec81cea0041d9ac2df932258d01
+R 155027f2bd0a2644348d1abb7c1fede1
 U drh
-Z f6c5b51155ddd0b8f9133fdab5d2a2d3
+Z 52af4bf5dc7ce62a9ad3e0cb3c9897c9
diff --git a/manifest.uuid b/manifest.uuid
index dbad784bdd..5c94e7e4ce 100644
--- a/manifest.uuid
+++ b/manifest.uuid
@@ -1 +1 @@
-29725de474f9aec81cea0041d9ac2df932258d01
\ No newline at end of file
+af18c0f431a1a6349e40249009f2ac222f8c8114
\ No newline at end of file
diff --git a/src/select.c b/src/select.c
index 637017033c..3ebcc2f301 100644
--- a/src/select.c
+++ b/src/select.c
@@ -12,7 +12,7 @@
 ** This file contains C code routines that are called by the parser
 ** to handle SELECT statements in SQLite.
 **
-** $Id: select.c,v 1.296 2006/01/20 18:10:57 drh Exp $
+** $Id: select.c,v 1.297 2006/01/21 22:19:55 drh Exp $
 */
 #include "sqliteInt.h"
 
@@ -2020,6 +2020,10 @@ static void substSelect(Select *p, int iTable, ExprList *pEList){
 **  (12)  The subquery is not the right term of a LEFT OUTER JOIN or the
 **        subquery has no WHERE clause.  (added by ticket #350)
 **
+**  (13)  The subquery and outer query do not both use LIMIT
+**
+**  (14)  The subquery does not use OFFSET
+**
 ** In this routine, the "p" parameter is a pointer to the outer query.
 ** The subquery is p->pSrc->a[iFrom].  isAgg is true if the outer query
 ** uses aggregates and subqueryIsAgg is true if the subquery uses aggregates.
@@ -2054,18 +2058,26 @@ static int flattenSubquery(
   pSubitem = &pSrc->a[iFrom];
   pSub = pSubitem->pSelect;
   assert( pSub!=0 );
-  if( isAgg && subqueryIsAgg ) return 0;
-  if( subqueryIsAgg && pSrc->nSrc>1 ) return 0;
+  if( isAgg && subqueryIsAgg ) return 0;                 /* Restriction (1)  */
+  if( subqueryIsAgg && pSrc->nSrc>1 ) return 0;          /* Restriction (2)  */
   pSubSrc = pSub->pSrc;
   assert( pSubSrc );
-  if( (pSub->pLimit && p->pLimit) || pSub->pOffset || 
-      (pSub->pLimit && isAgg) ) return 0;
-  if( pSubSrc->nSrc==0 ) return 0;
-  if( pSub->isDistinct && (pSrc->nSrc>1 || isAgg) ){
-     return 0;
+  /* Prior to version 3.1.2, when LIMIT and OFFSET had to be simple constants,
+  ** not arbitrary expresssions, we allowed some combining of LIMIT and OFFSET
+  ** because they could be computed at compile-time.  But when LIMIT and OFFSET
+  ** became arbitrary expressions, we were forced to add restrictions (13)
+  ** and (14). */
+  if( pSub->pLimit && p->pLimit ) return 0;              /* Restriction (13) */
+  if( pSub->pOffset ) return 0;                          /* Restriction (14) */
+  if( pSubSrc->nSrc==0 ) return 0;                       /* Restriction (7)  */
+  if( (pSub->isDistinct || pSub->pLimit) 
+         && (pSrc->nSrc>1 || isAgg) ){          /* Restrictions (4)(5)(8)(9) */
+     return 0;       
+  }
+  if( p->isDistinct && subqueryIsAgg ) return 0;         /* Restriction (6)  */
+  if( (p->disallowOrderBy || p->pOrderBy) && pSub->pOrderBy ){
+     return 0;                                           /* Restriction (11) */
   }
-  if( p->isDistinct && subqueryIsAgg ) return 0;
-  if( (p->disallowOrderBy || p->pOrderBy) && pSub->pOrderBy ) return 0;
 
   /* Restriction 3:  If the subquery is a join, make sure the subquery is 
   ** not used as the right operand of an outer join.  Examples of why this
@@ -2195,6 +2207,9 @@ static int flattenSubquery(
 
   /*
   ** SELECT ... FROM (SELECT ... LIMIT a OFFSET b) LIMIT x OFFSET y;
+  **
+  ** One is tempted to try to add a and b to combine the limits.  But this
+  ** does not work if either limit is negative.
   */
   if( pSub->pLimit ){
     p->pLimit = pSub->pLimit;