Speed up date_histogram without children

server/src/internalClusterTest/java/org/elasticsearch/action/search/TransportSearchIT.java

@@ -600,5 +600,10 @@ public void preCollection() throws IOException {}
 
         @Override
         public void postCollection() throws IOException {}
+
+        @Override
+        public Aggregator[] subAggregators() {
+            throw new UnsupportedOperationException();
+        }
     }
 }

server/src/main/java/org/elasticsearch/common/Rounding.java

@@ -291,6 +291,8 @@ public interface Prepared {
          * next rounded value in specified units if possible.
          */
         double roundingSize(long utcMillis, DateTimeUnit timeUnit);
+
+        long[] fixedRoundingPoints();
     }
     /**
      * Prepare to round many times.
@@ -435,6 +437,11 @@ protected Prepared maybeUseArray(long minUtcMillis, long maxUtcMillis, int max)
             }
             return new ArrayRounding(values, i, this);
         }
+
+        @Override
+        public long[] fixedRoundingPoints() {
+            return null;
+        }
     }
 
     static class TimeUnitRounding extends Rounding {
@@ -1253,6 +1260,12 @@ public long nextRoundingValue(long utcMillis) {
                 public double roundingSize(long utcMillis, DateTimeUnit timeUnit) {
                     return delegatePrepared.roundingSize(utcMillis, timeUnit);
                 }
+
+                @Override
+                public long[] fixedRoundingPoints() {
+                    // TODO we can likely translate here
+                    return null;
+                }
             };
         }
 
@@ -1335,5 +1348,10 @@ public long nextRoundingValue(long utcMillis) {
         public double roundingSize(long utcMillis, DateTimeUnit timeUnit) {
             return delegate.roundingSize(utcMillis, timeUnit);
         }
+
+        @Override
+        public long[] fixedRoundingPoints() {
+            return Arrays.copyOf(values, max);
+        }
     }
 }

server/src/main/java/org/elasticsearch/search/aggregations/AdaptingAggregator.java

@@ -0,0 +1,85 @@
+package org.elasticsearch.search.aggregations;
+
+import org.apache.lucene.index.LeafReaderContext;
+import org.apache.lucene.search.ScoreMode;
+import org.elasticsearch.search.aggregations.bucket.BucketsAggregator;
+import org.elasticsearch.search.internal.SearchContext;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+public abstract class AdaptingAggregator extends Aggregator {
+    private final Aggregator delegate;
+
+    public AdaptingAggregator(Aggregator delegate) {
+        this.delegate = delegate;
+    }
+
+    @Override
+    public void close() {
+        delegate.close();
+    }
+
+    @Override
+    public ScoreMode scoreMode() {
+        return delegate.scoreMode();
+    }
+
+    @Override
+    public String name() {
+        return delegate.name();
+    }
+
+    @Override
+    public SearchContext context() {
+        return delegate.context();
+    }
+
+    @Override
+    public Aggregator parent() {
+        return delegate.parent();
+    }
+
+    @Override
+    public Aggregator subAggregator(String name) {
+        return delegate.subAggregator(name);
+    }
+
+    @Override
+    public LeafBucketCollector getLeafCollector(LeafReaderContext ctx) throws IOException {
+        return delegate.getLeafCollector(ctx);
+    }
+
+    @Override
+    public void preCollection() throws IOException {
+        delegate.preCollection();
+    }
+
+    @Override
+    public void postCollection() throws IOException {
+        delegate.postCollection();
+    }
+
+    @Override
+    public InternalAggregation[] buildAggregations(long[] owningBucketOrds) throws IOException {
+        InternalAggregation[] delegateResults = delegate.buildAggregations(owningBucketOrds);
+        InternalAggregation[] result = new InternalAggregation[owningBucketOrds.length];
+        for (int ordIdx = 0; ordIdx < owningBucketOrds.length; ordIdx++) {
+            result[ordIdx] = adapt(delegateResults[ordIdx]);
+        }
+        return result;
+    }
+
+    @Override
+    public InternalAggregation buildEmptyAggregation() {
+        return adapt(delegate.buildEmptyAggregation());
+    }
+
+    @Override
+    public Aggregator[] subAggregators() {
+        return delegate.subAggregators();
+    }
+
+    protected abstract InternalAggregation adapt(InternalAggregation delegateResult);
+}

server/src/main/java/org/elasticsearch/search/aggregations/Aggregator.java

@@ -178,6 +178,11 @@ public final InternalAggregation buildTopLevel() throws IOException {
      */
     public void collectDebugInfo(BiConsumer<String, Object> add) {}
 
+    /**
+     * Get the aggregators running under this one.
+     */
+    public abstract Aggregator[] subAggregators();
+
     /** Aggregation mode for sub aggregations. */
     public enum SubAggCollectionMode implements Writeable {
 

server/src/main/java/org/elasticsearch/search/aggregations/AggregatorBase.java

@@ -225,6 +225,7 @@ public Aggregator parent() {
         return parent;
     }
 
+    @Override
     public Aggregator[] subAggregators() {
         return subAggregators;
     }
@@ -277,7 +278,7 @@ protected void doClose() {}
     protected void doPostCollection() throws IOException {
     }
 
-    protected final InternalAggregations buildEmptySubAggregations() {
+    public final InternalAggregations buildEmptySubAggregations() {
         List<InternalAggregation> aggs = new ArrayList<>();
         for (Aggregator aggregator : subAggregators) {
             aggs.add(aggregator.buildEmptyAggregation());

server/src/main/java/org/elasticsearch/search/aggregations/bucket/DeferringBucketCollector.java

@@ -131,6 +131,11 @@ public Aggregator resolveSortPath(PathElement next, Iterator<PathElement> path)
         public BucketComparator bucketComparator(String key, SortOrder order) {
             throw new UnsupportedOperationException("Can't sort on deferred aggregations");
         }
+
+        @Override
+        public Aggregator[] subAggregators() {
+            return in.subAggregators();
+        }
     }
 
 }