SOLR-13764: Introduce IntervalsQParserPlugin

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/.gitignore

@@ -24,3 +24,4 @@
 
 lib/
 test-lib/
+.vscode/

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,166 @@
+/*
+ * 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.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")
+    QueryResponse response =
+        new QueryRequest(
+                params(
+                    "q",
+                    "{!intervals df=subject}$q1",
+                    "json",
+                    "{json_queries:{q1:{match:{query:quick}}"
+                        + (random().nextBoolean() ? ",ignore:{match:{query:lazy}}}}" : "}}"),
+                    "fl",
+                    "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
+    QueryResponse lazyResponse =
+        new QueryRequest(
+                params(
+                    "q",
+                    "{!intervals df=subject}$q1",
+                    "json",
+                    "{json_queries:{q1:{match:{query:lazy}}"
+                        + (random().nextBoolean() ? ",ignore:{match:{query:quick}}}}" : "}}"),
+                    "fl",
+                    "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 QueryRequest(
+                params(
+                    "q",
+                    "{!intervals df=subject}$q1",
+                    "json",
+                    "{json_queries:{q1:{all_of:{ordered:true,"
+                        + "intervals:[{match:{query:quick}},{match:{query:fox}}]}}}}",
+                    "fl",
+                    "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. Note: the leading space before the first "{!" is required, otherwise the
+    // whole q string is parsed as a single set of local params rather than two clauses.
+    response =
+        new QueryRequest(
+                params(
+                    "q",
+                    " {!intervals df=subject}$q1 {!intervals df=subject}$q2",
+                    "json",
+                    "{json_queries:{q1:{match:{query:quick}},q2:{match:{query:lazy}}}}",
+                    "fl",
+                    "id"))
+            .process(cluster.getSolrClient(), COLLECTION);
+    assertEquals(3, response.getResults().getNumFound());
+
+    // intersection of two top-level interval queries (using "+" to require both clauses):
+    // "quick" (docs 1, 3) and "brown" (docs 1, 2) — only doc 1 has both terms
+    response =
+        new QueryRequest(
+                params(
+                    "q",
+                    " +{!intervals df=subject}$q1 +{!intervals df=subject}$q2",
+                    "json",
+                    "{json_queries:{q1:{match:{query:quick}},q2:{match:{query:brown}}}}",
+                    "fl",
+                    "id"))
+            .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 {