From f9b0d5f0bc7eac28967a9e621dacb4a528a72f75 Mon Sep 17 00:00:00 2001
From: Ankit Jain <akjain@amazon.com>
Date: Tue, 24 Oct 2023 00:37:30 -0700
Subject: [PATCH 01/21] Adding filter based optimization logic to date
 histogram aggregation

Signed-off-by: Ankit Jain <akjain@amazon.com>
---
 .idea/runConfigurations/Debug_OpenSearch.xml  |   6 +-
 .../java/org/opensearch/common/Rounding.java  |  30 ++---
 .../opensearch/indices/IndicesQueryCache.java |   6 +
 .../histogram/DateHistogramAggregator.java    | 124 +++++++++++++++++-
 .../aggregations/support/ValuesSource.java    |   2 +-
 5 files changed, 150 insertions(+), 18 deletions(-)

diff --git a/.idea/runConfigurations/Debug_OpenSearch.xml b/.idea/runConfigurations/Debug_OpenSearch.xml
index 0d8bf59823acf..c18046f873477 100644
--- a/.idea/runConfigurations/Debug_OpenSearch.xml
+++ b/.idea/runConfigurations/Debug_OpenSearch.xml
@@ -6,6 +6,10 @@
     <option name="HOST" value="localhost" />
     <option name="PORT" value="5005" />
     <option name="AUTO_RESTART" value="true" />
+    <RunnerSettings RunnerId="Debug">
+      <option name="DEBUG_PORT" value="5005" />
+      <option name="LOCAL" value="false" />
+    </RunnerSettings>
     <method v="2" />
   </configuration>
-</component>
+</component>
\ No newline at end of file
diff --git a/server/src/main/java/org/opensearch/common/Rounding.java b/server/src/main/java/org/opensearch/common/Rounding.java
index 667eb4529fe38..1b46e48e6bd7d 100644
--- a/server/src/main/java/org/opensearch/common/Rounding.java
+++ b/server/src/main/java/org/opensearch/common/Rounding.java
@@ -95,7 +95,7 @@ long roundFloor(long utcMillis) {
             }
 
             @Override
-            long extraLocalOffsetLookup() {
+            public long extraLocalOffsetLookup() {
                 return extraLocalOffsetLookup;
             }
         },
@@ -106,7 +106,7 @@ long roundFloor(long utcMillis) {
                 return DateUtils.roundYear(utcMillis);
             }
 
-            long extraLocalOffsetLookup() {
+            public long extraLocalOffsetLookup() {
                 return extraLocalOffsetLookup;
             }
         },
@@ -117,7 +117,7 @@ long roundFloor(long utcMillis) {
                 return DateUtils.roundQuarterOfYear(utcMillis);
             }
 
-            long extraLocalOffsetLookup() {
+            public long extraLocalOffsetLookup() {
                 return extraLocalOffsetLookup;
             }
         },
@@ -128,7 +128,7 @@ long roundFloor(long utcMillis) {
                 return DateUtils.roundMonthOfYear(utcMillis);
             }
 
-            long extraLocalOffsetLookup() {
+            public long extraLocalOffsetLookup() {
                 return extraLocalOffsetLookup;
             }
         },
@@ -137,7 +137,7 @@ long roundFloor(long utcMillis) {
                 return DateUtils.roundFloor(utcMillis, this.ratio);
             }
 
-            long extraLocalOffsetLookup() {
+            public long extraLocalOffsetLookup() {
                 return ratio;
             }
         },
@@ -146,7 +146,7 @@ long roundFloor(long utcMillis) {
                 return DateUtils.roundFloor(utcMillis, ratio);
             }
 
-            long extraLocalOffsetLookup() {
+            public long extraLocalOffsetLookup() {
                 return ratio;
             }
         },
@@ -161,7 +161,7 @@ long roundFloor(long utcMillis) {
                 return DateUtils.roundFloor(utcMillis, ratio);
             }
 
-            long extraLocalOffsetLookup() {
+            public long extraLocalOffsetLookup() {
                 return ratio;
             }
         },
@@ -176,7 +176,7 @@ long roundFloor(long utcMillis) {
                 return DateUtils.roundFloor(utcMillis, ratio);
             }
 
-            long extraLocalOffsetLookup() {
+            public long extraLocalOffsetLookup() {
                 return ratio;
             }
         };
@@ -213,7 +213,7 @@ long extraLocalOffsetLookup() {
          * look up so that we can see transitions that we might have rounded
          * down beyond.
          */
-        abstract long extraLocalOffsetLookup();
+        public abstract long extraLocalOffsetLookup();
 
         public byte getId() {
             return id;
@@ -462,11 +462,11 @@ protected Prepared maybeUseArray(long minUtcMillis, long maxUtcMillis, int max)
      *
      * @opensearch.internal
      */
-    static class TimeUnitRounding extends Rounding {
+    public static class TimeUnitRounding extends Rounding {
         static final byte ID = 1;
 
-        private final DateTimeUnit unit;
-        private final ZoneId timeZone;
+        public final DateTimeUnit unit;
+        public final ZoneId timeZone;
         private final boolean unitRoundsToMidnight;
 
         TimeUnitRounding(DateTimeUnit unit, ZoneId timeZone) {
@@ -920,11 +920,11 @@ public final long nextRoundingValue(long utcMillis) {
      *
      * @opensearch.internal
      */
-    static class TimeIntervalRounding extends Rounding {
+    public static class TimeIntervalRounding extends Rounding {
         static final byte ID = 2;
 
-        private final long interval;
-        private final ZoneId timeZone;
+        public final long interval;
+        public final ZoneId timeZone;
 
         TimeIntervalRounding(long interval, ZoneId timeZone) {
             if (interval < 1) throw new IllegalArgumentException("Zero or negative time interval not supported");
diff --git a/server/src/main/java/org/opensearch/indices/IndicesQueryCache.java b/server/src/main/java/org/opensearch/indices/IndicesQueryCache.java
index 228723045d8cc..136bfd48f8759 100644
--- a/server/src/main/java/org/opensearch/indices/IndicesQueryCache.java
+++ b/server/src/main/java/org/opensearch/indices/IndicesQueryCache.java
@@ -186,6 +186,12 @@ public BulkScorer bulkScorer(LeafReaderContext context) throws IOException {
             return in.bulkScorer(context);
         }
 
+        @Override
+        public int count(LeafReaderContext context) throws IOException {
+            shardKeyMap.add(context.reader());
+            return in.count(context);
+        }
+
         @Override
         public boolean isCacheable(LeafReaderContext ctx) {
             return in.isCacheable(ctx);
diff --git a/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/DateHistogramAggregator.java b/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/DateHistogramAggregator.java
index f602eea7a9b12..cacd8b0d8e675 100644
--- a/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/DateHistogramAggregator.java
+++ b/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/DateHistogramAggregator.java
@@ -33,8 +33,13 @@
 
 import org.apache.lucene.index.LeafReaderContext;
 import org.apache.lucene.index.SortedNumericDocValues;
+import org.apache.lucene.search.CollectionTerminatedException;
+import org.apache.lucene.search.IndexOrDocValuesQuery;
+import org.apache.lucene.search.PointRangeQuery;
 import org.apache.lucene.search.ScoreMode;
+import org.apache.lucene.search.Weight;
 import org.apache.lucene.util.CollectionUtil;
+import org.apache.lucene.util.NumericUtils;
 import org.opensearch.common.Nullable;
 import org.opensearch.common.Rounding;
 import org.opensearch.common.lease.Releasables;
@@ -53,7 +58,10 @@
 import org.opensearch.search.internal.SearchContext;
 
 import java.io.IOException;
+import java.time.ZoneId;
+import java.time.format.TextStyle;
 import java.util.Collections;
+import java.util.Locale;
 import java.util.Map;
 import java.util.function.BiConsumer;
 
@@ -81,6 +89,8 @@ class DateHistogramAggregator extends BucketsAggregator implements SizedBucketAg
     private final LongBounds extendedBounds;
     private final LongBounds hardBounds;
 
+    private Weight[] filters = null;
+
     private final LongKeyedBucketOrds bucketOrds;
 
     DateHistogramAggregator(
@@ -99,7 +109,6 @@ class DateHistogramAggregator extends BucketsAggregator implements SizedBucketAg
         CardinalityUpperBound cardinality,
         Map<String, Object> metadata
     ) throws IOException {
-
         super(name, factories, aggregationContext, parent, CardinalityUpperBound.MANY, metadata);
         this.rounding = rounding;
         this.preparedRounding = preparedRounding;
@@ -114,6 +123,25 @@ class DateHistogramAggregator extends BucketsAggregator implements SizedBucketAg
         this.formatter = valuesSourceConfig.format();
 
         bucketOrds = LongKeyedBucketOrds.build(context.bigArrays(), cardinality);
+
+        // Create the filters for fast aggregation only if the query is instance
+        // of point range query and there aren't any parent/sub aggregations
+        if (parent() == null && subAggregators.length == 0) {
+            // TODO: Is there better way of getting aggregation field? Can this cause NPE?
+            final String fieldName = (((ValuesSource.Numeric.FieldData) valuesSource).indexFieldData).getFieldName();
+            if (context.query() instanceof IndexOrDocValuesQuery) {
+                final IndexOrDocValuesQuery q = (IndexOrDocValuesQuery) context.query();
+                if (q.getIndexQuery() instanceof PointRangeQuery) {
+                    final PointRangeQuery prq = (PointRangeQuery) q.getIndexQuery();
+                    // Ensure that the query and aggregation are on the same field
+                    if (valuesSource != null && prq.getField().equals(fieldName)) {
+                        long low = NumericUtils.sortableBytesToLong(prq.getLowerPoint(), 0);
+                        long high = NumericUtils.sortableBytesToLong(prq.getUpperPoint(), 0);
+                        createFilterForAggregations(fieldName, low, high);
+                    }
+                }
+            }
+        }
     }
 
     @Override
@@ -129,10 +157,22 @@ public LeafBucketCollector getLeafCollector(LeafReaderContext ctx, LeafBucketCol
         if (valuesSource == null) {
             return LeafBucketCollector.NO_OP_COLLECTOR;
         }
+
+        // Need to be declared as final and array for usage within the
+        // LeafCollector subclass later
+        final boolean[] useOpt = new boolean[1];
+        useOpt[0] = true;
+
         SortedNumericDocValues values = valuesSource.longValues(ctx);
         return new LeafBucketCollectorBase(sub, values) {
             @Override
             public void collect(int doc, long owningBucketOrd) throws IOException {
+                // Try fast filter aggregation if the filters have been created
+                // Skip if tried before and gave incorrect/incomplete results
+                if (useOpt[0] && filters != null) {
+                    useOpt[0] = tryFastFilterAggregation(ctx, owningBucketOrd);
+                }
+
                 if (values.advanceExact(doc)) {
                     int valuesCount = values.docValueCount();
 
@@ -226,4 +266,86 @@ public double bucketSize(long bucket, Rounding.DateTimeUnit unitSize) {
             return 1.0;
         }
     }
+
+    private boolean tryFastFilterAggregation(LeafReaderContext ctx, long owningBucketOrd) throws IOException {
+        final int[] counts = new int[filters.length];
+        int i;
+        for (i = 0; i < filters.length; i++) {
+            counts[i] = filters[i].count(ctx);
+            if (counts[i] == -1) {
+                // Cannot use the optimization if any of the counts
+                // is -1 indicating the segment might have deleted documents
+                return false;
+            }
+        }
+
+        for (i = 0; i < filters.length; i++) {
+            long bucketOrd = bucketOrds.add(
+                owningBucketOrd,
+                preparedRounding.round(NumericUtils.sortableBytesToLong(((PointRangeQuery) filters[i].getQuery()).getLowerPoint(), 0))
+            );
+            if (bucketOrd < 0) { // already seen
+                bucketOrd = -1 - bucketOrd;
+            }
+            incrementBucketDocCount(bucketOrd, counts[i]);
+        }
+        throw new CollectionTerminatedException();
+    }
+
+    private boolean isUTCTimeZone(final ZoneId zoneId) {
+        return "Z".equals(zoneId.getDisplayName(TextStyle.FULL, Locale.ENGLISH));
+    }
+
+    private void createFilterForAggregations(String field, long low, long high) throws IOException {
+        long interval = Long.MAX_VALUE;
+        if (rounding instanceof Rounding.TimeUnitRounding) {
+            interval = (((Rounding.TimeUnitRounding) rounding).unit).extraLocalOffsetLookup();
+            if (!isUTCTimeZone(((Rounding.TimeUnitRounding) rounding).timeZone)) {
+                // Fast filter aggregation cannot be used if it needs time zone rounding
+                return;
+            }
+        } else if (rounding instanceof Rounding.TimeIntervalRounding) {
+            interval = ((Rounding.TimeIntervalRounding) rounding).interval;
+            if (!isUTCTimeZone(((Rounding.TimeIntervalRounding) rounding).timeZone)) {
+                // Fast filter aggregation cannot be used if it needs time zone rounding
+                return;
+            }
+        }
+
+        // Return if the interval ratio could not be figured out correctly
+        if (interval == Long.MAX_VALUE) return;
+
+        // Calculate the number of buckets using range and interval
+        long roundedLow = preparedRounding.round(low);
+        int bucketCount = 0;
+        while (roundedLow < high) {
+            bucketCount++;
+            roundedLow += interval;
+            // Below rounding is needed as the interval could return in
+            // non-rounded values for something like calendar month
+            roundedLow = preparedRounding.round(roundedLow);
+        }
+
+        if (bucketCount > 0) {
+            int i = 0;
+            filters = new Weight[bucketCount];
+            while (i < bucketCount) {
+                byte[] lower = new byte[8];
+                NumericUtils.longToSortableBytes(low, lower, 0);
+                byte[] upper = new byte[8];
+                // Calculate the upper bucket
+                roundedLow = preparedRounding.round(low);
+                roundedLow = preparedRounding.round(roundedLow + interval);
+                // Subtract -1 if the minimum is roundedLow as roundedLow itself
+                // is included in the next bucket
+                NumericUtils.longToSortableBytes(Math.min(roundedLow - 1, high), upper, 0);
+                filters[i++] = context.searcher().createWeight(new PointRangeQuery(field, lower, upper, 1) {
+                    @Override
+                    protected String toString(int dimension, byte[] value) {
+                        return null;
+                    }
+                }, ScoreMode.COMPLETE_NO_SCORES, 1);
+            }
+        }
+    }
 }
diff --git a/server/src/main/java/org/opensearch/search/aggregations/support/ValuesSource.java b/server/src/main/java/org/opensearch/search/aggregations/support/ValuesSource.java
index 67d311db964d6..36afcac5da074 100644
--- a/server/src/main/java/org/opensearch/search/aggregations/support/ValuesSource.java
+++ b/server/src/main/java/org/opensearch/search/aggregations/support/ValuesSource.java
@@ -584,7 +584,7 @@ public boolean advanceExact(int target) throws IOException {
          */
         public static class FieldData extends Numeric {
 
-            protected final IndexNumericFieldData indexFieldData;
+            public final IndexNumericFieldData indexFieldData;
 
             public FieldData(IndexNumericFieldData indexFieldData) {
                 this.indexFieldData = indexFieldData;

From 05ca07b849f2e38befdf2a4afc3d2ac851d4f641 Mon Sep 17 00:00:00 2001
From: Ankit Jain <akjain@amazon.com>
Date: Fri, 3 Nov 2023 16:15:03 +0530
Subject: [PATCH 02/21] Reading the field name for aggregation correctly

Signed-off-by: Ankit Jain <akjain@amazon.com>
---
 .idea/runConfigurations/Debug_OpenSearch.xml  |  6 +----
 .../histogram/DateHistogramAggregator.java    | 22 ++++++++++---------
 .../aggregations/support/ValuesSource.java    |  2 +-
 3 files changed, 14 insertions(+), 16 deletions(-)

diff --git a/.idea/runConfigurations/Debug_OpenSearch.xml b/.idea/runConfigurations/Debug_OpenSearch.xml
index c18046f873477..0d8bf59823acf 100644
--- a/.idea/runConfigurations/Debug_OpenSearch.xml
+++ b/.idea/runConfigurations/Debug_OpenSearch.xml
@@ -6,10 +6,6 @@
     <option name="HOST" value="localhost" />
     <option name="PORT" value="5005" />
     <option name="AUTO_RESTART" value="true" />
-    <RunnerSettings RunnerId="Debug">
-      <option name="DEBUG_PORT" value="5005" />
-      <option name="LOCAL" value="false" />
-    </RunnerSettings>
     <method v="2" />
   </configuration>
-</component>
\ No newline at end of file
+</component>
diff --git a/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/DateHistogramAggregator.java b/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/DateHistogramAggregator.java
index cacd8b0d8e675..f6cab2b15b45b 100644
--- a/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/DateHistogramAggregator.java
+++ b/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/DateHistogramAggregator.java
@@ -127,17 +127,14 @@ class DateHistogramAggregator extends BucketsAggregator implements SizedBucketAg
         // Create the filters for fast aggregation only if the query is instance
         // of point range query and there aren't any parent/sub aggregations
         if (parent() == null && subAggregators.length == 0) {
-            // TODO: Is there better way of getting aggregation field? Can this cause NPE?
-            final String fieldName = (((ValuesSource.Numeric.FieldData) valuesSource).indexFieldData).getFieldName();
+            final String fieldName = valuesSourceConfig.fieldContext().field();
             if (context.query() instanceof IndexOrDocValuesQuery) {
                 final IndexOrDocValuesQuery q = (IndexOrDocValuesQuery) context.query();
                 if (q.getIndexQuery() instanceof PointRangeQuery) {
                     final PointRangeQuery prq = (PointRangeQuery) q.getIndexQuery();
                     // Ensure that the query and aggregation are on the same field
-                    if (valuesSource != null && prq.getField().equals(fieldName)) {
-                        long low = NumericUtils.sortableBytesToLong(prq.getLowerPoint(), 0);
-                        long high = NumericUtils.sortableBytesToLong(prq.getUpperPoint(), 0);
-                        createFilterForAggregations(fieldName, low, high);
+                    if (prq.getField().equals(fieldName)) {
+                        createFilterForAggregations(fieldName, prq.getLowerPoint(), prq.getUpperPoint());
                     }
                 }
             }
@@ -159,9 +156,9 @@ public LeafBucketCollector getLeafCollector(LeafReaderContext ctx, LeafBucketCol
         }
 
         // Need to be declared as final and array for usage within the
-        // LeafCollector subclass later
+        // LeafBucketCollectorBase subclass below
         final boolean[] useOpt = new boolean[1];
-        useOpt[0] = true;
+        useOpt[0] = filters != null;
 
         SortedNumericDocValues values = valuesSource.longValues(ctx);
         return new LeafBucketCollectorBase(sub, values) {
@@ -169,7 +166,7 @@ public LeafBucketCollector getLeafCollector(LeafReaderContext ctx, LeafBucketCol
             public void collect(int doc, long owningBucketOrd) throws IOException {
                 // Try fast filter aggregation if the filters have been created
                 // Skip if tried before and gave incorrect/incomplete results
-                if (useOpt[0] && filters != null) {
+                if (useOpt[0]) {
                     useOpt[0] = tryFastFilterAggregation(ctx, owningBucketOrd);
                 }
 
@@ -296,7 +293,9 @@ private boolean isUTCTimeZone(final ZoneId zoneId) {
         return "Z".equals(zoneId.getDisplayName(TextStyle.FULL, Locale.ENGLISH));
     }
 
-    private void createFilterForAggregations(String field, long low, long high) throws IOException {
+    private void createFilterForAggregations(String field, byte[] lowerPoint, byte[] upperPoint) throws IOException {
+        final long low = NumericUtils.sortableBytesToLong(lowerPoint, 0);
+        final long high = NumericUtils.sortableBytesToLong(upperPoint, 0);
         long interval = Long.MAX_VALUE;
         if (rounding instanceof Rounding.TimeUnitRounding) {
             interval = (((Rounding.TimeUnitRounding) rounding).unit).extraLocalOffsetLookup();
@@ -310,6 +309,9 @@ private void createFilterForAggregations(String field, long low, long high) thro
                 // Fast filter aggregation cannot be used if it needs time zone rounding
                 return;
             }
+        } else {
+            // Unexpected scenario, exit and fall back to original
+            return;
         }
 
         // Return if the interval ratio could not be figured out correctly
diff --git a/server/src/main/java/org/opensearch/search/aggregations/support/ValuesSource.java b/server/src/main/java/org/opensearch/search/aggregations/support/ValuesSource.java
index 36afcac5da074..67d311db964d6 100644
--- a/server/src/main/java/org/opensearch/search/aggregations/support/ValuesSource.java
+++ b/server/src/main/java/org/opensearch/search/aggregations/support/ValuesSource.java
@@ -584,7 +584,7 @@ public boolean advanceExact(int target) throws IOException {
          */
         public static class FieldData extends Numeric {
 
-            public final IndexNumericFieldData indexFieldData;
+            protected final IndexNumericFieldData indexFieldData;
 
             public FieldData(IndexNumericFieldData indexFieldData) {
                 this.indexFieldData = indexFieldData;

From e7f8a8c89ecd31ac0eb5339d04bd182d603d7076 Mon Sep 17 00:00:00 2001
From: Ankit Jain <akjain@amazon.com>
Date: Fri, 3 Nov 2023 16:29:07 +0530
Subject: [PATCH 03/21] Adding the limit on number of buckets for filter
 aggregation

Signed-off-by: Ankit Jain <akjain@amazon.com>
---
 .../aggregations/bucket/histogram/DateHistogramAggregator.java | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/DateHistogramAggregator.java b/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/DateHistogramAggregator.java
index f6cab2b15b45b..d225355774b9b 100644
--- a/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/DateHistogramAggregator.java
+++ b/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/DateHistogramAggregator.java
@@ -75,6 +75,7 @@
  */
 class DateHistogramAggregator extends BucketsAggregator implements SizedBucketAggregator {
 
+    private static final int MAX_NUM_FILTER_BUCKETS = 1024;
     private final ValuesSource.Numeric valuesSource;
     private final DocValueFormat formatter;
     private final Rounding rounding;
@@ -328,7 +329,7 @@ private void createFilterForAggregations(String field, byte[] lowerPoint, byte[]
             roundedLow = preparedRounding.round(roundedLow);
         }
 
-        if (bucketCount > 0) {
+        if (bucketCount > 0 && bucketCount <= MAX_NUM_FILTER_BUCKETS) {
             int i = 0;
             filters = new Weight[bucketCount];
             while (i < bucketCount) {

From d8487f8729dc6700dd941f3e059edc27f13d0787 Mon Sep 17 00:00:00 2001
From: Ankit Jain <akjain@amazon.com>
Date: Mon, 6 Nov 2023 14:02:34 +0530
Subject: [PATCH 04/21] Applying the optimizations for match all query as well

Signed-off-by: Ankit Jain <akjain@amazon.com>
---
 .../histogram/DateHistogramAggregator.java    | 43 +++++++++++++------
 1 file changed, 31 insertions(+), 12 deletions(-)

diff --git a/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/DateHistogramAggregator.java b/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/DateHistogramAggregator.java
index d225355774b9b..1ad4868e53eb3 100644
--- a/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/DateHistogramAggregator.java
+++ b/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/DateHistogramAggregator.java
@@ -34,7 +34,9 @@
 import org.apache.lucene.index.LeafReaderContext;
 import org.apache.lucene.index.SortedNumericDocValues;
 import org.apache.lucene.search.CollectionTerminatedException;
+import org.apache.lucene.search.ConstantScoreQuery;
 import org.apache.lucene.search.IndexOrDocValuesQuery;
+import org.apache.lucene.search.MatchAllDocsQuery;
 import org.apache.lucene.search.PointRangeQuery;
 import org.apache.lucene.search.ScoreMode;
 import org.apache.lucene.search.Weight;
@@ -61,6 +63,7 @@
 import java.time.ZoneId;
 import java.time.format.TextStyle;
 import java.util.Collections;
+import java.util.List;
 import java.util.Locale;
 import java.util.Map;
 import java.util.function.BiConsumer;
@@ -135,9 +138,27 @@ class DateHistogramAggregator extends BucketsAggregator implements SizedBucketAg
                     final PointRangeQuery prq = (PointRangeQuery) q.getIndexQuery();
                     // Ensure that the query and aggregation are on the same field
                     if (prq.getField().equals(fieldName)) {
-                        createFilterForAggregations(fieldName, prq.getLowerPoint(), prq.getUpperPoint());
+                        createFilterForAggregations(fieldName,
+                            NumericUtils.sortableBytesToLong(prq.getLowerPoint(), 0),
+                            NumericUtils.sortableBytesToLong(prq.getUpperPoint(), 0));
                     }
                 }
+            } else if (context.query() instanceof ConstantScoreQuery) {
+                final ConstantScoreQuery csq = (ConstantScoreQuery) context.query();
+                // Ensure that the constant score query is instance of match all query
+                if (csq.getQuery() instanceof MatchAllDocsQuery) {
+                    final List<LeafReaderContext> leaves = aggregationContext.searcher().getIndexReader().leaves();
+                    long min = Long.MAX_VALUE, max = Long.MIN_VALUE;
+                    // Since the query does not specify bounds for aggregation, we can
+                    // build the global min/max from local min/max within each segment
+                    for (LeafReaderContext leaf : leaves) {
+                        min = Math.min(min, NumericUtils.sortableBytesToLong(
+                            leaf.reader().getPointValues(fieldName).getMinPackedValue(), 0));
+                        max = Math.max(max, NumericUtils.sortableBytesToLong(
+                            leaf.reader().getPointValues(fieldName).getMaxPackedValue(), 0));
+                    }
+                    createFilterForAggregations(fieldName, min, max);
+                }
             }
         }
     }
@@ -294,10 +315,8 @@ private boolean isUTCTimeZone(final ZoneId zoneId) {
         return "Z".equals(zoneId.getDisplayName(TextStyle.FULL, Locale.ENGLISH));
     }
 
-    private void createFilterForAggregations(String field, byte[] lowerPoint, byte[] upperPoint) throws IOException {
-        final long low = NumericUtils.sortableBytesToLong(lowerPoint, 0);
-        final long high = NumericUtils.sortableBytesToLong(upperPoint, 0);
-        long interval = Long.MAX_VALUE;
+    private void createFilterForAggregations(final String field, final long low, final long high) throws IOException {
+        long interval;
         if (rounding instanceof Rounding.TimeUnitRounding) {
             interval = (((Rounding.TimeUnitRounding) rounding).unit).extraLocalOffsetLookup();
             if (!isUTCTimeZone(((Rounding.TimeUnitRounding) rounding).timeZone)) {
@@ -323,21 +342,21 @@ private void createFilterForAggregations(String field, byte[] lowerPoint, byte[]
         int bucketCount = 0;
         while (roundedLow < high) {
             bucketCount++;
-            roundedLow += interval;
             // Below rounding is needed as the interval could return in
             // non-rounded values for something like calendar month
-            roundedLow = preparedRounding.round(roundedLow);
+            roundedLow = preparedRounding.round(roundedLow + interval);
         }
 
         if (bucketCount > 0 && bucketCount <= MAX_NUM_FILTER_BUCKETS) {
             int i = 0;
             filters = new Weight[bucketCount];
+            roundedLow = preparedRounding.round(low);
             while (i < bucketCount) {
-                byte[] lower = new byte[8];
-                NumericUtils.longToSortableBytes(low, lower, 0);
-                byte[] upper = new byte[8];
-                // Calculate the upper bucket
-                roundedLow = preparedRounding.round(low);
+                // Calculate the lower bucket bound
+                final byte[] lower = new byte[8];
+                NumericUtils.longToSortableBytes(Math.max(roundedLow, low), lower, 0);
+                // Calculate the upper bucket bound
+                final byte[] upper = new byte[8];
                 roundedLow = preparedRounding.round(roundedLow + interval);
                 // Subtract -1 if the minimum is roundedLow as roundedLow itself
                 // is included in the next bucket

From d4ada64bc4cc2bc993f5f958708b6673a7f184dd Mon Sep 17 00:00:00 2001
From: Ankit Jain <akjain@amazon.com>
Date: Mon, 6 Nov 2023 15:21:19 +0530
Subject: [PATCH 05/21] Handling the unwrapped match all query

Signed-off-by: Ankit Jain <akjain@amazon.com>
---
 .../histogram/DateHistogramAggregator.java    | 31 ++++++++++---------
 1 file changed, 17 insertions(+), 14 deletions(-)

diff --git a/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/DateHistogramAggregator.java b/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/DateHistogramAggregator.java
index 1ad4868e53eb3..b54a103e32358 100644
--- a/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/DateHistogramAggregator.java
+++ b/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/DateHistogramAggregator.java
@@ -147,18 +147,10 @@ class DateHistogramAggregator extends BucketsAggregator implements SizedBucketAg
                 final ConstantScoreQuery csq = (ConstantScoreQuery) context.query();
                 // Ensure that the constant score query is instance of match all query
                 if (csq.getQuery() instanceof MatchAllDocsQuery) {
-                    final List<LeafReaderContext> leaves = aggregationContext.searcher().getIndexReader().leaves();
-                    long min = Long.MAX_VALUE, max = Long.MIN_VALUE;
-                    // Since the query does not specify bounds for aggregation, we can
-                    // build the global min/max from local min/max within each segment
-                    for (LeafReaderContext leaf : leaves) {
-                        min = Math.min(min, NumericUtils.sortableBytesToLong(
-                            leaf.reader().getPointValues(fieldName).getMinPackedValue(), 0));
-                        max = Math.max(max, NumericUtils.sortableBytesToLong(
-                            leaf.reader().getPointValues(fieldName).getMaxPackedValue(), 0));
-                    }
-                    createFilterForAggregations(fieldName, min, max);
+                    findBoundsAndCreateFilters(fieldName, context);
                 }
+            } else if (context.query() instanceof MatchAllDocsQuery) {
+                findBoundsAndCreateFilters(fieldName, context);
             }
         }
     }
@@ -311,6 +303,20 @@ private boolean tryFastFilterAggregation(LeafReaderContext ctx, long owningBucke
         throw new CollectionTerminatedException();
     }
 
+    private void findBoundsAndCreateFilters(final String fieldName, final SearchContext context) throws IOException {
+        final List<LeafReaderContext> leaves = context.searcher().getIndexReader().leaves();
+        long min = Long.MAX_VALUE, max = Long.MIN_VALUE;
+        // Since the query does not specify bounds for aggregation, we can
+        // build the global min/max from local min/max within each segment
+        for (LeafReaderContext leaf : leaves) {
+            min = Math.min(min, NumericUtils.sortableBytesToLong(
+                leaf.reader().getPointValues(fieldName).getMinPackedValue(), 0));
+            max = Math.max(max, NumericUtils.sortableBytesToLong(
+                leaf.reader().getPointValues(fieldName).getMaxPackedValue(), 0));
+        }
+        createFilterForAggregations(fieldName, min, max);
+    }
+
     private boolean isUTCTimeZone(final ZoneId zoneId) {
         return "Z".equals(zoneId.getDisplayName(TextStyle.FULL, Locale.ENGLISH));
     }
@@ -334,9 +340,6 @@ private void createFilterForAggregations(final String field, final long low, fin
             return;
         }
 
-        // Return if the interval ratio could not be figured out correctly
-        if (interval == Long.MAX_VALUE) return;
-
         // Calculate the number of buckets using range and interval
         long roundedLow = preparedRounding.round(low);
         int bucketCount = 0;

From f12ed7721096353d1380aa57ab38898fe3993446 Mon Sep 17 00:00:00 2001
From: Ankit Jain <akjain@amazon.com>
Date: Fri, 17 Nov 2023 11:34:11 +0530
Subject: [PATCH 06/21] Adding logic for recursively unwrapping the query

Signed-off-by: Ankit Jain <akjain@amazon.com>
---
 .../histogram/DateHistogramAggregator.java    | 58 ++++++++++++-------
 1 file changed, 37 insertions(+), 21 deletions(-)

diff --git a/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/DateHistogramAggregator.java b/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/DateHistogramAggregator.java
index b54a103e32358..ec084d8ef82a8 100644
--- a/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/DateHistogramAggregator.java
+++ b/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/DateHistogramAggregator.java
@@ -38,6 +38,7 @@
 import org.apache.lucene.search.IndexOrDocValuesQuery;
 import org.apache.lucene.search.MatchAllDocsQuery;
 import org.apache.lucene.search.PointRangeQuery;
+import org.apache.lucene.search.Query;
 import org.apache.lucene.search.ScoreMode;
 import org.apache.lucene.search.Weight;
 import org.apache.lucene.util.CollectionUtil;
@@ -45,6 +46,8 @@
 import org.opensearch.common.Nullable;
 import org.opensearch.common.Rounding;
 import org.opensearch.common.lease.Releasables;
+import org.opensearch.common.lucene.search.function.FunctionScoreQuery;
+import org.opensearch.index.query.DateRangeIncludingNowQuery;
 import org.opensearch.search.DocValueFormat;
 import org.opensearch.search.aggregations.Aggregator;
 import org.opensearch.search.aggregations.AggregatorFactories;
@@ -63,10 +66,12 @@
 import java.time.ZoneId;
 import java.time.format.TextStyle;
 import java.util.Collections;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
 import java.util.function.BiConsumer;
+import java.util.function.Function;
 
 /**
  * An aggregator for date values. Every date is rounded down using a configured
@@ -89,6 +94,8 @@ class DateHistogramAggregator extends BucketsAggregator implements SizedBucketAg
     private final BucketOrder order;
     private final boolean keyed;
 
+    private final Map<Class, Function<Query, Query>> queryWrappers;
+
     private final long minDocCount;
     private final LongBounds extendedBounds;
     private final LongBounds hardBounds;
@@ -125,6 +132,11 @@ class DateHistogramAggregator extends BucketsAggregator implements SizedBucketAg
         // TODO: Stop using null here
         this.valuesSource = valuesSourceConfig.hasValues() ? (ValuesSource.Numeric) valuesSourceConfig.getValuesSource() : null;
         this.formatter = valuesSourceConfig.format();
+        this.queryWrappers = new HashMap<>();
+        queryWrappers.put(ConstantScoreQuery.class, q -> ((ConstantScoreQuery) q).getQuery());
+        queryWrappers.put(FunctionScoreQuery.class, q -> ((FunctionScoreQuery) q).getSubQuery());
+        queryWrappers.put(DateRangeIncludingNowQuery.class, q -> ((DateRangeIncludingNowQuery) q).getQuery());
+        queryWrappers.put(IndexOrDocValuesQuery.class, q -> ((IndexOrDocValuesQuery) q).getIndexQuery());
 
         bucketOrds = LongKeyedBucketOrds.build(context.bigArrays(), cardinality);
 
@@ -132,24 +144,18 @@ class DateHistogramAggregator extends BucketsAggregator implements SizedBucketAg
         // of point range query and there aren't any parent/sub aggregations
         if (parent() == null && subAggregators.length == 0) {
             final String fieldName = valuesSourceConfig.fieldContext().field();
-            if (context.query() instanceof IndexOrDocValuesQuery) {
-                final IndexOrDocValuesQuery q = (IndexOrDocValuesQuery) context.query();
-                if (q.getIndexQuery() instanceof PointRangeQuery) {
-                    final PointRangeQuery prq = (PointRangeQuery) q.getIndexQuery();
-                    // Ensure that the query and aggregation are on the same field
-                    if (prq.getField().equals(fieldName)) {
-                        createFilterForAggregations(fieldName,
-                            NumericUtils.sortableBytesToLong(prq.getLowerPoint(), 0),
-                            NumericUtils.sortableBytesToLong(prq.getUpperPoint(), 0));
-                    }
-                }
-            } else if (context.query() instanceof ConstantScoreQuery) {
-                final ConstantScoreQuery csq = (ConstantScoreQuery) context.query();
-                // Ensure that the constant score query is instance of match all query
-                if (csq.getQuery() instanceof MatchAllDocsQuery) {
-                    findBoundsAndCreateFilters(fieldName, context);
+            final Query cq = unwrapIntoConcreteQuery(context.query());
+            if (cq instanceof PointRangeQuery) {
+                final PointRangeQuery prq = (PointRangeQuery) cq;
+                // Ensure that the query and aggregation are on the same field
+                if (prq.getField().equals(fieldName)) {
+                    createFilterForAggregations(
+                        fieldName,
+                        NumericUtils.sortableBytesToLong(prq.getLowerPoint(), 0),
+                        NumericUtils.sortableBytesToLong(prq.getUpperPoint(), 0)
+                    );
                 }
-            } else if (context.query() instanceof MatchAllDocsQuery) {
+            } else if (cq instanceof MatchAllDocsQuery) {
                 findBoundsAndCreateFilters(fieldName, context);
             }
         }
@@ -303,16 +309,26 @@ private boolean tryFastFilterAggregation(LeafReaderContext ctx, long owningBucke
         throw new CollectionTerminatedException();
     }
 
+    /**
+     * Recursively unwraps query into the concrete form
+     * for applying the optimization
+     */
+    private Query unwrapIntoConcreteQuery(Query query) {
+        while (queryWrappers.containsKey(query.getClass())) {
+            query = queryWrappers.get(query.getClass()).apply(query);
+        }
+
+        return query;
+    }
+
     private void findBoundsAndCreateFilters(final String fieldName, final SearchContext context) throws IOException {
         final List<LeafReaderContext> leaves = context.searcher().getIndexReader().leaves();
         long min = Long.MAX_VALUE, max = Long.MIN_VALUE;
         // Since the query does not specify bounds for aggregation, we can
         // build the global min/max from local min/max within each segment
         for (LeafReaderContext leaf : leaves) {
-            min = Math.min(min, NumericUtils.sortableBytesToLong(
-                leaf.reader().getPointValues(fieldName).getMinPackedValue(), 0));
-            max = Math.max(max, NumericUtils.sortableBytesToLong(
-                leaf.reader().getPointValues(fieldName).getMaxPackedValue(), 0));
+            min = Math.min(min, NumericUtils.sortableBytesToLong(leaf.reader().getPointValues(fieldName).getMinPackedValue(), 0));
+            max = Math.max(max, NumericUtils.sortableBytesToLong(leaf.reader().getPointValues(fieldName).getMaxPackedValue(), 0));
         }
         createFilterForAggregations(fieldName, min, max);
     }

From d9bbd1fe0cd0e499b9f233653cdba549fe6c93e3 Mon Sep 17 00:00:00 2001
From: Ankit Jain <akjain@amazon.com>
Date: Fri, 17 Nov 2023 15:01:40 +0530
Subject: [PATCH 07/21] Restructuring the code for making it more reusable and
 unit testable

Signed-off-by: Ankit Jain <akjain@amazon.com>
---
 .../histogram/DateHistogramAggregator.java    | 112 +------------
 .../bucket/histogram/FilterRewriteHelper.java | 153 ++++++++++++++++++
 2 files changed, 159 insertions(+), 106 deletions(-)
 create mode 100644 server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/FilterRewriteHelper.java

diff --git a/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/DateHistogramAggregator.java b/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/DateHistogramAggregator.java
index ec084d8ef82a8..b105654b84ea2 100644
--- a/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/DateHistogramAggregator.java
+++ b/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/DateHistogramAggregator.java
@@ -34,8 +34,6 @@
 import org.apache.lucene.index.LeafReaderContext;
 import org.apache.lucene.index.SortedNumericDocValues;
 import org.apache.lucene.search.CollectionTerminatedException;
-import org.apache.lucene.search.ConstantScoreQuery;
-import org.apache.lucene.search.IndexOrDocValuesQuery;
 import org.apache.lucene.search.MatchAllDocsQuery;
 import org.apache.lucene.search.PointRangeQuery;
 import org.apache.lucene.search.Query;
@@ -46,8 +44,6 @@
 import org.opensearch.common.Nullable;
 import org.opensearch.common.Rounding;
 import org.opensearch.common.lease.Releasables;
-import org.opensearch.common.lucene.search.function.FunctionScoreQuery;
-import org.opensearch.index.query.DateRangeIncludingNowQuery;
 import org.opensearch.search.DocValueFormat;
 import org.opensearch.search.aggregations.Aggregator;
 import org.opensearch.search.aggregations.AggregatorFactories;
@@ -63,15 +59,9 @@
 import org.opensearch.search.internal.SearchContext;
 
 import java.io.IOException;
-import java.time.ZoneId;
-import java.time.format.TextStyle;
 import java.util.Collections;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Locale;
 import java.util.Map;
 import java.util.function.BiConsumer;
-import java.util.function.Function;
 
 /**
  * An aggregator for date values. Every date is rounded down using a configured
@@ -82,8 +72,6 @@
  * @opensearch.internal
  */
 class DateHistogramAggregator extends BucketsAggregator implements SizedBucketAggregator {
-
-    private static final int MAX_NUM_FILTER_BUCKETS = 1024;
     private final ValuesSource.Numeric valuesSource;
     private final DocValueFormat formatter;
     private final Rounding rounding;
@@ -93,15 +81,10 @@ class DateHistogramAggregator extends BucketsAggregator implements SizedBucketAg
     private final Rounding.Prepared preparedRounding;
     private final BucketOrder order;
     private final boolean keyed;
-
-    private final Map<Class, Function<Query, Query>> queryWrappers;
-
     private final long minDocCount;
     private final LongBounds extendedBounds;
     private final LongBounds hardBounds;
-
     private Weight[] filters = null;
-
     private final LongKeyedBucketOrds bucketOrds;
 
     DateHistogramAggregator(
@@ -132,11 +115,6 @@ class DateHistogramAggregator extends BucketsAggregator implements SizedBucketAg
         // TODO: Stop using null here
         this.valuesSource = valuesSourceConfig.hasValues() ? (ValuesSource.Numeric) valuesSourceConfig.getValuesSource() : null;
         this.formatter = valuesSourceConfig.format();
-        this.queryWrappers = new HashMap<>();
-        queryWrappers.put(ConstantScoreQuery.class, q -> ((ConstantScoreQuery) q).getQuery());
-        queryWrappers.put(FunctionScoreQuery.class, q -> ((FunctionScoreQuery) q).getSubQuery());
-        queryWrappers.put(DateRangeIncludingNowQuery.class, q -> ((DateRangeIncludingNowQuery) q).getQuery());
-        queryWrappers.put(IndexOrDocValuesQuery.class, q -> ((IndexOrDocValuesQuery) q).getIndexQuery());
 
         bucketOrds = LongKeyedBucketOrds.build(context.bigArrays(), cardinality);
 
@@ -144,19 +122,22 @@ class DateHistogramAggregator extends BucketsAggregator implements SizedBucketAg
         // of point range query and there aren't any parent/sub aggregations
         if (parent() == null && subAggregators.length == 0) {
             final String fieldName = valuesSourceConfig.fieldContext().field();
-            final Query cq = unwrapIntoConcreteQuery(context.query());
+            final Query cq = FilterRewriteHelper.unwrapIntoConcreteQuery(context.query());
             if (cq instanceof PointRangeQuery) {
                 final PointRangeQuery prq = (PointRangeQuery) cq;
                 // Ensure that the query and aggregation are on the same field
                 if (prq.getField().equals(fieldName)) {
-                    createFilterForAggregations(
+                    FilterRewriteHelper.createFilterForAggregations(
+                        aggregationContext,
+                        rounding,
+                        preparedRounding,
                         fieldName,
                         NumericUtils.sortableBytesToLong(prq.getLowerPoint(), 0),
                         NumericUtils.sortableBytesToLong(prq.getUpperPoint(), 0)
                     );
                 }
             } else if (cq instanceof MatchAllDocsQuery) {
-                findBoundsAndCreateFilters(fieldName, context);
+                FilterRewriteHelper.findBoundsAndCreateFilters(context, rounding, preparedRounding, fieldName);
             }
         }
     }
@@ -308,85 +289,4 @@ private boolean tryFastFilterAggregation(LeafReaderContext ctx, long owningBucke
         }
         throw new CollectionTerminatedException();
     }
-
-    /**
-     * Recursively unwraps query into the concrete form
-     * for applying the optimization
-     */
-    private Query unwrapIntoConcreteQuery(Query query) {
-        while (queryWrappers.containsKey(query.getClass())) {
-            query = queryWrappers.get(query.getClass()).apply(query);
-        }
-
-        return query;
-    }
-
-    private void findBoundsAndCreateFilters(final String fieldName, final SearchContext context) throws IOException {
-        final List<LeafReaderContext> leaves = context.searcher().getIndexReader().leaves();
-        long min = Long.MAX_VALUE, max = Long.MIN_VALUE;
-        // Since the query does not specify bounds for aggregation, we can
-        // build the global min/max from local min/max within each segment
-        for (LeafReaderContext leaf : leaves) {
-            min = Math.min(min, NumericUtils.sortableBytesToLong(leaf.reader().getPointValues(fieldName).getMinPackedValue(), 0));
-            max = Math.max(max, NumericUtils.sortableBytesToLong(leaf.reader().getPointValues(fieldName).getMaxPackedValue(), 0));
-        }
-        createFilterForAggregations(fieldName, min, max);
-    }
-
-    private boolean isUTCTimeZone(final ZoneId zoneId) {
-        return "Z".equals(zoneId.getDisplayName(TextStyle.FULL, Locale.ENGLISH));
-    }
-
-    private void createFilterForAggregations(final String field, final long low, final long high) throws IOException {
-        long interval;
-        if (rounding instanceof Rounding.TimeUnitRounding) {
-            interval = (((Rounding.TimeUnitRounding) rounding).unit).extraLocalOffsetLookup();
-            if (!isUTCTimeZone(((Rounding.TimeUnitRounding) rounding).timeZone)) {
-                // Fast filter aggregation cannot be used if it needs time zone rounding
-                return;
-            }
-        } else if (rounding instanceof Rounding.TimeIntervalRounding) {
-            interval = ((Rounding.TimeIntervalRounding) rounding).interval;
-            if (!isUTCTimeZone(((Rounding.TimeIntervalRounding) rounding).timeZone)) {
-                // Fast filter aggregation cannot be used if it needs time zone rounding
-                return;
-            }
-        } else {
-            // Unexpected scenario, exit and fall back to original
-            return;
-        }
-
-        // Calculate the number of buckets using range and interval
-        long roundedLow = preparedRounding.round(low);
-        int bucketCount = 0;
-        while (roundedLow < high) {
-            bucketCount++;
-            // Below rounding is needed as the interval could return in
-            // non-rounded values for something like calendar month
-            roundedLow = preparedRounding.round(roundedLow + interval);
-        }
-
-        if (bucketCount > 0 && bucketCount <= MAX_NUM_FILTER_BUCKETS) {
-            int i = 0;
-            filters = new Weight[bucketCount];
-            roundedLow = preparedRounding.round(low);
-            while (i < bucketCount) {
-                // Calculate the lower bucket bound
-                final byte[] lower = new byte[8];
-                NumericUtils.longToSortableBytes(Math.max(roundedLow, low), lower, 0);
-                // Calculate the upper bucket bound
-                final byte[] upper = new byte[8];
-                roundedLow = preparedRounding.round(roundedLow + interval);
-                // Subtract -1 if the minimum is roundedLow as roundedLow itself
-                // is included in the next bucket
-                NumericUtils.longToSortableBytes(Math.min(roundedLow - 1, high), upper, 0);
-                filters[i++] = context.searcher().createWeight(new PointRangeQuery(field, lower, upper, 1) {
-                    @Override
-                    protected String toString(int dimension, byte[] value) {
-                        return null;
-                    }
-                }, ScoreMode.COMPLETE_NO_SCORES, 1);
-            }
-        }
-    }
 }
diff --git a/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/FilterRewriteHelper.java b/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/FilterRewriteHelper.java
new file mode 100644
index 0000000000000..c3a604706a289
--- /dev/null
+++ b/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/FilterRewriteHelper.java
@@ -0,0 +1,153 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.search.aggregations.bucket.histogram;
+
+import org.apache.lucene.index.LeafReaderContext;
+import org.apache.lucene.search.ConstantScoreQuery;
+import org.apache.lucene.search.IndexOrDocValuesQuery;
+import org.apache.lucene.search.PointRangeQuery;
+import org.apache.lucene.search.Query;
+import org.apache.lucene.search.ScoreMode;
+import org.apache.lucene.search.Weight;
+import org.apache.lucene.util.NumericUtils;
+import org.opensearch.common.Rounding;
+import org.opensearch.common.lucene.search.function.FunctionScoreQuery;
+import org.opensearch.index.query.DateRangeIncludingNowQuery;
+import org.opensearch.search.internal.SearchContext;
+
+import java.io.IOException;
+import java.time.ZoneId;
+import java.time.format.TextStyle;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.function.Function;
+
+public class FilterRewriteHelper {
+    private static final int MAX_NUM_FILTER_BUCKETS = 1024;
+    private static final Map<Class, Function<Query, Query>> queryWrappers;
+
+    // Initialize the wrappers map for unwrapping the query
+    static {
+        queryWrappers = new HashMap<>();
+        queryWrappers.put(ConstantScoreQuery.class, q -> ((ConstantScoreQuery) q).getQuery());
+        queryWrappers.put(FunctionScoreQuery.class, q -> ((FunctionScoreQuery) q).getSubQuery());
+        queryWrappers.put(DateRangeIncludingNowQuery.class, q -> ((DateRangeIncludingNowQuery) q).getQuery());
+        queryWrappers.put(IndexOrDocValuesQuery.class, q -> ((IndexOrDocValuesQuery) q).getIndexQuery());
+    }
+
+    /**
+     * Recursively unwraps query into the concrete form
+     * for applying the optimization
+     */
+    public static Query unwrapIntoConcreteQuery(Query query) {
+        while (queryWrappers.containsKey(query.getClass())) {
+            query = queryWrappers.get(query.getClass()).apply(query);
+        }
+
+        return query;
+    }
+
+    /**
+     * Finds the min and max bounds for segments within the passed search context
+     * and creates the weight filters using range queries within those bounds
+     */
+    public static void findBoundsAndCreateFilters(
+        final SearchContext context,
+        final Rounding rounding,
+        final Rounding.Prepared preparedRounding,
+        final String fieldName
+    ) throws IOException {
+        final List<LeafReaderContext> leaves = context.searcher().getIndexReader().leaves();
+        long min = Long.MAX_VALUE, max = Long.MIN_VALUE;
+        // Since the query does not specify bounds for aggregation, we can
+        // build the global min/max from local min/max within each segment
+        for (LeafReaderContext leaf : leaves) {
+            min = Math.min(min, NumericUtils.sortableBytesToLong(leaf.reader().getPointValues(fieldName).getMinPackedValue(), 0));
+            max = Math.max(max, NumericUtils.sortableBytesToLong(leaf.reader().getPointValues(fieldName).getMaxPackedValue(), 0));
+        }
+        createFilterForAggregations(context, rounding, preparedRounding, fieldName, min, max);
+    }
+
+    /**
+     * Helper function for checking if the time zone requested for date histogram
+     * aggregation is utc or not
+     */
+    private static boolean isUTCTimeZone(final ZoneId zoneId) {
+        return "Z".equals(zoneId.getDisplayName(TextStyle.FULL, Locale.ENGLISH));
+    }
+
+    /**
+     * Creates the range query filters for aggregations using the interval, min/max
+     * bounds and the rounding values
+     */
+    public static Weight[] createFilterForAggregations(
+        final SearchContext context,
+        final Rounding rounding,
+        final Rounding.Prepared preparedRounding,
+        final String field,
+        final long low,
+        final long high
+    ) throws IOException {
+        long interval;
+        if (rounding instanceof Rounding.TimeUnitRounding) {
+            interval = (((Rounding.TimeUnitRounding) rounding).unit).extraLocalOffsetLookup();
+            if (!isUTCTimeZone(((Rounding.TimeUnitRounding) rounding).timeZone)) {
+                // Fast filter aggregation cannot be used if it needs time zone rounding
+                return null;
+            }
+        } else if (rounding instanceof Rounding.TimeIntervalRounding) {
+            interval = ((Rounding.TimeIntervalRounding) rounding).interval;
+            if (!isUTCTimeZone(((Rounding.TimeIntervalRounding) rounding).timeZone)) {
+                // Fast filter aggregation cannot be used if it needs time zone rounding
+                return null;
+            }
+        } else {
+            // Unexpected scenario, exit and fall back to original
+            return null;
+        }
+
+        // Calculate the number of buckets using range and interval
+        long roundedLow = preparedRounding.round(low);
+        int bucketCount = 0;
+        while (roundedLow < high) {
+            bucketCount++;
+            // Below rounding is needed as the interval could return in
+            // non-rounded values for something like calendar month
+            roundedLow = preparedRounding.round(roundedLow + interval);
+        }
+
+        Weight[] filters = null;
+        if (bucketCount > 0 && bucketCount <= MAX_NUM_FILTER_BUCKETS) {
+            int i = 0;
+            filters = new Weight[bucketCount];
+            roundedLow = preparedRounding.round(low);
+            while (i < bucketCount) {
+                // Calculate the lower bucket bound
+                final byte[] lower = new byte[8];
+                NumericUtils.longToSortableBytes(Math.max(roundedLow, low), lower, 0);
+                // Calculate the upper bucket bound
+                final byte[] upper = new byte[8];
+                roundedLow = preparedRounding.round(roundedLow + interval);
+                // Subtract -1 if the minimum is roundedLow as roundedLow itself
+                // is included in the next bucket
+                NumericUtils.longToSortableBytes(Math.min(roundedLow - 1, high), upper, 0);
+                filters[i++] = context.searcher().createWeight(new PointRangeQuery(field, lower, upper, 1) {
+                    @Override
+                    protected String toString(int dimension, byte[] value) {
+                        return null;
+                    }
+                }, ScoreMode.COMPLETE_NO_SCORES, 1);
+            }
+        }
+
+        return filters;
+    }
+}

From 5f25240dbb65a3101a41295bac7d0626feaa33c4 Mon Sep 17 00:00:00 2001
From: Ankit Jain <akjain@amazon.com>
Date: Fri, 17 Nov 2023 15:05:50 +0530
Subject: [PATCH 08/21] Adding javadocs for fixing build failure

Signed-off-by: Ankit Jain <akjain@amazon.com>
---
 .../aggregations/bucket/histogram/FilterRewriteHelper.java  | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/FilterRewriteHelper.java b/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/FilterRewriteHelper.java
index c3a604706a289..26d2369a54817 100644
--- a/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/FilterRewriteHelper.java
+++ b/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/FilterRewriteHelper.java
@@ -30,6 +30,12 @@
 import java.util.Map;
 import java.util.function.Function;
 
+/**
+ * Helpers functions to rewrite and optimize aggregations using
+ * range filter queries
+ *
+ * @opensearch.internal
+ */
 public class FilterRewriteHelper {
     private static final int MAX_NUM_FILTER_BUCKETS = 1024;
     private static final Map<Class, Function<Query, Query>> queryWrappers;

From 88b7cca26955f5ea85e1cae000a75e2b69ad4968 Mon Sep 17 00:00:00 2001
From: Ankit Jain <akjain@amazon.com>
Date: Fri, 17 Nov 2023 16:28:45 +0530
Subject: [PATCH 09/21] Fixing minor bugs in refactoring

Signed-off-by: Ankit Jain <akjain@amazon.com>
---
 .../bucket/histogram/DateHistogramAggregator.java           | 6 +++---
 .../aggregations/bucket/histogram/FilterRewriteHelper.java  | 5 +++--
 2 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/DateHistogramAggregator.java b/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/DateHistogramAggregator.java
index b105654b84ea2..e1b8e4746263b 100644
--- a/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/DateHistogramAggregator.java
+++ b/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/DateHistogramAggregator.java
@@ -127,8 +127,8 @@ class DateHistogramAggregator extends BucketsAggregator implements SizedBucketAg
                 final PointRangeQuery prq = (PointRangeQuery) cq;
                 // Ensure that the query and aggregation are on the same field
                 if (prq.getField().equals(fieldName)) {
-                    FilterRewriteHelper.createFilterForAggregations(
-                        aggregationContext,
+                    filters = FilterRewriteHelper.createFilterForAggregations(
+                        context,
                         rounding,
                         preparedRounding,
                         fieldName,
@@ -137,7 +137,7 @@ class DateHistogramAggregator extends BucketsAggregator implements SizedBucketAg
                     );
                 }
             } else if (cq instanceof MatchAllDocsQuery) {
-                FilterRewriteHelper.findBoundsAndCreateFilters(context, rounding, preparedRounding, fieldName);
+                filters = FilterRewriteHelper.findBoundsAndCreateFilters(context, rounding, preparedRounding, fieldName);
             }
         }
     }
diff --git a/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/FilterRewriteHelper.java b/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/FilterRewriteHelper.java
index 26d2369a54817..76aaf68987894 100644
--- a/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/FilterRewriteHelper.java
+++ b/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/FilterRewriteHelper.java
@@ -65,7 +65,7 @@ public static Query unwrapIntoConcreteQuery(Query query) {
      * Finds the min and max bounds for segments within the passed search context
      * and creates the weight filters using range queries within those bounds
      */
-    public static void findBoundsAndCreateFilters(
+    public static Weight[] findBoundsAndCreateFilters(
         final SearchContext context,
         final Rounding rounding,
         final Rounding.Prepared preparedRounding,
@@ -79,7 +79,8 @@ public static void findBoundsAndCreateFilters(
             min = Math.min(min, NumericUtils.sortableBytesToLong(leaf.reader().getPointValues(fieldName).getMinPackedValue(), 0));
             max = Math.max(max, NumericUtils.sortableBytesToLong(leaf.reader().getPointValues(fieldName).getMaxPackedValue(), 0));
         }
-        createFilterForAggregations(context, rounding, preparedRounding, fieldName, min, max);
+        
+        return createFilterForAggregations(context, rounding, preparedRounding, fieldName, min, max);
     }
 
     /**

From 0c27add46d16c6ba05a231f19f1e2150e671c0b5 Mon Sep 17 00:00:00 2001
From: Ankit Jain <akjain@amazon.com>
Date: Sat, 18 Nov 2023 17:39:40 +0530
Subject: [PATCH 10/21] Adding logic for optimizing auto date histogram

Signed-off-by: Ankit Jain <akjain@amazon.com>
---
 .../AutoDateHistogramAggregator.java          | 86 ++++++++++++++++++-
 .../histogram/DateHistogramAggregator.java    | 28 +++---
 .../bucket/histogram/FilterRewriteHelper.java | 42 ++++++---
 3 files changed, 123 insertions(+), 33 deletions(-)

diff --git a/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/AutoDateHistogramAggregator.java b/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/AutoDateHistogramAggregator.java
index b4f1e78f77aaf..feaf3877b5be9 100644
--- a/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/AutoDateHistogramAggregator.java
+++ b/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/AutoDateHistogramAggregator.java
@@ -33,8 +33,12 @@
 
 import org.apache.lucene.index.LeafReaderContext;
 import org.apache.lucene.index.SortedNumericDocValues;
+import org.apache.lucene.search.CollectionTerminatedException;
+import org.apache.lucene.search.PointRangeQuery;
 import org.apache.lucene.search.ScoreMode;
+import org.apache.lucene.search.Weight;
 import org.apache.lucene.util.CollectionUtil;
+import org.apache.lucene.util.NumericUtils;
 import org.opensearch.common.Rounding;
 import org.opensearch.common.Rounding.Prepared;
 import org.opensearch.common.lease.Releasables;
@@ -169,14 +173,14 @@ public final DeferringBucketCollector getDeferringCollector() {
         return deferringCollector;
     }
 
-    protected abstract LeafBucketCollector getLeafCollector(SortedNumericDocValues values, LeafBucketCollector sub) throws IOException;
+    protected abstract LeafBucketCollector getLeafCollector2(LeafReaderContext ctx, LeafBucketCollector sub) throws IOException;
 
     @Override
     public final LeafBucketCollector getLeafCollector(LeafReaderContext ctx, LeafBucketCollector sub) throws IOException {
         if (valuesSource == null) {
             return LeafBucketCollector.NO_OP_COLLECTOR;
         }
-        return getLeafCollector(valuesSource.longValues(ctx), sub);
+        return getLeafCollector2(ctx, sub);
     }
 
     protected final InternalAggregation[] buildAggregations(
@@ -263,6 +267,9 @@ private static class FromSingle extends AutoDateHistogramAggregator {
         private long min = Long.MAX_VALUE;
         private long max = Long.MIN_VALUE;
 
+        private Weight[] filters = null;
+        private final ValuesSource.Numeric valuesSource;
+
         FromSingle(
             String name,
             AggregatorFactories factories,
@@ -288,13 +295,80 @@ private static class FromSingle extends AutoDateHistogramAggregator {
 
             preparedRounding = prepareRounding(0);
             bucketOrds = new LongKeyedBucketOrds.FromSingle(context.bigArrays());
+
+            this.valuesSource = valuesSourceConfig.hasValues() ? (ValuesSource.Numeric) valuesSourceConfig.getValuesSource() : null;
+            // Create the filters for fast aggregation only if the query is instance
+            // of point range query and there aren't any parent/sub aggregations
+            if (parent() == null && subAggregators.length == 0) {
+                final String fieldName = valuesSourceConfig.fieldContext().field();
+                final long[] bounds = FilterRewriteHelper.getAggregationBounds(context, fieldName);
+                if (bounds != null) {
+                    final Rounding rounding = getMinimumRounding(bounds[0], bounds[1]);
+                    filters = FilterRewriteHelper.createFilterForAggregations(context, rounding, preparedRounding, fieldName, bounds[0], bounds[1]);
+                }
+            }
+        }
+
+        private Rounding getMinimumRounding(final long low, final long high) {
+            // max - min / targetBuckets = bestDuration
+            // find the right innerInterval this bestDuration belongs to
+            // since we cannot exceed targetBuckets, bestDuration should go up,
+            // so the right innerInterval should be an upper bound
+            long bestDuration = (high - low) / targetBuckets;
+            while (roundingIdx < roundingInfos.length - 1) {
+                final RoundingInfo curRoundingInfo = roundingInfos[roundingIdx];
+                final int temp = curRoundingInfo.innerIntervals[curRoundingInfo.innerIntervals.length-1];
+                // If the interval duration is covered by the maximum inner interval,
+                // we can start with this outer interval for creating the buckets
+                if (bestDuration <= temp * curRoundingInfo.roughEstimateDurationMillis) {
+                    break;
+                }
+                roundingIdx++;
+            }
+
+            preparedRounding = prepareRounding(roundingIdx);
+            return roundingInfos[roundingIdx].rounding;
+        }
+
+        boolean tryFastFilterAggregation(LeafReaderContext ctx, long owningBucketOrd) throws IOException {
+            final int[] counts = new int[filters.length];
+            int i;
+            for (i = 0; i < filters.length; i++) {
+                counts[i] = filters[i].count(ctx);
+                if (counts[i] == -1) {
+                    // Cannot use the optimization if any of the counts
+                    // is -1 indicating the segment might have deleted documents
+                    return false;
+                }
+            }
+
+            for (i = 0; i < filters.length; i++) {
+                long bucketOrd = bucketOrds.add(
+                    owningBucketOrd,
+                    preparedRounding.round(NumericUtils.sortableBytesToLong(((PointRangeQuery) filters[i].getQuery()).getLowerPoint(), 0))
+                );
+                if (bucketOrd < 0) { // already seen
+                    bucketOrd = -1 - bucketOrd;
+                }
+                incrementBucketDocCount(bucketOrd, counts[i]);
+            }
+            throw new CollectionTerminatedException();
         }
 
         @Override
-        protected LeafBucketCollector getLeafCollector(SortedNumericDocValues values, LeafBucketCollector sub) throws IOException {
+        protected LeafBucketCollector getLeafCollector2(LeafReaderContext ctx, LeafBucketCollector sub) throws IOException {
+            SortedNumericDocValues values = valuesSource.longValues(ctx);
+
+            final boolean[] useOpt = new boolean[1];
+            useOpt[0] = filters != null;
+
             return new LeafBucketCollectorBase(sub, values) {
                 @Override
                 public void collect(int doc, long owningBucketOrd) throws IOException {
+                    if (useOpt[0]) {
+                        useOpt[0] = tryFastFilterAggregation(ctx, owningBucketOrd);
+                    }
+
                     assert owningBucketOrd == 0;
                     if (false == values.advanceExact(doc)) {
                         return;
@@ -471,6 +545,8 @@ private static class FromMany extends AutoDateHistogramAggregator {
          */
         private int rebucketCount = 0;
 
+        private final ValuesSource.Numeric valuesSource;
+
         FromMany(
             String name,
             AggregatorFactories factories,
@@ -505,10 +581,12 @@ private static class FromMany extends AutoDateHistogramAggregator {
             preparedRoundings[0] = roundingPreparer.apply(roundingInfos[0].rounding);
             bucketOrds = new LongKeyedBucketOrds.FromMany(context.bigArrays());
             liveBucketCountUnderestimate = context.bigArrays().newIntArray(1, true);
+            this.valuesSource = valuesSourceConfig.hasValues() ? (ValuesSource.Numeric) valuesSourceConfig.getValuesSource() : null;
         }
 
         @Override
-        protected LeafBucketCollector getLeafCollector(SortedNumericDocValues values, LeafBucketCollector sub) throws IOException {
+        protected LeafBucketCollector getLeafCollector2(LeafReaderContext ctx, LeafBucketCollector sub) throws IOException {
+            SortedNumericDocValues values = valuesSource.longValues(ctx);
             return new LeafBucketCollectorBase(sub, values) {
                 @Override
                 public void collect(int doc, long owningBucketOrd) throws IOException {
diff --git a/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/DateHistogramAggregator.java b/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/DateHistogramAggregator.java
index e1b8e4746263b..d796b1fa253f5 100644
--- a/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/DateHistogramAggregator.java
+++ b/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/DateHistogramAggregator.java
@@ -34,9 +34,7 @@
 import org.apache.lucene.index.LeafReaderContext;
 import org.apache.lucene.index.SortedNumericDocValues;
 import org.apache.lucene.search.CollectionTerminatedException;
-import org.apache.lucene.search.MatchAllDocsQuery;
 import org.apache.lucene.search.PointRangeQuery;
-import org.apache.lucene.search.Query;
 import org.apache.lucene.search.ScoreMode;
 import org.apache.lucene.search.Weight;
 import org.apache.lucene.util.CollectionUtil;
@@ -122,22 +120,16 @@ class DateHistogramAggregator extends BucketsAggregator implements SizedBucketAg
         // of point range query and there aren't any parent/sub aggregations
         if (parent() == null && subAggregators.length == 0) {
             final String fieldName = valuesSourceConfig.fieldContext().field();
-            final Query cq = FilterRewriteHelper.unwrapIntoConcreteQuery(context.query());
-            if (cq instanceof PointRangeQuery) {
-                final PointRangeQuery prq = (PointRangeQuery) cq;
-                // Ensure that the query and aggregation are on the same field
-                if (prq.getField().equals(fieldName)) {
-                    filters = FilterRewriteHelper.createFilterForAggregations(
-                        context,
-                        rounding,
-                        preparedRounding,
-                        fieldName,
-                        NumericUtils.sortableBytesToLong(prq.getLowerPoint(), 0),
-                        NumericUtils.sortableBytesToLong(prq.getUpperPoint(), 0)
-                    );
-                }
-            } else if (cq instanceof MatchAllDocsQuery) {
-                filters = FilterRewriteHelper.findBoundsAndCreateFilters(context, rounding, preparedRounding, fieldName);
+            final long[] bounds = FilterRewriteHelper.getAggregationBounds(context, fieldName);
+            if (bounds != null) {
+                filters = FilterRewriteHelper.createFilterForAggregations(
+                    context,
+                    rounding,
+                    preparedRounding,
+                    fieldName,
+                    bounds[0],
+                    bounds[1]
+                );
             }
         }
     }
diff --git a/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/FilterRewriteHelper.java b/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/FilterRewriteHelper.java
index 76aaf68987894..72fc00789c950 100644
--- a/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/FilterRewriteHelper.java
+++ b/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/FilterRewriteHelper.java
@@ -11,6 +11,7 @@
 import org.apache.lucene.index.LeafReaderContext;
 import org.apache.lucene.search.ConstantScoreQuery;
 import org.apache.lucene.search.IndexOrDocValuesQuery;
+import org.apache.lucene.search.MatchAllDocsQuery;
 import org.apache.lucene.search.PointRangeQuery;
 import org.apache.lucene.search.Query;
 import org.apache.lucene.search.ScoreMode;
@@ -63,14 +64,8 @@ public static Query unwrapIntoConcreteQuery(Query query) {
 
     /**
      * Finds the min and max bounds for segments within the passed search context
-     * and creates the weight filters using range queries within those bounds
      */
-    public static Weight[] findBoundsAndCreateFilters(
-        final SearchContext context,
-        final Rounding rounding,
-        final Rounding.Prepared preparedRounding,
-        final String fieldName
-    ) throws IOException {
+    private static long[] getIndexBoundsFromLeaves(final SearchContext context, final String fieldName) throws IOException {
         final List<LeafReaderContext> leaves = context.searcher().getIndexReader().leaves();
         long min = Long.MAX_VALUE, max = Long.MIN_VALUE;
         // Since the query does not specify bounds for aggregation, we can
@@ -79,8 +74,29 @@ public static Weight[] findBoundsAndCreateFilters(
             min = Math.min(min, NumericUtils.sortableBytesToLong(leaf.reader().getPointValues(fieldName).getMinPackedValue(), 0));
             max = Math.max(max, NumericUtils.sortableBytesToLong(leaf.reader().getPointValues(fieldName).getMaxPackedValue(), 0));
         }
-        
-        return createFilterForAggregations(context, rounding, preparedRounding, fieldName, min, max);
+
+        return new long[] { min, max };
+    }
+
+    public static long[] getAggregationBounds(final SearchContext context, final String fieldName) throws IOException {
+        final Query cq = unwrapIntoConcreteQuery(context.query());
+        final long[] indexBounds = getIndexBoundsFromLeaves(context, fieldName);
+        if (cq instanceof PointRangeQuery) {
+            final PointRangeQuery prq = (PointRangeQuery) cq;
+            // Ensure that the query and aggregation are on the same field
+            if (prq.getField().equals(fieldName)) {
+                return new long[] {
+                    // Minimum bound for aggregation is the max between query and global
+                    Math.max(NumericUtils.sortableBytesToLong(prq.getLowerPoint(), 0), indexBounds[0]),
+                    // Maximum bound for aggregation is the min between query and global
+                    Math.min(NumericUtils.sortableBytesToLong(prq.getUpperPoint(), 0), indexBounds[1])
+                };
+            }
+        } else if (cq instanceof MatchAllDocsQuery) {
+            return indexBounds;
+        }
+
+        return null;
     }
 
     /**
@@ -123,12 +139,16 @@ public static Weight[] createFilterForAggregations(
 
         // Calculate the number of buckets using range and interval
         long roundedLow = preparedRounding.round(low);
+        long prevRounded = roundedLow;
         int bucketCount = 0;
         while (roundedLow < high) {
             bucketCount++;
             // Below rounding is needed as the interval could return in
             // non-rounded values for something like calendar month
             roundedLow = preparedRounding.round(roundedLow + interval);
+            if (prevRounded == roundedLow)
+                break;
+            prevRounded = roundedLow;
         }
 
         Weight[] filters = null;
@@ -139,13 +159,13 @@ public static Weight[] createFilterForAggregations(
             while (i < bucketCount) {
                 // Calculate the lower bucket bound
                 final byte[] lower = new byte[8];
-                NumericUtils.longToSortableBytes(Math.max(roundedLow, low), lower, 0);
+                NumericUtils.longToSortableBytes(i==0 ? low : roundedLow, lower, 0);
                 // Calculate the upper bucket bound
                 final byte[] upper = new byte[8];
                 roundedLow = preparedRounding.round(roundedLow + interval);
                 // Subtract -1 if the minimum is roundedLow as roundedLow itself
                 // is included in the next bucket
-                NumericUtils.longToSortableBytes(Math.min(roundedLow - 1, high), upper, 0);
+                NumericUtils.longToSortableBytes(i+1==bucketCount ? high : roundedLow - 1, upper, 0);
                 filters[i++] = context.searcher().createWeight(new PointRangeQuery(field, lower, upper, 1) {
                     @Override
                     protected String toString(int dimension, byte[] value) {

From c19f785e74a7618a5249bbc569a5d34393f2808d Mon Sep 17 00:00:00 2001
From: Ankit Jain <akjain@amazon.com>
Date: Mon, 20 Nov 2023 13:37:51 +0530
Subject: [PATCH 11/21] Fixing bugs and passing unit tests for date histogram

Signed-off-by: Ankit Jain <akjain@amazon.com>
---
 .../index/mapper/DateFieldMapper.java         | 10 +++++
 .../AutoDateHistogramAggregator.java          | 35 ++++++++++++++----
 .../histogram/DateHistogramAggregator.java    | 37 +++++++++++++------
 .../bucket/histogram/FilterRewriteHelper.java | 32 ++++++++++------
 4 files changed, 84 insertions(+), 30 deletions(-)

diff --git a/server/src/main/java/org/opensearch/index/mapper/DateFieldMapper.java b/server/src/main/java/org/opensearch/index/mapper/DateFieldMapper.java
index 3b832628695fe..d98e6ea6af83d 100644
--- a/server/src/main/java/org/opensearch/index/mapper/DateFieldMapper.java
+++ b/server/src/main/java/org/opensearch/index/mapper/DateFieldMapper.java
@@ -409,6 +409,16 @@ public long parse(String value) {
             return resolution.convert(DateFormatters.from(dateTimeFormatter().parse(value), dateTimeFormatter().locale()).toInstant());
         }
 
+        public long convertNanosToMillis(long nanoSecondsSinceEpoch) {
+            if (resolution.numericType.equals(NumericType.DATE_NANOSECONDS)) return DateUtils.toMilliSeconds(nanoSecondsSinceEpoch);
+            return nanoSecondsSinceEpoch;
+        }
+
+        public long convertRoundedMillisToNanos(long milliSecondsSinceEpoch) {
+            if (resolution.numericType.equals(NumericType.DATE_NANOSECONDS)) return DateUtils.toNanoSeconds(milliSecondsSinceEpoch);
+            return milliSecondsSinceEpoch;
+        }
+
         @Override
         public ValueFetcher valueFetcher(QueryShardContext context, SearchLookup searchLookup, String format) {
             DateFormatter defaultFormatter = dateTimeFormatter();
diff --git a/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/AutoDateHistogramAggregator.java b/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/AutoDateHistogramAggregator.java
index feaf3877b5be9..ef483aa7b5c61 100644
--- a/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/AutoDateHistogramAggregator.java
+++ b/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/AutoDateHistogramAggregator.java
@@ -45,6 +45,7 @@
 import org.opensearch.common.util.IntArray;
 import org.opensearch.common.util.LongArray;
 import org.opensearch.core.common.util.ByteArray;
+import org.opensearch.index.mapper.DateFieldMapper;
 import org.opensearch.search.DocValueFormat;
 import org.opensearch.search.aggregations.Aggregator;
 import org.opensearch.search.aggregations.AggregatorFactories;
@@ -58,6 +59,7 @@
 import org.opensearch.search.aggregations.bucket.MergingBucketsDeferringCollector;
 import org.opensearch.search.aggregations.bucket.histogram.AutoDateHistogramAggregationBuilder.RoundingInfo;
 import org.opensearch.search.aggregations.bucket.terms.LongKeyedBucketOrds;
+import org.opensearch.search.aggregations.support.FieldContext;
 import org.opensearch.search.aggregations.support.ValuesSource;
 import org.opensearch.search.aggregations.support.ValuesSourceConfig;
 import org.opensearch.search.internal.SearchContext;
@@ -269,6 +271,7 @@ private static class FromSingle extends AutoDateHistogramAggregator {
 
         private Weight[] filters = null;
         private final ValuesSource.Numeric valuesSource;
+        private DateFieldMapper.DateFieldType fieldType;
 
         FromSingle(
             String name,
@@ -300,11 +303,25 @@ private static class FromSingle extends AutoDateHistogramAggregator {
             // Create the filters for fast aggregation only if the query is instance
             // of point range query and there aren't any parent/sub aggregations
             if (parent() == null && subAggregators.length == 0) {
-                final String fieldName = valuesSourceConfig.fieldContext().field();
-                final long[] bounds = FilterRewriteHelper.getAggregationBounds(context, fieldName);
-                if (bounds != null) {
-                    final Rounding rounding = getMinimumRounding(bounds[0], bounds[1]);
-                    filters = FilterRewriteHelper.createFilterForAggregations(context, rounding, preparedRounding, fieldName, bounds[0], bounds[1]);
+                final FieldContext fieldContext = valuesSourceConfig.fieldContext();
+                if (fieldContext != null) {
+                    final String fieldName = fieldContext.field();
+                    final long[] bounds = FilterRewriteHelper.getAggregationBounds(context, fieldName);
+                    if (bounds != null) {
+                        assert fieldContext.fieldType() instanceof DateFieldMapper.DateFieldType;
+                        fieldType = (DateFieldMapper.DateFieldType) fieldContext.fieldType();
+                        // TODO: Use millis bound?
+                        final Rounding rounding = getMinimumRounding(bounds[0], bounds[1]);
+                        filters = FilterRewriteHelper.createFilterForAggregations(
+                            context,
+                            rounding,
+                            preparedRounding,
+                            fieldName,
+                            fieldType,
+                            bounds[0],
+                            bounds[1]
+                        );
+                    }
                 }
             }
         }
@@ -317,7 +334,7 @@ private Rounding getMinimumRounding(final long low, final long high) {
             long bestDuration = (high - low) / targetBuckets;
             while (roundingIdx < roundingInfos.length - 1) {
                 final RoundingInfo curRoundingInfo = roundingInfos[roundingIdx];
-                final int temp = curRoundingInfo.innerIntervals[curRoundingInfo.innerIntervals.length-1];
+                final int temp = curRoundingInfo.innerIntervals[curRoundingInfo.innerIntervals.length - 1];
                 // If the interval duration is covered by the maximum inner interval,
                 // we can start with this outer interval for creating the buckets
                 if (bestDuration <= temp * curRoundingInfo.roughEstimateDurationMillis) {
@@ -345,7 +362,11 @@ boolean tryFastFilterAggregation(LeafReaderContext ctx, long owningBucketOrd) th
             for (i = 0; i < filters.length; i++) {
                 long bucketOrd = bucketOrds.add(
                     owningBucketOrd,
-                    preparedRounding.round(NumericUtils.sortableBytesToLong(((PointRangeQuery) filters[i].getQuery()).getLowerPoint(), 0))
+                    preparedRounding.round(
+                        fieldType.convertNanosToMillis(
+                            NumericUtils.sortableBytesToLong(((PointRangeQuery) filters[i].getQuery()).getLowerPoint(), 0)
+                        )
+                    )
                 );
                 if (bucketOrd < 0) { // already seen
                     bucketOrd = -1 - bucketOrd;
diff --git a/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/DateHistogramAggregator.java b/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/DateHistogramAggregator.java
index d796b1fa253f5..59c508fa3a5ea 100644
--- a/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/DateHistogramAggregator.java
+++ b/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/DateHistogramAggregator.java
@@ -42,6 +42,7 @@
 import org.opensearch.common.Nullable;
 import org.opensearch.common.Rounding;
 import org.opensearch.common.lease.Releasables;
+import org.opensearch.index.mapper.DateFieldMapper;
 import org.opensearch.search.DocValueFormat;
 import org.opensearch.search.aggregations.Aggregator;
 import org.opensearch.search.aggregations.AggregatorFactories;
@@ -52,6 +53,7 @@
 import org.opensearch.search.aggregations.LeafBucketCollectorBase;
 import org.opensearch.search.aggregations.bucket.BucketsAggregator;
 import org.opensearch.search.aggregations.bucket.terms.LongKeyedBucketOrds;
+import org.opensearch.search.aggregations.support.FieldContext;
 import org.opensearch.search.aggregations.support.ValuesSource;
 import org.opensearch.search.aggregations.support.ValuesSourceConfig;
 import org.opensearch.search.internal.SearchContext;
@@ -84,6 +86,7 @@ class DateHistogramAggregator extends BucketsAggregator implements SizedBucketAg
     private final LongBounds hardBounds;
     private Weight[] filters = null;
     private final LongKeyedBucketOrds bucketOrds;
+    private DateFieldMapper.DateFieldType fieldType;
 
     DateHistogramAggregator(
         String name,
@@ -119,17 +122,23 @@ class DateHistogramAggregator extends BucketsAggregator implements SizedBucketAg
         // Create the filters for fast aggregation only if the query is instance
         // of point range query and there aren't any parent/sub aggregations
         if (parent() == null && subAggregators.length == 0) {
-            final String fieldName = valuesSourceConfig.fieldContext().field();
-            final long[] bounds = FilterRewriteHelper.getAggregationBounds(context, fieldName);
-            if (bounds != null) {
-                filters = FilterRewriteHelper.createFilterForAggregations(
-                    context,
-                    rounding,
-                    preparedRounding,
-                    fieldName,
-                    bounds[0],
-                    bounds[1]
-                );
+            final FieldContext fieldContext = valuesSourceConfig.fieldContext();
+            if (fieldContext != null) {
+                final String fieldName = fieldContext.field();
+                final long[] bounds = FilterRewriteHelper.getAggregationBounds(context, fieldName);
+                if (bounds != null) {
+                    assert fieldContext.fieldType() instanceof DateFieldMapper.DateFieldType;
+                    fieldType = (DateFieldMapper.DateFieldType) fieldContext.fieldType();
+                    filters = FilterRewriteHelper.createFilterForAggregations(
+                        context,
+                        rounding,
+                        preparedRounding,
+                        fieldName,
+                        fieldType,
+                        bounds[0],
+                        bounds[1]
+                    );
+                }
             }
         }
     }
@@ -272,7 +281,11 @@ private boolean tryFastFilterAggregation(LeafReaderContext ctx, long owningBucke
         for (i = 0; i < filters.length; i++) {
             long bucketOrd = bucketOrds.add(
                 owningBucketOrd,
-                preparedRounding.round(NumericUtils.sortableBytesToLong(((PointRangeQuery) filters[i].getQuery()).getLowerPoint(), 0))
+                preparedRounding.round(
+                    fieldType.convertNanosToMillis(
+                        NumericUtils.sortableBytesToLong(((PointRangeQuery) filters[i].getQuery()).getLowerPoint(), 0)
+                    )
+                )
             );
             if (bucketOrd < 0) { // already seen
                 bucketOrd = -1 - bucketOrd;
diff --git a/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/FilterRewriteHelper.java b/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/FilterRewriteHelper.java
index 72fc00789c950..a6b0dc686099c 100644
--- a/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/FilterRewriteHelper.java
+++ b/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/FilterRewriteHelper.java
@@ -9,6 +9,7 @@
 package org.opensearch.search.aggregations.bucket.histogram;
 
 import org.apache.lucene.index.LeafReaderContext;
+import org.apache.lucene.index.PointValues;
 import org.apache.lucene.search.ConstantScoreQuery;
 import org.apache.lucene.search.IndexOrDocValuesQuery;
 import org.apache.lucene.search.MatchAllDocsQuery;
@@ -19,6 +20,7 @@
 import org.apache.lucene.util.NumericUtils;
 import org.opensearch.common.Rounding;
 import org.opensearch.common.lucene.search.function.FunctionScoreQuery;
+import org.opensearch.index.mapper.DateFieldMapper;
 import org.opensearch.index.query.DateRangeIncludingNowQuery;
 import org.opensearch.search.internal.SearchContext;
 
@@ -71,10 +73,15 @@ private static long[] getIndexBoundsFromLeaves(final SearchContext context, fina
         // Since the query does not specify bounds for aggregation, we can
         // build the global min/max from local min/max within each segment
         for (LeafReaderContext leaf : leaves) {
-            min = Math.min(min, NumericUtils.sortableBytesToLong(leaf.reader().getPointValues(fieldName).getMinPackedValue(), 0));
-            max = Math.max(max, NumericUtils.sortableBytesToLong(leaf.reader().getPointValues(fieldName).getMaxPackedValue(), 0));
+            final PointValues values = leaf.reader().getPointValues(fieldName);
+            if (values != null) {
+                min = Math.min(min, NumericUtils.sortableBytesToLong(values.getMinPackedValue(), 0));
+                max = Math.max(max, NumericUtils.sortableBytesToLong(values.getMaxPackedValue(), 0));
+            }
         }
 
+        if (min == Long.MAX_VALUE || max == Long.MIN_VALUE) return null;
+
         return new long[] { min, max };
     }
 
@@ -89,8 +96,7 @@ public static long[] getAggregationBounds(final SearchContext context, final Str
                     // Minimum bound for aggregation is the max between query and global
                     Math.max(NumericUtils.sortableBytesToLong(prq.getLowerPoint(), 0), indexBounds[0]),
                     // Maximum bound for aggregation is the min between query and global
-                    Math.min(NumericUtils.sortableBytesToLong(prq.getUpperPoint(), 0), indexBounds[1])
-                };
+                    Math.min(NumericUtils.sortableBytesToLong(prq.getUpperPoint(), 0), indexBounds[1]) };
             }
         } else if (cq instanceof MatchAllDocsQuery) {
             return indexBounds;
@@ -116,6 +122,7 @@ public static Weight[] createFilterForAggregations(
         final Rounding rounding,
         final Rounding.Prepared preparedRounding,
         final String field,
+        final DateFieldMapper.DateFieldType fieldType,
         final long low,
         final long high
     ) throws IOException {
@@ -138,16 +145,15 @@ public static Weight[] createFilterForAggregations(
         }
 
         // Calculate the number of buckets using range and interval
-        long roundedLow = preparedRounding.round(low);
+        long roundedLow = preparedRounding.round(fieldType.convertNanosToMillis(low));
         long prevRounded = roundedLow;
         int bucketCount = 0;
-        while (roundedLow < high) {
+        while (roundedLow <= fieldType.convertNanosToMillis(high)) {
             bucketCount++;
             // Below rounding is needed as the interval could return in
             // non-rounded values for something like calendar month
             roundedLow = preparedRounding.round(roundedLow + interval);
-            if (prevRounded == roundedLow)
-                break;
+            if (prevRounded == roundedLow) break;
             prevRounded = roundedLow;
         }
 
@@ -155,17 +161,21 @@ public static Weight[] createFilterForAggregations(
         if (bucketCount > 0 && bucketCount <= MAX_NUM_FILTER_BUCKETS) {
             int i = 0;
             filters = new Weight[bucketCount];
-            roundedLow = preparedRounding.round(low);
+            roundedLow = preparedRounding.round(fieldType.convertNanosToMillis(low));
             while (i < bucketCount) {
                 // Calculate the lower bucket bound
                 final byte[] lower = new byte[8];
-                NumericUtils.longToSortableBytes(i==0 ? low : roundedLow, lower, 0);
+                NumericUtils.longToSortableBytes(i == 0 ? low : fieldType.convertRoundedMillisToNanos(roundedLow), lower, 0);
                 // Calculate the upper bucket bound
                 final byte[] upper = new byte[8];
                 roundedLow = preparedRounding.round(roundedLow + interval);
                 // Subtract -1 if the minimum is roundedLow as roundedLow itself
                 // is included in the next bucket
-                NumericUtils.longToSortableBytes(i+1==bucketCount ? high : roundedLow - 1, upper, 0);
+                NumericUtils.longToSortableBytes(
+                    i + 1 == bucketCount ? high : fieldType.convertRoundedMillisToNanos(roundedLow) - 1,
+                    upper,
+                    0
+                );
                 filters[i++] = context.searcher().createWeight(new PointRangeQuery(field, lower, upper, 1) {
                     @Override
                     protected String toString(int dimension, byte[] value) {

From e900f8e625195d6846fcaef0693d4b0e1a418a5c Mon Sep 17 00:00:00 2001
From: Ankit Jain <akjain@amazon.com>
Date: Mon, 20 Nov 2023 14:46:29 +0530
Subject: [PATCH 12/21] Temporarily reverting auto date histogram changes

Signed-off-by: Ankit Jain <akjain@amazon.com>
---
 .../AutoDateHistogramAggregator.java          | 102 +-----------------
 1 file changed, 4 insertions(+), 98 deletions(-)

diff --git a/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/AutoDateHistogramAggregator.java b/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/AutoDateHistogramAggregator.java
index ef483aa7b5c61..254eba4aaee6a 100644
--- a/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/AutoDateHistogramAggregator.java
+++ b/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/AutoDateHistogramAggregator.java
@@ -33,19 +33,14 @@
 
 import org.apache.lucene.index.LeafReaderContext;
 import org.apache.lucene.index.SortedNumericDocValues;
-import org.apache.lucene.search.CollectionTerminatedException;
-import org.apache.lucene.search.PointRangeQuery;
 import org.apache.lucene.search.ScoreMode;
-import org.apache.lucene.search.Weight;
 import org.apache.lucene.util.CollectionUtil;
-import org.apache.lucene.util.NumericUtils;
 import org.opensearch.common.Rounding;
 import org.opensearch.common.Rounding.Prepared;
 import org.opensearch.common.lease.Releasables;
 import org.opensearch.common.util.IntArray;
 import org.opensearch.common.util.LongArray;
 import org.opensearch.core.common.util.ByteArray;
-import org.opensearch.index.mapper.DateFieldMapper;
 import org.opensearch.search.DocValueFormat;
 import org.opensearch.search.aggregations.Aggregator;
 import org.opensearch.search.aggregations.AggregatorFactories;
@@ -59,7 +54,6 @@
 import org.opensearch.search.aggregations.bucket.MergingBucketsDeferringCollector;
 import org.opensearch.search.aggregations.bucket.histogram.AutoDateHistogramAggregationBuilder.RoundingInfo;
 import org.opensearch.search.aggregations.bucket.terms.LongKeyedBucketOrds;
-import org.opensearch.search.aggregations.support.FieldContext;
 import org.opensearch.search.aggregations.support.ValuesSource;
 import org.opensearch.search.aggregations.support.ValuesSourceConfig;
 import org.opensearch.search.internal.SearchContext;
@@ -175,14 +169,14 @@ public final DeferringBucketCollector getDeferringCollector() {
         return deferringCollector;
     }
 
-    protected abstract LeafBucketCollector getLeafCollector2(LeafReaderContext ctx, LeafBucketCollector sub) throws IOException;
+    protected abstract LeafBucketCollector getLeafCollector(SortedNumericDocValues values, LeafBucketCollector sub) throws IOException;
 
     @Override
     public final LeafBucketCollector getLeafCollector(LeafReaderContext ctx, LeafBucketCollector sub) throws IOException {
         if (valuesSource == null) {
             return LeafBucketCollector.NO_OP_COLLECTOR;
         }
-        return getLeafCollector2(ctx, sub);
+        return getLeafCollector(valuesSource.longValues(ctx), sub);
     }
 
     protected final InternalAggregation[] buildAggregations(
@@ -269,9 +263,7 @@ private static class FromSingle extends AutoDateHistogramAggregator {
         private long min = Long.MAX_VALUE;
         private long max = Long.MIN_VALUE;
 
-        private Weight[] filters = null;
         private final ValuesSource.Numeric valuesSource;
-        private DateFieldMapper.DateFieldType fieldType;
 
         FromSingle(
             String name,
@@ -300,96 +292,13 @@ private static class FromSingle extends AutoDateHistogramAggregator {
             bucketOrds = new LongKeyedBucketOrds.FromSingle(context.bigArrays());
 
             this.valuesSource = valuesSourceConfig.hasValues() ? (ValuesSource.Numeric) valuesSourceConfig.getValuesSource() : null;
-            // Create the filters for fast aggregation only if the query is instance
-            // of point range query and there aren't any parent/sub aggregations
-            if (parent() == null && subAggregators.length == 0) {
-                final FieldContext fieldContext = valuesSourceConfig.fieldContext();
-                if (fieldContext != null) {
-                    final String fieldName = fieldContext.field();
-                    final long[] bounds = FilterRewriteHelper.getAggregationBounds(context, fieldName);
-                    if (bounds != null) {
-                        assert fieldContext.fieldType() instanceof DateFieldMapper.DateFieldType;
-                        fieldType = (DateFieldMapper.DateFieldType) fieldContext.fieldType();
-                        // TODO: Use millis bound?
-                        final Rounding rounding = getMinimumRounding(bounds[0], bounds[1]);
-                        filters = FilterRewriteHelper.createFilterForAggregations(
-                            context,
-                            rounding,
-                            preparedRounding,
-                            fieldName,
-                            fieldType,
-                            bounds[0],
-                            bounds[1]
-                        );
-                    }
-                }
-            }
-        }
-
-        private Rounding getMinimumRounding(final long low, final long high) {
-            // max - min / targetBuckets = bestDuration
-            // find the right innerInterval this bestDuration belongs to
-            // since we cannot exceed targetBuckets, bestDuration should go up,
-            // so the right innerInterval should be an upper bound
-            long bestDuration = (high - low) / targetBuckets;
-            while (roundingIdx < roundingInfos.length - 1) {
-                final RoundingInfo curRoundingInfo = roundingInfos[roundingIdx];
-                final int temp = curRoundingInfo.innerIntervals[curRoundingInfo.innerIntervals.length - 1];
-                // If the interval duration is covered by the maximum inner interval,
-                // we can start with this outer interval for creating the buckets
-                if (bestDuration <= temp * curRoundingInfo.roughEstimateDurationMillis) {
-                    break;
-                }
-                roundingIdx++;
-            }
-
-            preparedRounding = prepareRounding(roundingIdx);
-            return roundingInfos[roundingIdx].rounding;
-        }
-
-        boolean tryFastFilterAggregation(LeafReaderContext ctx, long owningBucketOrd) throws IOException {
-            final int[] counts = new int[filters.length];
-            int i;
-            for (i = 0; i < filters.length; i++) {
-                counts[i] = filters[i].count(ctx);
-                if (counts[i] == -1) {
-                    // Cannot use the optimization if any of the counts
-                    // is -1 indicating the segment might have deleted documents
-                    return false;
-                }
-            }
-
-            for (i = 0; i < filters.length; i++) {
-                long bucketOrd = bucketOrds.add(
-                    owningBucketOrd,
-                    preparedRounding.round(
-                        fieldType.convertNanosToMillis(
-                            NumericUtils.sortableBytesToLong(((PointRangeQuery) filters[i].getQuery()).getLowerPoint(), 0)
-                        )
-                    )
-                );
-                if (bucketOrd < 0) { // already seen
-                    bucketOrd = -1 - bucketOrd;
-                }
-                incrementBucketDocCount(bucketOrd, counts[i]);
-            }
-            throw new CollectionTerminatedException();
         }
 
         @Override
-        protected LeafBucketCollector getLeafCollector2(LeafReaderContext ctx, LeafBucketCollector sub) throws IOException {
-            SortedNumericDocValues values = valuesSource.longValues(ctx);
-
-            final boolean[] useOpt = new boolean[1];
-            useOpt[0] = filters != null;
-
+        protected LeafBucketCollector getLeafCollector(SortedNumericDocValues values, LeafBucketCollector sub) throws IOException {
             return new LeafBucketCollectorBase(sub, values) {
                 @Override
                 public void collect(int doc, long owningBucketOrd) throws IOException {
-                    if (useOpt[0]) {
-                        useOpt[0] = tryFastFilterAggregation(ctx, owningBucketOrd);
-                    }
-
                     assert owningBucketOrd == 0;
                     if (false == values.advanceExact(doc)) {
                         return;
@@ -566,7 +475,6 @@ private static class FromMany extends AutoDateHistogramAggregator {
          */
         private int rebucketCount = 0;
 
-        private final ValuesSource.Numeric valuesSource;
 
         FromMany(
             String name,
@@ -602,12 +510,10 @@ private static class FromMany extends AutoDateHistogramAggregator {
             preparedRoundings[0] = roundingPreparer.apply(roundingInfos[0].rounding);
             bucketOrds = new LongKeyedBucketOrds.FromMany(context.bigArrays());
             liveBucketCountUnderestimate = context.bigArrays().newIntArray(1, true);
-            this.valuesSource = valuesSourceConfig.hasValues() ? (ValuesSource.Numeric) valuesSourceConfig.getValuesSource() : null;
         }
 
         @Override
-        protected LeafBucketCollector getLeafCollector2(LeafReaderContext ctx, LeafBucketCollector sub) throws IOException {
-            SortedNumericDocValues values = valuesSource.longValues(ctx);
+        protected LeafBucketCollector getLeafCollector(SortedNumericDocValues values, LeafBucketCollector sub) throws IOException {
             return new LeafBucketCollectorBase(sub, values) {
                 @Override
                 public void collect(int doc, long owningBucketOrd) throws IOException {

From e2dbf887670ed285eac41baabf52460274398a05 Mon Sep 17 00:00:00 2001
From: Ankit Jain <akjain@amazon.com>
Date: Mon, 20 Nov 2023 17:41:50 +0530
Subject: [PATCH 13/21] Fixing spotless check bugs

Signed-off-by: Ankit Jain <akjain@amazon.com>
---
 .../bucket/histogram/AutoDateHistogramAggregator.java        | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/AutoDateHistogramAggregator.java b/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/AutoDateHistogramAggregator.java
index 254eba4aaee6a..b4f1e78f77aaf 100644
--- a/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/AutoDateHistogramAggregator.java
+++ b/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/AutoDateHistogramAggregator.java
@@ -263,8 +263,6 @@ private static class FromSingle extends AutoDateHistogramAggregator {
         private long min = Long.MAX_VALUE;
         private long max = Long.MIN_VALUE;
 
-        private final ValuesSource.Numeric valuesSource;
-
         FromSingle(
             String name,
             AggregatorFactories factories,
@@ -290,8 +288,6 @@ private static class FromSingle extends AutoDateHistogramAggregator {
 
             preparedRounding = prepareRounding(0);
             bucketOrds = new LongKeyedBucketOrds.FromSingle(context.bigArrays());
-
-            this.valuesSource = valuesSourceConfig.hasValues() ? (ValuesSource.Numeric) valuesSourceConfig.getValuesSource() : null;
         }
 
         @Override
@@ -475,7 +471,6 @@ private static class FromMany extends AutoDateHistogramAggregator {
          */
         private int rebucketCount = 0;
 
-
         FromMany(
             String name,
             AggregatorFactories factories,

From 06d6c425f38294c8787040665317ab3b718a302d Mon Sep 17 00:00:00 2001
From: Ankit Jain <akjain@amazon.com>
Date: Mon, 20 Nov 2023 20:09:33 +0530
Subject: [PATCH 14/21] Adding back auto date histogram and passing all unit
 tests

Signed-off-by: Ankit Jain <akjain@amazon.com>
---
 .../AutoDateHistogramAggregator.java          | 123 +++++++++++++++++-
 .../AutoDateHistogramAggregatorTests.java     |   1 +
 2 files changed, 120 insertions(+), 4 deletions(-)

diff --git a/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/AutoDateHistogramAggregator.java b/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/AutoDateHistogramAggregator.java
index b4f1e78f77aaf..14d820d1ce879 100644
--- a/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/AutoDateHistogramAggregator.java
+++ b/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/AutoDateHistogramAggregator.java
@@ -33,14 +33,19 @@
 
 import org.apache.lucene.index.LeafReaderContext;
 import org.apache.lucene.index.SortedNumericDocValues;
+import org.apache.lucene.search.CollectionTerminatedException;
+import org.apache.lucene.search.PointRangeQuery;
 import org.apache.lucene.search.ScoreMode;
+import org.apache.lucene.search.Weight;
 import org.apache.lucene.util.CollectionUtil;
+import org.apache.lucene.util.NumericUtils;
 import org.opensearch.common.Rounding;
 import org.opensearch.common.Rounding.Prepared;
 import org.opensearch.common.lease.Releasables;
 import org.opensearch.common.util.IntArray;
 import org.opensearch.common.util.LongArray;
 import org.opensearch.core.common.util.ByteArray;
+import org.opensearch.index.mapper.DateFieldMapper;
 import org.opensearch.search.DocValueFormat;
 import org.opensearch.search.aggregations.Aggregator;
 import org.opensearch.search.aggregations.AggregatorFactories;
@@ -54,6 +59,7 @@
 import org.opensearch.search.aggregations.bucket.MergingBucketsDeferringCollector;
 import org.opensearch.search.aggregations.bucket.histogram.AutoDateHistogramAggregationBuilder.RoundingInfo;
 import org.opensearch.search.aggregations.bucket.terms.LongKeyedBucketOrds;
+import org.opensearch.search.aggregations.support.FieldContext;
 import org.opensearch.search.aggregations.support.ValuesSource;
 import org.opensearch.search.aggregations.support.ValuesSourceConfig;
 import org.opensearch.search.internal.SearchContext;
@@ -125,9 +131,13 @@ static AutoDateHistogramAggregator build(
      * {@link MergingBucketsDeferringCollector#mergeBuckets(long[])}.
      */
     private MergingBucketsDeferringCollector deferringCollector;
+    private Weight[] filters = null;
+    private DateFieldMapper.DateFieldType fieldType;
 
     protected final RoundingInfo[] roundingInfos;
     protected final int targetBuckets;
+    protected int roundingIdx;
+    protected Rounding.Prepared preparedRounding;
 
     private AutoDateHistogramAggregator(
         String name,
@@ -148,6 +158,84 @@ private AutoDateHistogramAggregator(
         this.formatter = valuesSourceConfig.format();
         this.roundingInfos = roundingInfos;
         this.roundingPreparer = roundingPreparer;
+        this.preparedRounding = prepareRounding(0);
+
+        // Create the filters for fast aggregation only if the query is instance
+        // of point range query and there aren't any parent/sub aggregations
+        if (parent() == null && subAggregators.length == 0) {
+            final FieldContext fieldContext = valuesSourceConfig.fieldContext();
+            if (fieldContext != null) {
+                final String fieldName = fieldContext.field();
+                final long[] bounds = FilterRewriteHelper.getAggregationBounds(context, fieldName);
+                if (bounds != null) {
+                    assert fieldContext.fieldType() instanceof DateFieldMapper.DateFieldType;
+                    fieldType = (DateFieldMapper.DateFieldType) fieldContext.fieldType();
+                    filters = FilterRewriteHelper.createFilterForAggregations(
+                        context,
+                        getMinimumRounding(bounds[0], bounds[1]),
+                        preparedRounding,
+                        fieldName,
+                        fieldType,
+                        bounds[0],
+                        bounds[1]
+                    );
+                }
+            }
+        }
+    }
+
+    private Rounding getMinimumRounding(final long low, final long high) {
+        // max - min / targetBuckets = bestDuration
+        // find the right innerInterval this bestDuration belongs to
+        // since we cannot exceed targetBuckets, bestDuration should go up,
+        // so the right innerInterval should be an upper bound
+        long bestDuration = (high - low) / targetBuckets;
+        while (roundingIdx < roundingInfos.length - 1) {
+            final RoundingInfo curRoundingInfo = roundingInfos[roundingIdx];
+            final int temp = curRoundingInfo.innerIntervals[curRoundingInfo.innerIntervals.length - 1];
+            // If the interval duration is covered by the maximum inner interval,
+            // we can start with this outer interval for creating the buckets
+            if (bestDuration <= temp * curRoundingInfo.roughEstimateDurationMillis) {
+                break;
+            }
+            roundingIdx++;
+        }
+
+        preparedRounding = prepareRounding(roundingIdx);
+        return roundingInfos[roundingIdx].rounding;
+    }
+
+    protected abstract LongKeyedBucketOrds getBucketOrds();
+
+    private boolean tryFastFilterAggregation(LeafReaderContext ctx, long owningBucketOrd) throws IOException {
+        final int[] counts = new int[filters.length];
+        int i;
+        for (i = 0; i < filters.length; i++) {
+            counts[i] = filters[i].count(ctx);
+            if (counts[i] == -1) {
+                // Cannot use the optimization if any of the counts
+                // is -1 indicating the segment might have deleted documents
+                return false;
+            }
+        }
+
+        for (i = 0; i < filters.length; i++) {
+            if (counts[i] > 0) {
+                long bucketOrd = getBucketOrds().add(
+                    owningBucketOrd,
+                    preparedRounding.round(
+                        fieldType.convertNanosToMillis(
+                            NumericUtils.sortableBytesToLong(((PointRangeQuery) filters[i].getQuery()).getLowerPoint(), 0)
+                        )
+                    )
+                );
+                if (bucketOrd < 0) { // already seen
+                    bucketOrd = -1 - bucketOrd;
+                }
+                incrementBucketDocCount(bucketOrd, counts[i]);
+            }
+        }
+        throw new CollectionTerminatedException();
     }
 
     @Override
@@ -176,7 +264,27 @@ public final LeafBucketCollector getLeafCollector(LeafReaderContext ctx, LeafBuc
         if (valuesSource == null) {
             return LeafBucketCollector.NO_OP_COLLECTOR;
         }
-        return getLeafCollector(valuesSource.longValues(ctx), sub);
+
+        final SortedNumericDocValues values = valuesSource.longValues(ctx);
+        final LeafBucketCollector iteratingCollector = getLeafCollector(values, sub);
+
+        // Need to be declared as final and array for usage within the
+        // LeafBucketCollectorBase subclass below
+        final boolean[] useOpt = new boolean[1];
+        useOpt[0] = filters != null;
+
+        return new LeafBucketCollectorBase(sub, values) {
+            @Override
+            public void collect(int doc, long owningBucketOrd) throws IOException {
+                // Try fast filter aggregation if the filters have been created
+                // Skip if tried before and gave incorrect/incomplete results
+                if (useOpt[0]) {
+                    useOpt[0] = tryFastFilterAggregation(ctx, owningBucketOrd);
+                }
+
+                iteratingCollector.collect(doc, owningBucketOrd);
+            }
+        };
     }
 
     protected final InternalAggregation[] buildAggregations(
@@ -247,8 +355,6 @@ protected final void merge(long[] mergeMap, long newNumBuckets) {
      * @opensearch.internal
      */
     private static class FromSingle extends AutoDateHistogramAggregator {
-        private int roundingIdx;
-        private Rounding.Prepared preparedRounding;
         /**
          * Map from value to bucket ordinals.
          * <p>
@@ -286,10 +392,14 @@ private static class FromSingle extends AutoDateHistogramAggregator {
                 metadata
             );
 
-            preparedRounding = prepareRounding(0);
             bucketOrds = new LongKeyedBucketOrds.FromSingle(context.bigArrays());
         }
 
+        @Override
+        protected LongKeyedBucketOrds getBucketOrds() {
+            return bucketOrds;
+        }
+
         @Override
         protected LeafBucketCollector getLeafCollector(SortedNumericDocValues values, LeafBucketCollector sub) throws IOException {
             return new LeafBucketCollectorBase(sub, values) {
@@ -507,6 +617,11 @@ private static class FromMany extends AutoDateHistogramAggregator {
             liveBucketCountUnderestimate = context.bigArrays().newIntArray(1, true);
         }
 
+        @Override
+        protected LongKeyedBucketOrds getBucketOrds() {
+            return bucketOrds;
+        }
+
         @Override
         protected LeafBucketCollector getLeafCollector(SortedNumericDocValues values, LeafBucketCollector sub) throws IOException {
             return new LeafBucketCollectorBase(sub, values) {
diff --git a/server/src/test/java/org/opensearch/search/aggregations/bucket/histogram/AutoDateHistogramAggregatorTests.java b/server/src/test/java/org/opensearch/search/aggregations/bucket/histogram/AutoDateHistogramAggregatorTests.java
index 37cd7a42c7cdf..dda053af78b30 100644
--- a/server/src/test/java/org/opensearch/search/aggregations/bucket/histogram/AutoDateHistogramAggregatorTests.java
+++ b/server/src/test/java/org/opensearch/search/aggregations/bucket/histogram/AutoDateHistogramAggregatorTests.java
@@ -969,6 +969,7 @@ private void indexSampleData(List<ZonedDateTime> dataset, RandomIndexWriter inde
         for (final ZonedDateTime date : dataset) {
             final long instant = date.toInstant().toEpochMilli();
             document.add(new SortedNumericDocValuesField(DATE_FIELD, instant));
+            document.add(new LongPoint(DATE_FIELD, instant));
             document.add(new LongPoint(INSTANT_FIELD, instant));
             document.add(new SortedNumericDocValuesField(NUMERIC_FIELD, i));
             indexWriter.addDocument(document);

From 62542c72ebd1bcfc1f873c0407b78df4887005f6 Mon Sep 17 00:00:00 2001
From: Ankit Jain <akjain@amazon.com>
Date: Mon, 20 Nov 2023 23:00:43 +0530
Subject: [PATCH 15/21] Fixing the integration tests for reduced collector work

Signed-off-by: Ankit Jain <akjain@amazon.com>
---
 .../rest-api-spec/test/search.aggregation/10_histogram.yml    | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/rest-api-spec/src/main/resources/rest-api-spec/test/search.aggregation/10_histogram.yml b/rest-api-spec/src/main/resources/rest-api-spec/test/search.aggregation/10_histogram.yml
index 3b16cdb13a22f..a57d9b7bff591 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/test/search.aggregation/10_histogram.yml
+++ b/rest-api-spec/src/main/resources/rest-api-spec/test/search.aggregation/10_histogram.yml
@@ -546,7 +546,7 @@ setup:
   - match: { aggregations.histo.buckets.3.doc_count: 1 }
   - match: { profile.shards.0.aggregations.0.type: NumericHistogramAggregator }
   - match: { profile.shards.0.aggregations.0.description: histo }
-  - match: { profile.shards.0.aggregations.0.breakdown.collect_count: 4 }
+  - match: { profile.shards.0.aggregations.0.breakdown.collect_count: 1 }
   - match: { profile.shards.0.aggregations.0.debug.total_buckets: 3 }
 
 ---
@@ -598,7 +598,7 @@ setup:
   - match: { aggregations.histo.buckets.0.doc_count: 2 }
   - match: { profile.shards.0.aggregations.0.type: DateHistogramAggregator }
   - match: { profile.shards.0.aggregations.0.description: histo }
-  - match: { profile.shards.0.aggregations.0.breakdown.collect_count: 4 }
+  - match: { profile.shards.0.aggregations.0.breakdown.collect_count: 1 }
   - match: { profile.shards.0.aggregations.0.debug.total_buckets: 3 }
 
 ---

From e09f2ebf55c2168acfe5bc6844a737f9799bfa34 Mon Sep 17 00:00:00 2001
From: Ankit Jain <akjain@amazon.com>
Date: Mon, 20 Nov 2023 23:39:08 +0530
Subject: [PATCH 16/21] Fixing the integration test regression

Signed-off-by: Ankit Jain <akjain@amazon.com>
---
 .../rest-api-spec/test/search.aggregation/10_histogram.yml      | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/rest-api-spec/src/main/resources/rest-api-spec/test/search.aggregation/10_histogram.yml b/rest-api-spec/src/main/resources/rest-api-spec/test/search.aggregation/10_histogram.yml
index a57d9b7bff591..fdfbc64ac33e9 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/test/search.aggregation/10_histogram.yml
+++ b/rest-api-spec/src/main/resources/rest-api-spec/test/search.aggregation/10_histogram.yml
@@ -546,7 +546,7 @@ setup:
   - match: { aggregations.histo.buckets.3.doc_count: 1 }
   - match: { profile.shards.0.aggregations.0.type: NumericHistogramAggregator }
   - match: { profile.shards.0.aggregations.0.description: histo }
-  - match: { profile.shards.0.aggregations.0.breakdown.collect_count: 1 }
+  - match: { profile.shards.0.aggregations.0.breakdown.collect_count: 4 }
   - match: { profile.shards.0.aggregations.0.debug.total_buckets: 3 }
 
 ---

From 95627c88011232685ffaed2c295165dd3fafaa88 Mon Sep 17 00:00:00 2001
From: Ankit Jain <akjain@amazon.com>
Date: Wed, 22 Nov 2023 22:40:28 +0530
Subject: [PATCH 17/21] Addressing code review comments

Signed-off-by: Ankit Jain <akjain@amazon.com>
---
 CHANGELOG.md                                  |  1 +
 .../java/org/opensearch/common/Rounding.java  | 24 +++++++++++++++----
 .../bucket/histogram/FilterRewriteHelper.java |  8 +++----
 3 files changed, 25 insertions(+), 8 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 54438d28ad35f..fe8da1917cf9e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -125,6 +125,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 - Add instrumentation for indexing in transport bulk action and transport shard bulk action. ([#10273](https://github.com/opensearch-project/OpenSearch/pull/10273))
 - [BUG] Disable sort optimization for HALF_FLOAT ([#10999](https://github.com/opensearch-project/OpenSearch/pull/10999))
 - Performance improvement for MultiTerm Queries on Keyword fields ([#7057](https://github.com/opensearch-project/OpenSearch/issues/7057))
+- Performance improvement for date histogram aggregations without sub-aggregations ([#11083](https://github.com/opensearch-project/OpenSearch/pull/11083))
 
 ### Deprecated
 
diff --git a/server/src/main/java/org/opensearch/common/Rounding.java b/server/src/main/java/org/opensearch/common/Rounding.java
index 1b46e48e6bd7d..3137d4b9b2e79 100644
--- a/server/src/main/java/org/opensearch/common/Rounding.java
+++ b/server/src/main/java/org/opensearch/common/Rounding.java
@@ -465,8 +465,8 @@ protected Prepared maybeUseArray(long minUtcMillis, long maxUtcMillis, int max)
     public static class TimeUnitRounding extends Rounding {
         static final byte ID = 1;
 
-        public final DateTimeUnit unit;
-        public final ZoneId timeZone;
+        private final DateTimeUnit unit;
+        private final ZoneId timeZone;
         private final boolean unitRoundsToMidnight;
 
         TimeUnitRounding(DateTimeUnit unit, ZoneId timeZone) {
@@ -490,6 +490,14 @@ public byte id() {
             return ID;
         }
 
+        public DateTimeUnit getUnit() {
+            return this.unit;
+        }
+
+        public ZoneId getTimeZone() {
+            return this.timeZone;
+        }
+
         private LocalDateTime truncateLocalDateTime(LocalDateTime localDateTime) {
             switch (unit) {
                 case SECOND_OF_MINUTE:
@@ -923,8 +931,8 @@ public final long nextRoundingValue(long utcMillis) {
     public static class TimeIntervalRounding extends Rounding {
         static final byte ID = 2;
 
-        public final long interval;
-        public final ZoneId timeZone;
+        private final long interval;
+        private final ZoneId timeZone;
 
         TimeIntervalRounding(long interval, ZoneId timeZone) {
             if (interval < 1) throw new IllegalArgumentException("Zero or negative time interval not supported");
@@ -947,6 +955,14 @@ public byte id() {
             return ID;
         }
 
+        public long getInterval() {
+            return this.interval;
+        }
+
+        public ZoneId getTimeZone() {
+            return this.timeZone;
+        }
+
         @Override
         public Prepared prepare(long minUtcMillis, long maxUtcMillis) {
             long minLookup = minUtcMillis - interval;
diff --git a/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/FilterRewriteHelper.java b/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/FilterRewriteHelper.java
index a6b0dc686099c..0fa086361d3cc 100644
--- a/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/FilterRewriteHelper.java
+++ b/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/FilterRewriteHelper.java
@@ -128,14 +128,14 @@ public static Weight[] createFilterForAggregations(
     ) throws IOException {
         long interval;
         if (rounding instanceof Rounding.TimeUnitRounding) {
-            interval = (((Rounding.TimeUnitRounding) rounding).unit).extraLocalOffsetLookup();
-            if (!isUTCTimeZone(((Rounding.TimeUnitRounding) rounding).timeZone)) {
+            interval = (((Rounding.TimeUnitRounding) rounding).getUnit()).extraLocalOffsetLookup();
+            if (!isUTCTimeZone(((Rounding.TimeUnitRounding) rounding).getTimeZone())) {
                 // Fast filter aggregation cannot be used if it needs time zone rounding
                 return null;
             }
         } else if (rounding instanceof Rounding.TimeIntervalRounding) {
-            interval = ((Rounding.TimeIntervalRounding) rounding).interval;
-            if (!isUTCTimeZone(((Rounding.TimeIntervalRounding) rounding).timeZone)) {
+            interval = ((Rounding.TimeIntervalRounding) rounding).getInterval();
+            if (!isUTCTimeZone(((Rounding.TimeIntervalRounding) rounding).getTimeZone())) {
                 // Fast filter aggregation cannot be used if it needs time zone rounding
                 return null;
             }

From 15f9543f97f93114bfdf57325718a5ca56192d1a Mon Sep 17 00:00:00 2001
From: Ankit Jain <akjain@amazon.com>
Date: Mon, 27 Nov 2023 22:28:28 +0530
Subject: [PATCH 18/21] Fixing hardbound, missing and script test cases

Signed-off-by: Ankit Jain <akjain@amazon.com>
---
 .../bucket/histogram/AutoDateHistogramAggregator.java    | 2 +-
 .../bucket/histogram/DateHistogramAggregator.java        | 9 ++++++++-
 2 files changed, 9 insertions(+), 2 deletions(-)

diff --git a/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/AutoDateHistogramAggregator.java b/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/AutoDateHistogramAggregator.java
index 14d820d1ce879..4dc4c40138719 100644
--- a/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/AutoDateHistogramAggregator.java
+++ b/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/AutoDateHistogramAggregator.java
@@ -162,7 +162,7 @@ private AutoDateHistogramAggregator(
 
         // Create the filters for fast aggregation only if the query is instance
         // of point range query and there aren't any parent/sub aggregations
-        if (parent() == null && subAggregators.length == 0) {
+        if (parent() == null && subAggregators.length == 0 && valuesSourceConfig.missing() == null && valuesSourceConfig.script() == null) {
             final FieldContext fieldContext = valuesSourceConfig.fieldContext();
             if (fieldContext != null) {
                 final String fieldName = fieldContext.field();
diff --git a/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/DateHistogramAggregator.java b/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/DateHistogramAggregator.java
index 59c508fa3a5ea..659cb54d3affe 100644
--- a/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/DateHistogramAggregator.java
+++ b/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/DateHistogramAggregator.java
@@ -121,7 +121,7 @@ class DateHistogramAggregator extends BucketsAggregator implements SizedBucketAg
 
         // Create the filters for fast aggregation only if the query is instance
         // of point range query and there aren't any parent/sub aggregations
-        if (parent() == null && subAggregators.length == 0) {
+        if (parent() == null && subAggregators.length == 0 && valuesSourceConfig.missing() == null && valuesSourceConfig.script() == null) {
             final FieldContext fieldContext = valuesSourceConfig.fieldContext();
             if (fieldContext != null) {
                 final String fieldName = fieldContext.field();
@@ -129,6 +129,13 @@ class DateHistogramAggregator extends BucketsAggregator implements SizedBucketAg
                 if (bounds != null) {
                     assert fieldContext.fieldType() instanceof DateFieldMapper.DateFieldType;
                     fieldType = (DateFieldMapper.DateFieldType) fieldContext.fieldType();
+
+                    // Update min/max limit if user specified any hard bounds
+                    if (hardBounds != null) {
+                        bounds[0] = Math.max(bounds[0], hardBounds.getMin());
+                        bounds[1] = Math.min(bounds[1], hardBounds.getMax());
+                    }
+
                     filters = FilterRewriteHelper.createFilterForAggregations(
                         context,
                         rounding,

From 4c3b917736a307e3ce84dd28fa0324d7a94ec8fe Mon Sep 17 00:00:00 2001
From: Ankit Jain <akjain@amazon.com>
Date: Mon, 27 Nov 2023 22:49:58 +0530
Subject: [PATCH 19/21] Removing collect_count validation to prevent backward
 compatibility tests from failing

Signed-off-by: Ankit Jain <akjain@amazon.com>
---
 .../rest-api-spec/test/search.aggregation/10_histogram.yml       | 1 -
 1 file changed, 1 deletion(-)

diff --git a/rest-api-spec/src/main/resources/rest-api-spec/test/search.aggregation/10_histogram.yml b/rest-api-spec/src/main/resources/rest-api-spec/test/search.aggregation/10_histogram.yml
index fdfbc64ac33e9..e7da9a0bc454c 100644
--- a/rest-api-spec/src/main/resources/rest-api-spec/test/search.aggregation/10_histogram.yml
+++ b/rest-api-spec/src/main/resources/rest-api-spec/test/search.aggregation/10_histogram.yml
@@ -598,7 +598,6 @@ setup:
   - match: { aggregations.histo.buckets.0.doc_count: 2 }
   - match: { profile.shards.0.aggregations.0.type: DateHistogramAggregator }
   - match: { profile.shards.0.aggregations.0.description: histo }
-  - match: { profile.shards.0.aggregations.0.breakdown.collect_count: 1 }
   - match: { profile.shards.0.aggregations.0.debug.total_buckets: 3 }
 
 ---

From b5359341410510ebb7ebc23fa92b14dda47178e1 Mon Sep 17 00:00:00 2001
From: Ankit Jain <akjain@amazon.com>
Date: Tue, 28 Nov 2023 00:01:44 +0530
Subject: [PATCH 20/21] Finally fixing hardbounds test case

Signed-off-by: Ankit Jain <akjain@amazon.com>
---
 .../histogram/DateHistogramAggregator.java    | 24 ++++++++++---------
 1 file changed, 13 insertions(+), 11 deletions(-)

diff --git a/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/DateHistogramAggregator.java b/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/DateHistogramAggregator.java
index 659cb54d3affe..bf3af306d7005 100644
--- a/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/DateHistogramAggregator.java
+++ b/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/DateHistogramAggregator.java
@@ -133,7 +133,7 @@ class DateHistogramAggregator extends BucketsAggregator implements SizedBucketAg
                     // Update min/max limit if user specified any hard bounds
                     if (hardBounds != null) {
                         bounds[0] = Math.max(bounds[0], hardBounds.getMin());
-                        bounds[1] = Math.min(bounds[1], hardBounds.getMax());
+                        bounds[1] = Math.min(bounds[1], hardBounds.getMax() - 1); // hard bounds max is exclusive
                     }
 
                     filters = FilterRewriteHelper.createFilterForAggregations(
@@ -286,18 +286,20 @@ private boolean tryFastFilterAggregation(LeafReaderContext ctx, long owningBucke
         }
 
         for (i = 0; i < filters.length; i++) {
-            long bucketOrd = bucketOrds.add(
-                owningBucketOrd,
-                preparedRounding.round(
-                    fieldType.convertNanosToMillis(
-                        NumericUtils.sortableBytesToLong(((PointRangeQuery) filters[i].getQuery()).getLowerPoint(), 0)
+            if (counts[i] > 0) {
+                long bucketOrd = bucketOrds.add(
+                    owningBucketOrd,
+                    preparedRounding.round(
+                        fieldType.convertNanosToMillis(
+                            NumericUtils.sortableBytesToLong(((PointRangeQuery) filters[i].getQuery()).getLowerPoint(), 0)
+                        )
                     )
-                )
-            );
-            if (bucketOrd < 0) { // already seen
-                bucketOrd = -1 - bucketOrd;
+                );
+                if (bucketOrd < 0) { // already seen
+                    bucketOrd = -1 - bucketOrd;
+                }
+                incrementBucketDocCount(bucketOrd, counts[i]);
             }
-            incrementBucketDocCount(bucketOrd, counts[i]);
         }
         throw new CollectionTerminatedException();
     }

From e225781cf00a50217519545efa92ad11b5e55b36 Mon Sep 17 00:00:00 2001
From: Ankit Jain <akjain@amazon.com>
Date: Tue, 28 Nov 2023 18:39:14 +0530
Subject: [PATCH 21/21] Refactoring code for reusability

Signed-off-by: Ankit Jain <akjain@amazon.com>
---
 .../AutoDateHistogramAggregator.java          | 84 +++++-----------
 .../histogram/DateHistogramAggregator.java    | 96 +++++++-----------
 .../bucket/histogram/FilterRewriteHelper.java | 97 ++++++++++++++++++-
 3 files changed, 152 insertions(+), 125 deletions(-)

diff --git a/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/AutoDateHistogramAggregator.java b/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/AutoDateHistogramAggregator.java
index 4dc4c40138719..a71c15d551927 100644
--- a/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/AutoDateHistogramAggregator.java
+++ b/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/AutoDateHistogramAggregator.java
@@ -33,12 +33,9 @@
 
 import org.apache.lucene.index.LeafReaderContext;
 import org.apache.lucene.index.SortedNumericDocValues;
-import org.apache.lucene.search.CollectionTerminatedException;
-import org.apache.lucene.search.PointRangeQuery;
 import org.apache.lucene.search.ScoreMode;
 import org.apache.lucene.search.Weight;
 import org.apache.lucene.util.CollectionUtil;
-import org.apache.lucene.util.NumericUtils;
 import org.opensearch.common.Rounding;
 import org.opensearch.common.Rounding.Prepared;
 import org.opensearch.common.lease.Releasables;
@@ -59,7 +56,6 @@
 import org.opensearch.search.aggregations.bucket.MergingBucketsDeferringCollector;
 import org.opensearch.search.aggregations.bucket.histogram.AutoDateHistogramAggregationBuilder.RoundingInfo;
 import org.opensearch.search.aggregations.bucket.terms.LongKeyedBucketOrds;
-import org.opensearch.search.aggregations.support.FieldContext;
 import org.opensearch.search.aggregations.support.ValuesSource;
 import org.opensearch.search.aggregations.support.ValuesSourceConfig;
 import org.opensearch.search.internal.SearchContext;
@@ -131,8 +127,8 @@ static AutoDateHistogramAggregator build(
      * {@link MergingBucketsDeferringCollector#mergeBuckets(long[])}.
      */
     private MergingBucketsDeferringCollector deferringCollector;
-    private Weight[] filters = null;
-    private DateFieldMapper.DateFieldType fieldType;
+    private final Weight[] filters;
+    private final DateFieldMapper.DateFieldType fieldType;
 
     protected final RoundingInfo[] roundingInfos;
     protected final int targetBuckets;
@@ -160,27 +156,23 @@ private AutoDateHistogramAggregator(
         this.roundingPreparer = roundingPreparer;
         this.preparedRounding = prepareRounding(0);
 
-        // Create the filters for fast aggregation only if the query is instance
-        // of point range query and there aren't any parent/sub aggregations
-        if (parent() == null && subAggregators.length == 0 && valuesSourceConfig.missing() == null && valuesSourceConfig.script() == null) {
-            final FieldContext fieldContext = valuesSourceConfig.fieldContext();
-            if (fieldContext != null) {
-                final String fieldName = fieldContext.field();
-                final long[] bounds = FilterRewriteHelper.getAggregationBounds(context, fieldName);
-                if (bounds != null) {
-                    assert fieldContext.fieldType() instanceof DateFieldMapper.DateFieldType;
-                    fieldType = (DateFieldMapper.DateFieldType) fieldContext.fieldType();
-                    filters = FilterRewriteHelper.createFilterForAggregations(
-                        context,
-                        getMinimumRounding(bounds[0], bounds[1]),
-                        preparedRounding,
-                        fieldName,
-                        fieldType,
-                        bounds[0],
-                        bounds[1]
-                    );
-                }
-            }
+        FilterRewriteHelper.FilterContext filterContext = FilterRewriteHelper.buildFastFilterContext(
+            parent(),
+            subAggregators.length,
+            context,
+            b -> getMinimumRounding(b[0], b[1]),
+            // Passing prepared rounding as supplier to ensure the correct prepared
+            // rounding is set as it is done during getMinimumRounding
+            () -> preparedRounding,
+            valuesSourceConfig,
+            fc -> FilterRewriteHelper.getAggregationBounds(context, fc.field())
+        );
+        if (filterContext != null) {
+            fieldType = filterContext.fieldType;
+            filters = filterContext.filters;
+        } else {
+            fieldType = null;
+            filters = null;
         }
     }
 
@@ -207,37 +199,6 @@ private Rounding getMinimumRounding(final long low, final long high) {
 
     protected abstract LongKeyedBucketOrds getBucketOrds();
 
-    private boolean tryFastFilterAggregation(LeafReaderContext ctx, long owningBucketOrd) throws IOException {
-        final int[] counts = new int[filters.length];
-        int i;
-        for (i = 0; i < filters.length; i++) {
-            counts[i] = filters[i].count(ctx);
-            if (counts[i] == -1) {
-                // Cannot use the optimization if any of the counts
-                // is -1 indicating the segment might have deleted documents
-                return false;
-            }
-        }
-
-        for (i = 0; i < filters.length; i++) {
-            if (counts[i] > 0) {
-                long bucketOrd = getBucketOrds().add(
-                    owningBucketOrd,
-                    preparedRounding.round(
-                        fieldType.convertNanosToMillis(
-                            NumericUtils.sortableBytesToLong(((PointRangeQuery) filters[i].getQuery()).getLowerPoint(), 0)
-                        )
-                    )
-                );
-                if (bucketOrd < 0) { // already seen
-                    bucketOrd = -1 - bucketOrd;
-                }
-                incrementBucketDocCount(bucketOrd, counts[i]);
-            }
-        }
-        throw new CollectionTerminatedException();
-    }
-
     @Override
     public final ScoreMode scoreMode() {
         if (valuesSource != null && valuesSource.needsScores()) {
@@ -279,7 +240,12 @@ public void collect(int doc, long owningBucketOrd) throws IOException {
                 // Try fast filter aggregation if the filters have been created
                 // Skip if tried before and gave incorrect/incomplete results
                 if (useOpt[0]) {
-                    useOpt[0] = tryFastFilterAggregation(ctx, owningBucketOrd);
+                    useOpt[0] = FilterRewriteHelper.tryFastFilterAggregation(ctx, filters, fieldType, (key, count) -> {
+                        incrementBucketDocCount(
+                            FilterRewriteHelper.getBucketOrd(getBucketOrds().add(owningBucketOrd, preparedRounding.round(key))),
+                            count
+                        );
+                    });
                 }
 
                 iteratingCollector.collect(doc, owningBucketOrd);
diff --git a/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/DateHistogramAggregator.java b/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/DateHistogramAggregator.java
index bf3af306d7005..8437e1dce9fe0 100644
--- a/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/DateHistogramAggregator.java
+++ b/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/DateHistogramAggregator.java
@@ -33,12 +33,9 @@
 
 import org.apache.lucene.index.LeafReaderContext;
 import org.apache.lucene.index.SortedNumericDocValues;
-import org.apache.lucene.search.CollectionTerminatedException;
-import org.apache.lucene.search.PointRangeQuery;
 import org.apache.lucene.search.ScoreMode;
 import org.apache.lucene.search.Weight;
 import org.apache.lucene.util.CollectionUtil;
-import org.apache.lucene.util.NumericUtils;
 import org.opensearch.common.Nullable;
 import org.opensearch.common.Rounding;
 import org.opensearch.common.lease.Releasables;
@@ -84,9 +81,9 @@ class DateHistogramAggregator extends BucketsAggregator implements SizedBucketAg
     private final long minDocCount;
     private final LongBounds extendedBounds;
     private final LongBounds hardBounds;
-    private Weight[] filters = null;
+    private final Weight[] filters;
     private final LongKeyedBucketOrds bucketOrds;
-    private DateFieldMapper.DateFieldType fieldType;
+    private final DateFieldMapper.DateFieldType fieldType;
 
     DateHistogramAggregator(
         String name,
@@ -119,35 +116,34 @@ class DateHistogramAggregator extends BucketsAggregator implements SizedBucketAg
 
         bucketOrds = LongKeyedBucketOrds.build(context.bigArrays(), cardinality);
 
-        // Create the filters for fast aggregation only if the query is instance
-        // of point range query and there aren't any parent/sub aggregations
-        if (parent() == null && subAggregators.length == 0 && valuesSourceConfig.missing() == null && valuesSourceConfig.script() == null) {
-            final FieldContext fieldContext = valuesSourceConfig.fieldContext();
-            if (fieldContext != null) {
-                final String fieldName = fieldContext.field();
-                final long[] bounds = FilterRewriteHelper.getAggregationBounds(context, fieldName);
-                if (bounds != null) {
-                    assert fieldContext.fieldType() instanceof DateFieldMapper.DateFieldType;
-                    fieldType = (DateFieldMapper.DateFieldType) fieldContext.fieldType();
-
-                    // Update min/max limit if user specified any hard bounds
-                    if (hardBounds != null) {
-                        bounds[0] = Math.max(bounds[0], hardBounds.getMin());
-                        bounds[1] = Math.min(bounds[1], hardBounds.getMax() - 1); // hard bounds max is exclusive
-                    }
+        FilterRewriteHelper.FilterContext filterContext = FilterRewriteHelper.buildFastFilterContext(
+            parent,
+            subAggregators.length,
+            context,
+            x -> rounding,
+            () -> preparedRounding,
+            valuesSourceConfig,
+            this::computeBounds
+        );
+        if (filterContext != null) {
+            fieldType = filterContext.fieldType;
+            filters = filterContext.filters;
+        } else {
+            filters = null;
+            fieldType = null;
+        }
+    }
 
-                    filters = FilterRewriteHelper.createFilterForAggregations(
-                        context,
-                        rounding,
-                        preparedRounding,
-                        fieldName,
-                        fieldType,
-                        bounds[0],
-                        bounds[1]
-                    );
-                }
+    private long[] computeBounds(final FieldContext fieldContext) throws IOException {
+        final long[] bounds = FilterRewriteHelper.getAggregationBounds(context, fieldContext.field());
+        if (bounds != null) {
+            // Update min/max limit if user specified any hard bounds
+            if (hardBounds != null) {
+                bounds[0] = Math.max(bounds[0], hardBounds.getMin());
+                bounds[1] = Math.min(bounds[1], hardBounds.getMax() - 1); // hard bounds max is exclusive
             }
         }
+        return bounds;
     }
 
     @Override
@@ -176,7 +172,12 @@ public void collect(int doc, long owningBucketOrd) throws IOException {
                 // Try fast filter aggregation if the filters have been created
                 // Skip if tried before and gave incorrect/incomplete results
                 if (useOpt[0]) {
-                    useOpt[0] = tryFastFilterAggregation(ctx, owningBucketOrd);
+                    useOpt[0] = FilterRewriteHelper.tryFastFilterAggregation(ctx, filters, fieldType, (key, count) -> {
+                        incrementBucketDocCount(
+                            FilterRewriteHelper.getBucketOrd(bucketOrds.add(owningBucketOrd, preparedRounding.round(key))),
+                            count
+                        );
+                    });
                 }
 
                 if (values.advanceExact(doc)) {
@@ -272,35 +273,4 @@ public double bucketSize(long bucket, Rounding.DateTimeUnit unitSize) {
             return 1.0;
         }
     }
-
-    private boolean tryFastFilterAggregation(LeafReaderContext ctx, long owningBucketOrd) throws IOException {
-        final int[] counts = new int[filters.length];
-        int i;
-        for (i = 0; i < filters.length; i++) {
-            counts[i] = filters[i].count(ctx);
-            if (counts[i] == -1) {
-                // Cannot use the optimization if any of the counts
-                // is -1 indicating the segment might have deleted documents
-                return false;
-            }
-        }
-
-        for (i = 0; i < filters.length; i++) {
-            if (counts[i] > 0) {
-                long bucketOrd = bucketOrds.add(
-                    owningBucketOrd,
-                    preparedRounding.round(
-                        fieldType.convertNanosToMillis(
-                            NumericUtils.sortableBytesToLong(((PointRangeQuery) filters[i].getQuery()).getLowerPoint(), 0)
-                        )
-                    )
-                );
-                if (bucketOrd < 0) { // already seen
-                    bucketOrd = -1 - bucketOrd;
-                }
-                incrementBucketDocCount(bucketOrd, counts[i]);
-            }
-        }
-        throw new CollectionTerminatedException();
-    }
 }
diff --git a/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/FilterRewriteHelper.java b/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/FilterRewriteHelper.java
index 0fa086361d3cc..c6f8296e29dc0 100644
--- a/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/FilterRewriteHelper.java
+++ b/server/src/main/java/org/opensearch/search/aggregations/bucket/histogram/FilterRewriteHelper.java
@@ -10,6 +10,7 @@
 
 import org.apache.lucene.index.LeafReaderContext;
 import org.apache.lucene.index.PointValues;
+import org.apache.lucene.search.CollectionTerminatedException;
 import org.apache.lucene.search.ConstantScoreQuery;
 import org.apache.lucene.search.IndexOrDocValuesQuery;
 import org.apache.lucene.search.MatchAllDocsQuery;
@@ -18,10 +19,13 @@
 import org.apache.lucene.search.ScoreMode;
 import org.apache.lucene.search.Weight;
 import org.apache.lucene.util.NumericUtils;
+import org.opensearch.common.CheckedFunction;
 import org.opensearch.common.Rounding;
 import org.opensearch.common.lucene.search.function.FunctionScoreQuery;
 import org.opensearch.index.mapper.DateFieldMapper;
 import org.opensearch.index.query.DateRangeIncludingNowQuery;
+import org.opensearch.search.aggregations.support.FieldContext;
+import org.opensearch.search.aggregations.support.ValuesSourceConfig;
 import org.opensearch.search.internal.SearchContext;
 
 import java.io.IOException;
@@ -31,7 +35,9 @@
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
+import java.util.function.BiConsumer;
 import java.util.function.Function;
+import java.util.function.Supplier;
 
 /**
  * Helpers functions to rewrite and optimize aggregations using
@@ -40,6 +46,17 @@
  * @opensearch.internal
  */
 public class FilterRewriteHelper {
+
+    static class FilterContext {
+        final DateFieldMapper.DateFieldType fieldType;
+        final Weight[] filters;
+
+        public FilterContext(DateFieldMapper.DateFieldType fieldType, Weight[] filters) {
+            this.fieldType = fieldType;
+            this.filters = filters;
+        }
+    }
+
     private static final int MAX_NUM_FILTER_BUCKETS = 1024;
     private static final Map<Class, Function<Query, Query>> queryWrappers;
 
@@ -56,7 +73,7 @@ public class FilterRewriteHelper {
      * Recursively unwraps query into the concrete form
      * for applying the optimization
      */
-    public static Query unwrapIntoConcreteQuery(Query query) {
+    private static Query unwrapIntoConcreteQuery(Query query) {
         while (queryWrappers.containsKey(query.getClass())) {
             query = queryWrappers.get(query.getClass()).apply(query);
         }
@@ -85,7 +102,7 @@ private static long[] getIndexBoundsFromLeaves(final SearchContext context, fina
         return new long[] { min, max };
     }
 
-    public static long[] getAggregationBounds(final SearchContext context, final String fieldName) throws IOException {
+    static long[] getAggregationBounds(final SearchContext context, final String fieldName) throws IOException {
         final Query cq = unwrapIntoConcreteQuery(context.query());
         final long[] indexBounds = getIndexBoundsFromLeaves(context, fieldName);
         if (cq instanceof PointRangeQuery) {
@@ -117,7 +134,7 @@ private static boolean isUTCTimeZone(final ZoneId zoneId) {
      * Creates the range query filters for aggregations using the interval, min/max
      * bounds and the rounding values
      */
-    public static Weight[] createFilterForAggregations(
+    private static Weight[] createFilterForAggregations(
         final SearchContext context,
         final Rounding rounding,
         final Rounding.Prepared preparedRounding,
@@ -187,4 +204,78 @@ protected String toString(int dimension, byte[] value) {
 
         return filters;
     }
+
+    static FilterContext buildFastFilterContext(
+        final Object parent,
+        final int subAggLength,
+        SearchContext context,
+        Function<long[], Rounding> roundingFunction,
+        Supplier<Rounding.Prepared> preparedRoundingSupplier,
+        ValuesSourceConfig valuesSourceConfig,
+        CheckedFunction<FieldContext, long[], IOException> computeBounds
+    ) throws IOException {
+        // Create the filters for fast aggregation only if the query is instance
+        // of point range query and there aren't any parent/sub aggregations
+        if (parent == null && subAggLength == 0 && valuesSourceConfig.missing() == null && valuesSourceConfig.script() == null) {
+            final FieldContext fieldContext = valuesSourceConfig.fieldContext();
+            if (fieldContext != null) {
+                final String fieldName = fieldContext.field();
+                final long[] bounds = computeBounds.apply(fieldContext);
+                if (bounds != null) {
+                    assert fieldContext.fieldType() instanceof DateFieldMapper.DateFieldType;
+                    final DateFieldMapper.DateFieldType fieldType = (DateFieldMapper.DateFieldType) fieldContext.fieldType();
+                    final Rounding rounding = roundingFunction.apply(bounds);
+                    final Weight[] filters = FilterRewriteHelper.createFilterForAggregations(
+                        context,
+                        rounding,
+                        preparedRoundingSupplier.get(),
+                        fieldName,
+                        fieldType,
+                        bounds[0],
+                        bounds[1]
+                    );
+                    return new FilterContext(fieldType, filters);
+                }
+            }
+        }
+        return null;
+    }
+
+    static long getBucketOrd(long bucketOrd) {
+        if (bucketOrd < 0) { // already seen
+            bucketOrd = -1 - bucketOrd;
+        }
+
+        return bucketOrd;
+    }
+
+    static boolean tryFastFilterAggregation(
+        final LeafReaderContext ctx,
+        final Weight[] filters,
+        final DateFieldMapper.DateFieldType fieldType,
+        final BiConsumer<Long, Integer> incrementDocCount
+    ) throws IOException {
+        final int[] counts = new int[filters.length];
+        int i;
+        for (i = 0; i < filters.length; i++) {
+            counts[i] = filters[i].count(ctx);
+            if (counts[i] == -1) {
+                // Cannot use the optimization if any of the counts
+                // is -1 indicating the segment might have deleted documents
+                return false;
+            }
+        }
+
+        for (i = 0; i < filters.length; i++) {
+            if (counts[i] > 0) {
+                incrementDocCount.accept(
+                    fieldType.convertNanosToMillis(
+                        NumericUtils.sortableBytesToLong(((PointRangeQuery) filters[i].getQuery()).getLowerPoint(), 0)
+                    ),
+                    counts[i]
+                );
+            }
+        }
+        throw new CollectionTerminatedException();
+    }
 }