Index: src/select.c
==================================================================
--- src/select.c
+++ src/select.c
@@ -1431,10 +1431,12 @@
     if( sqlite3ExprIsInteger(p->pLimit, &n) ){
       sqlite3VdbeAddOp2(v, OP_Integer, n, iLimit);
       VdbeComment((v, "LIMIT counter"));
       if( n==0 ){
         sqlite3VdbeAddOp2(v, OP_Goto, 0, iBreak);
+      }else{
+        if( p->nSelectRow > (double)n ) p->nSelectRow = (double)n;
       }
     }else{
       sqlite3ExprCode(pParse, p->pLimit, iLimit);
       sqlite3VdbeAddOp1(v, OP_MustBeInt, iLimit);
       VdbeComment((v, "LIMIT counter"));
@@ -1592,10 +1594,11 @@
   /* Generate code for the left and right SELECT statements.
   */
   switch( p->op ){
     case TK_ALL: {
       int addr = 0;
+      int nLimit;
       assert( !pPrior->pLimit );
       pPrior->pLimit = p->pLimit;
       pPrior->pOffset = p->pOffset;
       explainSetInteger(iSub1, pParse->iNextSelectId);
       rc = sqlite3Select(pParse, pPrior, &dest);
@@ -1614,10 +1617,17 @@
       explainSetInteger(iSub2, pParse->iNextSelectId);
       rc = sqlite3Select(pParse, p, &dest);
       testcase( rc!=SQLITE_OK );
       pDelete = p->pPrior;
       p->pPrior = pPrior;
+      p->nSelectRow += pPrior->nSelectRow;
+      if( pPrior->pLimit
+       && sqlite3ExprIsInteger(pPrior->pLimit, &nLimit)
+       && p->nSelectRow > (double)nLimit 
+      ){
+        p->nSelectRow = (double)nLimit;
+      }
       if( addr ){
         sqlite3VdbeJumpHere(v, addr);
       }
       break;
     }
@@ -1686,10 +1696,11 @@
       ** Be sure to delete p->pOrderBy, therefore, to avoid a memory leak. */
       sqlite3ExprListDelete(db, p->pOrderBy);
       pDelete = p->pPrior;
       p->pPrior = pPrior;
       p->pOrderBy = 0;
+      if( p->op==TK_UNION ) p->nSelectRow += pPrior->nSelectRow;
       sqlite3ExprDelete(db, p->pLimit);
       p->pLimit = pLimit;
       p->pOffset = pOffset;
       p->iLimit = 0;
       p->iOffset = 0;
@@ -1765,10 +1776,11 @@
       explainSetInteger(iSub2, pParse->iNextSelectId);
       rc = sqlite3Select(pParse, p, &intersectdest);
       testcase( rc!=SQLITE_OK );
       pDelete = p->pPrior;
       p->pPrior = pPrior;
+      if( p->nSelectRow>pPrior->nSelectRow ) p->nSelectRow = pPrior->nSelectRow;
       sqlite3ExprDelete(db, p->pLimit);
       p->pLimit = pLimit;
       p->pOffset = pOffset;
 
       /* Generate code to take the intersection of the two temporary
@@ -2351,17 +2363,19 @@
   }else{  
     addrEofA = sqlite3VdbeAddOp2(v, OP_If, regEofB, labelEnd);
     sqlite3VdbeAddOp2(v, OP_Gosub, regOutB, addrOutB);
     sqlite3VdbeAddOp1(v, OP_Yield, regAddrB);
     sqlite3VdbeAddOp2(v, OP_Goto, 0, addrEofA);
+    p->nSelectRow += pPrior->nSelectRow;
   }
 
   /* Generate a subroutine to run when the results from select B
   ** are exhausted and only data in select A remains.
   */
   if( op==TK_INTERSECT ){
     addrEofB = addrEofA;
+    if( p->nSelectRow > pPrior->nSelectRow ) p->nSelectRow = pPrior->nSelectRow;
   }else{  
     VdbeNoopComment((v, "eof-B subroutine"));
     addrEofB = sqlite3VdbeAddOp2(v, OP_If, regEofA, labelEnd);
     sqlite3VdbeAddOp2(v, OP_Gosub, regOutA, addrOutA);
     sqlite3VdbeAddOp1(v, OP_Yield, regAddrA);
@@ -3752,10 +3766,11 @@
       sqlite3SelectDestInit(&dest, SRT_EphemTab, pItem->iCursor);
       assert( pItem->isPopulated==0 );
       explainSetInteger(pItem->iSelectId, pParse->iNextSelectId);
       sqlite3Select(pParse, pSub, &dest);
       pItem->isPopulated = 1;
+      pItem->pTab->nRowEst = (unsigned)pSub->nSelectRow;
     }
     if( /*pParse->nErr ||*/ db->mallocFailed ){
       goto select_end;
     }
     pParse->nHeight -= sqlite3SelectExprHeight(p);
@@ -3844,10 +3859,11 @@
   }
 
   /* Set the limiter.
   */
   iEnd = sqlite3VdbeMakeLabel(v);
+  p->nSelectRow = (double)LARGEST_INT64;
   computeLimitRegisters(pParse, p, iEnd);
 
   /* Open a virtual index to use for the distinct set.
   */
   if( p->selFlags & SF_Distinct ){
@@ -3867,10 +3883,11 @@
     /* This case is for non-aggregate queries
     ** Begin the database scan
     */
     pWInfo = sqlite3WhereBegin(pParse, pTabList, pWhere, &pOrderBy, 0);
     if( pWInfo==0 ) goto select_end;
+    if( pWInfo->nRowOut < p->nSelectRow ) p->nSelectRow = pWInfo->nRowOut;
 
     /* If sorting index that was created by a prior OP_OpenEphemeral 
     ** instruction ended up not being needed, then change the OP_OpenEphemeral
     ** into an OP_Noop.
     */
@@ -3911,10 +3928,13 @@
         pItem->iAlias = 0;
       }
       for(k=pGroupBy->nExpr, pItem=pGroupBy->a; k>0; k--, pItem++){
         pItem->iAlias = 0;
       }
+      if( p->nSelectRow>(double)100 ) p->nSelectRow = (double)100;
+    }else{
+      p->nSelectRow = (double)1;
     }
 
  
     /* Create a label to jump to when we want to abort the query */
     addrEnd = sqlite3VdbeMakeLabel(v);

Index: src/sqliteInt.h
==================================================================
--- src/sqliteInt.h
+++ src/sqliteInt.h
@@ -1945,10 +1945,11 @@
   int iContinue;                 /* Jump here to continue with next record */
   int iBreak;                    /* Jump here to break out of the loop */
   int nLevel;                    /* Number of nested loop */
   struct WhereClause *pWC;       /* Decomposition of the WHERE clause */
   double savedNQueryLoop;        /* pParse->nQueryLoop outside the WHERE loop */
+  double nRowOut;                /* Estimated number of output rows */
   WhereLevel a[1];               /* Information about each nest loop in WHERE */
 };
 
 /*
 ** A NameContext defines a context in which to resolve table and column
@@ -2020,10 +2021,11 @@
   Select *pRightmost;    /* Right-most select in a compound select statement */
   Expr *pLimit;          /* LIMIT expression. NULL means not used. */
   Expr *pOffset;         /* OFFSET expression. NULL means not used. */
   int iLimit, iOffset;   /* Memory registers holding LIMIT & OFFSET counters */
   int addrOpenEphm[3];   /* OP_OpenEphem opcodes related to this select */
+  double nSelectRow;     /* Estimated number of result rows */
 };
 
 /*
 ** Allowed values for Select.selFlags.  The "SF" prefix stands for
 ** "Select Flag".

Index: src/where.c
==================================================================
--- src/where.c
+++ src/where.c
@@ -4421,17 +4421,19 @@
   /* Open all tables in the pTabList and any indices selected for
   ** searching those tables.
   */
   sqlite3CodeVerifySchema(pParse, -1); /* Insert the cookie verifier Goto */
   notReady = ~(Bitmask)0;
+  pWInfo->nRowOut = (double)1;
   for(i=0, pLevel=pWInfo->a; i<nTabList; i++, pLevel++){
     Table *pTab;     /* Table to open */
     int iDb;         /* Index of database containing table/index */
 
     pTabItem = &pTabList->a[pLevel->iFrom];
     pTab = pTabItem->pTab;
     pLevel->iTabCur = pTabItem->iCursor;
+    pWInfo->nRowOut *= pLevel->plan.nRow;
     iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
     if( (pTab->tabFlags & TF_Ephemeral)!=0 || pTab->pSelect ){
       /* Do nothing */
     }else
 #ifndef SQLITE_OMIT_VIRTUALTABLE

Index: test/autoindex1.test
==================================================================
--- test/autoindex1.test
+++ test/autoindex1.test
@@ -243,9 +243,9 @@
   1 0 0 {SCAN TABLE sheep AS s (~1000000 rows)} 
   1 1 1 {SEARCH TABLE flock_owner AS prev USING INDEX sqlite_autoindex_flock_owner_1 (flock_no=? AND owner_change_date<?) (~2 rows)} 
   1 0 0 {EXECUTE CORRELATED SCALAR SUBQUERY 2} 
   2 0 0 {SEARCH TABLE flock_owner AS later USING COVERING INDEX sqlite_autoindex_flock_owner_1 (flock_no=? AND owner_change_date>? AND owner_change_date<?) (~1 rows)} 
   0 0 0 {SCAN TABLE sheep AS x USING INDEX sheep_reg_flock_index (~1000000 rows)} 
-  0 1 1 {SEARCH SUBQUERY 1 AS y USING AUTOMATIC COVERING INDEX (sheep_no=?) (~7 rows)}
+  0 1 1 {SEARCH SUBQUERY 1 AS y USING AUTOMATIC COVERING INDEX (sheep_no=?) (~8 rows)}
 }
 
 finish_test

Index: test/eqp.test
==================================================================
--- test/eqp.test
+++ test/eqp.test
@@ -68,10 +68,49 @@
 } {
   0 0 0 {SCAN TABLE t3 (~1000000 rows)}
   0 0 0 {USE TEMP B-TREE FOR GROUP BY}
   0 0 0 {USE TEMP B-TREE FOR DISTINCT}
 }
+
+do_eqp_test 1.7 {
+  SELECT * FROM t3 JOIN (SELECT 1)
+} {
+  0 0 1 {SCAN SUBQUERY 1 (~1 rows)}
+  0 1 0 {SCAN TABLE t3 (~1000000 rows)}
+}
+do_eqp_test 1.8 {
+  SELECT * FROM t3 JOIN (SELECT 1 UNION SELECT 2)
+} {
+  1 0 0 {COMPOUND SUBQUERIES 2 AND 3 USING TEMP B-TREE (UNION)}
+  0 0 1 {SCAN SUBQUERY 1 (~2 rows)}
+  0 1 0 {SCAN TABLE t3 (~1000000 rows)}
+}
+do_eqp_test 1.9 {
+  SELECT * FROM t3 JOIN (SELECT 1 EXCEPT SELECT a FROM t3 LIMIT 17)
+} {
+  3 0 0 {SCAN TABLE t3 (~1000000 rows)}
+  1 0 0 {COMPOUND SUBQUERIES 2 AND 3 USING TEMP B-TREE (EXCEPT)}
+  0 0 1 {SCAN SUBQUERY 1 (~17 rows)}
+  0 1 0 {SCAN TABLE t3 (~1000000 rows)}
+}
+do_eqp_test 1.10 {
+  SELECT * FROM t3 JOIN (SELECT 1 INTERSECT SELECT a FROM t3 LIMIT 17)
+} {
+  3 0 0 {SCAN TABLE t3 (~1000000 rows)}
+  1 0 0 {COMPOUND SUBQUERIES 2 AND 3 USING TEMP B-TREE (INTERSECT)}
+  0 0 1 {SCAN SUBQUERY 1 (~1 rows)}
+  0 1 0 {SCAN TABLE t3 (~1000000 rows)}
+}
+
+do_eqp_test 1.11 {
+  SELECT * FROM t3 JOIN (SELECT 1 UNION ALL SELECT a FROM t3 LIMIT 17)
+} {
+  3 0 0 {SCAN TABLE t3 (~1000000 rows)}
+  1 0 0 {COMPOUND SUBQUERIES 2 AND 3 (UNION ALL)}
+  0 0 1 {SCAN SUBQUERY 1 (~17 rows)}
+  0 1 0 {SCAN TABLE t3 (~1000000 rows)}
+}
 
 #-------------------------------------------------------------------------
 # Test cases eqp-2.* - tests for single select statements.
 #
 drop_all_tables
@@ -165,11 +204,11 @@
 det 3.2.1 {
   SELECT * FROM (SELECT * FROM t1 ORDER BY x LIMIT 10) ORDER BY y LIMIT 5
 } {
   1 0 0 {SCAN TABLE t1 (~1000000 rows)} 
   1 0 0 {USE TEMP B-TREE FOR ORDER BY} 
-  0 0 0 {SCAN SUBQUERY 1 (~1000000 rows)} 
+  0 0 0 {SCAN SUBQUERY 1 (~10 rows)} 
   0 0 0 {USE TEMP B-TREE FOR ORDER BY}
 }
 det 3.2.2 {
   SELECT * FROM 
     (SELECT * FROM t1 ORDER BY x LIMIT 10) AS x1,
@@ -177,12 +216,12 @@
   ORDER BY x2.y LIMIT 5
 } {
   1 0 0 {SCAN TABLE t1 (~1000000 rows)} 
   1 0 0 {USE TEMP B-TREE FOR ORDER BY} 
   2 0 0 {SCAN TABLE t2 USING INDEX t2i1 (~1000000 rows)} 
-  0 0 0 {SCAN SUBQUERY 1 AS x1 (~1000000 rows)} 
-  0 1 1 {SCAN SUBQUERY 2 AS x2 (~1000000 rows)} 
+  0 0 0 {SCAN SUBQUERY 1 AS x1 (~10 rows)} 
+  0 1 1 {SCAN SUBQUERY 2 AS x2 (~10 rows)} 
   0 0 0 {USE TEMP B-TREE FOR ORDER BY}
 }
 
 det 3.3.1 {
   SELECT * FROM t1 WHERE y IN (SELECT y FROM t2)
@@ -414,11 +453,11 @@
 # SUBQUERY 1 (~1000000 rows) 0|0|0|USE TEMP B-TREE FOR GROUP BY
 det 5.10 {
   SELECT count(*) FROM (SELECT max(b) AS x FROM t1 GROUP BY a) GROUP BY x
 } {
   1 0 0 {SCAN TABLE t1 USING COVERING INDEX i2 (~1000000 rows)}
-  0 0 0 {SCAN SUBQUERY 1 (~1000000 rows)}
+  0 0 0 {SCAN SUBQUERY 1 (~100 rows)}
   0 0 0 {USE TEMP B-TREE FOR GROUP BY}
 }
 
 # EVIDENCE-OF: R-18544-33103 sqlite> EXPLAIN QUERY PLAN SELECT * FROM
 # (SELECT * FROM t2 WHERE c=1), t1; 0|0|0|SEARCH TABLE t2 USING INDEX i4