SOLR-13764: Introduce IntervalsQParserPlugin

.gitignore

@@ -46,6 +46,7 @@ CLAUDE.md
 GEMINI.md
 .gemini/
 
+.vscode/
 # WANT TO ADD MORE?  You can tell Git without adding to this file:
 # See https://git-scm.com/docs/gitignore
 # In particular, if you have tools you use, add to $GIT_DIR/info/exclude or use core.excludesFile

changelog/unreleased/SOLR-13764-intervals-query-parser.yml

@@ -0,0 +1,10 @@
+# See https://github.com/apache/solr/blob/main/dev-docs/changelog.adoc
+title: Add Intervals Query Parser
+type: added
+authors:
+  - name: Mikhail Khludnev
+    nick: mkhludnev
+    url: https://home.apache.org/phonebook.html?uid=mkhl
+links:
+  - name: SOLR-13764
+    url: https://issues.apache.org/jira/browse/SOLR-13764

solr/core/src/java/org/apache/solr/request/json/RequestUtil.java

@@ -38,6 +38,12 @@
 import org.noggit.ObjectBuilder;
 
 public class RequestUtil {
+  /**
+   * Top-level JSON key holding the map of named query definitions, referenced elsewhere (e.g. by
+   * {@link org.apache.solr.search.IntervalsQParserPlugin}) via a {@code $name} local param value.
+   */
+  public static final String JSON_QUERIES_KEY = "json_queries";
+
   /**
    * Set default-ish params on a SolrQueryRequest as well as do standard macro processing and JSON
    * request parsing.
@@ -254,6 +260,10 @@ public static void processParams(
                 SolrException.ErrorCode.BAD_REQUEST,
                 "Expected Map for 'queries', received " + queriesJsonObj);
           }
+        } else if (JSON_QUERIES_KEY.equals(key)) {
+          // passed through as a parsed object for use by SearchComponent.prepare() at subordinate
+          // nodes; not processed here
+          continue;
         } else if ("params".equals(key) || "facet".equals(key)) {
           // handled elsewhere
           continue;

solr/core/src/java/org/apache/solr/search/QParserPlugin.java

@@ -92,6 +92,7 @@ public abstract class QParserPlugin implements NamedListInitializedPlugin {
     map.put(VectorSimilarityQParserPlugin.NAME, new VectorSimilarityQParserPlugin());
     map.put(FuzzyQParserPlugin.NAME, new FuzzyQParserPlugin());
     map.put(NumericRangeQParserPlugin.NAME, new NumericRangeQParserPlugin());
+    map.put(IntervalsQParserPlugin.NAME, new IntervalsQParserPlugin());
 
     standardPlugins = Collections.unmodifiableMap(map);
   }

solr/core/src/test/org/apache/solr/search/DistributedQParserTest.java

@@ -0,0 +1,172 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.solr.search;
+
+import org.apache.solr.client.solrj.request.CollectionAdminRequest;
+import org.apache.solr.client.solrj.request.QueryRequest;
+import org.apache.solr.client.solrj.request.UpdateRequest;
+import org.apache.solr.client.solrj.request.json.DirectJsonQueryRequest;
+import org.apache.solr.client.solrj.response.QueryResponse;
+import org.apache.solr.cloud.SolrCloudTestCase;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+/**
+ * Distributed search tests for the standard query parsers: {@code lucene}, {@code dismax}, {@code
+ * edismax}, and {@code intervals}.
+ */
+public class DistributedQParserTest extends SolrCloudTestCase {
+
+  private static final String COLLECTION = "distributed-qparser";
+
+  @BeforeClass
+  public static void setupCluster() throws Exception {
+    configureCluster(2).addConfig("conf", configset("cloud-dynamic")).configure();
+
+    CollectionAdminRequest.createCollection(COLLECTION, "conf", 2, 1)
+        .process(cluster.getSolrClient());
+    cluster.waitForActiveCollection(COLLECTION, 2, 2);
+
+    new UpdateRequest()
+        .add(sdoc("id", "1", "subject", "quick brown fox"))
+        .add(sdoc("id", "2", "subject", "lazy brown dog"))
+        .add(sdoc("id", "3", "subject", "quick red dog"))
+        .add(sdoc("id", "4", "subject", "slow green cat"))
+        .commit(cluster.getSolrClient(), COLLECTION);
+  }
+
+  @Test
+  public void testLuceneQParser() throws Exception {
+    QueryResponse response =
+        new QueryRequest(params("q", "subject:quick", "defType", "lucene", "fl", "id"))
+            .process(cluster.getSolrClient(), COLLECTION);
+    assertEquals(2, response.getResults().getNumFound());
+
+    response =
+        new QueryRequest(params("q", "subject:brown", "defType", "lucene", "fl", "id"))
+            .process(cluster.getSolrClient(), COLLECTION);
+    assertEquals(2, response.getResults().getNumFound());
+  }
+
+  @Test
+  public void testDismaxQParser() throws Exception {
+    QueryResponse response =
+        new QueryRequest(params("q", "quick", "defType", "dismax", "qf", "subject", "fl", "id"))
+            .process(cluster.getSolrClient(), COLLECTION);
+    assertEquals(2, response.getResults().getNumFound());
+
+    response =
+        new QueryRequest(params("q", "brown dog", "defType", "dismax", "qf", "subject", "fl", "id"))
+            .process(cluster.getSolrClient(), COLLECTION);
+    assertEquals(3, response.getResults().getNumFound());
+  }
+
+  @Test
+  public void testEdismaxQParser() throws Exception {
+    QueryResponse response =
+        new QueryRequest(params("q", "quick", "defType", "edismax", "qf", "subject", "fl", "id"))
+            .process(cluster.getSolrClient(), COLLECTION);
+    assertEquals(2, response.getResults().getNumFound());
+
+    response =
+        new QueryRequest(
+                params("q", "brown dog", "defType", "edismax", "qf", "subject", "fl", "id"))
+            .process(cluster.getSolrClient(), COLLECTION);
+    assertEquals(3, response.getResults().getNumFound());
+  }
+
+  @Test
+  public void testIntervalsQParser() throws Exception {
+    // match rule: "quick" appears in docs 1 ("quick brown fox") and 3 ("quick red dog")
+    String jsonQueries =
+        "'q1': {'match': {'query': 'quick'}}"
+            + (random().nextBoolean() ? ", 'ignore': {'match': {'query': 'lazy'}}" : "");
+    QueryResponse response =
+        new DirectJsonQueryRequest(
+                "{"
+                    + "'query': {intervals: {df: subject, query: $q1}},"
+                    + "'json_queries': {"
+                    + jsonQueries
+                    + "},"
+                    + "'fields': 'id'"
+                    + "}")
+            .process(cluster.getSolrClient(), COLLECTION);
+    assertEquals(2, response.getResults().getNumFound());
+
+    // a distinct match rule: "lazy" appears only in doc 2 ("lazy brown dog") — confirm the
+    // result differs from the "quick" query above
+    jsonQueries =
+        "'q1': {'match': {'query': 'lazy'}}"
+            + (random().nextBoolean() ? ", 'ignore': {'match': {'query': 'quick'}}" : "");
+    QueryResponse lazyResponse =
+        new DirectJsonQueryRequest(
+                "{"
+                    + "'query': {intervals: {df: subject, query: $q1}},"
+                    + "'json_queries': {"
+                    + jsonQueries
+                    + "},"
+                    + "'fields': 'id'"
+                    + "}")
+            .process(cluster.getSolrClient(), COLLECTION);
+    assertEquals(1, lazyResponse.getResults().getNumFound());
+    assertNotEquals(response.getResults().getNumFound(), lazyResponse.getResults().getNumFound());
+
+    // all_of ordered: "quick" then "fox" — only doc 1 ("quick brown fox") matches
+    response =
+        new DirectJsonQueryRequest(
+                "{"
+                    + "'query': {intervals: {df: subject, query: $q1}},"
+                    + "'json_queries': {'q1': {'all_of': {'ordered': true,"
+                    + "'intervals': [{'match': {'query': 'quick'}},{'match': {'query': 'fox'}}]}}},"
+                    + "'fields': 'id'"
+                    + "}")
+            .process(cluster.getSolrClient(), COLLECTION);
+    assertEquals(1, response.getResults().getNumFound());
+
+    // union of two top-level interval queries: "quick" (docs 1, 3) or "lazy" (doc 2) — three
+    // docs match
+    response =
+        new DirectJsonQueryRequest(
+                "{"
+                    + "'query': {'bool': {'should': ["
+                    + "{intervals: {df: subject, query: $q1}},"
+                    + "{intervals: {df: subject, query: $q2}}]}},"
+                    + "'json_queries': {'q1': {'match': {'query': 'quick'}},"
+                    + "'q2': {'match': {'query': 'lazy'}}},"
+                    + "'fields': 'id'"
+                    + "}")
+            .process(cluster.getSolrClient(), COLLECTION);
+    assertEquals(3, response.getResults().getNumFound());
+
+    // intersection of two top-level interval queries: "quick" (docs 1, 3) and "brown"
+    // (docs 1, 2) — only doc 1 has both terms
+    response =
+        new DirectJsonQueryRequest(
+                "{"
+                    + "'query': {'bool': {'must': ["
+                    + "  {intervals: {df: subject, query: $q1}},"
+                    + "  {intervals: { query: $q2}}"
+                    + "]}},"
+                    + "'json_queries': {'q1': {'match': {'query': 'quick'}},"
+                    + "'q2': {'match': {'query': 'brown'}}},"
+                    + "'fields': 'id',"
+                    + "params:{df: subject}"
+                    + "}")
+            .process(cluster.getSolrClient(), COLLECTION);
+    assertEquals(1, response.getResults().getNumFound());
+  }
+}

solr/core/src/test/org/apache/solr/search/QueryEqualityTest.java

@@ -174,6 +174,17 @@ public void testQueryFuzzy() throws Exception {
     }
   }
 
+  public void testQueryIntervals() throws Exception {
+    try (SolrQueryRequest req = req("myField", "foo_s")) {
+      req.setJSON(Map.of("json_queries", Map.of("q1", Map.of("term", Map.of("value", "asdf")))));
+      assertQueryEquals(
+          IntervalsQParserPlugin.NAME,
+          req,
+          "{!intervals df=$myField}$q1",
+          "{!intervals df=foo_s}$q1");
+    }
+  }
+
   public void testQueryBoost() throws Exception {
     SolrQueryRequest req = req("df", "foo_s", "myBoost", "sum(3,foo_i)");
     try {