diff --git a/benchmarks/src/main/java/io/druid/benchmark/query/SqlBenchmark.java b/benchmarks/src/main/java/io/druid/benchmark/query/SqlBenchmark.java
index 53fa05f1c764..e9ea84fa8bd0 100644
--- a/benchmarks/src/main/java/io/druid/benchmark/query/SqlBenchmark.java
+++ b/benchmarks/src/main/java/io/druid/benchmark/query/SqlBenchmark.java
@@ -45,6 +45,7 @@
 import io.druid.segment.serde.ComplexMetrics;
 import io.druid.sql.calcite.planner.Calcites;
 import io.druid.sql.calcite.planner.PlannerConfig;
+import io.druid.sql.calcite.rel.QueryMaker;
 import io.druid.sql.calcite.table.DruidTable;
 import io.druid.sql.calcite.util.CalciteTests;
 import io.druid.sql.calcite.util.SpecificSegmentsQuerySegmentWalker;
@@ -133,9 +134,8 @@ public void setup() throws Exception
     final Map<String, Table> tableMap = ImmutableMap.<String, Table>of(
         "foo",
         new DruidTable(
-            walker,
+            new QueryMaker(walker, plannerConfig),
             new TableDataSource("foo"),
-            plannerConfig,
             ImmutableMap.of(
                 "__time", ValueType.LONG,
                 "dimSequential", ValueType.STRING,
diff --git a/docs/content/configuration/broker.md b/docs/content/configuration/broker.md
index 079aba4d3d7c..a70083473622 100644
--- a/docs/content/configuration/broker.md
+++ b/docs/content/configuration/broker.md
@@ -101,6 +101,7 @@ The broker's [SQL planner](../querying/sql.html) can be configured through the f
 
 |Property|Description|Default|
 |--------|-----------|-------|
+|`druid.sql.planner.maxQueryCount`|Maximum number of queries to issue, including nested queries. Set to 1 to disable sub-queries, or set to 0 for unlimited.|8|
 |`druid.sql.planner.maxSemiJoinRowsInMemory`|Maximum number of rows to keep in memory for executing two-stage semi-join queries like `SELECT * FROM Employee WHERE DeptName IN (SELECT DeptName FROM Dept)`.|100000|
 |`druid.sql.planner.maxTopNLimit`|Maximum threshold for a [TopN query](../querying/topnquery.html). Higher limits will be planned as [GroupBy queries](../querying/groupbyquery.html) instead.|100000|
 |`druid.sql.planner.metadataRefreshPeriod`|Throttle for metadata refreshes.|PT1M|
diff --git a/docs/content/querying/groupbyquery.md b/docs/content/querying/groupbyquery.md
index c1cc7ebf7942..a33da89f3219 100644
--- a/docs/content/querying/groupbyquery.md
+++ b/docs/content/querying/groupbyquery.md
@@ -156,6 +156,12 @@ indexing mechanism, and runs the outer query on these materialized results. "v2"
 inner query's results stream with off-heap fact map and on-heap string dictionary that can spill to disk. Both
 strategy perform the outer query on the broker in a single-threaded fashion.
 
+Note that groupBys require a separate merge buffer on the broker for each layer beyond the first layer of the groupBy.
+With the v2 groupBy strategy, this can potentially lead to deadlocks for groupBys nested beyond two layers, since the
+merge buffers are limited in number and are acquired one-by-one and not as a complete set. At this time we recommend
+that you avoid deeply-nested groupBys with the v2 strategy. Doubly-nested groupBys (groupBy -> groupBy -> table) are
+safe and do not suffer from this issue.
+
 #### Server configuration
 
 When using the "v1" strategy, the following runtime properties apply:
diff --git a/docs/content/querying/sql.md b/docs/content/querying/sql.md
index 98da2be86aab..1e56b58fe856 100644
--- a/docs/content/querying/sql.md
+++ b/docs/content/querying/sql.md
@@ -77,6 +77,20 @@ If `druid.sql.planner.useFallback` is enabled, full SQL is possible on metadata
 recommended in production since it can generate unscalable query plans. The JDBC driver allows accessing
 table and column metadata through `connection.getMetaData()` even if useFallback is off.
 
+### Approximate queries
+
+The following SQL queries and features may be executed using approximate algorithms:
+
+- `COUNT(DISTINCT col)` aggregations use [HyperLogLog](http://algo.inria.fr/flajolet/Publications/FlFuGaMe07.pdf), a
+fast approximate distinct counting algorithm. If you need exact distinct counts, you can instead use
+`SELECT COUNT(*) FROM (SELECT DISTINCT col FROM druid.foo)`, which will use a slower and more resource intensive exact
+algorithm.
+- TopN-style queries with a single grouping column, like
+`SELECT col1, SUM(col2) FROM druid.foo GROUP BY col1 ORDER BY SUM(col2) DESC LIMIT 100`, by default will be executed
+as [TopN queries](topnquery.html), which use an approximate algorithm. To disable this behavior, and use exact
+algorithms for topN-style queries, set
+[druid.sql.planner.useApproximateTopN](../configuration/broker.html#sql-planner-configuration) to "false".
+
 ### Time functions
 
 Druid's SQL language supports a number of time operations, including:
@@ -85,12 +99,33 @@ Druid's SQL language supports a number of time operations, including:
 - `EXTRACT(<granularity> FROM __time)` for grouping or filtering on time parts, like `SELECT EXTRACT(HOUR FROM __time), SUM(cnt) FROM druid.foo GROUP BY EXTRACT(HOUR FROM __time)`
 - Comparisons to `TIMESTAMP '<time string>'` for time filters, like `SELECT COUNT(*) FROM druid.foo WHERE __time >= TIMESTAMP '2000-01-01 00:00:00' AND __time < TIMESTAMP '2001-01-01 00:00:00'`
 
-### Semi-joins
+### Subqueries
+
+Druid's SQL layer supports many types of subqueries, including the ones listed below.
+
+#### Nested groupBy
+
+Subqueries involving `FROM (SELECT ... GROUP BY ...)` may be executed as
+[nested groupBys](groupbyquery.html#nested-groupbys). For example, the following query can be used to perform an
+exact distinct count using a nested groupBy.
+
+```sql
+SELECT COUNT(*) FROM (SELECT DISTINCT col FROM druid.foo)
+```
+
+Note that groupBys require a separate merge buffer on the broker for each layer beyond the first layer of the groupBy.
+With the v2 groupBy strategy, this can potentially lead to deadlocks for groupBys nested beyond two layers, since the
+merge buffers are limited in number and are acquired one-by-one and not as a complete set. At this time we recommend
+that you avoid deeply-nested groupBys with the v2 strategy. Doubly-nested groupBys (groupBy -> groupBy -> table) are
+safe and do not suffer from this issue. If you like, you can forbid deeper nesting by setting
+`druid.sql.planner.maxQueryCount = 2`.
+
+#### Semi-joins
 
-Semi-joins involving `IN (SELECT ...)`, like the following, are planned with a special process.
+Semi-join subqueries involving `WHERE ... IN (SELECT ...)`, like the following, are executed with a special process.
 
 ```sql
-SELECT x, count(*)
+SELECT x, COUNT(*)
 FROM druid.foo
 WHERE x IN (SELECT x FROM druid.bar WHERE y = 'baz')
 GROUP BY x
@@ -121,7 +156,6 @@ Additionally, some Druid features are not supported by the SQL language. Some un
 
 - [Multi-value dimensions](multi-value-dimensions.html).
 - [Query-time lookups](lookups.html).
-- [Nested groupBy queries](groupbyquery.html#nested-groupbys).
 - Extensions, including [approximate histograms](../development/extensions-core/approximate-histograms.html) and
 [DataSketches](../development/extensions-core/datasketches-aggregators.html).
 
diff --git a/processing/src/test/java/io/druid/query/groupby/GroupByQueryRunnerTest.java b/processing/src/test/java/io/druid/query/groupby/GroupByQueryRunnerTest.java
index 862405a45cfc..3a238fac8410 100644
--- a/processing/src/test/java/io/druid/query/groupby/GroupByQueryRunnerTest.java
+++ b/processing/src/test/java/io/druid/query/groupby/GroupByQueryRunnerTest.java
@@ -138,6 +138,35 @@
 @RunWith(Parameterized.class)
 public class GroupByQueryRunnerTest
 {
+  public static final ObjectMapper DEFAULT_MAPPER = new DefaultObjectMapper(new SmileFactory());
+  public static final DruidProcessingConfig DEFAULT_PROCESSING_CONFIG = new DruidProcessingConfig()
+  {
+    @Override
+    public String getFormatString()
+    {
+      return null;
+    }
+
+    @Override
+    public int intermediateComputeSizeBytes()
+    {
+      return 10 * 1024 * 1024;
+    }
+
+    @Override
+    public int getNumMergeBuffers()
+    {
+      // There are some tests that need to allocate two buffers (simulating two levels of merging)
+      return 2;
+    }
+
+    @Override
+    public int getNumThreads()
+    {
+      return 2;
+    }
+  };
+
   private final QueryRunner<Row> runner;
   private GroupByQueryRunnerFactory factory;
   private GroupByQueryConfig config;
@@ -253,13 +282,22 @@ public static GroupByQueryRunnerFactory makeQueryRunnerFactory(
       final GroupByQueryConfig config
   )
   {
-    return makeQueryRunnerFactory(new DefaultObjectMapper(new SmileFactory()), config);
+    return makeQueryRunnerFactory(DEFAULT_MAPPER, config, DEFAULT_PROCESSING_CONFIG);
   }
 
   public static GroupByQueryRunnerFactory makeQueryRunnerFactory(
       final ObjectMapper mapper,
       final GroupByQueryConfig config
   )
+  {
+    return makeQueryRunnerFactory(mapper, config, DEFAULT_PROCESSING_CONFIG);
+  }
+
+  public static GroupByQueryRunnerFactory makeQueryRunnerFactory(
+      final ObjectMapper mapper,
+      final GroupByQueryConfig config,
+      final DruidProcessingConfig processingConfig
+  )
   {
     final Supplier<GroupByQueryConfig> configSupplier = Suppliers.ofInstance(config);
     final StupidPool<ByteBuffer> bufferPool = new StupidPool<>(
@@ -269,7 +307,7 @@ public static GroupByQueryRunnerFactory makeQueryRunnerFactory(
           @Override
           public ByteBuffer get()
           {
-            return ByteBuffer.allocateDirect(10 * 1024 * 1024);
+            return ByteBuffer.allocateDirect(processingConfig.intermediateComputeSizeBytes());
           }
         }
     );
@@ -279,10 +317,10 @@ public ByteBuffer get()
           @Override
           public ByteBuffer get()
           {
-            return ByteBuffer.allocateDirect(10 * 1024 * 1024);
+            return ByteBuffer.allocateDirect(processingConfig.intermediateComputeSizeBytes());
           }
         },
-        2 // There are some tests that need to allocate two buffers (simulating two levels of merging)
+        processingConfig.getNumMergeBuffers()
     );
     final GroupByStrategySelector strategySelector = new GroupByStrategySelector(
         configSupplier,
@@ -293,20 +331,7 @@ public ByteBuffer get()
             bufferPool
         ),
         new GroupByStrategyV2(
-            new DruidProcessingConfig()
-            {
-              @Override
-              public String getFormatString()
-              {
-                return null;
-              }
-
-              @Override
-              public int getNumThreads()
-              {
-                return 2;
-              }
-            },
+            processingConfig,
             configSupplier,
             bufferPool,
             mergeBufferPool,
diff --git a/sql/src/main/java/io/druid/sql/calcite/DruidSchema.java b/sql/src/main/java/io/druid/sql/calcite/DruidSchema.java
index 2aa467366d16..7cc99305d229 100644
--- a/sql/src/main/java/io/druid/sql/calcite/DruidSchema.java
+++ b/sql/src/main/java/io/druid/sql/calcite/DruidSchema.java
@@ -50,6 +50,7 @@
 import io.druid.segment.column.ValueType;
 import io.druid.server.coordination.DruidServerMetadata;
 import io.druid.sql.calcite.planner.PlannerConfig;
+import io.druid.sql.calcite.rel.QueryMaker;
 import io.druid.sql.calcite.table.DruidTable;
 import io.druid.timeline.DataSegment;
 import org.apache.calcite.linq4j.tree.Expression;
@@ -77,6 +78,7 @@ public class DruidSchema extends AbstractSchema
   private final TimelineServerView serverView;
   private final PlannerConfig config;
   private final ExecutorService cacheExec;
+  private final QueryMaker queryMaker;
   private final ConcurrentMap<String, Table> tables;
 
   // For awaitInitialization.
@@ -102,6 +104,7 @@ public DruidSchema(
     this.serverView = Preconditions.checkNotNull(serverView, "serverView");
     this.config = Preconditions.checkNotNull(config, "config");
     this.cacheExec = ScheduledExecutors.fixed(1, "DruidSchema-Cache-%d");
+    this.queryMaker = new QueryMaker(walker, config);
     this.tables = Maps.newConcurrentMap();
   }
 
@@ -349,9 +352,8 @@ private DruidTable computeTable(final String dataSource)
     }
 
     return new DruidTable(
-        walker,
+        queryMaker,
         new TableDataSource(dataSource),
-        config,
         columnValueTypes
     );
   }
diff --git a/sql/src/main/java/io/druid/sql/calcite/expression/Expressions.java b/sql/src/main/java/io/druid/sql/calcite/expression/Expressions.java
index d052378e2127..cf0a7c76d459 100644
--- a/sql/src/main/java/io/druid/sql/calcite/expression/Expressions.java
+++ b/sql/src/main/java/io/druid/sql/calcite/expression/Expressions.java
@@ -47,7 +47,7 @@
 import io.druid.segment.column.Column;
 import io.druid.sql.calcite.aggregation.PostAggregatorFactory;
 import io.druid.sql.calcite.filtration.Filtration;
-import io.druid.sql.calcite.table.DruidTable;
+import io.druid.sql.calcite.table.RowSignature;
 import org.apache.calcite.jdbc.JavaTypeFactoryImpl;
 import org.apache.calcite.rel.core.Project;
 import org.apache.calcite.rex.RexCall;
@@ -112,23 +112,23 @@ private Expressions()
   }
 
   /**
-   * Translate a field access, possibly through a projection, to an underlying Druid table.
+   * Translate a field access, possibly through a projection, to an underlying Druid dataSource.
    *
-   * @param druidTable  underlying Druid table
-   * @param project     projection, or null
-   * @param fieldNumber number of the field to access
+   * @param rowSignature row signature of underlying Druid dataSource
+   * @param project      projection, or null
+   * @param fieldNumber  number of the field to access
    *
    * @return row expression
    */
   public static RexNode fromFieldAccess(
-      final DruidTable druidTable,
+      final RowSignature rowSignature,
       final Project project,
       final int fieldNumber
   )
   {
     if (project == null) {
       // I don't think the factory impl matters here.
-      return RexInputRef.of(fieldNumber, druidTable.getRowType(new JavaTypeFactoryImpl()));
+      return RexInputRef.of(fieldNumber, rowSignature.getRelDataType(new JavaTypeFactoryImpl()));
     } else {
       return project.getChildExps().get(fieldNumber);
     }
@@ -332,13 +332,11 @@ public static String toMathExpression(
   /**
    * Translates "condition" to a Druid filter, or returns null if we cannot translate the condition.
    *
-   * @param druidTable Druid table, if the rows come from a table scan; null otherwise
-   * @param rowOrder   order of columns in the rows to be filtered
-   * @param expression Calcite row expression
+   * @param rowSignature row signature of the dataSource to be filtered
+   * @param expression   Calcite row expression
    */
   public static DimFilter toFilter(
-      final DruidTable druidTable,
-      final List<String> rowOrder,
+      final RowSignature rowSignature,
       final RexNode expression
   )
   {
@@ -347,7 +345,7 @@ public static DimFilter toFilter(
         || expression.getKind() == SqlKind.NOT) {
       final List<DimFilter> filters = Lists.newArrayList();
       for (final RexNode rexNode : ((RexCall) expression).getOperands()) {
-        final DimFilter nextFilter = toFilter(druidTable, rowOrder, rexNode);
+        final DimFilter nextFilter = toFilter(rowSignature, rexNode);
         if (nextFilter == null) {
           return null;
         }
@@ -364,7 +362,7 @@ public static DimFilter toFilter(
       }
     } else {
       // Handle filter conditions on everything else.
-      return toLeafFilter(druidTable, rowOrder, expression);
+      return toLeafFilter(rowSignature, expression);
     }
   }
 
@@ -372,13 +370,11 @@ public static DimFilter toFilter(
    * Translates "condition" to a Druid filter, assuming it does not contain any boolean expressions. Returns null
    * if we cannot translate the condition.
    *
-   * @param druidTable Druid table, if the rows come from a table scan; null otherwise
-   * @param rowOrder   order of columns in the rows to be filtered
-   * @param expression Calcite row expression
+   * @param rowSignature row signature of the dataSource to be filtered
+   * @param expression   Calcite row expression
    */
   private static DimFilter toLeafFilter(
-      final DruidTable druidTable,
-      final List<String> rowOrder,
+      final RowSignature rowSignature,
       final RexNode expression
   )
   {
@@ -392,8 +388,8 @@ private static DimFilter toLeafFilter(
 
     if (kind == SqlKind.LIKE) {
       final List<RexNode> operands = ((RexCall) expression).getOperands();
-      final RowExtraction rex = EXPRESSION_CONVERTER.convert(rowOrder, operands.get(0));
-      if (rex == null || !rex.isFilterable(druidTable)) {
+      final RowExtraction rex = EXPRESSION_CONVERTER.convert(rowSignature.getRowOrder(), operands.get(0));
+      if (rex == null || !rex.isFilterable(rowSignature)) {
         return null;
       }
       return new LikeDimFilter(
@@ -428,8 +424,8 @@ private static DimFilter toLeafFilter(
       }
 
       // lhs must be translatable to a RowExtraction to be filterable
-      final RowExtraction rex = EXPRESSION_CONVERTER.convert(rowOrder, lhs);
-      if (rex == null || !rex.isFilterable(druidTable)) {
+      final RowExtraction rex = EXPRESSION_CONVERTER.convert(rowSignature.getRowOrder(), lhs);
+      if (rex == null || !rex.isFilterable(rowSignature)) {
         return null;
       }
 
diff --git a/sql/src/main/java/io/druid/sql/calcite/expression/RowExtraction.java b/sql/src/main/java/io/druid/sql/calcite/expression/RowExtraction.java
index 0f943fecbe53..776ada76f712 100644
--- a/sql/src/main/java/io/druid/sql/calcite/expression/RowExtraction.java
+++ b/sql/src/main/java/io/druid/sql/calcite/expression/RowExtraction.java
@@ -28,7 +28,7 @@
 import io.druid.segment.column.ValueType;
 import io.druid.segment.filter.Filters;
 import io.druid.sql.calcite.rel.DruidQueryBuilder;
-import io.druid.sql.calcite.table.DruidTable;
+import io.druid.sql.calcite.table.RowSignature;
 
 /**
  * Represents an extraction of a value from a Druid row. Can be used for grouping, filtering, etc.
@@ -112,30 +112,25 @@ public ExtractionFn getExtractionFn()
   }
 
   /**
-   * Check if this extraction can be used to build a filter on a Druid table. This method exists because we can't
+   * Check if this extraction can be used to build a filter on a Druid dataSource. This method exists because we can't
    * filter on floats (yet) and things like DruidFilterRule need to check for that.
    *
-   * If a null table is passed in, this method always returns true.
+   * @param rowSignature row signature of the dataSource
    *
-   * @param druidTable Druid table, or null
-   *
-   * @return whether or not this extraction is filterable; will be true if druidTable is null
+   * @return whether or not this extraction is filterable
    */
-  public boolean isFilterable(final DruidTable druidTable)
+  public boolean isFilterable(final RowSignature rowSignature)
   {
-    return druidTable == null ||
-           Filters.FILTERABLE_TYPES.contains(druidTable.getColumnType(druidTable.getColumnNumber(column)));
+    return Filters.FILTERABLE_TYPES.contains(rowSignature.getColumnType(column));
   }
 
-  public DimensionSpec toDimensionSpec(final DruidTable druidTable, final String outputName)
+  public DimensionSpec toDimensionSpec(final RowSignature rowSignature, final String outputName)
   {
-    final int columnNumber = druidTable.getColumnNumber(column);
-    if (columnNumber < 0) {
+    final ValueType columnType = rowSignature.getColumnType(column);
+    if (columnType == null) {
       return null;
     }
 
-    final ValueType columnType = druidTable.getColumnType(columnNumber);
-
     if (columnType == ValueType.STRING || (column.equals(Column.TIME_COLUMN_NAME) && extractionFn != null)) {
       return extractionFn == null
              ? new DefaultDimensionSpec(column, outputName)
diff --git a/sql/src/main/java/io/druid/sql/calcite/filtration/ConvertBoundsToSelectors.java b/sql/src/main/java/io/druid/sql/calcite/filtration/ConvertBoundsToSelectors.java
index d587a2b6639d..15585bf093df 100644
--- a/sql/src/main/java/io/druid/sql/calcite/filtration/ConvertBoundsToSelectors.java
+++ b/sql/src/main/java/io/druid/sql/calcite/filtration/ConvertBoundsToSelectors.java
@@ -24,21 +24,20 @@
 import io.druid.query.filter.SelectorDimFilter;
 import io.druid.query.ordering.StringComparator;
 import io.druid.sql.calcite.expression.RowExtraction;
-import io.druid.sql.calcite.table.DruidTable;
-import io.druid.sql.calcite.table.DruidTables;
+import io.druid.sql.calcite.table.RowSignature;
 
 public class ConvertBoundsToSelectors extends BottomUpTransform
 {
-  private final DruidTable druidTable;
+  private final RowSignature sourceRowSignature;
 
-  private ConvertBoundsToSelectors(final DruidTable druidTable)
+  private ConvertBoundsToSelectors(final RowSignature sourceRowSignature)
   {
-    this.druidTable = druidTable;
+    this.sourceRowSignature = sourceRowSignature;
   }
 
-  public static ConvertBoundsToSelectors create(final DruidTable druidTable)
+  public static ConvertBoundsToSelectors create(final RowSignature sourceRowSignature)
   {
-    return new ConvertBoundsToSelectors(druidTable);
+    return new ConvertBoundsToSelectors(sourceRowSignature);
   }
 
   @Override
@@ -46,8 +45,7 @@ public DimFilter process(DimFilter filter)
   {
     if (filter instanceof BoundDimFilter) {
       final BoundDimFilter bound = (BoundDimFilter) filter;
-      final StringComparator naturalStringComparator = DruidTables.naturalStringComparator(
-          druidTable,
+      final StringComparator naturalStringComparator = sourceRowSignature.naturalStringComparator(
           RowExtraction.of(bound.getDimension(), bound.getExtractionFn())
       );
 
diff --git a/sql/src/main/java/io/druid/sql/calcite/filtration/ConvertSelectorsToIns.java b/sql/src/main/java/io/druid/sql/calcite/filtration/ConvertSelectorsToIns.java
index 7a01afe8475f..4d7572b84a24 100644
--- a/sql/src/main/java/io/druid/sql/calcite/filtration/ConvertSelectorsToIns.java
+++ b/sql/src/main/java/io/druid/sql/calcite/filtration/ConvertSelectorsToIns.java
@@ -27,24 +27,23 @@
 import io.druid.query.filter.OrDimFilter;
 import io.druid.query.filter.SelectorDimFilter;
 import io.druid.sql.calcite.expression.RowExtraction;
-import io.druid.sql.calcite.table.DruidTable;
-import io.druid.sql.calcite.table.DruidTables;
+import io.druid.sql.calcite.table.RowSignature;
 
 import java.util.List;
 import java.util.Map;
 
 public class ConvertSelectorsToIns extends BottomUpTransform
 {
-  private final DruidTable druidTable;
+  private final RowSignature sourceRowSignature;
 
-  private ConvertSelectorsToIns(final DruidTable druidTable)
+  private ConvertSelectorsToIns(final RowSignature sourceRowSignature)
   {
-    this.druidTable = druidTable;
+    this.sourceRowSignature = sourceRowSignature;
   }
 
-  public static ConvertSelectorsToIns create(final DruidTable druidTable)
+  public static ConvertSelectorsToIns create(final RowSignature sourceRowSignature)
   {
-    return new ConvertSelectorsToIns(druidTable);
+    return new ConvertSelectorsToIns(sourceRowSignature);
   }
 
   @Override
@@ -62,8 +61,7 @@ public DimFilter process(DimFilter filter)
           final SelectorDimFilter selector = (SelectorDimFilter) child;
           final BoundRefKey boundRefKey = BoundRefKey.from(
               selector,
-              DruidTables.naturalStringComparator(
-                  druidTable,
+              sourceRowSignature.naturalStringComparator(
                   RowExtraction.of(selector.getDimension(), selector.getExtractionFn())
               )
           );
diff --git a/sql/src/main/java/io/druid/sql/calcite/filtration/Filtration.java b/sql/src/main/java/io/druid/sql/calcite/filtration/Filtration.java
index 37448a6780d3..896c57c48780 100644
--- a/sql/src/main/java/io/druid/sql/calcite/filtration/Filtration.java
+++ b/sql/src/main/java/io/druid/sql/calcite/filtration/Filtration.java
@@ -28,7 +28,7 @@
 import io.druid.query.filter.JavaScriptDimFilter;
 import io.druid.query.spec.MultipleIntervalSegmentSpec;
 import io.druid.query.spec.QuerySegmentSpec;
-import io.druid.sql.calcite.table.DruidTable;
+import io.druid.sql.calcite.table.RowSignature;
 import org.joda.time.Interval;
 
 import java.util.List;
@@ -109,15 +109,15 @@ public DimFilter getDimFilter()
    *
    * @return equivalent Filtration
    */
-  public Filtration optimize(final DruidTable druidTable)
+  public Filtration optimize(final RowSignature sourceRowSignature)
   {
     return transform(
         this,
         ImmutableList.of(
             CombineAndSimplifyBounds.instance(),
             MoveTimeFiltersToIntervals.instance(),
-            ConvertBoundsToSelectors.create(druidTable),
-            ConvertSelectorsToIns.create(druidTable),
+            ConvertBoundsToSelectors.create(sourceRowSignature),
+            ConvertSelectorsToIns.create(sourceRowSignature),
             MoveMarkerFiltersToIntervals.instance(),
             ValidateNoMarkerFiltersRemain.instance()
         )
@@ -129,7 +129,7 @@ public Filtration optimize(final DruidTable druidTable)
    *
    * @return equivalent Filtration
    */
-  public Filtration optimizeFilterOnly(final DruidTable druidTable)
+  public Filtration optimizeFilterOnly(final RowSignature sourceRowSignature)
   {
     if (!intervals.equals(ImmutableList.of(eternity()))) {
       throw new ISE("Cannot optimizeFilterOnly when intervals are set");
@@ -139,8 +139,8 @@ public Filtration optimizeFilterOnly(final DruidTable druidTable)
         this,
         ImmutableList.<Function<Filtration, Filtration>>of(
             CombineAndSimplifyBounds.instance(),
-            ConvertBoundsToSelectors.create(druidTable),
-            ConvertSelectorsToIns.create(druidTable)
+            ConvertBoundsToSelectors.create(sourceRowSignature),
+            ConvertSelectorsToIns.create(sourceRowSignature)
         )
     );
 
diff --git a/sql/src/main/java/io/druid/sql/calcite/planner/PlannerConfig.java b/sql/src/main/java/io/druid/sql/calcite/planner/PlannerConfig.java
index 7ed2f4d630ec..4e57b679bfe0 100644
--- a/sql/src/main/java/io/druid/sql/calcite/planner/PlannerConfig.java
+++ b/sql/src/main/java/io/druid/sql/calcite/planner/PlannerConfig.java
@@ -33,6 +33,9 @@ public class PlannerConfig
   @JsonProperty
   private int maxTopNLimit = 100000;
 
+  @JsonProperty
+  private int maxQueryCount = 8;
+
   @JsonProperty
   private int selectThreshold = 1000;
 
@@ -60,6 +63,11 @@ public int getMaxTopNLimit()
     return maxTopNLimit;
   }
 
+  public int getMaxQueryCount()
+  {
+    return maxTopNLimit;
+  }
+
   public int getSelectThreshold()
   {
     return selectThreshold;
@@ -98,6 +106,9 @@ public boolean equals(Object o)
     if (maxTopNLimit != that.maxTopNLimit) {
       return false;
     }
+    if (maxQueryCount != that.maxQueryCount) {
+      return false;
+    }
     if (selectThreshold != that.selectThreshold) {
       return false;
     }
@@ -113,7 +124,6 @@ public boolean equals(Object o)
     return metadataRefreshPeriod != null
            ? metadataRefreshPeriod.equals(that.metadataRefreshPeriod)
            : that.metadataRefreshPeriod == null;
-
   }
 
   @Override
@@ -122,6 +132,7 @@ public int hashCode()
     int result = metadataRefreshPeriod != null ? metadataRefreshPeriod.hashCode() : 0;
     result = 31 * result + maxSemiJoinRowsInMemory;
     result = 31 * result + maxTopNLimit;
+    result = 31 * result + maxQueryCount;
     result = 31 * result + selectThreshold;
     result = 31 * result + (useApproximateCountDistinct ? 1 : 0);
     result = 31 * result + (useApproximateTopN ? 1 : 0);
@@ -136,6 +147,7 @@ public String toString()
            "metadataRefreshPeriod=" + metadataRefreshPeriod +
            ", maxSemiJoinRowsInMemory=" + maxSemiJoinRowsInMemory +
            ", maxTopNLimit=" + maxTopNLimit +
+           ", maxQueryCount=" + maxQueryCount +
            ", selectThreshold=" + selectThreshold +
            ", useApproximateCountDistinct=" + useApproximateCountDistinct +
            ", useApproximateTopN=" + useApproximateTopN +
diff --git a/sql/src/main/java/io/druid/sql/calcite/planner/Rules.java b/sql/src/main/java/io/druid/sql/calcite/planner/Rules.java
index aea79f0b2464..2611061da610 100644
--- a/sql/src/main/java/io/druid/sql/calcite/planner/Rules.java
+++ b/sql/src/main/java/io/druid/sql/calcite/planner/Rules.java
@@ -22,10 +22,9 @@
 import com.google.common.collect.ImmutableList;
 import io.druid.sql.calcite.rule.DruidBindableConverterRule;
 import io.druid.sql.calcite.rule.DruidFilterRule;
-import io.druid.sql.calcite.rule.DruidSelectProjectionRule;
-import io.druid.sql.calcite.rule.DruidSelectSortRule;
 import io.druid.sql.calcite.rule.DruidSemiJoinRule;
 import io.druid.sql.calcite.rule.GroupByRules;
+import io.druid.sql.calcite.rule.SelectRules;
 import org.apache.calcite.adapter.enumerable.EnumerableInterpreterRule;
 import org.apache.calcite.adapter.enumerable.EnumerableRules;
 import org.apache.calcite.interpreter.Bindables;
@@ -197,13 +196,12 @@ public static List<RelOptRule> ruleSet(final PlannerConfig plannerConfig)
 
     // Druid-specific rules.
     rules.add(DruidFilterRule.instance());
-    rules.add(DruidSelectSortRule.instance());
-    rules.add(DruidSelectProjectionRule.instance());
 
     if (plannerConfig.getMaxSemiJoinRowsInMemory() > 0) {
-      rules.add(DruidSemiJoinRule.instance());
+      rules.add(DruidSemiJoinRule.create(plannerConfig));
     }
 
+    rules.addAll(SelectRules.rules());
     rules.addAll(GroupByRules.rules(plannerConfig));
 
     // Allow conversion of Druid queries to Bindable convention.
diff --git a/sql/src/main/java/io/druid/sql/calcite/rel/DruidNestedGroupBy.java b/sql/src/main/java/io/druid/sql/calcite/rel/DruidNestedGroupBy.java
new file mode 100644
index 000000000000..e891745b61b5
--- /dev/null
+++ b/sql/src/main/java/io/druid/sql/calcite/rel/DruidNestedGroupBy.java
@@ -0,0 +1,174 @@
+/*
+ * Licensed to Metamarkets Group Inc. (Metamarkets) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. Metamarkets licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package io.druid.sql.calcite.rel;
+
+import com.google.common.base.Function;
+import io.druid.query.QueryDataSource;
+import io.druid.query.filter.DimFilter;
+import io.druid.sql.calcite.table.RowSignature;
+import org.apache.calcite.interpreter.BindableConvention;
+import org.apache.calcite.interpreter.Row;
+import org.apache.calcite.plan.RelOptCluster;
+import org.apache.calcite.plan.RelOptCost;
+import org.apache.calcite.plan.RelOptPlanner;
+import org.apache.calcite.plan.RelTraitSet;
+import org.apache.calcite.rel.RelWriter;
+import org.apache.calcite.rel.metadata.RelMetadataQuery;
+import org.apache.calcite.rel.type.RelDataType;
+
+import java.util.List;
+
+public class DruidNestedGroupBy extends DruidRel<DruidNestedGroupBy>
+{
+  private final DruidRel sourceRel;
+  private final DruidQueryBuilder queryBuilder;
+
+  private DruidNestedGroupBy(
+      RelOptCluster cluster,
+      RelTraitSet traitSet,
+      DruidRel sourceRel,
+      DruidQueryBuilder queryBuilder
+  )
+  {
+    super(cluster, traitSet, sourceRel.getQueryMaker());
+    this.sourceRel = sourceRel;
+    this.queryBuilder = queryBuilder;
+
+    if (sourceRel.getQueryBuilder().getGrouping() == null) {
+      throw new IllegalArgumentException("inner query must be groupBy");
+    }
+
+    if (queryBuilder.getGrouping() == null) {
+      throw new IllegalArgumentException("outer query must be groupBy");
+    }
+  }
+
+  public static DruidNestedGroupBy from(
+      final DruidRel sourceRel,
+      final DimFilter filter,
+      final Grouping grouping,
+      final RelDataType rowType,
+      final List<String> rowOrder
+  )
+  {
+    return new DruidNestedGroupBy(
+        sourceRel.getCluster(),
+        sourceRel.getTraitSet(),
+        sourceRel,
+        DruidQueryBuilder.fullScan(
+            sourceRel.getOutputRowSignature(),
+            sourceRel.getCluster().getTypeFactory()
+        ).withFilter(filter).withGrouping(grouping, rowType, rowOrder)
+    );
+  }
+
+  @Override
+  public RowSignature getSourceRowSignature()
+  {
+    return sourceRel.getOutputRowSignature();
+  }
+
+  @Override
+  public DruidQueryBuilder getQueryBuilder()
+  {
+    return queryBuilder;
+  }
+
+  @Override
+  public void accumulate(final Function<Row, Void> sink)
+  {
+    final QueryDataSource queryDataSource = sourceRel.asDataSource();
+    if (queryDataSource != null) {
+      getQueryMaker().accumulate(
+          queryDataSource,
+          sourceRel.getOutputRowSignature(),
+          queryBuilder,
+          sink
+      );
+    }
+  }
+
+  @Override
+  public DruidNestedGroupBy withQueryBuilder(DruidQueryBuilder newQueryBuilder)
+  {
+    return new DruidNestedGroupBy(
+        getCluster(),
+        getTraitSet().plusAll(newQueryBuilder.getRelTraits()),
+        sourceRel,
+        newQueryBuilder
+    );
+  }
+
+  @Override
+  public int getQueryCount()
+  {
+    return 1 + sourceRel.getQueryCount();
+  }
+
+  @Override
+  public QueryDataSource asDataSource()
+  {
+    final QueryDataSource queryDataSource = sourceRel.asDataSource();
+    if (queryDataSource == null) {
+      return null;
+    } else {
+      return new QueryDataSource(
+          queryBuilder.toGroupByQuery(queryDataSource, sourceRel.getOutputRowSignature())
+      );
+    }
+  }
+
+  @Override
+  public DruidNestedGroupBy asBindable()
+  {
+    return new DruidNestedGroupBy(
+        getCluster(),
+        getTraitSet().plus(BindableConvention.INSTANCE),
+        sourceRel,
+        queryBuilder
+    );
+  }
+
+  @Override
+  public Class<Object[]> getElementType()
+  {
+    return Object[].class;
+  }
+
+  @Override
+  public RelWriter explainTerms(RelWriter pw)
+  {
+    return pw
+        .item("sourceRel", sourceRel)
+        .item("queryBuilder", queryBuilder);
+  }
+
+  @Override
+  protected RelDataType deriveRowType()
+  {
+    return queryBuilder.getRowType();
+  }
+
+  @Override
+  public RelOptCost computeSelfCost(final RelOptPlanner planner, final RelMetadataQuery mq)
+  {
+    return sourceRel.computeSelfCost(planner, mq).multiplyBy(2.0);
+  }
+}
diff --git a/sql/src/main/java/io/druid/sql/calcite/rel/DruidQueryBuilder.java b/sql/src/main/java/io/druid/sql/calcite/rel/DruidQueryBuilder.java
index e77329ca7f8d..a2f7afc8ebd6 100644
--- a/sql/src/main/java/io/druid/sql/calcite/rel/DruidQueryBuilder.java
+++ b/sql/src/main/java/io/druid/sql/calcite/rel/DruidQueryBuilder.java
@@ -19,35 +19,44 @@
 
 package io.druid.sql.calcite.rel;
 
-import com.google.common.base.Function;
 import com.google.common.base.Preconditions;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.Iterables;
 import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
 import io.druid.granularity.QueryGranularities;
 import io.druid.granularity.QueryGranularity;
 import io.druid.java.util.common.ISE;
+import io.druid.query.DataSource;
 import io.druid.query.dimension.DimensionSpec;
 import io.druid.query.filter.DimFilter;
+import io.druid.query.groupby.GroupByQuery;
+import io.druid.query.groupby.having.DimFilterHavingSpec;
 import io.druid.query.groupby.orderby.DefaultLimitSpec;
 import io.druid.query.groupby.orderby.OrderByColumnSpec;
+import io.druid.query.select.PagingSpec;
+import io.druid.query.select.SelectQuery;
+import io.druid.query.timeseries.TimeseriesQuery;
 import io.druid.query.topn.DimensionTopNMetricSpec;
 import io.druid.query.topn.InvertedTopNMetricSpec;
 import io.druid.query.topn.NumericTopNMetricSpec;
 import io.druid.query.topn.TopNMetricSpec;
+import io.druid.query.topn.TopNQuery;
 import io.druid.segment.column.Column;
+import io.druid.segment.column.ValueType;
 import io.druid.sql.calcite.expression.ExtractionFns;
-import io.druid.sql.calcite.planner.PlannerConfig;
-import io.druid.sql.calcite.table.DruidTable;
-import org.apache.calcite.interpreter.Row;
+import io.druid.sql.calcite.filtration.Filtration;
+import io.druid.sql.calcite.table.RowSignature;
 import org.apache.calcite.plan.RelTrait;
 import org.apache.calcite.rel.RelCollations;
 import org.apache.calcite.rel.RelFieldCollation;
 import org.apache.calcite.rel.type.RelDataType;
 import org.apache.calcite.rel.type.RelDataTypeFactory;
 import org.apache.calcite.rel.type.RelDataTypeField;
+import org.apache.calcite.sql.type.SqlTypeName;
 
 import java.util.List;
+import java.util.Map;
 
 public class DruidQueryBuilder
 {
@@ -57,7 +66,7 @@ public class DruidQueryBuilder
   private final DimFilter having;
   private final DefaultLimitSpec limitSpec;
   private final RelDataType rowType;
-  private final List<String> rowOrder;
+  private final RowSignature outputRowSignature;
 
   private DruidQueryBuilder(
       final DimFilter filter,
@@ -75,16 +84,37 @@ private DruidQueryBuilder(
     this.having = having;
     this.limitSpec = limitSpec;
     this.rowType = Preconditions.checkNotNull(rowType, "rowType");
-    this.rowOrder = Preconditions.checkNotNull(ImmutableList.copyOf(rowOrder), "rowOrder");
 
     if (selectProjection != null && grouping != null) {
       throw new ISE("Cannot have both selectProjection and grouping");
     }
+
+    final RowSignature.Builder rowSignatureBuilder = RowSignature.builder();
+
+    for (int i = 0; i < rowOrder.size(); i++) {
+      final RelDataTypeField field = rowType.getFieldList().get(i);
+      final SqlTypeName sqlTypeName = field.getType().getSqlTypeName();
+      final ValueType valueType;
+
+      if (SqlTypeName.APPROX_TYPES.contains(sqlTypeName)) {
+        valueType = ValueType.FLOAT;
+      } else if (SqlTypeName.DATETIME_TYPES.contains(sqlTypeName) || SqlTypeName.EXACT_TYPES.contains(sqlTypeName)) {
+        valueType = ValueType.LONG;
+      } else if (SqlTypeName.CHAR_TYPES.contains(sqlTypeName)) {
+        valueType = ValueType.STRING;
+      } else {
+        throw new ISE("Cannot translate sqlTypeName[%s] to Druid type for field[%s]", sqlTypeName, rowOrder.get(i));
+      }
+
+      rowSignatureBuilder.add(rowOrder.get(i), valueType);
+    }
+
+    this.outputRowSignature = rowSignatureBuilder.build();
   }
 
-  public static DruidQueryBuilder fullScan(final DruidTable druidTable, final RelDataTypeFactory relDataTypeFactory)
+  public static DruidQueryBuilder fullScan(final RowSignature rowSignature, final RelDataTypeFactory relDataTypeFactory)
   {
-    final RelDataType rowType = druidTable.getRowType(relDataTypeFactory);
+    final RelDataType rowType = rowSignature.getRelDataType(relDataTypeFactory);
     final List<String> rowOrder = Lists.newArrayListWithCapacity(rowType.getFieldCount());
     for (RelDataTypeField field : rowType.getFieldList()) {
       rowOrder.add(field.getName());
@@ -94,8 +124,15 @@ public static DruidQueryBuilder fullScan(final DruidTable druidTable, final RelD
 
   public DruidQueryBuilder withFilter(final DimFilter newFilter)
   {
-    Preconditions.checkNotNull(newFilter, "newFilter");
-    return new DruidQueryBuilder(newFilter, selectProjection, grouping, having, limitSpec, rowType, rowOrder);
+    return new DruidQueryBuilder(
+        newFilter,
+        selectProjection,
+        grouping,
+        having,
+        limitSpec,
+        rowType,
+        outputRowSignature.getRowOrder()
+    );
   }
 
   public DruidQueryBuilder withSelectProjection(final SelectProjection newProjection, final List<String> newRowOrder)
@@ -152,14 +189,30 @@ public DruidQueryBuilder withHaving(final DimFilter newHaving)
     Preconditions.checkState(limitSpec == null, "cannot add having after limitSpec");
     Preconditions.checkState(grouping != null, "cannot add having before grouping");
     Preconditions.checkNotNull(newHaving, "newHaving");
-    return new DruidQueryBuilder(filter, selectProjection, grouping, newHaving, limitSpec, rowType, rowOrder);
+    return new DruidQueryBuilder(
+        filter,
+        selectProjection,
+        grouping,
+        newHaving,
+        limitSpec,
+        rowType,
+        outputRowSignature.getRowOrder()
+    );
   }
 
   public DruidQueryBuilder withLimitSpec(final DefaultLimitSpec newLimitSpec)
   {
     Preconditions.checkState(limitSpec == null, "cannot add limitSpec twice");
     Preconditions.checkNotNull(newLimitSpec, "newLimitSpec");
-    return new DruidQueryBuilder(filter, selectProjection, grouping, having, newLimitSpec, rowType, rowOrder);
+    return new DruidQueryBuilder(
+        filter,
+        selectProjection,
+        grouping,
+        having,
+        newLimitSpec,
+        rowType,
+        outputRowSignature.getRowOrder()
+    );
   }
 
   public DimFilter getFilter()
@@ -187,6 +240,18 @@ public DefaultLimitSpec getLimitSpec()
     return limitSpec;
   }
 
+  /**
+   * Returns the output row signature for this DruidQueryBuilder. Useful if we will go on to do something else with
+   * the rows, like make a QueryDataSource or use a HavingSpec. Note that the field names may be different from the
+   * field names returned by {@link #getRowType()}, although positionally they will line up.
+   *
+   * @return Druid row signature
+   */
+  public RowSignature getOutputRowSignature()
+  {
+    return outputRowSignature;
+  }
+
   public RelDataType getRowType()
   {
     return rowType;
@@ -194,7 +259,7 @@ public RelDataType getRowType()
 
   public List<String> getRowOrder()
   {
-    return rowOrder;
+    return outputRowSignature.getRowOrder();
   }
 
   public RelTrait[] getRelTraits()
@@ -202,7 +267,7 @@ public RelTrait[] getRelTraits()
     final List<RelFieldCollation> collations = Lists.newArrayList();
     if (limitSpec != null) {
       for (OrderByColumnSpec orderBy : limitSpec.getColumns()) {
-        final int i = rowOrder.indexOf(orderBy.getDimension());
+        final int i = outputRowSignature.getRowOrder().indexOf(orderBy.getDimension());
         final RelFieldCollation.Direction direction = orderBy.getDirection() == OrderByColumnSpec.Direction.ASCENDING
                                                       ? RelFieldCollation.Direction.ASCENDING
                                                       : RelFieldCollation.Direction.DESCENDING;
@@ -217,39 +282,28 @@ public RelTrait[] getRelTraits()
     }
   }
 
-  public void accumulate(
-      final DruidTable druidTable,
-      final Function<Row, Void> sink
-  )
-  {
-    final PlannerConfig config = druidTable.getPlannerConfig();
-
-    if (grouping == null) {
-      QueryMaker.executeSelect(druidTable, this, sink);
-    } else if (asQueryGranularityIfTimeseries() != null) {
-      QueryMaker.executeTimeseries(druidTable, this, sink);
-    } else if (asTopNMetricSpecIfTopN(config.getMaxTopNLimit(), config.isUseApproximateTopN()) != null) {
-      QueryMaker.executeTopN(druidTable, this, sink);
-    } else {
-      QueryMaker.executeGroupBy(druidTable, this, sink);
-    }
-  }
-
   /**
-   * Determine if this query can be run as a Timeseries query, and if so, return the query granularity.
+   * Return this query as a Timeseries query, or null if this query is not compatible with Timeseries.
    *
-   * @return query granularity, or null
+   * @param dataSource         data source to query
+   * @param sourceRowSignature row signature of the dataSource
+   *
+   * @return query or null
    */
-  public QueryGranularity asQueryGranularityIfTimeseries()
+  public TimeseriesQuery toTimeseriesQuery(
+      final DataSource dataSource,
+      final RowSignature sourceRowSignature
+  )
   {
-    if (grouping == null) {
+    if (grouping == null || having != null) {
       return null;
     }
 
+    final QueryGranularity queryGranularity;
     final List<DimensionSpec> dimensions = grouping.getDimensions();
 
     if (dimensions.isEmpty()) {
-      return QueryGranularities.ALL;
+      queryGranularity = QueryGranularities.ALL;
     } else if (dimensions.size() == 1) {
       final DimensionSpec dimensionSpec = Iterables.getOnlyElement(dimensions);
       final QueryGranularity gran = ExtractionFns.toQueryGranularity(dimensionSpec.getExtractionFn());
@@ -259,35 +313,58 @@ public QueryGranularity asQueryGranularityIfTimeseries()
         return null;
       }
 
-      if (having != null) {
-        // Timeseries does not offer HAVING.
-        return null;
-      }
-
-      // Timeseries only applies if sort is null, or if sort is on the time dimension.
+      // Timeseries only applies if sort is null, or if the first sort field is the time dimension.
       final boolean sortingOnTime =
           limitSpec == null || limitSpec.getColumns().isEmpty()
           || (limitSpec.getLimit() == Integer.MAX_VALUE
-              && limitSpec.getColumns().size() == 1
               && limitSpec.getColumns().get(0).getDimension().equals(dimensionSpec.getOutputName()));
 
       if (sortingOnTime) {
-        return ExtractionFns.toQueryGranularity(dimensionSpec.getExtractionFn());
+        queryGranularity = gran;
+      } else {
+        return null;
       }
+    } else {
+      return null;
+    }
+
+    final Filtration filtration = Filtration.create(filter).optimize(sourceRowSignature);
+
+    final boolean descending;
+    if (limitSpec != null && !limitSpec.getColumns().isEmpty()) {
+      descending = limitSpec.getColumns().get(0).getDirection() == OrderByColumnSpec.Direction.DESCENDING;
+    } else {
+      descending = false;
     }
 
-    return null;
+    final Map<String, Object> context = Maps.newHashMap();
+    context.put("skipEmptyBuckets", true);
+
+    return new TimeseriesQuery(
+        dataSource,
+        filtration.getQuerySegmentSpec(),
+        descending,
+        filtration.getDimFilter(),
+        queryGranularity,
+        grouping.getAggregatorFactories(),
+        grouping.getPostAggregators(),
+        context
+    );
   }
 
   /**
-   * Determine if this query can be run as a topN query, and if so, returns the metric spec for ordering.
+   * Return this query as a TopN query, or null if this query is not compatible with TopN.
    *
-   * @param maxTopNLimit       maximum limit to consider for conversion to a topN
-   * @param useApproximateTopN true if we should allow approximate topNs, false otherwise
+   * @param dataSource         data source to query
+   * @param sourceRowSignature row signature of the dataSource
+   * @param maxTopNLimit       maxTopNLimit from a PlannerConfig
+   * @param useApproximateTopN from a PlannerConfig
    *
-   * @return metric spec, or null
+   * @return query or null
    */
-  public TopNMetricSpec asTopNMetricSpecIfTopN(
+  public TopNQuery toTopNQuery(
+      final DataSource dataSource,
+      final RowSignature sourceRowSignature,
       final int maxTopNLimit,
       final boolean useApproximateTopN
   )
@@ -304,6 +381,7 @@ public TopNMetricSpec asTopNMetricSpecIfTopN(
 
     final DimensionSpec dimensionSpec = Iterables.getOnlyElement(grouping.getDimensions());
     final OrderByColumnSpec limitColumn = Iterables.getOnlyElement(limitSpec.getColumns());
+    final TopNMetricSpec topNMetricSpec;
 
     if (limitColumn.getDimension().equals(dimensionSpec.getOutputName())) {
       // DimensionTopNMetricSpec is exact; always return it even if allowApproximate is false.
@@ -311,18 +389,115 @@ public TopNMetricSpec asTopNMetricSpecIfTopN(
           null,
           limitColumn.getDimensionComparator()
       );
-      return limitColumn.getDirection() == OrderByColumnSpec.Direction.ASCENDING
-             ? baseMetricSpec
-             : new InvertedTopNMetricSpec(baseMetricSpec);
+      topNMetricSpec = limitColumn.getDirection() == OrderByColumnSpec.Direction.ASCENDING
+                       ? baseMetricSpec
+                       : new InvertedTopNMetricSpec(baseMetricSpec);
     } else if (useApproximateTopN) {
       // ORDER BY metric
       final NumericTopNMetricSpec baseMetricSpec = new NumericTopNMetricSpec(limitColumn.getDimension());
-      return limitColumn.getDirection() == OrderByColumnSpec.Direction.ASCENDING
-             ? new InvertedTopNMetricSpec(baseMetricSpec)
-             : baseMetricSpec;
+      topNMetricSpec = limitColumn.getDirection() == OrderByColumnSpec.Direction.ASCENDING
+                       ? new InvertedTopNMetricSpec(baseMetricSpec)
+                       : baseMetricSpec;
     } else {
       return null;
     }
+
+    final Filtration filtration = Filtration.create(filter).optimize(sourceRowSignature);
+
+    return new TopNQuery(
+        dataSource,
+        Iterables.getOnlyElement(grouping.getDimensions()),
+        topNMetricSpec,
+        limitSpec.getLimit(),
+        filtration.getQuerySegmentSpec(),
+        filtration.getDimFilter(),
+        QueryGranularities.ALL,
+        grouping.getAggregatorFactories(),
+        grouping.getPostAggregators(),
+        null
+    );
+  }
+
+  /**
+   * Return this query as a GroupBy query, or null if this query is not compatible with GroupBy.
+   *
+   * @param dataSource         data source to query
+   * @param sourceRowSignature row signature of the dataSource
+   *
+   * @return query or null
+   */
+  public GroupByQuery toGroupByQuery(
+      final DataSource dataSource,
+      final RowSignature sourceRowSignature
+  )
+  {
+    if (grouping == null) {
+      return null;
+    }
+
+    final Filtration filtration = Filtration.create(filter).optimize(sourceRowSignature);
+
+    return new GroupByQuery(
+        dataSource,
+        filtration.getQuerySegmentSpec(),
+        filtration.getDimFilter(),
+        QueryGranularities.ALL,
+        grouping.getDimensions(),
+        grouping.getAggregatorFactories(),
+        grouping.getPostAggregators(),
+        having != null ? new DimFilterHavingSpec(having) : null,
+        limitSpec,
+        null
+    );
+  }
+
+  /**
+   * Return this query as a Select query, or null if this query is not compatible with Select.
+   *
+   * @param dataSource         data source to query
+   * @param sourceRowSignature row signature of the dataSource
+   *
+   * @return query or null
+   */
+  public SelectQuery toSelectQuery(
+      final DataSource dataSource,
+      final RowSignature sourceRowSignature
+  )
+  {
+    if (grouping != null) {
+      return null;
+    }
+
+    final Filtration filtration = Filtration.create(filter).optimize(sourceRowSignature);
+    final boolean descending;
+
+    if (limitSpec != null) {
+      // Safe to assume limitSpec has zero or one entry; DruidSelectSortRule wouldn't push in anything else.
+      if (limitSpec.getColumns().size() > 0) {
+        final OrderByColumnSpec orderBy = Iterables.getOnlyElement(limitSpec.getColumns());
+        if (!orderBy.getDimension().equals(Column.TIME_COLUMN_NAME)) {
+          throw new ISE("WTF?! Got select with non-time orderBy[%s]", orderBy);
+        }
+        descending = orderBy.getDirection() == OrderByColumnSpec.Direction.DESCENDING;
+      } else {
+        descending = false;
+      }
+    } else {
+      descending = false;
+    }
+
+    return new SelectQuery(
+        dataSource,
+        filtration.getQuerySegmentSpec(),
+        descending,
+        filtration.getDimFilter(),
+        QueryGranularities.ALL,
+        selectProjection != null ? selectProjection.getDimensions() : ImmutableList.<DimensionSpec>of(),
+        selectProjection != null ? selectProjection.getMetrics() : ImmutableList.<String>of(),
+        null,
+        new PagingSpec(null, 0) /* dummy -- will be replaced */,
+        null
+    );
   }
 
   @Override
@@ -355,7 +530,9 @@ public boolean equals(Object o)
     if (rowType != null ? !rowType.equals(that.rowType) : that.rowType != null) {
       return false;
     }
-    return rowOrder != null ? rowOrder.equals(that.rowOrder) : that.rowOrder == null;
+    return outputRowSignature != null
+           ? outputRowSignature.equals(that.outputRowSignature)
+           : that.outputRowSignature == null;
 
   }
 
@@ -368,7 +545,7 @@ public int hashCode()
     result = 31 * result + (having != null ? having.hashCode() : 0);
     result = 31 * result + (limitSpec != null ? limitSpec.hashCode() : 0);
     result = 31 * result + (rowType != null ? rowType.hashCode() : 0);
-    result = 31 * result + (rowOrder != null ? rowOrder.hashCode() : 0);
+    result = 31 * result + (outputRowSignature != null ? outputRowSignature.hashCode() : 0);
     return result;
   }
 
@@ -381,7 +558,7 @@ public String toString()
            ", grouping=" + grouping +
            ", having=" + having +
            ", limitSpec=" + limitSpec +
-           ", rowOrder=" + rowOrder +
+           ", outputRowSignature=" + outputRowSignature +
            '}';
   }
 }
diff --git a/sql/src/main/java/io/druid/sql/calcite/rel/DruidQueryRel.java b/sql/src/main/java/io/druid/sql/calcite/rel/DruidQueryRel.java
index 4007712e4ccb..0db39970a081 100644
--- a/sql/src/main/java/io/druid/sql/calcite/rel/DruidQueryRel.java
+++ b/sql/src/main/java/io/druid/sql/calcite/rel/DruidQueryRel.java
@@ -22,8 +22,11 @@
 import com.google.common.base.Function;
 import com.google.common.base.Preconditions;
 import com.google.common.collect.ImmutableList;
+import io.druid.query.QueryDataSource;
+import io.druid.query.groupby.GroupByQuery;
 import io.druid.sql.calcite.filtration.Filtration;
 import io.druid.sql.calcite.table.DruidTable;
+import io.druid.sql.calcite.table.RowSignature;
 import org.apache.calcite.interpreter.BindableConvention;
 import org.apache.calcite.interpreter.Row;
 import org.apache.calcite.plan.RelOptCluster;
@@ -37,6 +40,13 @@
 
 public class DruidQueryRel extends DruidRel<DruidQueryRel>
 {
+  // Factors used for computing cost (see computeSelfCost). These are intended to encourage pushing down filters
+  // and limits through stacks of nested queries when possible.
+  private static final double COST_BASE = 1.0;
+  private static final double COST_FILTER_MULTIPLIER = 0.1;
+  private static final double COST_GROUPING_MULTIPLIER = 0.5;
+  private static final double COST_LIMIT_MULTIPLIER = 0.5;
+
   private final RelOptTable table;
   private final DruidTable druidTable;
   private final DruidQueryBuilder queryBuilder;
@@ -49,7 +59,7 @@ private DruidQueryRel(
       final DruidQueryBuilder queryBuilder
   )
   {
-    super(cluster, traitSet);
+    super(cluster, traitSet, druidTable.getQueryMaker());
     this.table = Preconditions.checkNotNull(table, "table");
     this.druidTable = Preconditions.checkNotNull(druidTable, "druidTable");
     this.queryBuilder = Preconditions.checkNotNull(queryBuilder, "queryBuilder");
@@ -70,10 +80,29 @@ public static DruidQueryRel fullScan(
         traitSet,
         table,
         druidTable,
-        DruidQueryBuilder.fullScan(druidTable, cluster.getTypeFactory())
+        DruidQueryBuilder.fullScan(druidTable.getRowSignature(), cluster.getTypeFactory())
+    );
+  }
+
+  @Override
+  public QueryDataSource asDataSource()
+  {
+    final GroupByQuery groupByQuery = getQueryBuilder().toGroupByQuery(
+        druidTable.getDataSource(),
+        druidTable.getRowSignature()
     );
+
+    if (groupByQuery == null) {
+      // QueryDataSources must currently embody groupBy queries. This will thrown an exception if the query
+      // cannot be converted to a groupBy, but that's OK because we really shouldn't get into that situation anyway.
+      // That would be a bug in our planner rules.
+      throw new IllegalStateException("WTF?! Tried to convert query to QueryDataSource but couldn't make a groupBy?");
+    }
+
+    return new QueryDataSource(groupByQuery);
   }
 
+  @Override
   public DruidQueryRel asBindable()
   {
     return new DruidQueryRel(
@@ -85,16 +114,19 @@ public DruidQueryRel asBindable()
     );
   }
 
-  public DruidTable getDruidTable()
+  @Override
+  public RowSignature getSourceRowSignature()
   {
-    return druidTable;
+    return druidTable.getRowSignature();
   }
 
+  @Override
   public DruidQueryBuilder getQueryBuilder()
   {
     return queryBuilder;
   }
 
+  @Override
   public DruidQueryRel withQueryBuilder(final DruidQueryBuilder newQueryBuilder)
   {
     return new DruidQueryRel(
@@ -106,10 +138,16 @@ public DruidQueryRel withQueryBuilder(final DruidQueryBuilder newQueryBuilder)
     );
   }
 
+  @Override
+  public int getQueryCount()
+  {
+    return 1;
+  }
+
   @Override
   public void accumulate(final Function<Row, Void> sink)
   {
-    queryBuilder.accumulate(druidTable, sink);
+    getQueryMaker().accumulate(druidTable.getDataSource(), druidTable.getRowSignature(), queryBuilder, sink);
   }
 
   @Override
@@ -135,7 +173,7 @@ public RelWriter explainTerms(final RelWriter pw)
   {
     pw.item("dataSource", druidTable.getDataSource());
     if (queryBuilder != null) {
-      final Filtration filtration = Filtration.create(queryBuilder.getFilter()).optimize(druidTable);
+      final Filtration filtration = Filtration.create(queryBuilder.getFilter()).optimize(getSourceRowSignature());
       if (!filtration.getIntervals().equals(ImmutableList.of(Filtration.eternity()))) {
         pw.item("intervals", filtration.getIntervals());
       }
@@ -163,6 +201,20 @@ public RelWriter explainTerms(final RelWriter pw)
   @Override
   public RelOptCost computeSelfCost(final RelOptPlanner planner, final RelMetadataQuery mq)
   {
-    return super.computeSelfCost(planner, mq).multiplyBy(0.1);
+    double cost = COST_BASE;
+
+    if (queryBuilder.getFilter() != null) {
+      cost *= COST_FILTER_MULTIPLIER;
+    }
+
+    if (queryBuilder.getGrouping() != null) {
+      cost *= COST_GROUPING_MULTIPLIER;
+    }
+
+    if (queryBuilder.getLimitSpec() != null) {
+      cost *= COST_LIMIT_MULTIPLIER;
+    }
+
+    return planner.getCostFactory().makeCost(cost, 0, 0);
   }
 }
diff --git a/sql/src/main/java/io/druid/sql/calcite/rel/DruidRel.java b/sql/src/main/java/io/druid/sql/calcite/rel/DruidRel.java
index a72847d65e92..a4d3eda67028 100644
--- a/sql/src/main/java/io/druid/sql/calcite/rel/DruidRel.java
+++ b/sql/src/main/java/io/druid/sql/calcite/rel/DruidRel.java
@@ -20,7 +20,8 @@
 package io.druid.sql.calcite.rel;
 
 import com.google.common.base.Function;
-import io.druid.sql.calcite.table.DruidTable;
+import io.druid.query.QueryDataSource;
+import io.druid.sql.calcite.table.RowSignature;
 import org.apache.calcite.DataContext;
 import org.apache.calcite.interpreter.BindableRel;
 import org.apache.calcite.interpreter.Node;
@@ -33,21 +34,52 @@
 
 public abstract class DruidRel<T extends DruidRel> extends AbstractRelNode implements BindableRel
 {
-  public DruidRel(RelOptCluster cluster, RelTraitSet traitSet)
+  private final QueryMaker queryMaker;
+
+  public DruidRel(RelOptCluster cluster, RelTraitSet traitSet, QueryMaker queryMaker)
   {
     super(cluster, traitSet);
+    this.queryMaker = queryMaker;
   }
 
-  public abstract DruidTable getDruidTable();
+  public abstract RowSignature getSourceRowSignature();
+
+  public final RowSignature getOutputRowSignature()
+  {
+    return getQueryBuilder().getOutputRowSignature();
+  }
 
   public abstract DruidQueryBuilder getQueryBuilder();
 
+  /**
+   * Return the number of Druid queries this rel involves, including sub-queries. Simple queries will return 1.
+   *
+   * @return number of nested queries
+   */
+  public abstract int getQueryCount();
+
   public abstract void accumulate(Function<Row, Void> sink);
 
   public abstract T withQueryBuilder(DruidQueryBuilder newQueryBuilder);
 
+  /**
+   * Convert this DruidRel to a QueryDataSource, for embedding in some other outer query. This may be an expensive
+   * operation. For example, DruidSemiJoin needs to execute the right-hand side query in order to complete this
+   * method.
+   *
+   * This method may return null if it knows that this rel will yield an empty result set.
+   *
+   * @return query dataSource, or null if it is known in advance that this rel will yield an empty result set.
+   */
+  public abstract QueryDataSource asDataSource();
+
   public abstract T asBindable();
 
+  public QueryMaker getQueryMaker()
+  {
+    return queryMaker;
+  }
+
   @Override
   public Node implement(InterpreterImplementor implementor)
   {
diff --git a/sql/src/main/java/io/druid/sql/calcite/rel/DruidSemiJoin.java b/sql/src/main/java/io/druid/sql/calcite/rel/DruidSemiJoin.java
index 9aafcf6a963d..1d8ac0360e44 100644
--- a/sql/src/main/java/io/druid/sql/calcite/rel/DruidSemiJoin.java
+++ b/sql/src/main/java/io/druid/sql/calcite/rel/DruidSemiJoin.java
@@ -25,6 +25,7 @@
 import com.google.common.collect.Sets;
 import io.druid.java.util.common.ISE;
 import io.druid.java.util.common.Pair;
+import io.druid.query.QueryDataSource;
 import io.druid.query.ResourceLimitExceededException;
 import io.druid.query.dimension.DimensionSpec;
 import io.druid.query.filter.AndDimFilter;
@@ -33,8 +34,7 @@
 import io.druid.query.filter.OrDimFilter;
 import io.druid.sql.calcite.aggregation.Aggregation;
 import io.druid.sql.calcite.expression.RowExtraction;
-import io.druid.sql.calcite.table.DruidTable;
-import io.druid.sql.calcite.table.DruidTables;
+import io.druid.sql.calcite.table.RowSignature;
 import org.apache.calcite.DataContext;
 import org.apache.calcite.interpreter.BindableConvention;
 import org.apache.calcite.interpreter.Row;
@@ -74,7 +74,7 @@ private DruidSemiJoin(
       final int maxSemiJoinRowsInMemory
   )
   {
-    super(cluster, traitSet);
+    super(cluster, traitSet, left.getQueryMaker());
     this.semiJoin = semiJoin;
     this.left = left;
     this.right = right;
@@ -86,9 +86,9 @@ private DruidSemiJoin(
 
   public static DruidSemiJoin from(
       final SemiJoin semiJoin,
-      final RelTraitSet traitSet,
       final DruidRel left,
-      final DruidRel right
+      final DruidRel right,
+      final int maxSemiJoinRowsInMemory
   )
   {
     if (semiJoin.getLeftKeys().size() != semiJoin.getRightKeys().size()) {
@@ -107,14 +107,14 @@ public static DruidSemiJoin from(
 
     return new DruidSemiJoin(
         semiJoin.getCluster(),
-        traitSet,
+        semiJoin.getTraitSet(),
         semiJoin,
         left,
         right,
         semiJoin.getCondition(),
         listBuilder.build(),
         semiJoin.getRightKeys(),
-        right.getDruidTable().getPlannerConfig().getMaxSemiJoinRowsInMemory()
+        maxSemiJoinRowsInMemory
     );
   }
 
@@ -125,9 +125,9 @@ public Class<Object[]> getElementType()
   }
 
   @Override
-  public DruidTable getDruidTable()
+  public RowSignature getSourceRowSignature()
   {
-    return left.getDruidTable();
+    return left.getSourceRowSignature();
   }
 
   @Override
@@ -152,6 +152,13 @@ public DruidSemiJoin withQueryBuilder(final DruidQueryBuilder newQueryBuilder)
     );
   }
 
+  @Override
+  public QueryDataSource asDataSource()
+  {
+    final DruidRel rel = getLeftRelWithFilter();
+    return rel != null ? rel.asDataSource() : null;
+  }
+
   @Override
   public DruidSemiJoin asBindable()
   {
@@ -169,76 +176,17 @@ public DruidSemiJoin asBindable()
   }
 
   @Override
-  public void accumulate(final Function<Row, Void> sink)
+  public int getQueryCount()
   {
-    final Pair<DruidQueryBuilder, List<Integer>> pair = getRightQueryBuilderWithGrouping();
-    final DruidQueryBuilder rightQueryBuilderAdjusted = pair.lhs;
-    final List<Integer> rightKeysAdjusted = pair.rhs;
-
-    // Build list of acceptable values from right side.
-    final Set<List<String>> valuess = Sets.newHashSet();
-    final List<DimFilter> filters = Lists.newArrayList();
-    rightQueryBuilderAdjusted.accumulate(
-        right.getDruidTable(),
-        new Function<Row, Void>()
-        {
-          @Override
-          public Void apply(final Row row)
-          {
-            final List<String> values = Lists.newArrayListWithCapacity(rightKeysAdjusted.size());
-
-            for (int i : rightKeysAdjusted) {
-              final Object value = row.getObject(i);
-              final String stringValue = value != null ? String.valueOf(value) : "";
-              values.add(stringValue);
-              if (values.size() > maxSemiJoinRowsInMemory) {
-                throw new ResourceLimitExceededException(
-                    String.format("maxSemiJoinRowsInMemory[%,d] exceeded", maxSemiJoinRowsInMemory)
-                );
-              }
-            }
-
-            if (valuess.add(values)) {
-              final List<DimFilter> bounds = Lists.newArrayList();
-              for (int i = 0; i < values.size(); i++) {
-                bounds.add(
-                    new BoundDimFilter(
-                        leftRowExtractions.get(i).getColumn(),
-                        values.get(i),
-                        values.get(i),
-                        false,
-                        false,
-                        null,
-                        leftRowExtractions.get(i).getExtractionFn(),
-                        DruidTables.naturalStringComparator(getDruidTable(), leftRowExtractions.get(i))
-                    )
-                );
-              }
-              filters.add(new AndDimFilter(bounds));
-            }
-            return null;
-          }
-        }
-    );
-
-    valuess.clear();
-
-    if (!filters.isEmpty()) {
-      // Add a filter to the left side. Use OR of singleton Bound filters so they can be simplified later.
-      final DimFilter semiJoinFilter = new OrDimFilter(filters);
-      final DimFilter newFilter = left.getQueryBuilder().getFilter() == null
-                                  ? semiJoinFilter
-                                  : new AndDimFilter(
-                                      ImmutableList.of(
-                                          semiJoinFilter,
-                                          left.getQueryBuilder().getFilter()
-                                      )
-                                  );
+    return left.getQueryCount() + right.getQueryCount();
+  }
 
-      left.getQueryBuilder().withFilter(newFilter).accumulate(
-          left.getDruidTable(),
-          sink
-      );
+  @Override
+  public void accumulate(final Function<Row, Void> sink)
+  {
+    final DruidRel rel = getLeftRelWithFilter();
+    if (rel != null) {
+      rel.accumulate(sink);
     }
   }
 
@@ -259,10 +207,8 @@ public RelWriter explainTerms(RelWriter pw)
   {
     final Pair<DruidQueryBuilder, List<Integer>> rightQueryBuilderWithGrouping = getRightQueryBuilderWithGrouping();
     return pw
-        .item("leftDataSource", left.getDruidTable().getDataSource())
         .item("leftRowExtractions", leftRowExtractions)
         .item("leftQuery", left.getQueryBuilder())
-        .item("rightDataSource", right.getDruidTable().getDataSource())
         .item("rightKeysAdjusted", rightQueryBuilderWithGrouping.rhs)
         .item("rightQuery", rightQueryBuilderWithGrouping.lhs);
   }
@@ -270,7 +216,7 @@ public RelWriter explainTerms(RelWriter pw)
   @Override
   public RelOptCost computeSelfCost(final RelOptPlanner planner, final RelMetadataQuery mq)
   {
-    return semiJoin.computeSelfCost(planner, mq).multiplyBy(0.1);
+    return right.computeSelfCost(planner, mq).plus(left.computeSelfCost(planner, mq).multiplyBy(50));
   }
 
   private Pair<DruidQueryBuilder, List<Integer>> getRightQueryBuilderWithGrouping()
@@ -292,7 +238,7 @@ private Pair<DruidQueryBuilder, List<Integer>> getRightQueryBuilderWithGrouping(
           throw new ISE("WTF?! Can't find dimensionSpec to group on!");
         }
 
-        final DimensionSpec dimensionSpec = rex.toDimensionSpec(left.getDruidTable(), keyDimensionOutputName);
+        final DimensionSpec dimensionSpec = rex.toDimensionSpec(left.getSourceRowSignature(), keyDimensionOutputName);
         if (dimensionSpec == null) {
           throw new ISE("WTF?! Can't translate row expression to dimensionSpec: %s", rex);
         }
@@ -314,4 +260,79 @@ private Pair<DruidQueryBuilder, List<Integer>> getRightQueryBuilderWithGrouping(
       return Pair.of(newQueryBuilder, rightKeysAdjusted);
     }
   }
+
+  /**
+   * Returns a copy of the left rel with the filter applied from the right-hand side. This is an expensive operation
+   * since it actually executes the right-hand side query.
+   */
+  private DruidRel getLeftRelWithFilter()
+  {
+    final Pair<DruidQueryBuilder, List<Integer>> pair = getRightQueryBuilderWithGrouping();
+    final DruidRel rightRelAdjusted = right.withQueryBuilder(pair.lhs);
+    final List<Integer> rightKeysAdjusted = pair.rhs;
+
+    // Build list of acceptable values from right side.
+    final Set<List<String>> valuess = Sets.newHashSet();
+    final List<DimFilter> filters = Lists.newArrayList();
+    rightRelAdjusted.accumulate(
+        new Function<Row, Void>()
+        {
+          @Override
+          public Void apply(final Row row)
+          {
+            final List<String> values = Lists.newArrayListWithCapacity(rightKeysAdjusted.size());
+
+            for (int i : rightKeysAdjusted) {
+              final Object value = row.getObject(i);
+              final String stringValue = value != null ? String.valueOf(value) : "";
+              values.add(stringValue);
+              if (values.size() > maxSemiJoinRowsInMemory) {
+                throw new ResourceLimitExceededException(
+                    String.format("maxSemiJoinRowsInMemory[%,d] exceeded", maxSemiJoinRowsInMemory)
+                );
+              }
+            }
+
+            if (valuess.add(values)) {
+              final List<DimFilter> bounds = Lists.newArrayList();
+              for (int i = 0; i < values.size(); i++) {
+                bounds.add(
+                    new BoundDimFilter(
+                        leftRowExtractions.get(i).getColumn(),
+                        values.get(i),
+                        values.get(i),
+                        false,
+                        false,
+                        null,
+                        leftRowExtractions.get(i).getExtractionFn(),
+                        getSourceRowSignature().naturalStringComparator(leftRowExtractions.get(i))
+                    )
+                );
+              }
+              filters.add(new AndDimFilter(bounds));
+            }
+            return null;
+          }
+        }
+    );
+
+    valuess.clear();
+
+    if (!filters.isEmpty()) {
+      // Add a filter to the left side. Use OR of singleton Bound filters so they can be simplified later.
+      final DimFilter semiJoinFilter = new OrDimFilter(filters);
+      final DimFilter newFilter = left.getQueryBuilder().getFilter() == null
+                                  ? semiJoinFilter
+                                  : new AndDimFilter(
+                                      ImmutableList.of(
+                                          semiJoinFilter,
+                                          left.getQueryBuilder().getFilter()
+                                      )
+                                  );
+
+      return left.withQueryBuilder(left.getQueryBuilder().withFilter(newFilter));
+    } else {
+      return null;
+    }
+  }
 }
diff --git a/sql/src/main/java/io/druid/sql/calcite/rel/QueryMaker.java b/sql/src/main/java/io/druid/sql/calcite/rel/QueryMaker.java
index 836d219ea033..a403c4269dda 100644
--- a/sql/src/main/java/io/druid/sql/calcite/rel/QueryMaker.java
+++ b/sql/src/main/java/io/druid/sql/calcite/rel/QueryMaker.java
@@ -23,23 +23,19 @@
 import com.google.common.base.Preconditions;
 import com.google.common.base.Strings;
 import com.google.common.base.Throwables;
-import com.google.common.collect.ImmutableList;
 import com.google.common.collect.Iterables;
 import com.google.common.collect.Maps;
 import com.google.common.primitives.Doubles;
 import com.google.common.primitives.Ints;
 import io.druid.common.guava.GuavaUtils;
-import io.druid.granularity.QueryGranularities;
-import io.druid.granularity.QueryGranularity;
 import io.druid.java.util.common.ISE;
 import io.druid.java.util.common.guava.Accumulator;
-import io.druid.java.util.common.logger.Logger;
+import io.druid.query.DataSource;
+import io.druid.query.QueryDataSource;
+import io.druid.query.QuerySegmentWalker;
 import io.druid.query.Result;
 import io.druid.query.dimension.DimensionSpec;
 import io.druid.query.groupby.GroupByQuery;
-import io.druid.query.groupby.having.DimFilterHavingSpec;
-import io.druid.query.groupby.orderby.DefaultLimitSpec;
-import io.druid.query.groupby.orderby.OrderByColumnSpec;
 import io.druid.query.select.EventHolder;
 import io.druid.query.select.PagingSpec;
 import io.druid.query.select.SelectQuery;
@@ -47,12 +43,11 @@
 import io.druid.query.timeseries.TimeseriesQuery;
 import io.druid.query.timeseries.TimeseriesResultValue;
 import io.druid.query.topn.DimensionAndMetricValueExtractor;
-import io.druid.query.topn.TopNMetricSpec;
 import io.druid.query.topn.TopNQuery;
 import io.druid.query.topn.TopNResultValue;
 import io.druid.segment.column.Column;
-import io.druid.sql.calcite.filtration.Filtration;
-import io.druid.sql.calcite.table.DruidTable;
+import io.druid.sql.calcite.planner.PlannerConfig;
+import io.druid.sql.calcite.table.RowSignature;
 import org.apache.calcite.interpreter.Row;
 import org.apache.calcite.interpreter.Sink;
 import org.apache.calcite.rel.type.RelDataTypeField;
@@ -70,11 +65,16 @@
 
 public class QueryMaker
 {
-  private final static Logger log = new Logger(QueryMaker.class);
+  private final QuerySegmentWalker walker;
+  private final PlannerConfig plannerConfig;
 
-  private QueryMaker()
+  public QueryMaker(
+      final QuerySegmentWalker walker,
+      final PlannerConfig plannerConfig
+  )
   {
-    // No instantiation.
+    this.walker = walker;
+    this.plannerConfig = plannerConfig;
   }
 
   public static Function<Row, Void> sinkFunction(final Sink sink)
@@ -95,9 +95,59 @@ public Void apply(final Row row)
     };
   }
 
-  public static void executeSelect(
-      final DruidTable druidTable,
+  public void accumulate(
+      final DataSource dataSource,
+      final RowSignature sourceRowSignature,
+      final DruidQueryBuilder queryBuilder,
+      final Function<Row, Void> sink
+  )
+  {
+    if (dataSource instanceof QueryDataSource) {
+      final GroupByQuery outerQuery = queryBuilder.toGroupByQuery(dataSource, sourceRowSignature);
+      if (outerQuery == null) {
+        // Bug in the planner rules. They shouldn't allow this to happen.
+        throw new IllegalStateException("Can't use QueryDataSource without an outer groupBy query!");
+      }
+
+      executeGroupBy(queryBuilder, outerQuery, sink);
+      return;
+    }
+
+    final TimeseriesQuery timeseriesQuery = queryBuilder.toTimeseriesQuery(dataSource, sourceRowSignature);
+    if (timeseriesQuery != null) {
+      executeTimeseries(queryBuilder, timeseriesQuery, sink);
+      return;
+    }
+
+    final TopNQuery topNQuery = queryBuilder.toTopNQuery(
+        dataSource,
+        sourceRowSignature,
+        plannerConfig.getMaxTopNLimit(),
+        plannerConfig.isUseApproximateTopN()
+    );
+    if (topNQuery != null) {
+      executeTopN(queryBuilder, topNQuery, sink);
+      return;
+    }
+
+    final GroupByQuery groupByQuery = queryBuilder.toGroupByQuery(dataSource, sourceRowSignature);
+    if (groupByQuery != null) {
+      executeGroupBy(queryBuilder, groupByQuery, sink);
+      return;
+    }
+
+    final SelectQuery selectQuery = queryBuilder.toSelectQuery(dataSource, sourceRowSignature);
+    if (selectQuery != null) {
+      executeSelect(queryBuilder, selectQuery, sink);
+      return;
+    }
+
+    throw new IllegalStateException("WTF?! Cannot execute query even though we planned it?");
+  }
+
+  private void executeSelect(
       final DruidQueryBuilder queryBuilder,
+      final SelectQuery baseQuery,
       final Function<Row, Void> sink
   )
   {
@@ -105,28 +155,7 @@ public static void executeSelect(
 
     final List<RelDataTypeField> fieldList = queryBuilder.getRowType().getFieldList();
     final Row.RowBuilder rowBuilder = Row.newBuilder(fieldList.size());
-    final Filtration filtration = Filtration.create(queryBuilder.getFilter()).optimize(druidTable);
-    final SelectProjection selectProjection = queryBuilder.getSelectProjection();
-    final Integer limit;
-    final boolean descending;
-
-    if (queryBuilder.getLimitSpec() != null) {
-      limit = queryBuilder.getLimitSpec().getLimit();
-
-      // Safe to assume limitSpec has zero or one entry; DruidSelectSortRule wouldn't push in anything else.
-      if (queryBuilder.getLimitSpec().getColumns().size() > 0) {
-        final OrderByColumnSpec orderBy = Iterables.getOnlyElement(queryBuilder.getLimitSpec().getColumns());
-        if (!orderBy.getDimension().equals(Column.TIME_COLUMN_NAME)) {
-          throw new ISE("WTF?! Got select with non-time orderBy[%s]", orderBy);
-        }
-        descending = orderBy.getDirection() == OrderByColumnSpec.Direction.DESCENDING;
-      } else {
-        descending = false;
-      }
-    } else {
-      limit = null;
-      descending = false;
-    }
+    final Integer limit = queryBuilder.getLimitSpec() != null ? queryBuilder.getLimitSpec().getLimit() : null;
 
     // Loop through pages.
     final AtomicBoolean morePages = new AtomicBoolean(true);
@@ -134,17 +163,12 @@ public static void executeSelect(
     final AtomicLong rowsRead = new AtomicLong();
 
     while (morePages.get()) {
-      final SelectQuery query = new SelectQuery(
-          druidTable.getDataSource(),
-          filtration.getQuerySegmentSpec(),
-          descending,
-          filtration.getDimFilter(),
-          QueryGranularities.ALL,
-          selectProjection != null ? selectProjection.getDimensions() : ImmutableList.<DimensionSpec>of(),
-          selectProjection != null ? selectProjection.getMetrics() : ImmutableList.<String>of(),
-          null,
-          new PagingSpec(pagingIdentifiers.get(), druidTable.getPlannerConfig().getSelectThreshold(), true),
-          null
+      final SelectQuery query = baseQuery.withPagingSpec(
+          new PagingSpec(
+              pagingIdentifiers.get(),
+              plannerConfig.getSelectThreshold(),
+              true
+          )
       );
 
       Hook.QUERY_PLAN.run(query);
@@ -152,7 +176,7 @@ public static void executeSelect(
       morePages.set(false);
       final AtomicBoolean gotResult = new AtomicBoolean();
 
-      query.run(druidTable.getQuerySegmentWalker(), Maps.<String, Object>newHashMap()).accumulate(
+      query.run(walker, Maps.<String, Object>newHashMap()).accumulate(
           null,
           new Accumulator<Object, Result<SelectResultValue>>()
           {
@@ -198,56 +222,20 @@ public Object accumulate(final Object accumulated, final Result<SelectResultValu
     }
   }
 
-  public static void executeTimeseries(
-      final DruidTable druidTable,
+  private void executeTimeseries(
       final DruidQueryBuilder queryBuilder,
+      final TimeseriesQuery query,
       final Function<Row, Void> sink
   )
   {
-    final QueryGranularity queryGranularity = queryBuilder.asQueryGranularityIfTimeseries();
-
-    if (queryGranularity == null) {
-      throw new ISE("WTF?! executeTimeseries called on query that cannot become a timeseries?!");
-    }
-
-    final String timeOutputName = queryBuilder.getGrouping().getDimensions().size() == 1
-                                  ? queryBuilder.getGrouping().getDimensions().get(0).getOutputName()
-                                  : null;
-
     final List<RelDataTypeField> fieldList = queryBuilder.getRowType().getFieldList();
+    final List<DimensionSpec> dimensions = queryBuilder.getGrouping().getDimensions();
+    final String timeOutputName = dimensions.isEmpty() ? null : Iterables.getOnlyElement(dimensions).getOutputName();
     final Row.RowBuilder rowBuilder = Row.newBuilder(fieldList.size());
-    final Filtration filtration = Filtration.create(queryBuilder.getFilter()).optimize(druidTable);
-
-    final boolean descending;
-
-    if (queryBuilder.getLimitSpec() != null) {
-      final DefaultLimitSpec limitSpec = queryBuilder.getLimitSpec();
-
-      // Sanity checks; these preconditions should be assured by DruidQueryBuilder.accumulate.
-      Preconditions.checkState(limitSpec.getColumns().size() == 1);
-      Preconditions.checkState(limitSpec.getColumns().get(0).getDimension().equals(timeOutputName));
-      descending = limitSpec.getColumns().get(0).getDirection() == OrderByColumnSpec.Direction.DESCENDING;
-    } else {
-      descending = false;
-    }
-
-    final Map<String, Object> context = Maps.newHashMap();
-    context.put("skipEmptyBuckets", true);
-
-    final TimeseriesQuery query = new TimeseriesQuery(
-        druidTable.getDataSource(),
-        filtration.getQuerySegmentSpec(),
-        descending,
-        filtration.getDimFilter(),
-        queryGranularity,
-        queryBuilder.getGrouping().getAggregatorFactories(),
-        queryBuilder.getGrouping().getPostAggregators(),
-        context
-    );
 
     Hook.QUERY_PLAN.run(query);
 
-    query.run(druidTable.getQuerySegmentWalker(), Maps.<String, Object>newHashMap()).accumulate(
+    query.run(walker, Maps.<String, Object>newHashMap()).accumulate(
         null,
         new Accumulator<Object, Result<TimeseriesResultValue>>()
         {
@@ -274,39 +262,18 @@ public Object accumulate(final Object accumulated, final Result<TimeseriesResult
     );
   }
 
-  public static void executeTopN(
-      final DruidTable druidTable,
+  private void executeTopN(
       final DruidQueryBuilder queryBuilder,
+      final TopNQuery query,
       final Function<Row, Void> sink
   )
   {
-    // OK to hard-code permissive values here; this method is only called if we really do want a topN.
-    final TopNMetricSpec topNMetricSpec = queryBuilder.asTopNMetricSpecIfTopN(Integer.MAX_VALUE, true);
-
-    if (topNMetricSpec == null) {
-      throw new ISE("WTF?! executeTopN called on query that cannot become a topN?!");
-    }
-
     final List<RelDataTypeField> fieldList = queryBuilder.getRowType().getFieldList();
     final Row.RowBuilder rowBuilder = Row.newBuilder(fieldList.size());
-    final Filtration filtration = Filtration.create(queryBuilder.getFilter()).optimize(druidTable);
-
-    final TopNQuery query = new TopNQuery(
-        druidTable.getDataSource(),
-        Iterables.getOnlyElement(queryBuilder.getGrouping().getDimensions()),
-        topNMetricSpec,
-        queryBuilder.getLimitSpec().getLimit(),
-        filtration.getQuerySegmentSpec(),
-        filtration.getDimFilter(),
-        QueryGranularities.ALL,
-        queryBuilder.getGrouping().getAggregatorFactories(),
-        queryBuilder.getGrouping().getPostAggregators(),
-        null
-    );
 
     Hook.QUERY_PLAN.run(query);
 
-    query.run(druidTable.getQuerySegmentWalker(), Maps.<String, Object>newHashMap()).accumulate(
+    query.run(walker, Maps.<String, Object>newHashMap()).accumulate(
         null,
         new Accumulator<Object, Result<TopNResultValue>>()
         {
@@ -331,34 +298,18 @@ public Object accumulate(final Object accumulated, final Result<TopNResultValue>
     );
   }
 
-  public static void executeGroupBy(
-      final DruidTable druidTable,
+  private void executeGroupBy(
       final DruidQueryBuilder queryBuilder,
+      final GroupByQuery query,
       final Function<Row, Void> sink
   )
   {
-    Preconditions.checkState(queryBuilder.getGrouping() != null, "grouping must be non-null");
-
     final List<RelDataTypeField> fieldList = queryBuilder.getRowType().getFieldList();
     final Row.RowBuilder rowBuilder = Row.newBuilder(fieldList.size());
-    final Filtration filtration = Filtration.create(queryBuilder.getFilter()).optimize(druidTable);
-
-    final GroupByQuery query = new GroupByQuery(
-        druidTable.getDataSource(),
-        filtration.getQuerySegmentSpec(),
-        filtration.getDimFilter(),
-        QueryGranularities.ALL,
-        queryBuilder.getGrouping().getDimensions(),
-        queryBuilder.getGrouping().getAggregatorFactories(),
-        queryBuilder.getGrouping().getPostAggregators(),
-        queryBuilder.getHaving() != null ? new DimFilterHavingSpec(queryBuilder.getHaving()) : null,
-        queryBuilder.getLimitSpec(),
-        null
-    );
 
     Hook.QUERY_PLAN.run(query);
 
-    query.run(druidTable.getQuerySegmentWalker(), Maps.<String, Object>newHashMap()).accumulate(
+    query.run(walker, Maps.<String, Object>newHashMap()).accumulate(
         null,
         new Accumulator<Object, io.druid.data.input.Row>()
         {
diff --git a/sql/src/main/java/io/druid/sql/calcite/rule/DruidFilterRule.java b/sql/src/main/java/io/druid/sql/calcite/rule/DruidFilterRule.java
index f40592ff3420..55e44943b668 100644
--- a/sql/src/main/java/io/druid/sql/calcite/rule/DruidFilterRule.java
+++ b/sql/src/main/java/io/druid/sql/calcite/rule/DruidFilterRule.java
@@ -53,8 +53,7 @@ public void onMatch(RelOptRuleCall call)
     }
 
     final DimFilter dimFilter = Expressions.toFilter(
-        druidRel.getDruidTable(),
-        druidRel.getQueryBuilder().getRowOrder(),
+        druidRel.getSourceRowSignature(),
         filter.getCondition()
     );
     if (dimFilter != null) {
diff --git a/sql/src/main/java/io/druid/sql/calcite/rule/DruidSelectProjectionRule.java b/sql/src/main/java/io/druid/sql/calcite/rule/DruidSelectProjectionRule.java
deleted file mode 100644
index 13995f3a9f72..000000000000
--- a/sql/src/main/java/io/druid/sql/calcite/rule/DruidSelectProjectionRule.java
+++ /dev/null
@@ -1,125 +0,0 @@
-/*
- * Licensed to Metamarkets Group Inc. (Metamarkets) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. Metamarkets licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package io.druid.sql.calcite.rule;
-
-import com.google.common.collect.Lists;
-import io.druid.query.dimension.DefaultDimensionSpec;
-import io.druid.query.dimension.DimensionSpec;
-import io.druid.query.dimension.ExtractionDimensionSpec;
-import io.druid.query.extraction.ExtractionFn;
-import io.druid.segment.column.Column;
-import io.druid.segment.column.ValueType;
-import io.druid.sql.calcite.expression.Expressions;
-import io.druid.sql.calcite.expression.RowExtraction;
-import io.druid.sql.calcite.rel.DruidRel;
-import io.druid.sql.calcite.rel.SelectProjection;
-import io.druid.sql.calcite.table.DruidTables;
-import org.apache.calcite.plan.RelOptRule;
-import org.apache.calcite.plan.RelOptRuleCall;
-import org.apache.calcite.rel.core.Project;
-
-import java.util.List;
-
-public class DruidSelectProjectionRule extends RelOptRule
-{
-  private static final DruidSelectProjectionRule INSTANCE = new DruidSelectProjectionRule();
-
-  private DruidSelectProjectionRule()
-  {
-    super(operand(Project.class, operand(DruidRel.class, none())));
-  }
-
-  public static DruidSelectProjectionRule instance()
-  {
-    return INSTANCE;
-  }
-
-  @Override
-  public void onMatch(RelOptRuleCall call)
-  {
-    final Project project = call.rel(0);
-    final DruidRel druidRel = call.rel(1);
-
-    if (druidRel.getQueryBuilder().getSelectProjection() != null
-        || druidRel.getQueryBuilder().getGrouping() != null
-        || druidRel.getQueryBuilder().getLimitSpec() != null) {
-      return;
-    }
-
-    // Only push in projections that can be used by the Select query.
-    // Leave anything more complicated to DruidAggregateProjectRule for possible handling in a GroupBy query.
-
-    final List<DimensionSpec> dimensions = Lists.newArrayList();
-    final List<String> metrics = Lists.newArrayList();
-    final List<String> rowOrder = Lists.newArrayList();
-
-    int dimOutputNameCounter = 0;
-    for (int i = 0; i < project.getRowType().getFieldCount(); i++) {
-      final RowExtraction rex = Expressions.toRowExtraction(
-          DruidTables.rowOrder(druidRel.getDruidTable()),
-          project.getChildExps().get(i)
-      );
-
-      if (rex == null) {
-        return;
-      }
-
-      final String column = rex.getColumn();
-      final ExtractionFn extractionFn = rex.getExtractionFn();
-
-      // Check if this field should be a dimension, a metric, or a reference to __time.
-      final ValueType columnType = druidRel.getDruidTable()
-                                           .getColumnType(druidRel.getDruidTable().getColumnNumber(column));
-
-      if (columnType == ValueType.STRING || (column.equals(Column.TIME_COLUMN_NAME) && extractionFn != null)) {
-        // Add to dimensions.
-        do {
-          dimOutputNameCounter++;
-        } while (druidRel.getDruidTable().getColumnNumber(GroupByRules.dimOutputName(dimOutputNameCounter)) >= 0);
-        final String outputName = GroupByRules.dimOutputName(dimOutputNameCounter);
-        final DimensionSpec dimensionSpec = extractionFn == null
-                                            ? new DefaultDimensionSpec(column, outputName)
-                                            : new ExtractionDimensionSpec(column, outputName, extractionFn);
-        dimensions.add(dimensionSpec);
-        rowOrder.add(outputName);
-      } else if (extractionFn == null && !column.equals(Column.TIME_COLUMN_NAME)) {
-        // Add to metrics.
-        metrics.add(column);
-        rowOrder.add(column);
-      } else if (extractionFn == null && column.equals(Column.TIME_COLUMN_NAME)) {
-        // This is __time.
-        rowOrder.add(Column.TIME_COLUMN_NAME);
-      } else {
-        // Don't know what to do!
-        return;
-      }
-    }
-
-    call.transformTo(
-        druidRel.withQueryBuilder(
-            druidRel.getQueryBuilder()
-                    .withSelectProjection(
-                        new SelectProjection(project, dimensions, metrics),
-                        rowOrder
-                    )
-        )
-    );
-  }
-}
diff --git a/sql/src/main/java/io/druid/sql/calcite/rule/DruidSelectSortRule.java b/sql/src/main/java/io/druid/sql/calcite/rule/DruidSelectSortRule.java
deleted file mode 100644
index 85534e0682eb..000000000000
--- a/sql/src/main/java/io/druid/sql/calcite/rule/DruidSelectSortRule.java
+++ /dev/null
@@ -1,74 +0,0 @@
-/*
- * Licensed to Metamarkets Group Inc. (Metamarkets) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. Metamarkets licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package io.druid.sql.calcite.rule;
-
-import io.druid.query.groupby.orderby.DefaultLimitSpec;
-import io.druid.query.groupby.orderby.OrderByColumnSpec;
-import io.druid.segment.column.Column;
-import io.druid.sql.calcite.rel.DruidRel;
-import org.apache.calcite.plan.RelOptRule;
-import org.apache.calcite.plan.RelOptRuleCall;
-import org.apache.calcite.rel.core.Sort;
-
-import java.util.List;
-
-public class DruidSelectSortRule extends RelOptRule
-{
-  private static final DruidSelectSortRule INSTANCE = new DruidSelectSortRule();
-
-  private DruidSelectSortRule()
-  {
-    super(operand(Sort.class, operand(DruidRel.class, none())));
-  }
-
-  public static DruidSelectSortRule instance()
-  {
-    return INSTANCE;
-  }
-
-  @Override
-  public void onMatch(RelOptRuleCall call)
-  {
-    final Sort sort = call.rel(0);
-    final DruidRel druidRel = call.rel(1);
-
-    if (druidRel.getQueryBuilder().getGrouping() != null
-        || druidRel.getQueryBuilder().getLimitSpec() != null) {
-      return;
-    }
-
-    final DefaultLimitSpec limitSpec = GroupByRules.toLimitSpec(druidRel.getQueryBuilder().getRowOrder(), sort);
-    if (limitSpec == null) {
-      return;
-    }
-
-    // Only push in sorts that can be used by the Select query.
-    final List<OrderByColumnSpec> orderBys = limitSpec.getColumns();
-    if (orderBys.isEmpty() ||
-        (orderBys.size() == 1 && orderBys.get(0).getDimension().equals(Column.TIME_COLUMN_NAME))) {
-      call.transformTo(
-          druidRel.withQueryBuilder(
-              druidRel.getQueryBuilder()
-                      .withLimitSpec(limitSpec)
-          )
-      );
-    }
-  }
-}
diff --git a/sql/src/main/java/io/druid/sql/calcite/rule/DruidSemiJoinRule.java b/sql/src/main/java/io/druid/sql/calcite/rule/DruidSemiJoinRule.java
index 6c6533c12b77..4de14903ea0a 100644
--- a/sql/src/main/java/io/druid/sql/calcite/rule/DruidSemiJoinRule.java
+++ b/sql/src/main/java/io/druid/sql/calcite/rule/DruidSemiJoinRule.java
@@ -19,6 +19,7 @@
 
 package io.druid.sql.calcite.rule;
 
+import io.druid.sql.calcite.planner.PlannerConfig;
 import io.druid.sql.calcite.rel.DruidRel;
 import io.druid.sql.calcite.rel.DruidSemiJoin;
 import org.apache.calcite.plan.RelOptRule;
@@ -27,9 +28,9 @@
 
 public class DruidSemiJoinRule extends RelOptRule
 {
-  private static final DruidSemiJoinRule INSTANCE = new DruidSemiJoinRule();
+  private final PlannerConfig plannerConfig;
 
-  private DruidSemiJoinRule()
+  public DruidSemiJoinRule(final PlannerConfig plannerConfig)
   {
     super(
         operand(
@@ -38,11 +39,12 @@ private DruidSemiJoinRule()
             operand(DruidRel.class, none())
         )
     );
+    this.plannerConfig = plannerConfig;
   }
 
-  public static DruidSemiJoinRule instance()
+  public static DruidSemiJoinRule create(final PlannerConfig plannerConfig)
   {
-    return INSTANCE;
+    return new DruidSemiJoinRule(plannerConfig);
   }
 
   @Override
@@ -51,8 +53,19 @@ public void onMatch(RelOptRuleCall call)
     final SemiJoin semiJoin = call.rel(0);
     final DruidRel left = call.rel(1);
     final DruidRel right = call.rel(2);
-    final DruidSemiJoin druidSemiJoin = DruidSemiJoin.from(semiJoin, semiJoin.getTraitSet(), left, right);
+    final DruidSemiJoin druidSemiJoin = DruidSemiJoin.from(
+        semiJoin,
+        left,
+        right,
+        plannerConfig.getMaxSemiJoinRowsInMemory()
+    );
+
     if (druidSemiJoin != null) {
+      // Check maxQueryCount.
+      if (plannerConfig.getMaxQueryCount() > 0 && druidSemiJoin.getQueryCount() > plannerConfig.getMaxQueryCount()) {
+        return;
+      }
+
       call.transformTo(druidSemiJoin);
     }
   }
diff --git a/sql/src/main/java/io/druid/sql/calcite/rule/GroupByRules.java b/sql/src/main/java/io/druid/sql/calcite/rule/GroupByRules.java
index ec79cfbbc500..7cb63918a8b0 100644
--- a/sql/src/main/java/io/druid/sql/calcite/rule/GroupByRules.java
+++ b/sql/src/main/java/io/druid/sql/calcite/rule/GroupByRules.java
@@ -38,9 +38,7 @@
 import io.druid.query.aggregation.hyperloglog.HyperUniqueFinalizingPostAggregator;
 import io.druid.query.aggregation.post.ArithmeticPostAggregator;
 import io.druid.query.aggregation.post.FieldAccessPostAggregator;
-import io.druid.query.dimension.DefaultDimensionSpec;
 import io.druid.query.dimension.DimensionSpec;
-import io.druid.query.dimension.ExtractionDimensionSpec;
 import io.druid.query.filter.AndDimFilter;
 import io.druid.query.filter.DimFilter;
 import io.druid.query.filter.NotDimFilter;
@@ -48,18 +46,16 @@
 import io.druid.query.groupby.orderby.OrderByColumnSpec;
 import io.druid.query.ordering.StringComparator;
 import io.druid.query.ordering.StringComparators;
-import io.druid.segment.column.Column;
-import io.druid.segment.column.ValueType;
 import io.druid.sql.calcite.aggregation.Aggregation;
 import io.druid.sql.calcite.aggregation.PostAggregatorFactory;
 import io.druid.sql.calcite.expression.Expressions;
 import io.druid.sql.calcite.expression.RowExtraction;
 import io.druid.sql.calcite.filtration.Filtration;
 import io.druid.sql.calcite.planner.PlannerConfig;
+import io.druid.sql.calcite.rel.DruidNestedGroupBy;
 import io.druid.sql.calcite.rel.DruidRel;
 import io.druid.sql.calcite.rel.Grouping;
-import io.druid.sql.calcite.table.DruidTable;
-import io.druid.sql.calcite.table.DruidTables;
+import io.druid.sql.calcite.table.RowSignature;
 import org.apache.calcite.plan.RelOptRule;
 import org.apache.calcite.plan.RelOptRuleCall;
 import org.apache.calcite.rel.RelFieldCollation;
@@ -89,11 +85,12 @@ private GroupByRules()
   public static List<RelOptRule> rules(final PlannerConfig plannerConfig)
   {
     return ImmutableList.of(
-        new DruidAggregateRule(plannerConfig.isUseApproximateCountDistinct()),
-        new DruidAggregateProjectRule(plannerConfig.isUseApproximateCountDistinct()),
-        new DruidProjectAfterAggregationRule(),
-        new DruidFilterAfterAggregationRule(),
-        new DruidGroupBySortRule()
+        new DruidAggregateRule(plannerConfig),
+        new DruidAggregateProjectRule(plannerConfig),
+        new DruidAggregateProjectFilterRule(plannerConfig),
+        new DruidGroupByPostAggregationRule(),
+        new DruidGroupByHavingRule(),
+        new DruidGroupByLimitRule()
     );
   }
 
@@ -153,12 +150,20 @@ public String getExpression()
 
   public static class DruidAggregateRule extends RelOptRule
   {
-    final boolean approximateCountDistinct;
+    private final PlannerConfig plannerConfig;
 
-    private DruidAggregateRule(final boolean approximateCountDistinct)
+    private DruidAggregateRule(final PlannerConfig plannerConfig)
     {
       super(operand(Aggregate.class, operand(DruidRel.class, none())));
-      this.approximateCountDistinct = approximateCountDistinct;
+      this.plannerConfig = plannerConfig;
+    }
+
+    @Override
+    public boolean matches(RelOptRuleCall call)
+    {
+      final Aggregate aggregate = call.rel(0);
+      final DruidRel druidRel = call.rel(1);
+      return canApplyAggregate(druidRel, null, null, aggregate);
     }
 
     @Override
@@ -169,8 +174,10 @@ public void onMatch(RelOptRuleCall call)
       final DruidRel newDruidRel = GroupByRules.applyAggregate(
           druidRel,
           null,
+          null,
           aggregate,
-          approximateCountDistinct
+          plannerConfig.isUseApproximateCountDistinct(),
+          plannerConfig.getMaxQueryCount()
       );
       if (newDruidRel != null) {
         call.transformTo(newDruidRel);
@@ -180,12 +187,21 @@ public void onMatch(RelOptRuleCall call)
 
   public static class DruidAggregateProjectRule extends RelOptRule
   {
-    final boolean approximateCountDistinct;
+    private final PlannerConfig plannerConfig;
 
-    private DruidAggregateProjectRule(final boolean approximateCountDistinct)
+    private DruidAggregateProjectRule(final PlannerConfig plannerConfig)
     {
       super(operand(Aggregate.class, operand(Project.class, operand(DruidRel.class, none()))));
-      this.approximateCountDistinct = approximateCountDistinct;
+      this.plannerConfig = plannerConfig;
+    }
+
+    @Override
+    public boolean matches(RelOptRuleCall call)
+    {
+      final Aggregate aggregate = call.rel(0);
+      final Project project = call.rel(1);
+      final DruidRel druidRel = call.rel(2);
+      return canApplyAggregate(druidRel, null, project, aggregate);
     }
 
     @Override
@@ -196,9 +212,11 @@ public void onMatch(RelOptRuleCall call)
       final DruidRel druidRel = call.rel(2);
       final DruidRel newDruidRel = GroupByRules.applyAggregate(
           druidRel,
+          null,
           project,
           aggregate,
-          approximateCountDistinct
+          plannerConfig.isUseApproximateCountDistinct(),
+          plannerConfig.getMaxQueryCount()
       );
       if (newDruidRel != null) {
         call.transformTo(newDruidRel);
@@ -206,81 +224,186 @@ public void onMatch(RelOptRuleCall call)
     }
   }
 
-  public static class DruidProjectAfterAggregationRule extends RelOptRule
+  public static class DruidAggregateProjectFilterRule extends RelOptRule
   {
-    private DruidProjectAfterAggregationRule()
+    private final PlannerConfig plannerConfig;
+
+    private DruidAggregateProjectFilterRule(final PlannerConfig plannerConfig)
+    {
+      super(operand(Aggregate.class, operand(Project.class, operand(Filter.class, operand(DruidRel.class, none())))));
+      this.plannerConfig = plannerConfig;
+    }
+
+    @Override
+    public boolean matches(RelOptRuleCall call)
+    {
+      final Aggregate aggregate = call.rel(0);
+      final Project project = call.rel(1);
+      final Filter filter = call.rel(2);
+      final DruidRel druidRel = call.rel(3);
+      return canApplyAggregate(druidRel, filter, project, aggregate);
+    }
+
+    @Override
+    public void onMatch(RelOptRuleCall call)
+    {
+      final Aggregate aggregate = call.rel(0);
+      final Project project = call.rel(1);
+      final Filter filter = call.rel(2);
+      final DruidRel druidRel = call.rel(3);
+      final DruidRel newDruidRel = GroupByRules.applyAggregate(
+          druidRel,
+          filter,
+          project,
+          aggregate,
+          plannerConfig.isUseApproximateCountDistinct(),
+          plannerConfig.getMaxQueryCount()
+      );
+      if (newDruidRel != null) {
+        call.transformTo(newDruidRel);
+      }
+    }
+  }
+
+  public static class DruidGroupByPostAggregationRule extends RelOptRule
+  {
+    private DruidGroupByPostAggregationRule()
     {
       super(operand(Project.class, operand(DruidRel.class, none())));
     }
 
+    @Override
+    public boolean matches(RelOptRuleCall call)
+    {
+      final DruidRel druidRel = call.rel(1);
+      return canApplyPostAggregation(druidRel);
+    }
+
     @Override
     public void onMatch(RelOptRuleCall call)
     {
       final Project postProject = call.rel(0);
       final DruidRel druidRel = call.rel(1);
-      final DruidRel newDruidRel = GroupByRules.applyProjectAfterAggregate(druidRel, postProject);
+      final DruidRel newDruidRel = GroupByRules.applyPostAggregation(druidRel, postProject);
       if (newDruidRel != null) {
         call.transformTo(newDruidRel);
       }
     }
   }
 
-  public static class DruidFilterAfterAggregationRule extends RelOptRule
+  public static class DruidGroupByHavingRule extends RelOptRule
   {
-    private DruidFilterAfterAggregationRule()
+    private DruidGroupByHavingRule()
     {
       super(operand(Filter.class, operand(DruidRel.class, none())));
     }
 
+    @Override
+    public boolean matches(RelOptRuleCall call)
+    {
+      final DruidRel druidRel = call.rel(1);
+      return canApplyHaving(druidRel);
+    }
+
     @Override
     public void onMatch(RelOptRuleCall call)
     {
       final Filter postFilter = call.rel(0);
       final DruidRel druidRel = call.rel(1);
-      final DruidRel newDruidRel = GroupByRules.applyFilterAfterAggregate(druidRel, postFilter);
+      final DruidRel newDruidRel = GroupByRules.applyHaving(druidRel, postFilter);
       if (newDruidRel != null) {
         call.transformTo(newDruidRel);
       }
     }
   }
 
-  public static class DruidGroupBySortRule extends RelOptRule
+  public static class DruidGroupByLimitRule extends RelOptRule
   {
-    private DruidGroupBySortRule()
+    private DruidGroupByLimitRule()
     {
       super(operand(Sort.class, operand(DruidRel.class, none())));
     }
 
+    @Override
+    public boolean matches(RelOptRuleCall call)
+    {
+      final DruidRel druidRel = call.rel(1);
+      return canApplyLimit(druidRel);
+    }
+
     @Override
     public void onMatch(RelOptRuleCall call)
     {
       final Sort sort = call.rel(0);
       final DruidRel druidRel = call.rel(1);
-      final DruidRel newDruidRel = GroupByRules.applySort(druidRel, sort);
+      final DruidRel newDruidRel = GroupByRules.applyLimit(druidRel, sort);
       if (newDruidRel != null) {
         call.transformTo(newDruidRel);
       }
     }
   }
 
+  private static boolean canApplyAggregate(
+      final DruidRel druidRel,
+      final Filter filter,
+      final Project project,
+      final Aggregate aggregate
+  )
+  {
+    return (filter == null || druidRel.getQueryBuilder().getFilter() == null /* can't filter twice */)
+           && (project == null || druidRel.getQueryBuilder().getSelectProjection() == null /* can't project twice */)
+           && !aggregate.indicator
+           && aggregate.getGroupSets().size() == 1;
+  }
+
+  /**
+   * Applies a filter -> project -> aggregate chain to a druidRel. Do not call this method unless
+   * {@link #canApplyAggregate(DruidRel, Filter, Project, Aggregate)} returns true.
+   *
+   * @return new rel, or null if the chain cannot be applied
+   */
   private static DruidRel applyAggregate(
       final DruidRel druidRel,
+      final Filter filter0,
       final Project project0,
       final Aggregate aggregate,
-      final boolean approximateCountDistinct
+      final boolean approximateCountDistinct,
+      final int maxQueryCount
   )
   {
-    if ((project0 != null && druidRel.getQueryBuilder().getSelectProjection() != null /* can't project twice */)
-        || druidRel.getQueryBuilder().getGrouping() != null
-        || aggregate.indicator
-        || aggregate.getGroupSets().size() != 1) {
-      return null;
+    Preconditions.checkState(canApplyAggregate(druidRel, filter0, project0, aggregate), "Cannot applyAggregate.");
+
+    final RowSignature sourceRowSignature;
+    final boolean isNestedQuery = druidRel.getQueryBuilder().getGrouping() != null;
+
+    if (isNestedQuery) {
+      // Nested groupBy; source row signature is the output signature of druidRel.
+      sourceRowSignature = druidRel.getOutputRowSignature();
+    } else {
+      sourceRowSignature = druidRel.getSourceRowSignature();
+    }
+
+    // Filter that should be applied before aggregating.
+    final DimFilter filter;
+    if (filter0 != null) {
+      filter = Expressions.toFilter(sourceRowSignature, filter0.getCondition());
+      if (filter == null) {
+        // Can't plan this filter.
+        return null;
+      }
+    } else if (druidRel.getQueryBuilder().getFilter() != null && !isNestedQuery) {
+      // We're going to replace the existing druidRel, so inherit its filter.
+      filter = druidRel.getQueryBuilder().getFilter();
+    } else {
+      filter = null;
     }
 
+    // Projection that should be applied before aggregating.
     final Project project;
     if (project0 != null) {
       project = project0;
-    } else if (druidRel.getQueryBuilder().getSelectProjection() != null) {
+    } else if (druidRel.getQueryBuilder().getSelectProjection() != null && !isNestedQuery) {
+      // We're going to replace the existing druidRel, so inherit its projection.
       project = druidRel.getQueryBuilder().getSelectProjection().getProject();
     } else {
       project = null;
@@ -301,12 +424,16 @@ private static DruidRel applyAggregate(
         // nobody actually expects to see the literal.
         rowOrder.add(dimOutputName(dimOutputNameCounter++));
       } else {
-        final DimensionSpec dimensionSpec = toDimensionSpec(
-            druidRel.getDruidTable(),
-            Expressions.toRowExtraction(
-                DruidTables.rowOrder(druidRel.getDruidTable()),
-                Expressions.fromFieldAccess(druidRel.getDruidTable(), project, i)
-            ),
+        final RowExtraction rex = Expressions.toRowExtraction(
+            sourceRowSignature.getRowOrder(),
+            Expressions.fromFieldAccess(sourceRowSignature, project, i)
+        );
+        if (rex == null) {
+          return null;
+        }
+
+        final DimensionSpec dimensionSpec = rex.toDimensionSpec(
+            sourceRowSignature,
             dimOutputName(dimOutputNameCounter++)
         );
         if (dimensionSpec == null) {
@@ -321,7 +448,7 @@ private static DruidRel applyAggregate(
     for (int i = 0; i < aggregate.getAggCallList().size(); i++) {
       final AggregateCall aggCall = aggregate.getAggCallList().get(i);
       final Aggregation aggregation = translateAggregateCall(
-          druidRel,
+          sourceRowSignature,
           project,
           aggCall,
           i,
@@ -336,24 +463,49 @@ private static DruidRel applyAggregate(
       rowOrder.add(aggregation.getOutputName());
     }
 
-    return druidRel.withQueryBuilder(
-        druidRel.getQueryBuilder()
-                .withGrouping(
-                    Grouping.create(dimensions, aggregations),
-                    aggregate.getRowType(),
-                    rowOrder
-                )
-    );
+    if (isNestedQuery) {
+      // Nested groupBy.
+      final DruidNestedGroupBy retVal = DruidNestedGroupBy.from(
+          druidRel,
+          filter,
+          Grouping.create(dimensions, aggregations),
+          aggregate.getRowType(),
+          rowOrder
+      );
+
+      // Check maxQueryCount.
+      if (maxQueryCount > 0 && retVal.getQueryCount() > maxQueryCount) {
+        return null;
+      }
+
+      return retVal;
+    } else {
+      // groupBy on a base dataSource.
+      return druidRel.withQueryBuilder(
+          druidRel.getQueryBuilder()
+                  .withFilter(filter)
+                  .withGrouping(
+                      Grouping.create(dimensions, aggregations),
+                      aggregate.getRowType(),
+                      rowOrder
+                  )
+      );
+    }
   }
 
-  private static DruidRel applyProjectAfterAggregate(
-      final DruidRel druidRel,
-      final Project postProject
-  )
+  private static boolean canApplyPostAggregation(final DruidRel druidRel)
   {
-    if (druidRel.getQueryBuilder().getGrouping() == null || druidRel.getQueryBuilder().getLimitSpec() != null) {
-      return null;
-    }
+    return druidRel.getQueryBuilder().getGrouping() != null && druidRel.getQueryBuilder().getLimitSpec() == null;
+  }
+
+  /**
+   * Applies a projection to the aggregations of a druidRel, by potentially adding post-aggregators.
+   *
+   * @return new rel, or null if the projection cannot be applied
+   */
+  private static DruidRel applyPostAggregation(final DruidRel druidRel, final Project postProject)
+  {
+    Preconditions.checkState(canApplyPostAggregation(druidRel), "Cannot applyPostAggregation");
 
     final List<String> rowOrder = druidRel.getQueryBuilder().getRowOrder();
     final Grouping grouping = druidRel.getQueryBuilder().getGrouping();
@@ -411,20 +563,25 @@ private static DruidRel applyProjectAfterAggregate(
     );
   }
 
-  private static DruidRel applyFilterAfterAggregate(
-      final DruidRel druidRel,
-      final Filter postFilter
-  )
+  private static boolean canApplyHaving(final DruidRel druidRel)
   {
-    if (druidRel.getQueryBuilder().getGrouping() == null
-        || druidRel.getQueryBuilder().getHaving() != null
-        || druidRel.getQueryBuilder().getLimitSpec() != null) {
-      return null;
-    }
+    return druidRel.getQueryBuilder().getGrouping() != null
+           && druidRel.getQueryBuilder().getHaving() == null
+           && druidRel.getQueryBuilder().getLimitSpec() == null;
+  }
+
+  /**
+   * Applies a filter to an aggregating druidRel, as a HavingSpec. Do not call this method unless
+   * {@link #canApplyHaving(DruidRel)} returns true.
+   *
+   * @return new rel, or null if the filter cannot be applied
+   */
+  private static DruidRel applyHaving(final DruidRel druidRel, final Filter postFilter)
+  {
+    Preconditions.checkState(canApplyHaving(druidRel), "Cannot applyHaving.");
 
     final DimFilter dimFilter = Expressions.toFilter(
-        null, // null table; this filter is being applied as a HAVING on result rows
-        druidRel.getQueryBuilder().getRowOrder(),
+        druidRel.getOutputRowSignature(),
         postFilter.getCondition()
     );
 
@@ -438,15 +595,20 @@ private static DruidRel applyFilterAfterAggregate(
     }
   }
 
-  private static DruidRel applySort(
-      final DruidRel druidRel,
-      final Sort sort
-  )
+  private static boolean canApplyLimit(final DruidRel druidRel)
   {
-    if (druidRel.getQueryBuilder().getGrouping() == null || druidRel.getQueryBuilder().getLimitSpec() != null) {
-      // Can only sort when grouping and not already sorting.
-      return null;
-    }
+    return druidRel.getQueryBuilder().getGrouping() != null && druidRel.getQueryBuilder().getLimitSpec() == null;
+  }
+
+  /**
+   * Applies a sort to an aggregating druidRel, as a LimitSpec. Do not call this method unless
+   * {@link #canApplyLimit(DruidRel)} returns true.
+   *
+   * @return new rel, or null if the sort cannot be applied
+   */
+  private static DruidRel applyLimit(final DruidRel druidRel, final Sort sort)
+  {
+    Preconditions.checkState(canApplyLimit(druidRel), "Cannot applyLimit.");
 
     final Grouping grouping = druidRel.getQueryBuilder().getGrouping();
     final DefaultLimitSpec limitSpec = toLimitSpec(druidRel.getQueryBuilder().getRowOrder(), sort);
@@ -542,41 +704,13 @@ public static DefaultLimitSpec toLimitSpec(
     return new DefaultLimitSpec(orderBys, limit);
   }
 
-  private static DimensionSpec toDimensionSpec(
-      final DruidTable druidTable,
-      final RowExtraction rex,
-      final String name
-  )
-  {
-    if (rex == null) {
-      return null;
-    }
-
-    final int columnNumber = druidTable.getColumnNumber(rex.getColumn());
-    if (columnNumber < 0) {
-      return null;
-    }
-
-    final ValueType columnType = druidTable.getColumnType(columnNumber);
-
-    if (columnType == ValueType.STRING ||
-        (rex.getColumn().equals(Column.TIME_COLUMN_NAME) && rex.getExtractionFn() != null)) {
-      return rex.getExtractionFn() == null
-             ? new DefaultDimensionSpec(rex.getColumn(), name)
-             : new ExtractionDimensionSpec(rex.getColumn(), name, rex.getExtractionFn());
-    } else {
-      // Can't create dimensionSpecs for non-string, non-time.
-      return null;
-    }
-  }
-
   /**
    * Translate an AggregateCall to Druid equivalents.
    *
    * @return translated aggregation, or null if translation failed.
    */
   private static Aggregation translateAggregateCall(
-      final DruidRel druidRel,
+      final RowSignature sourceRowSignature,
       final Project project,
       final AggregateCall call,
       final int aggNumber,
@@ -584,7 +718,7 @@ private static Aggregation translateAggregateCall(
   )
   {
     final List<DimFilter> filters = Lists.newArrayList();
-    final List<String> rowOrder = DruidTables.rowOrder(druidRel.getDruidTable());
+    final List<String> rowOrder = sourceRowSignature.getRowOrder();
     final String name = aggOutputName(aggNumber);
     final SqlKind kind = call.getAggregation().getKind();
     final SqlTypeName outputType = call.getType().getSqlTypeName();
@@ -598,7 +732,7 @@ private static Aggregation translateAggregateCall(
       }
 
       final RexNode expression = project.getChildExps().get(call.filterArg);
-      final DimFilter filter = Expressions.toFilter(druidRel.getDruidTable(), rowOrder, expression);
+      final DimFilter filter = Expressions.toFilter(sourceRowSignature, expression);
       if (filter == null) {
         return null;
       }
@@ -611,19 +745,22 @@ private static Aggregation translateAggregateCall(
       retVal = Aggregation.create(new CountAggregatorFactory(name));
     } else if (call.getAggregation().getKind() == SqlKind.COUNT && call.isDistinct() && approximateCountDistinct) {
       // COUNT(DISTINCT x)
-      final DimensionSpec dimensionSpec = toDimensionSpec(
-          druidRel.getDruidTable(),
-          Expressions.toRowExtraction(
-              rowOrder,
-              Expressions.fromFieldAccess(
-                  druidRel.getDruidTable(),
-                  project,
-                  Iterables.getOnlyElement(call.getArgList())
-              )
-          ),
-          aggInternalName(aggNumber, "dimSpec")
+      final RowExtraction rex = Expressions.toRowExtraction(
+          rowOrder,
+          Expressions.fromFieldAccess(
+              sourceRowSignature,
+              project,
+              Iterables.getOnlyElement(call.getArgList())
+          )
       );
+      if (rex == null) {
+        return null;
+      }
 
+      final DimensionSpec dimensionSpec = rex.toDimensionSpec(
+          sourceRowSignature,
+          aggInternalName(aggNumber, "dimSpec")
+      );
       if (dimensionSpec == null) {
         return null;
       }
@@ -648,7 +785,7 @@ public PostAggregator factorize(String outputName)
       final FieldOrExpression input;
 
       final int inputField = Iterables.getOnlyElement(call.getArgList());
-      final RexNode rexNode = Expressions.fromFieldAccess(druidRel.getDruidTable(), project, inputField);
+      final RexNode rexNode = Expressions.fromFieldAccess(sourceRowSignature, project, inputField);
       final FieldOrExpression foe = FieldOrExpression.fromRexNode(rowOrder, rexNode);
 
       if (foe != null) {
@@ -668,8 +805,7 @@ public PostAggregator factorize(String outputName)
 
         // Operand 1: Filter
         final DimFilter filter = Expressions.toFilter(
-            druidRel.getDruidTable(),
-            rowOrder,
+            sourceRowSignature,
             caseCall.getOperands().get(0)
         );
         if (filter == null) {
@@ -764,7 +900,7 @@ public PostAggregator factorize(String outputName)
     final DimFilter filter = filters.isEmpty()
                              ? null
                              : Filtration.create(new AndDimFilter(filters))
-                                         .optimizeFilterOnly(druidRel.getDruidTable())
+                                         .optimizeFilterOnly(sourceRowSignature)
                                          .getDimFilter();
 
     return retVal != null ? retVal.filter(filter) : null;
diff --git a/sql/src/main/java/io/druid/sql/calcite/rule/SelectRules.java b/sql/src/main/java/io/druid/sql/calcite/rule/SelectRules.java
new file mode 100644
index 000000000000..8f4fd311a2c0
--- /dev/null
+++ b/sql/src/main/java/io/druid/sql/calcite/rule/SelectRules.java
@@ -0,0 +1,186 @@
+/*
+ * Licensed to Metamarkets Group Inc. (Metamarkets) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. Metamarkets licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package io.druid.sql.calcite.rule;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Lists;
+import io.druid.java.util.common.ISE;
+import io.druid.query.dimension.DimensionSpec;
+import io.druid.query.extraction.ExtractionFn;
+import io.druid.query.groupby.orderby.DefaultLimitSpec;
+import io.druid.query.groupby.orderby.OrderByColumnSpec;
+import io.druid.segment.column.Column;
+import io.druid.segment.column.ValueType;
+import io.druid.sql.calcite.expression.Expressions;
+import io.druid.sql.calcite.expression.RowExtraction;
+import io.druid.sql.calcite.rel.DruidRel;
+import io.druid.sql.calcite.rel.SelectProjection;
+import io.druid.sql.calcite.table.RowSignature;
+import org.apache.calcite.plan.RelOptRule;
+import org.apache.calcite.plan.RelOptRuleCall;
+import org.apache.calcite.rel.core.Project;
+import org.apache.calcite.rel.core.Sort;
+
+import java.util.List;
+
+public class SelectRules
+{
+  private SelectRules()
+  {
+    // No instantiation.
+  }
+
+  public static List<RelOptRule> rules()
+  {
+    return ImmutableList.of(
+        new DruidSelectProjectionRule(),
+        new DruidSelectSortRule()
+    );
+  }
+
+  static class DruidSelectProjectionRule extends RelOptRule
+  {
+    private DruidSelectProjectionRule()
+    {
+      super(operand(Project.class, operand(DruidRel.class, none())));
+    }
+
+    @Override
+    public boolean matches(RelOptRuleCall call)
+    {
+      final DruidRel druidRel = call.rel(1);
+
+      return druidRel.getQueryBuilder().getSelectProjection() == null
+             && druidRel.getQueryBuilder().getGrouping() == null
+             && druidRel.getQueryBuilder().getLimitSpec() == null;
+    }
+
+    @Override
+    public void onMatch(RelOptRuleCall call)
+    {
+      final Project project = call.rel(0);
+      final DruidRel druidRel = call.rel(1);
+
+      // Only push in projections that can be used by the Select query.
+      // Leave anything more complicated to DruidAggregateProjectRule for possible handling in a GroupBy query.
+
+      final RowSignature sourceRowSignature = druidRel.getSourceRowSignature();
+      final List<DimensionSpec> dimensions = Lists.newArrayList();
+      final List<String> metrics = Lists.newArrayList();
+      final List<String> rowOrder = Lists.newArrayList();
+
+      int dimOutputNameCounter = 0;
+      for (int i = 0; i < project.getRowType().getFieldCount(); i++) {
+        final RowExtraction rex = Expressions.toRowExtraction(
+            sourceRowSignature.getRowOrder(),
+            project.getChildExps().get(i)
+        );
+
+        if (rex == null) {
+          return;
+        }
+
+        final String column = rex.getColumn();
+        final ExtractionFn extractionFn = rex.getExtractionFn();
+
+        // Check if this field should be a dimension, a metric, or a reference to __time.
+        final ValueType columnType = sourceRowSignature.getColumnType(column);
+
+        if (columnType == ValueType.STRING || (column.equals(Column.TIME_COLUMN_NAME) && extractionFn != null)) {
+          // Add to dimensions.
+          do {
+            dimOutputNameCounter++;
+          } while (sourceRowSignature.getColumnType(GroupByRules.dimOutputName(dimOutputNameCounter)) != null);
+          final String outputName = GroupByRules.dimOutputName(dimOutputNameCounter);
+          final DimensionSpec dimensionSpec = rex.toDimensionSpec(sourceRowSignature, outputName);
+
+          if (dimensionSpec == null) {
+            // Really should have been possible due to the checks above.
+            throw new ISE("WTF?! Could not create DimensionSpec for rowExtraction[%s].", rex);
+          }
+
+          dimensions.add(dimensionSpec);
+          rowOrder.add(outputName);
+        } else if (extractionFn == null && !column.equals(Column.TIME_COLUMN_NAME)) {
+          // Add to metrics.
+          metrics.add(column);
+          rowOrder.add(column);
+        } else if (extractionFn == null && column.equals(Column.TIME_COLUMN_NAME)) {
+          // This is __time.
+          rowOrder.add(Column.TIME_COLUMN_NAME);
+        } else {
+          // Don't know what to do!
+          return;
+        }
+      }
+
+      call.transformTo(
+          druidRel.withQueryBuilder(
+              druidRel.getQueryBuilder()
+                      .withSelectProjection(
+                          new SelectProjection(project, dimensions, metrics),
+                          rowOrder
+                      )
+          )
+      );
+    }
+  }
+
+  static class DruidSelectSortRule extends RelOptRule
+  {
+    private DruidSelectSortRule()
+    {
+      super(operand(Sort.class, operand(DruidRel.class, none())));
+    }
+
+    @Override
+    public boolean matches(RelOptRuleCall call)
+    {
+      final DruidRel druidRel = call.rel(1);
+
+      return druidRel.getQueryBuilder().getGrouping() == null
+             && druidRel.getQueryBuilder().getLimitSpec() == null;
+    }
+
+    @Override
+    public void onMatch(RelOptRuleCall call)
+    {
+      final Sort sort = call.rel(0);
+      final DruidRel druidRel = call.rel(1);
+
+      final DefaultLimitSpec limitSpec = GroupByRules.toLimitSpec(druidRel.getQueryBuilder().getRowOrder(), sort);
+      if (limitSpec == null) {
+        return;
+      }
+
+      // Only push in sorts that can be used by the Select query.
+      final List<OrderByColumnSpec> orderBys = limitSpec.getColumns();
+      if (orderBys.isEmpty() ||
+          (orderBys.size() == 1 && orderBys.get(0).getDimension().equals(Column.TIME_COLUMN_NAME))) {
+        call.transformTo(
+            druidRel.withQueryBuilder(
+                druidRel.getQueryBuilder()
+                        .withLimitSpec(limitSpec)
+            )
+        );
+      }
+    }
+  }
+}
diff --git a/sql/src/main/java/io/druid/sql/calcite/table/DruidTable.java b/sql/src/main/java/io/druid/sql/calcite/table/DruidTable.java
index 1a92ae49d135..374ef492fae0 100644
--- a/sql/src/main/java/io/druid/sql/calcite/table/DruidTable.java
+++ b/sql/src/main/java/io/druid/sql/calcite/table/DruidTable.java
@@ -21,15 +21,10 @@
 
 import com.google.common.base.Preconditions;
 import com.google.common.collect.ImmutableSortedMap;
-import com.google.common.collect.Lists;
-import com.google.common.collect.Maps;
-import io.druid.java.util.common.ISE;
 import io.druid.query.DataSource;
-import io.druid.query.QuerySegmentWalker;
-import io.druid.segment.column.Column;
 import io.druid.segment.column.ValueType;
-import io.druid.sql.calcite.planner.PlannerConfig;
 import io.druid.sql.calcite.rel.DruidQueryRel;
+import io.druid.sql.calcite.rel.QueryMaker;
 import org.apache.calcite.plan.RelOptCluster;
 import org.apache.calcite.plan.RelOptTable;
 import org.apache.calcite.rel.RelNode;
@@ -39,45 +34,34 @@
 import org.apache.calcite.schema.Statistic;
 import org.apache.calcite.schema.Statistics;
 import org.apache.calcite.schema.TranslatableTable;
-import org.apache.calcite.sql.type.SqlTypeName;
 
-import java.util.List;
 import java.util.Map;
 
 public class DruidTable implements TranslatableTable
 {
-  private final QuerySegmentWalker walker;
+  private final QueryMaker queryMaker;
   private final DataSource dataSource;
-  private final PlannerConfig config;
-  private final Map<String, Integer> columnNumbers;
-  private final List<ValueType> columnTypes;
-  private final List<String> columnNames;
+  private final RowSignature rowSignature;
 
   public DruidTable(
-      final QuerySegmentWalker walker,
+      final QueryMaker queryMaker,
       final DataSource dataSource,
-      final PlannerConfig config,
       final Map<String, ValueType> columns
   )
   {
-    this.walker = Preconditions.checkNotNull(walker, "walker");
+    this.queryMaker = Preconditions.checkNotNull(queryMaker, "queryMaker");
     this.dataSource = Preconditions.checkNotNull(dataSource, "dataSource");
-    this.config = Preconditions.checkNotNull(config, "config");
-    this.columnNumbers = Maps.newLinkedHashMap();
-    this.columnTypes = Lists.newArrayList();
-    this.columnNames = Lists.newArrayList();
 
-    int i = 0;
+    final RowSignature.Builder rowSignatureBuilder = RowSignature.builder();
     for (Map.Entry<String, ValueType> entry : ImmutableSortedMap.copyOf(columns).entrySet()) {
-      columnNumbers.put(entry.getKey(), i++);
-      columnTypes.add(entry.getValue());
-      columnNames.add(entry.getKey());
+      rowSignatureBuilder.add(entry.getKey(), entry.getValue());
     }
+    this.rowSignature = rowSignatureBuilder.build();
   }
 
-  public QuerySegmentWalker getQuerySegmentWalker()
+  public QueryMaker getQueryMaker()
   {
-    return walker;
+    return queryMaker;
   }
 
   public DataSource getDataSource()
@@ -85,30 +69,9 @@ public DataSource getDataSource()
     return dataSource;
   }
 
-  public PlannerConfig getPlannerConfig()
+  public RowSignature getRowSignature()
   {
-    return config;
-  }
-
-  public int getColumnCount()
-  {
-    return columnNames.size();
-  }
-
-  public int getColumnNumber(final String name)
-  {
-    final Integer number = columnNumbers.get(name);
-    return number != null ? number : -1;
-  }
-
-  public String getColumnName(final int n)
-  {
-    return columnNames.get(n);
-  }
-
-  public ValueType getColumnType(final int n)
-  {
-    return columnTypes.get(n);
+    return rowSignature;
   }
 
   @Override
@@ -126,33 +89,7 @@ public Statistic getStatistic()
   @Override
   public RelDataType getRowType(final RelDataTypeFactory typeFactory)
   {
-    final RelDataTypeFactory.FieldInfoBuilder builder = typeFactory.builder();
-    for (Map.Entry<String, Integer> entry : columnNumbers.entrySet()) {
-      final RelDataType sqlTypeName;
-
-      if (entry.getKey().equals(Column.TIME_COLUMN_NAME)) {
-        sqlTypeName = typeFactory.createSqlType(SqlTypeName.TIMESTAMP);
-      } else {
-        final ValueType valueType = columnTypes.get(entry.getValue());
-        switch (valueType) {
-          case STRING:
-            // Note that there is no attempt here to handle multi-value in any special way. Maybe one day...
-            sqlTypeName = typeFactory.createSqlType(SqlTypeName.VARCHAR, RelDataType.PRECISION_NOT_SPECIFIED);
-            break;
-          case LONG:
-            sqlTypeName = typeFactory.createSqlType(SqlTypeName.BIGINT);
-            break;
-          case FLOAT:
-            sqlTypeName = typeFactory.createSqlType(SqlTypeName.FLOAT);
-            break;
-          default:
-            throw new ISE("WTF?! valueType[%s] not translatable?", valueType);
-        }
-      }
-
-      builder.add(entry.getKey(), sqlTypeName);
-    }
-    return builder.build();
+    return rowSignature.getRelDataType(typeFactory);
   }
 
   @Override
@@ -182,19 +119,14 @@ public boolean equals(Object o)
     if (dataSource != null ? !dataSource.equals(that.dataSource) : that.dataSource != null) {
       return false;
     }
-    if (columnNumbers != null ? !columnNumbers.equals(that.columnNumbers) : that.columnNumbers != null) {
-      return false;
-    }
-    return columnTypes != null ? columnTypes.equals(that.columnTypes) : that.columnTypes == null;
-
+    return rowSignature != null ? rowSignature.equals(that.rowSignature) : that.rowSignature == null;
   }
 
   @Override
   public int hashCode()
   {
     int result = dataSource != null ? dataSource.hashCode() : 0;
-    result = 31 * result + (columnNumbers != null ? columnNumbers.hashCode() : 0);
-    result = 31 * result + (columnTypes != null ? columnTypes.hashCode() : 0);
+    result = 31 * result + (rowSignature != null ? rowSignature.hashCode() : 0);
     return result;
   }
 
@@ -203,8 +135,7 @@ public String toString()
   {
     return "DruidTable{" +
            "dataSource=" + dataSource +
-           ", columnNumbers=" + columnNumbers +
-           ", columnTypes=" + columnTypes +
+           ", rowSignature=" + rowSignature +
            '}';
   }
 }
diff --git a/sql/src/main/java/io/druid/sql/calcite/table/DruidTables.java b/sql/src/main/java/io/druid/sql/calcite/table/DruidTables.java
deleted file mode 100644
index 58e5268ddc25..000000000000
--- a/sql/src/main/java/io/druid/sql/calcite/table/DruidTables.java
+++ /dev/null
@@ -1,76 +0,0 @@
-/*
- * Licensed to Metamarkets Group Inc. (Metamarkets) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. Metamarkets licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package io.druid.sql.calcite.table;
-
-import com.google.common.collect.Lists;
-import io.druid.query.ordering.StringComparator;
-import io.druid.query.ordering.StringComparators;
-import io.druid.segment.column.ValueType;
-import io.druid.sql.calcite.expression.RowExtraction;
-
-import java.util.List;
-
-public class DruidTables
-{
-  private DruidTables()
-  {
-    // No instantiation.
-  }
-
-  /**
-   * Returns the "natural" rowOrder for a Druid table. This is the order that a scan without projection would return.
-   *
-   * @param druidTable druid table
-   *
-   * @return natural row order
-   */
-  public static List<String> rowOrder(
-      final DruidTable druidTable
-  )
-  {
-    final List<String> rowOrder = Lists.newArrayListWithCapacity(druidTable.getColumnCount());
-    for (int i = 0; i < druidTable.getColumnCount(); i++) {
-      rowOrder.add(druidTable.getColumnName(i));
-    }
-    return rowOrder;
-  }
-
-  /**
-   * Return the "natural" {@link StringComparator} for an extraction from a Druid table. This will be a lexicographic
-   * comparator for String types and a numeric comparator for Number types.
-   *
-   * @param druidTable    underlying Druid table
-   * @param rowExtraction extraction from the table
-   *
-   * @return natural comparator
-   */
-  public static StringComparator naturalStringComparator(
-      final DruidTable druidTable,
-      final RowExtraction rowExtraction
-  )
-  {
-    if (rowExtraction.getExtractionFn() != null
-        || druidTable.getColumnType(druidTable.getColumnNumber(rowExtraction.getColumn())) == ValueType.STRING) {
-      return StringComparators.LEXICOGRAPHIC;
-    } else {
-      return StringComparators.NUMERIC;
-    }
-  }
-}
diff --git a/sql/src/main/java/io/druid/sql/calcite/table/RowSignature.java b/sql/src/main/java/io/druid/sql/calcite/table/RowSignature.java
new file mode 100644
index 000000000000..cadc4a6f01c4
--- /dev/null
+++ b/sql/src/main/java/io/druid/sql/calcite/table/RowSignature.java
@@ -0,0 +1,211 @@
+/*
+ * Licensed to Metamarkets Group Inc. (Metamarkets) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. Metamarkets licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package io.druid.sql.calcite.table;
+
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import io.druid.java.util.common.IAE;
+import io.druid.java.util.common.ISE;
+import io.druid.java.util.common.Pair;
+import io.druid.query.ordering.StringComparator;
+import io.druid.query.ordering.StringComparators;
+import io.druid.segment.column.Column;
+import io.druid.segment.column.ValueType;
+import io.druid.sql.calcite.expression.RowExtraction;
+import org.apache.calcite.rel.type.RelDataType;
+import org.apache.calcite.rel.type.RelDataTypeFactory;
+import org.apache.calcite.sql.type.SqlTypeName;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Type signature for a row in a Druid dataSource ("DruidTable") or query result. Rows have an ordering and every
+ * column has a defined type. This is a little bit of a fiction in the Druid world (where rows do not _actually_ have
+ * well defined types) but we do impose types for the SQL layer.
+ */
+public class RowSignature
+{
+  private final Map<String, ValueType> columnTypes;
+  private final List<String> columnNames;
+
+  public RowSignature(final List<Pair<String, ValueType>> columnTypeList)
+  {
+    final Map<String, ValueType> columnTypes0 = Maps.newHashMap();
+    final ImmutableList.Builder<String> columnNamesBuilder = ImmutableList.builder();
+
+    int i = 0;
+    for (Pair<String, ValueType> pair : columnTypeList) {
+      final ValueType existingType = columnTypes0.get(pair.lhs);
+      if (existingType != null && existingType != pair.rhs) {
+        throw new IAE("Column[%s] has conflicting types [%s] and [%s]", pair.lhs, existingType, pair.rhs);
+      }
+
+      columnTypes0.put(pair.lhs, pair.rhs);
+      columnNamesBuilder.add(pair.lhs);
+    }
+
+    this.columnTypes = ImmutableMap.copyOf(columnTypes0);
+    this.columnNames = columnNamesBuilder.build();
+  }
+
+  public static Builder builder()
+  {
+    return new Builder();
+  }
+
+  public ValueType getColumnType(final String name)
+  {
+    return columnTypes.get(name);
+  }
+
+  /**
+   * Returns the rowOrder for this signature, which is the list of column names in row order.
+   *
+   * @return row order
+   */
+  public List<String> getRowOrder()
+  {
+    return columnNames;
+  }
+
+  /**
+   * Return the "natural" {@link StringComparator} for an extraction from this row signature. This will be a
+   * lexicographic comparator for String types and a numeric comparator for Number types.
+   *
+   * @param rowExtraction extraction from this kind of row
+   *
+   * @return natural comparator
+   */
+  public StringComparator naturalStringComparator(final RowExtraction rowExtraction)
+  {
+    Preconditions.checkNotNull(rowExtraction, "rowExtraction");
+    if (rowExtraction.getExtractionFn() != null
+        || getColumnType(rowExtraction.getColumn()) == ValueType.STRING) {
+      return StringComparators.LEXICOGRAPHIC;
+    } else {
+      return StringComparators.NUMERIC;
+    }
+  }
+
+  /**
+   * Returns a Calcite RelDataType corresponding to this row signature.
+   *
+   * @param typeFactory factory for type construction
+   *
+   * @return Calcite row type
+   */
+  public RelDataType getRelDataType(final RelDataTypeFactory typeFactory)
+  {
+    final RelDataTypeFactory.FieldInfoBuilder builder = typeFactory.builder();
+    for (int columnNumber = 0; columnNumber < columnNames.size(); columnNumber++) {
+      final String columnName = columnNames.get(columnNumber);
+      final ValueType columnType = getColumnType(columnName);
+      final RelDataType sqlTypeName;
+
+      if (Column.TIME_COLUMN_NAME.equals(columnName)) {
+        sqlTypeName = typeFactory.createSqlType(SqlTypeName.TIMESTAMP);
+      } else {
+        switch (columnType) {
+          case STRING:
+            // Note that there is no attempt here to handle multi-value in any special way. Maybe one day...
+            sqlTypeName = typeFactory.createSqlType(SqlTypeName.VARCHAR, RelDataType.PRECISION_NOT_SPECIFIED);
+            break;
+          case LONG:
+            sqlTypeName = typeFactory.createSqlType(SqlTypeName.BIGINT);
+            break;
+          case FLOAT:
+            sqlTypeName = typeFactory.createSqlType(SqlTypeName.FLOAT);
+            break;
+          default:
+            throw new ISE("WTF?! valueType[%s] not translatable?", columnType);
+        }
+      }
+
+      builder.add(columnName, sqlTypeName);
+    }
+
+    return builder.build();
+  }
+
+  @Override
+  public boolean equals(Object o)
+  {
+    if (this == o) {
+      return true;
+    }
+    if (o == null || getClass() != o.getClass()) {
+      return false;
+    }
+
+    RowSignature that = (RowSignature) o;
+
+    if (columnTypes != null ? !columnTypes.equals(that.columnTypes) : that.columnTypes != null) {
+      return false;
+    }
+    return columnNames != null ? columnNames.equals(that.columnNames) : that.columnNames == null;
+  }
+
+  @Override
+  public int hashCode()
+  {
+    int result = columnTypes != null ? columnTypes.hashCode() : 0;
+    result = 31 * result + (columnNames != null ? columnNames.hashCode() : 0);
+    return result;
+  }
+
+  @Override
+  public String toString()
+  {
+    final StringBuilder s = new StringBuilder("RowSignature{");
+    for (int i = 0; i < columnNames.size(); i++) {
+      if (i > 0) {
+        s.append(", ");
+      }
+      final String columnName = columnNames.get(i);
+      s.append(columnName).append(":").append(getColumnType(columnName));
+    }
+    return s.append("}").toString();
+  }
+
+  public static class Builder
+  {
+    private final List<Pair<String, ValueType>> columnTypeList;
+
+    private Builder()
+    {
+      this.columnTypeList = Lists.newArrayList();
+    }
+
+    public Builder add(String columnName, ValueType columnType)
+    {
+      columnTypeList.add(Pair.of(columnName, columnType));
+      return this;
+    }
+
+    public RowSignature build()
+    {
+      return new RowSignature(columnTypeList);
+    }
+  }
+}
diff --git a/sql/src/test/java/io/druid/sql/calcite/CalciteQueryTest.java b/sql/src/test/java/io/druid/sql/calcite/CalciteQueryTest.java
index dc8d9696f382..cbfdd78c1615 100644
--- a/sql/src/test/java/io/druid/sql/calcite/CalciteQueryTest.java
+++ b/sql/src/test/java/io/druid/sql/calcite/CalciteQueryTest.java
@@ -19,15 +19,19 @@
 
 package io.druid.sql.calcite;
 
+import com.fasterxml.jackson.databind.ObjectMapper;
 import com.google.common.base.Function;
+import com.google.common.base.Throwables;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.Lists;
 import com.google.common.collect.Maps;
 import io.druid.granularity.QueryGranularities;
+import io.druid.jackson.DefaultObjectMapper;
 import io.druid.java.util.common.logger.Logger;
 import io.druid.query.Druids;
 import io.druid.query.Query;
+import io.druid.query.QueryDataSource;
 import io.druid.query.QuerySegmentWalker;
 import io.druid.query.aggregation.AggregatorFactory;
 import io.druid.query.aggregation.CountAggregatorFactory;
@@ -106,6 +110,7 @@ public class CalciteQueryTest
 {
   private static final Logger log = new Logger(CalciteQueryTest.class);
 
+  private static final ObjectMapper OBJECT_MAPPER = new DefaultObjectMapper();
   private static final PlannerConfig PLANNER_CONFIG_DEFAULT = new PlannerConfig();
   private static final PlannerConfig PLANNER_CONFIG_NO_TOPN = new PlannerConfig()
   {
@@ -131,6 +136,22 @@ public boolean isUseFallback()
       return true;
     }
   };
+  private static final PlannerConfig PLANNER_CONFIG_SINGLE_NESTING_ONLY = new PlannerConfig()
+  {
+    @Override
+    public int getMaxQueryCount()
+    {
+      return 2;
+    }
+  };
+  private static final PlannerConfig PLANNER_CONFIG_NO_SUBQUERIES = new PlannerConfig()
+  {
+    @Override
+    public int getMaxQueryCount()
+    {
+      return 1;
+    }
+  };
 
   private static final Map<String, Object> TIMESERIES_CONTEXT = ImmutableMap.<String, Object>of(
       "skipEmptyBuckets",
@@ -154,6 +175,8 @@ public void setUp() throws Exception
     connections.put(PLANNER_CONFIG_NO_TOPN, connectJdbc(walker, PLANNER_CONFIG_NO_TOPN));
     connections.put(PLANNER_CONFIG_SELECT_PAGING, connectJdbc(walker, PLANNER_CONFIG_SELECT_PAGING));
     connections.put(PLANNER_CONFIG_FALLBACK, connectJdbc(walker, PLANNER_CONFIG_FALLBACK));
+    connections.put(PLANNER_CONFIG_SINGLE_NESTING_ONLY, connectJdbc(walker, PLANNER_CONFIG_SINGLE_NESTING_ONLY));
+    connections.put(PLANNER_CONFIG_NO_SUBQUERIES, connectJdbc(walker, PLANNER_CONFIG_NO_SUBQUERIES));
 
     unhook = Hook.QUERY_PLAN.add(
         new Function<Object, Object>()
@@ -161,7 +184,12 @@ public void setUp() throws Exception
           @Override
           public Object apply(Object input)
           {
-            log.info("Issued query: %s", input);
+            try {
+              log.info("Issued query: %s", OBJECT_MAPPER.writerWithDefaultPrettyPrinter().writeValueAsString(input));
+            }
+            catch (Exception e) {
+              throw Throwables.propagate(e);
+            }
             recordedQueries.add((Query) input);
             return null;
           }
@@ -479,22 +507,33 @@ public void testUnplannableQueries() throws Exception
         + "  SUM(cnt) AS cnt\n"
         + "FROM druid.foo\n"
         + "GROUP BY (CAST(__time AS DATE) + EXTRACT(HOUR FROM __time) * INTERVAL '1' HOUR)", // Time arithmetic
+        "SELECT dim1, SUM(m1) AS m1_sum FROM druid.foo GROUP BY dim1 HAVING SUM(m1) > 1", // HAVING on float
         "SELECT columnName, typeName FROM metadata.COLUMNS WHERE tableName = 'foo'" // Metadata tables without fallback
     );
 
     for (final String query : queries) {
-      Exception e = null;
-      try {
-        testQuery(query, ImmutableList.<Query>of(), ImmutableList.<Object[]>of());
-      }
-      catch (Exception e1) {
-        e = e1;
-      }
+      assertQueryIsUnplannable(query);
+    }
+  }
 
-      if (!(e instanceof SQLException) || !(e.getCause() instanceof RelOptPlanner.CannotPlanException)) {
-        log.error(e, "Expected SQLException caused by CannotPlanException for query: %s", query);
-        Assert.fail(query);
-      }
+  private void assertQueryIsUnplannable(final String sql)
+  {
+    assertQueryIsUnplannable(PLANNER_CONFIG_DEFAULT, sql);
+  }
+
+  private void assertQueryIsUnplannable(final PlannerConfig plannerConfig, final String sql)
+  {
+    Exception e = null;
+    try {
+      testQuery(plannerConfig, sql, ImmutableList.<Query>of(), ImmutableList.<Object[]>of());
+    }
+    catch (Exception e1) {
+      e = e1;
+    }
+
+    if (!(e instanceof SQLException) || !(e.getCause() instanceof RelOptPlanner.CannotPlanException)) {
+      log.error(e, "Expected SQLException caused by CannotPlanException for query: %s", sql);
+      Assert.fail(sql);
     }
   }
 
@@ -895,7 +934,7 @@ public void testGroupByWithSortOnPostAggregation() throws Exception
   }
 
   @Test
-  public void testGroupByWithSortOnPostAggregationNoTopN() throws Exception
+  public void testGroupByWithSortOnPostAggregationNoTopNConfig() throws Exception
   {
     testQuery(
         PLANNER_CONFIG_NO_TOPN,
@@ -1297,12 +1336,10 @@ public void testCountStarWithNotOfComplexDisjointTimeFilter() throws Exception
                           NOT(SELECTOR("dim2", "a", null)),
                           AND(
                               NOT(TIME_BOUND("2000/2001")),
-                              NOT(
-                                  AND(
-                                      SELECTOR("dim1", "abc", null),
-                                      TIME_BOUND("2002-05-01/2003-05-01")
-                                  )
-                              )
+                              NOT(AND(
+                                  SELECTOR("dim1", "abc", null),
+                                  TIME_BOUND("2002-05-01/2003-05-01")
+                              ))
                           )
                       )
                   )
@@ -1530,6 +1567,378 @@ public void testCountDistinct() throws Exception
     );
   }
 
+  @Test
+  public void testDoubleNestedGroupBy() throws Exception
+  {
+    testQuery(
+        "SELECT SUM(cnt), COUNT(*) FROM (\n"
+        + "  SELECT dim2, SUM(t1.cnt) cnt FROM (\n"
+        + "    SELECT\n"
+        + "      dim1,\n"
+        + "      dim2,\n"
+        + "      COUNT(*) cnt\n"
+        + "    FROM druid.foo\n"
+        + "    GROUP BY dim1, dim2\n"
+        + "  ) t1\n"
+        + "  GROUP BY dim2\n"
+        + ") t2",
+        null,
+        ImmutableList.of(
+            new Object[]{6L, 3L}
+        )
+    );
+  }
+
+  @Test
+  public void testDoubleNestedGroupByForbiddenByConfig() throws Exception
+  {
+    assertQueryIsUnplannable(
+        PLANNER_CONFIG_SINGLE_NESTING_ONLY,
+        "SELECT SUM(cnt), COUNT(*) FROM (\n"
+        + "  SELECT dim2, SUM(t1.cnt) cnt FROM (\n"
+        + "    SELECT\n"
+        + "      dim1,\n"
+        + "      dim2,\n"
+        + "      COUNT(*) cnt\n"
+        + "    FROM druid.foo\n"
+        + "    GROUP BY dim1, dim2\n"
+        + "  ) t1\n"
+        + "  GROUP BY dim2\n"
+        + ") t2"
+    );
+  }
+
+  @Test
+  public void testExactCountDistinctUsingSubquery() throws Exception
+  {
+    testQuery(
+        PLANNER_CONFIG_SINGLE_NESTING_ONLY, // Sanity check; this query should work with a single level of nesting.
+        "SELECT\n"
+        + "  SUM(cnt),\n"
+        + "  COUNT(*)\n"
+        + "FROM (SELECT dim2, SUM(cnt) AS cnt FROM druid.foo GROUP BY dim2)",
+        ImmutableList.<Query>of(
+            GroupByQuery.builder()
+                        .setDataSource(
+                            new QueryDataSource(
+                                GroupByQuery.builder()
+                                            .setDataSource(CalciteTests.DATASOURCE)
+                                            .setInterval(QSS(Filtration.eternity()))
+                                            .setGranularity(QueryGranularities.ALL)
+                                            .setDimensions(DIMS(new DefaultDimensionSpec("dim2", "d0")))
+                                            .setAggregatorSpecs(AGGS(new LongSumAggregatorFactory("a0", "cnt")))
+                                            .build()
+                            )
+                        )
+                        .setInterval(QSS(Filtration.eternity()))
+                        .setGranularity(QueryGranularities.ALL)
+                        .setAggregatorSpecs(AGGS(
+                            new LongSumAggregatorFactory("a0", "a0"),
+                            new CountAggregatorFactory("a1")
+                        ))
+                        .build()
+        ),
+        ImmutableList.of(
+            new Object[]{6L, 3L}
+        )
+    );
+  }
+
+  @Test
+  public void testExactCountDistinctOfSemiJoinResult() throws Exception
+  {
+    testQuery(
+        "SELECT COUNT(*)\n"
+        + "FROM (\n"
+        + "  SELECT DISTINCT dim2\n"
+        + "  FROM druid.foo\n"
+        + "  WHERE SUBSTRING(dim2, 1, 1) IN (\n"
+        + "    SELECT SUBSTRING(dim1, 1, 1) FROM druid.foo WHERE dim1 <> ''\n"
+        + "  )\n"
+        + ")",
+        ImmutableList.<Query>of(
+            GroupByQuery.builder()
+                        .setDataSource(CalciteTests.DATASOURCE)
+                        .setInterval(QSS(Filtration.eternity()))
+                        .setGranularity(QueryGranularities.ALL)
+                        .setDimFilter(NOT(SELECTOR("dim1", "", null)))
+                        .setDimensions(DIMS(new ExtractionDimensionSpec(
+                            "dim1",
+                            "v0",
+                            new SubstringDimExtractionFn(0, 1)
+                        )))
+                        .build(),
+            GroupByQuery.builder()
+                        .setDataSource(
+                            new QueryDataSource(
+                                GroupByQuery.builder()
+                                            .setDataSource(CalciteTests.DATASOURCE)
+                                            .setInterval(QSS(Filtration.eternity()))
+                                            .setGranularity(QueryGranularities.ALL)
+                                            .setDimFilter(IN(
+                                                "dim2",
+                                                ImmutableList.of("1", "2", "a", "d"),
+                                                new SubstringDimExtractionFn(0, 1)
+                                            ))
+                                            .setDimensions(DIMS(new DefaultDimensionSpec("dim2", "d0")))
+                                            .build()
+                            )
+                        )
+                        .setInterval(QSS(Filtration.eternity()))
+                        .setGranularity(QueryGranularities.ALL)
+                        .setAggregatorSpecs(AGGS(
+                            new CountAggregatorFactory("a0")
+                        ))
+                        .build()
+
+        ),
+        ImmutableList.of(
+            new Object[]{2L}
+        )
+    );
+  }
+
+  @Test
+  public void testExactCountDistinctUsingSubqueryWithWherePushDown() throws Exception
+  {
+    testQuery(
+        "SELECT\n"
+        + "  SUM(cnt),\n"
+        + "  COUNT(*)\n"
+        + "FROM (SELECT dim2, SUM(cnt) AS cnt FROM druid.foo GROUP BY dim2)\n"
+        + "WHERE dim2 <> ''",
+        ImmutableList.<Query>of(
+            GroupByQuery.builder()
+                        .setDataSource(
+                            new QueryDataSource(
+                                GroupByQuery.builder()
+                                            .setDataSource(CalciteTests.DATASOURCE)
+                                            .setInterval(QSS(Filtration.eternity()))
+                                            .setDimFilter(NOT(SELECTOR("dim2", "", null)))
+                                            .setGranularity(QueryGranularities.ALL)
+                                            .setDimensions(DIMS(new DefaultDimensionSpec("dim2", "d0")))
+                                            .setAggregatorSpecs(AGGS(new LongSumAggregatorFactory("a0", "cnt")))
+                                            .build()
+                            )
+                        )
+                        .setInterval(QSS(Filtration.eternity()))
+                        .setGranularity(QueryGranularities.ALL)
+                        .setAggregatorSpecs(AGGS(
+                            new LongSumAggregatorFactory("a0", "a0"),
+                            new CountAggregatorFactory("a1")
+                        ))
+                        .build()
+        ),
+        ImmutableList.of(
+            new Object[]{3L, 2L}
+        )
+    );
+  }
+
+  @Test
+  public void testExactCountDistinctUsingSubqueryWithWhereToOuterFilter() throws Exception
+  {
+    testQuery(
+        "SELECT\n"
+        + "  SUM(cnt),\n"
+        + "  COUNT(*)\n"
+        + "FROM (SELECT dim2, SUM(cnt) AS cnt FROM druid.foo GROUP BY dim2 LIMIT 1)"
+        + "WHERE cnt > 0",
+        ImmutableList.<Query>of(
+            GroupByQuery.builder()
+                        .setDataSource(
+                            new QueryDataSource(
+                                GroupByQuery.builder()
+                                            .setDataSource(CalciteTests.DATASOURCE)
+                                            .setInterval(QSS(Filtration.eternity()))
+                                            .setGranularity(QueryGranularities.ALL)
+                                            .setDimensions(DIMS(new DefaultDimensionSpec("dim2", "d0")))
+                                            .setAggregatorSpecs(AGGS(new LongSumAggregatorFactory("a0", "cnt")))
+                                            .setLimit(1)
+                                            .build()
+                            )
+                        )
+                        .setDimFilter(BOUND("a0", "0", null, true, false, null, StringComparators.NUMERIC))
+                        .setInterval(QSS(Filtration.eternity()))
+                        .setGranularity(QueryGranularities.ALL)
+                        .setAggregatorSpecs(AGGS(
+                            new LongSumAggregatorFactory("a0", "a0"),
+                            new CountAggregatorFactory("a1")
+                        ))
+                        .build()
+        ),
+        ImmutableList.of(
+            new Object[]{3L, 1L}
+        )
+    );
+  }
+
+  @Test
+  public void testCompareExactAndApproximateCountDistinctUsingSubquery() throws Exception
+  {
+    testQuery(
+        "SELECT\n"
+        + "  COUNT(*) AS exact_count,\n"
+        + "  COUNT(DISTINCT dim1) AS approx_count,\n"
+        + "  (CAST(1 AS FLOAT) - COUNT(DISTINCT dim1) / COUNT(*)) * 100 AS error_pct\n"
+        + "FROM (SELECT DISTINCT dim1 FROM druid.foo WHERE dim1 <> '')",
+        ImmutableList.<Query>of(
+            GroupByQuery.builder()
+                        .setDataSource(
+                            new QueryDataSource(
+                                GroupByQuery.builder()
+                                            .setDataSource(CalciteTests.DATASOURCE)
+                                            .setInterval(QSS(Filtration.eternity()))
+                                            .setGranularity(QueryGranularities.ALL)
+                                            .setDimFilter(NOT(SELECTOR("dim1", "", null)))
+                                            .setDimensions(DIMS(new DefaultDimensionSpec("dim1", "d0")))
+                                            .build()
+                            )
+                        )
+                        .setInterval(QSS(Filtration.eternity()))
+                        .setGranularity(QueryGranularities.ALL)
+                        .setAggregatorSpecs(AGGS(
+                            new CountAggregatorFactory("a0"),
+                            new CardinalityAggregatorFactory(
+                                "a1",
+                                DIMS(new DefaultDimensionSpec("d0", "A1:dimSpec")),
+                                false
+                            )
+                        ))
+                        .setPostAggregatorSpecs(
+                            ImmutableList.<PostAggregator>of(
+                                new ArithmeticPostAggregator(
+                                    "a2",
+                                    "*",
+                                    ImmutableList.of(
+                                        new ArithmeticPostAggregator(
+                                            null,
+                                            "-",
+                                            ImmutableList.of(
+                                                new ConstantPostAggregator(
+                                                    null,
+                                                    1
+                                                ),
+                                                new ArithmeticPostAggregator(
+                                                    null,
+                                                    "quotient",
+                                                    ImmutableList.of(
+                                                        new HyperUniqueFinalizingPostAggregator(
+                                                            "a1",
+                                                            "a1"
+                                                        ),
+                                                        new FieldAccessPostAggregator(
+                                                            null,
+                                                            "a0"
+                                                        )
+                                                    )
+                                                )
+                                            )
+                                        ),
+                                        new ConstantPostAggregator(null, 100)
+                                    )
+                                )
+                            )
+                        )
+                        .build()
+        ),
+        ImmutableList.of(
+            new Object[]{5L, 5L, -0.1222693591629298}
+        )
+    );
+  }
+
+  @Test
+  public void testHistogramUsingSubquery() throws Exception
+  {
+    testQuery(
+        "SELECT\n"
+        + "  CAST(thecnt AS VARCHAR),\n"
+        + "  COUNT(*)\n"
+        + "FROM (SELECT dim2, SUM(cnt) AS thecnt FROM druid.foo GROUP BY dim2)\n"
+        + "GROUP BY CAST(thecnt AS VARCHAR)",
+        ImmutableList.<Query>of(
+            GroupByQuery.builder()
+                        .setDataSource(
+                            new QueryDataSource(
+                                GroupByQuery.builder()
+                                            .setDataSource(CalciteTests.DATASOURCE)
+                                            .setInterval(QSS(Filtration.eternity()))
+                                            .setGranularity(QueryGranularities.ALL)
+                                            .setDimensions(DIMS(new DefaultDimensionSpec("dim2", "d0")))
+                                            .setAggregatorSpecs(AGGS(new LongSumAggregatorFactory("a0", "cnt")))
+                                            .setPostAggregatorSpecs(ImmutableList.<PostAggregator>of(
+                                                new FieldAccessPostAggregator("a1", "a0")
+                                            ))
+                                            .build()
+                            )
+                        )
+                        .setInterval(QSS(Filtration.eternity()))
+                        .setGranularity(QueryGranularities.ALL)
+                        .setDimensions(DIMS(new DefaultDimensionSpec("a1", "d0")))
+                        .setAggregatorSpecs(AGGS(
+                            new CountAggregatorFactory("a0")
+                        ))
+                        .build()
+        ),
+        ImmutableList.of(
+            new Object[]{"1", 1L},
+            new Object[]{"2", 1L},
+            new Object[]{"3", 1L}
+        )
+    );
+  }
+
+  @Test
+  public void testHistogramUsingSubqueryWithSort() throws Exception
+  {
+    testQuery(
+        "SELECT\n"
+        + "  CAST(thecnt AS VARCHAR),\n"
+        + "  COUNT(*)\n"
+        + "FROM (SELECT dim2, SUM(cnt) AS thecnt FROM druid.foo GROUP BY dim2)\n"
+        + "GROUP BY CAST(thecnt AS VARCHAR) ORDER BY CAST(thecnt AS VARCHAR) LIMIT 2",
+        ImmutableList.<Query>of(
+            GroupByQuery.builder()
+                        .setDataSource(
+                            new QueryDataSource(
+                                GroupByQuery.builder()
+                                            .setDataSource(CalciteTests.DATASOURCE)
+                                            .setInterval(QSS(Filtration.eternity()))
+                                            .setGranularity(QueryGranularities.ALL)
+                                            .setDimensions(DIMS(new DefaultDimensionSpec("dim2", "d0")))
+                                            .setAggregatorSpecs(AGGS(new LongSumAggregatorFactory("a0", "cnt")))
+                                            .setPostAggregatorSpecs(ImmutableList.<PostAggregator>of(
+                                                new FieldAccessPostAggregator("a1", "a0")
+                                            ))
+                                            .build()
+                            )
+                        )
+                        .setInterval(QSS(Filtration.eternity()))
+                        .setGranularity(QueryGranularities.ALL)
+                        .setDimensions(DIMS(new DefaultDimensionSpec("a1", "d0")))
+                        .setAggregatorSpecs(AGGS(
+                            new CountAggregatorFactory("a0")
+                        ))
+                        .setLimitSpec(
+                            new DefaultLimitSpec(
+                                ImmutableList.of(new OrderByColumnSpec(
+                                    "d0",
+                                    OrderByColumnSpec.Direction.ASCENDING,
+                                    StringComparators.LEXICOGRAPHIC
+                                )),
+                                2
+                            )
+                        )
+                        .build()
+        ),
+        ImmutableList.of(
+            new Object[]{"1", 1L},
+            new Object[]{"2", 1L}
+        )
+    );
+  }
+
   @Test
   public void testCountDistinctArithmetic() throws Exception
   {
@@ -1624,7 +2033,7 @@ public void testCountDistinctOfSubstring() throws Exception
   }
 
   @Test
-  public void testGroupByLimitPushDown() throws Exception
+  public void testGroupBySortPushDown() throws Exception
   {
     testQuery(
         "SELECT dim1, dim2, SUM(cnt) FROM druid.foo GROUP BY dim1, dim2 ORDER BY dim2 LIMIT 4",
@@ -1709,54 +2118,6 @@ public void testGroupByLimitPushDownWithHavingOnLong() throws Exception
     );
   }
 
-  @Test
-  public void testGroupByLimitPushDownWithHavingOnDouble() throws Exception
-  {
-    testQuery(
-        "SELECT dim1, dim2, SUM(m1) AS m1_sum "
-        + "FROM druid.foo "
-        + "group by dim1, dim2 "
-        + "having SUM(m1) > 1 "
-        + "order by dim2 "
-        + "limit 4",
-        ImmutableList.<Query>of(
-            GroupByQuery.builder()
-                        .setDataSource(CalciteTests.DATASOURCE)
-                        .setInterval(QSS(Filtration.eternity()))
-                        .setGranularity(QueryGranularities.ALL)
-                        .setDimensions(
-                            DIMS(
-                                new DefaultDimensionSpec("dim2", "d1"),
-                                new DefaultDimensionSpec("dim1", "d0")
-                            )
-                        )
-                        .setAggregatorSpecs(
-                            AGGS(
-                                new DoubleSumAggregatorFactory("a0", "m1")
-                            )
-                        )
-                        .setLimitSpec(
-                            new DefaultLimitSpec(
-                                ImmutableList.of(
-                                    new OrderByColumnSpec("d1", OrderByColumnSpec.Direction.ASCENDING)
-                                ),
-                                4
-                            )
-                        )
-                        .setHavingSpec(new DimFilterHavingSpec(
-                            BOUND("a0", "1", null, true, false, null, StringComparators.NUMERIC)
-                        ))
-                        .build()
-        ),
-        ImmutableList.of(
-            new Object[]{"10.1", "", 2.0},
-            new Object[]{"2", "", 3.0},
-            new Object[]{"abc", "", 6.0},
-            new Object[]{"1", "a", 4.0}
-        )
-    );
-  }
-
   @Test
   public void testFilterOnTimeFloor() throws Exception
   {
@@ -1801,6 +2162,7 @@ public void testFilterOnTimeFloorMisaligned() throws Exception
   public void testGroupByFloor() throws Exception
   {
     testQuery(
+        PLANNER_CONFIG_NO_SUBQUERIES, // Sanity check; this simple query should work with subqueries disabled.
         "SELECT floor(CAST(dim1 AS float)), COUNT(*) FROM druid.foo GROUP BY floor(CAST(dim1 AS float))",
         ImmutableList.<Query>of(
             GroupByQuery.builder()
@@ -1962,7 +2324,7 @@ public void testGroupByStringLength() throws Exception
   public void testTimeseries() throws Exception
   {
     testQuery(
-        "SELECT gran, SUM(cnt) FROM (\n"
+        "SELECT SUM(cnt), gran FROM (\n"
         + "  SELECT floor(__time TO month) AS gran,\n"
         + "  cnt FROM druid.foo\n"
         + ") AS x\n"
@@ -1978,8 +2340,8 @@ public void testTimeseries() throws Exception
                   .build()
         ),
         ImmutableList.of(
-            new Object[]{T("2000-01-01"), 3L},
-            new Object[]{T("2001-01-01"), 3L}
+            new Object[]{3L, T("2000-01-01")},
+            new Object[]{3L, T("2001-01-01")}
         )
     );
   }
@@ -2228,6 +2590,7 @@ public void testGroupByTimeAndOtherDimension() throws Exception
   public void testUsingSubqueryAsFilter() throws Exception
   {
     testQuery(
+        PLANNER_CONFIG_SINGLE_NESTING_ONLY, // Sanity check; this query should work with a single level of nesting.
         "SELECT dim1, dim2, COUNT(*) FROM druid.foo "
         + "WHERE dim2 IN (SELECT dim1 FROM druid.foo WHERE dim1 <> '')"
         + "AND dim1 <> 'xxx'"
@@ -2271,6 +2634,18 @@ public void testUsingSubqueryAsFilter() throws Exception
     );
   }
 
+  @Test
+  public void testUsingSubqueryAsFilterForbiddenByConfig() throws Exception
+  {
+    assertQueryIsUnplannable(
+        PLANNER_CONFIG_NO_SUBQUERIES,
+        "SELECT dim1, dim2, COUNT(*) FROM druid.foo "
+        + "WHERE dim2 IN (SELECT dim1 FROM druid.foo WHERE dim1 <> '')"
+        + "AND dim1 <> 'xxx'"
+        + "group by dim1, dim2 ORDER BY dim2"
+    );
+  }
+
   @Test
   public void testUsingSubqueryAsFilterOnTwoColumns() throws Exception
   {
diff --git a/sql/src/test/java/io/druid/sql/calcite/util/CalciteTests.java b/sql/src/test/java/io/druid/sql/calcite/util/CalciteTests.java
index b6d7c1b5021c..be9d0d8dd6f8 100644
--- a/sql/src/test/java/io/druid/sql/calcite/util/CalciteTests.java
+++ b/sql/src/test/java/io/druid/sql/calcite/util/CalciteTests.java
@@ -30,6 +30,7 @@
 import io.druid.data.input.impl.TimeAndDimsParseSpec;
 import io.druid.data.input.impl.TimestampSpec;
 import io.druid.query.DefaultQueryRunnerFactoryConglomerate;
+import io.druid.query.DruidProcessingConfig;
 import io.druid.query.Query;
 import io.druid.query.QueryRunnerFactory;
 import io.druid.query.QueryRunnerFactoryConglomerate;
@@ -66,6 +67,7 @@
 import io.druid.segment.column.ValueType;
 import io.druid.segment.incremental.IncrementalIndexSchema;
 import io.druid.sql.calcite.planner.PlannerConfig;
+import io.druid.sql.calcite.rel.QueryMaker;
 import io.druid.sql.calcite.table.DruidTable;
 import io.druid.timeline.DataSegment;
 import io.druid.timeline.partition.LinearShardSpec;
@@ -198,6 +200,7 @@ public ByteBuffer get()
             .put(
                 GroupByQuery.class,
                 GroupByQueryRunnerTest.makeQueryRunnerFactory(
+                    GroupByQueryRunnerTest.DEFAULT_MAPPER,
                     new GroupByQueryConfig()
                     {
                       @Override
@@ -205,6 +208,27 @@ public String getDefaultStrategy()
                       {
                         return GroupByStrategySelector.STRATEGY_V2;
                       }
+                    },
+                    new DruidProcessingConfig()
+                    {
+                      @Override
+                      public String getFormatString()
+                      {
+                        return null;
+                      }
+
+                      @Override
+                      public int intermediateComputeSizeBytes()
+                      {
+                        return 10 * 1024 * 1024;
+                      }
+
+                      @Override
+                      public int getNumMergeBuffers()
+                      {
+                        // Need 3 buffers for CalciteQueryTest.testDoubleNestedGroupby.
+                        return 3;
+                      }
                     }
                 )
             )
@@ -224,7 +248,7 @@ public String getDefaultStrategy()
 
   public static DruidTable createDruidTable(final QuerySegmentWalker walker, final PlannerConfig plannerConfig)
   {
-    return new DruidTable(walker, new TableDataSource(DATASOURCE), plannerConfig, COLUMN_TYPES);
+    return new DruidTable(new QueryMaker(walker, plannerConfig), new TableDataSource(DATASOURCE), COLUMN_TYPES);
   }
 
   public static Schema createMockSchema(final QuerySegmentWalker walker, final PlannerConfig plannerConfig)
diff --git a/sql/src/test/java/io/druid/sql/calcite/util/SpecificSegmentsQuerySegmentWalker.java b/sql/src/test/java/io/druid/sql/calcite/util/SpecificSegmentsQuerySegmentWalker.java
index 332f9189671e..5c80e1a6e5fe 100644
--- a/sql/src/test/java/io/druid/sql/calcite/util/SpecificSegmentsQuerySegmentWalker.java
+++ b/sql/src/test/java/io/druid/sql/calcite/util/SpecificSegmentsQuerySegmentWalker.java
@@ -28,6 +28,7 @@
 import com.google.common.util.concurrent.MoreExecutors;
 import io.druid.java.util.common.ISE;
 import io.druid.java.util.common.guava.FunctionalIterable;
+import io.druid.java.util.common.guava.Sequence;
 import io.druid.query.FinalizeResultsQueryRunner;
 import io.druid.query.NoopQueryRunner;
 import io.druid.query.Query;
@@ -94,50 +95,72 @@ public <T> QueryRunner<T> getQueryRunnerForIntervals(
       final Iterable<Interval> intervals
   )
   {
-    final VersionedIntervalTimeline<String, Segment> timeline = getTimeline(query);
-    if (timeline == null) {
-      return new NoopQueryRunner<>();
+    final QueryRunnerFactory<T, Query<T>> factory = conglomerate.findFactory(query);
+    if (factory == null) {
+      throw new ISE("Unknown query type[%s].", query.getClass());
     }
 
-    final Iterable<SegmentDescriptor> specs = FunctionalIterable
-        .create(intervals)
-        .transformCat(
-            new Function<Interval, Iterable<TimelineObjectHolder<String, Segment>>>()
-            {
-              @Override
-              public Iterable<TimelineObjectHolder<String, Segment>> apply(final Interval interval)
-              {
-                return timeline.lookup(interval);
-              }
-            }
-        )
-        .transformCat(
-            new Function<TimelineObjectHolder<String, Segment>, Iterable<SegmentDescriptor>>()
-            {
-              @Override
-              public Iterable<SegmentDescriptor> apply(final TimelineObjectHolder<String, Segment> holder)
-              {
-                return FunctionalIterable
-                    .create(holder.getObject())
-                    .transform(
-                        new Function<PartitionChunk<Segment>, SegmentDescriptor>()
-                        {
-                          @Override
-                          public SegmentDescriptor apply(final PartitionChunk<Segment> chunk)
-                          {
-                            return new SegmentDescriptor(
-                                holder.getInterval(),
-                                holder.getVersion(),
-                                chunk.getChunkNumber()
-                            );
-                          }
-                        }
-                    );
-              }
-            }
-        );
+    final QueryToolChest<T, Query<T>> toolChest = factory.getToolchest();
 
-    return getQueryRunnerForSegments(query, specs);
+    return new FinalizeResultsQueryRunner<>(
+        toolChest.postMergeQueryDecoration(
+            toolChest.mergeResults(
+                toolChest.preMergeQueryDecoration(
+                    new QueryRunner<T>()
+                    {
+                      @Override
+                      public Sequence<T> run(Query<T> query, Map<String, Object> responseContext)
+                      {
+                        final VersionedIntervalTimeline<String, Segment> timeline = getTimelineForTableDataSource(query);
+                        return makeBaseRunner(
+                            query,
+                            toolChest,
+                            factory,
+                            FunctionalIterable
+                                .create(intervals)
+                                .transformCat(
+                                    new Function<Interval, Iterable<TimelineObjectHolder<String, Segment>>>()
+                                    {
+                                      @Override
+                                      public Iterable<TimelineObjectHolder<String, Segment>> apply(final Interval interval)
+                                      {
+                                        return timeline.lookup(interval);
+                                      }
+                                    }
+                                )
+                                .transformCat(
+                                    new Function<TimelineObjectHolder<String, Segment>, Iterable<SegmentDescriptor>>()
+                                    {
+                                      @Override
+                                      public Iterable<SegmentDescriptor> apply(final TimelineObjectHolder<String, Segment> holder)
+                                      {
+                                        return FunctionalIterable
+                                            .create(holder.getObject())
+                                            .transform(
+                                                new Function<PartitionChunk<Segment>, SegmentDescriptor>()
+                                                {
+                                                  @Override
+                                                  public SegmentDescriptor apply(final PartitionChunk<Segment> chunk)
+                                                  {
+                                                    return new SegmentDescriptor(
+                                                        holder.getInterval(),
+                                                        holder.getVersion(),
+                                                        chunk.getChunkNumber()
+                                                    );
+                                                  }
+                                                }
+                                            );
+                                      }
+                                    }
+                                )
+                        ).run(query, responseContext);
+                      }
+                    }
+                )
+            )
+        ),
+        toolChest
+    );
   }
 
   @Override
@@ -146,11 +169,6 @@ public <T> QueryRunner<T> getQueryRunnerForSegments(
       final Iterable<SegmentDescriptor> specs
   )
   {
-    final VersionedIntervalTimeline<String, Segment> timeline = getTimeline(query);
-    if (timeline == null) {
-      return new NoopQueryRunner<>();
-    }
-
     final QueryRunnerFactory<T, Query<T>> factory = conglomerate.findFactory(query);
     if (factory == null) {
       throw new ISE("Unknown query type[%s].", query.getClass());
@@ -158,6 +176,49 @@ public <T> QueryRunner<T> getQueryRunnerForSegments(
 
     final QueryToolChest<T, Query<T>> toolChest = factory.getToolchest();
 
+    return new FinalizeResultsQueryRunner<>(
+        toolChest.postMergeQueryDecoration(
+            toolChest.mergeResults(
+                toolChest.preMergeQueryDecoration(
+                    makeBaseRunner(query, toolChest, factory, specs)
+                )
+            )
+        ),
+        toolChest
+    );
+  }
+
+  @Override
+  public void close() throws IOException
+  {
+    for (Closeable closeable : closeables) {
+      Closeables.close(closeable, true);
+    }
+  }
+
+  private <T> VersionedIntervalTimeline<String, Segment> getTimelineForTableDataSource(Query<T> query)
+  {
+    if (query.getDataSource() instanceof TableDataSource) {
+      return timelines.get(((TableDataSource) query.getDataSource()).getName());
+    } else {
+      throw new UnsupportedOperationException(
+          String.format("DataSource type[%s] unsupported", query.getDataSource().getClass().getName())
+      );
+    }
+  }
+
+  private <T> QueryRunner<T> makeBaseRunner(
+      final Query<T> query,
+      final QueryToolChest<T, Query<T>> toolChest,
+      final QueryRunnerFactory<T, Query<T>> factory,
+      final Iterable<SegmentDescriptor> specs
+  )
+  {
+    final VersionedIntervalTimeline<String, Segment> timeline = getTimelineForTableDataSource(query);
+    if (timeline == null) {
+      return new NoopQueryRunner<>();
+    }
+
     return new FinalizeResultsQueryRunner<>(
         toolChest.mergeResults(
             factory.mergeRunners(
@@ -197,21 +258,4 @@ public QueryRunner<T> apply(PartitionChunk<Segment> chunk)
         toolChest
     );
   }
-
-  @Override
-  public void close() throws IOException
-  {
-    for (Closeable closeable : closeables) {
-      Closeables.close(closeable, true);
-    }
-  }
-
-  private <T> VersionedIntervalTimeline<String, Segment> getTimeline(Query<T> query)
-  {
-    if (query.getDataSource() instanceof TableDataSource) {
-      return timelines.get(((TableDataSource) query.getDataSource()).getName());
-    } else {
-      return null;
-    }
-  }
 }