Merge pull request ESQL-1227 from elastic/main

🤖 ESQL: Merge upstream

modules/aggregations/src/internalClusterTest/java/org/elasticsearch/aggregations/bucket/TimeSeriesAggregationsIT.java

@@ -11,6 +11,7 @@ package org.elasticsearch.aggregations.bucket;
 import org.elasticsearch.ElasticsearchException;
 import org.elasticsearch.action.DocWriteRequest;
 import org.elasticsearch.action.admin.indices.alias.Alias;
+import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
 import org.elasticsearch.action.index.IndexRequestBuilder;
 import org.elasticsearch.action.search.SearchResponse;
 import org.elasticsearch.action.support.WriteRequest;
@@ -334,7 +335,6 @@ public class TimeSeriesAggregationsIT extends AggregationIntegTestCase {
         assertThat(e.getRootCause().getMessage(), containsString("Time series aggregations cannot be used inside global aggregation."));
     }
 
-    @AwaitsFix(bugUrl = "https://github.com/elastic/elasticsearch/issues/96501")
     public void testStandAloneTimeSeriesAggWithMetricFilter() {
         boolean above = randomBoolean();
         int metric = randomIntBetween(0, numberOfMetrics - 1);
@@ -366,7 +366,6 @@ public class TimeSeriesAggregationsIT extends AggregationIntegTestCase {
         }
     }
 
-    @AwaitsFix(bugUrl = "https://github.com/elastic/elasticsearch/issues/96487")
     public void testRetrievingHits() {
         Map.Entry<String, Double> filterMetric = randomMetricAndValue(data);
         double lowerVal = filterMetric.getValue() - randomDoubleBetween(0, 100000, true);
@@ -525,6 +524,7 @@ public class TimeSeriesAggregationsIT extends AggregationIntegTestCase {
         response = client().prepareSearch("test").setQuery(queryBuilder).setSize(10).addAggregation(timeSeries("by_ts")).get();
         assertSearchResponse(response);
 
+        assertAcked(client().admin().indices().delete(new DeleteIndexRequest("test")).actionGet());
     }
 
     public static TimeSeriesAggregationBuilder timeSeries(String name) {

server/src/main/java/org/elasticsearch/index/query/RangeQueryBuilder.java

@@ -453,8 +453,10 @@ public class RangeQueryBuilder extends AbstractQueryBuilder<RangeQueryBuilder> i
                 coordinatorRewriteContext
             );
         }
-
-        return MappedFieldType.Relation.DISJOINT;
+        // If the field type is null or not of type DataFieldType then we have no idea whether this range query will match during
+        // coordinating rewrite. So we should return that it intersects, either the data node query rewrite or by actually running
+        // the query we know whether this range query actually matches.
+        return MappedFieldType.Relation.INTERSECTS;
     }
 
     protected MappedFieldType.Relation getRelation(final SearchExecutionContext searchExecutionContext) throws IOException {

server/src/test/java/org/elasticsearch/index/query/RangeQueryBuilderTests.java

@@ -41,6 +41,7 @@ import static org.elasticsearch.index.query.QueryBuilders.rangeQuery;
 import static org.hamcrest.Matchers.equalTo;
 import static org.hamcrest.Matchers.instanceOf;
 import static org.hamcrest.Matchers.not;
+import static org.hamcrest.Matchers.nullValue;
 import static org.hamcrest.Matchers.sameInstance;
 
 public class RangeQueryBuilderTests extends AbstractQueryTestCase<RangeQueryBuilder> {
@@ -557,6 +558,67 @@ public class RangeQueryBuilderTests extends AbstractQueryTestCase<RangeQueryBuil
         assertThat(rewritten, not(sameInstance(query)));
     }
 
+    public void testCoordinatorRewriteTimestampField() throws IOException {
+        final String timestampFieldName = "@timestamp";
+        RangeQueryBuilder query = new RangeQueryBuilder(timestampFieldName) {
+            @Override
+            protected QueryBuilder doSearchRewrite(SearchExecutionContext searchExecutionContext) throws IOException {
+                throw new UnsupportedOperationException("Unexpected rewrite on data node");
+            }
+        };
+        long minTimestamp = 1685714000000L;
+        long maxTimestamp = 1685715000000L;
+        final CoordinatorRewriteContext coordinatorRewriteContext = createCoordinatorRewriteContext(
+            new DateFieldMapper.DateFieldType(timestampFieldName),
+            minTimestamp,
+            maxTimestamp
+        );
+
+        // Before timestamp field range, so rewrites to match no docs:
+        long range = 10000L;
+        query.from(minTimestamp - range);
+        query.to(minTimestamp - 1);
+        QueryBuilder rewritten = query.rewrite(coordinatorRewriteContext);
+        assertThat(rewritten, not(sameInstance(query)));
+        assertThat(rewritten, instanceOf(MatchNoneQueryBuilder.class));
+
+        // After timestamp field range, so rewrites to match no docs:
+        query.from(maxTimestamp + 1);
+        query.to(maxTimestamp + range);
+        rewritten = query.rewrite(coordinatorRewriteContext);
+        assertThat(rewritten, not(sameInstance(query)));
+        assertThat(rewritten, instanceOf(MatchNoneQueryBuilder.class));
+
+        // Range within timestamp field range, so rewrite to open bounded range query:
+        query.from(minTimestamp - range);
+        query.to(maxTimestamp + range);
+        rewritten = query.rewrite(coordinatorRewriteContext);
+        assertThat(rewritten, not(sameInstance(query)));
+        assertThat(rewritten, instanceOf(RangeQueryBuilder.class));
+        RangeQueryBuilder rewrittenRangeQuery = (RangeQueryBuilder) rewritten;
+        assertThat(rewrittenRangeQuery.fieldName(), equalTo(timestampFieldName));
+        assertThat(rewrittenRangeQuery.from(), nullValue());
+        assertThat(rewrittenRangeQuery.to(), nullValue());
+
+        // Overlaps with timestamp field range, nothing that can be done so rewrite does nothing:
+        query.from(minTimestamp - (range / 2));
+        query.to(minTimestamp + (range / 2));
+        rewritten = query.rewrite(coordinatorRewriteContext);
+        assertThat(rewritten, sameInstance(query));
+
+        // Use different field name than timestamp field name, coordinating node rewrite should do nothing:
+        RangeQueryBuilder otherQuery = new RangeQueryBuilder("other_field") {
+            @Override
+            protected QueryBuilder doSearchRewrite(SearchExecutionContext searchExecutionContext) throws IOException {
+                throw new UnsupportedOperationException("Unexpected rewrite on data node");
+            }
+        };
+        otherQuery.from(minTimestamp - range);
+        otherQuery.to(minTimestamp - 1);
+        rewritten = otherQuery.rewrite(coordinatorRewriteContext);
+        assertThat(rewritten, sameInstance(otherQuery));
+    }
+
     public void testNoCoordinatorRewrite() throws IOException {
         final String fieldName = randomAlphaOfLengthBetween(1, 20);
         final RangeQueryBuilder query = new RangeQueryBuilder(fieldName) {

test/framework/src/main/java/org/elasticsearch/test/AbstractBuilderTestCase.java

@@ -576,11 +576,7 @@ public abstract class AbstractBuilderTestCase extends ESTestCase {
                 parserConfiguration,
                 this.client,
                 () -> nowInMillis,
-                IndexLongFieldRange.UNKNOWN.extendWithShardRange(
-                    randomIntBetween(0, 2),
-                    randomIntBetween(2, 5),
-                    ShardLongFieldRange.of(min, max)
-                ),
+                IndexLongFieldRange.NO_SHARDS.extendWithShardRange(0, 1, ShardLongFieldRange.of(min, max)),
                 dateFieldType
             );
         }