SOLR-14687: {!parent} and {!child} qparsers now use NestPathField (#4206)

The {!parent} and {!child} query parsers now support a parentPath local param that automatically derives the correct parent filter using the _nest_path_ field, making nested document queries easier to write correctly.  childPath is also added as an optional param to limit the child-side of both queries.

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: dsmiley <377295+dsmiley@users.noreply.github.com>

Author: dsmiley

changelog/unreleased/SOLR-14687-parentPath-param.yml

@@ -0,0 +1,9 @@
+# See https://github.com/apache/solr/blob/main/dev-docs/changelog.adoc
+title: The {!parent} and {!child} query parsers now support a parentPath local param that automatically derives the correct parent filter using the _nest_path_ field, making nested document queries easier to write correctly.  childPath is also added.
+type: added # added, changed, fixed, deprecated, removed, dependency_update, security, other
+authors:
+  - name: David Smiley
+  - name: hossman
+links:
+  - name: SOLR-14687
+    url: https://issues.apache.org/jira/browse/SOLR-14687

solr/core/src/java/org/apache/solr/search/join/BlockJoinChildQParser.java

@@ -25,6 +25,7 @@
 import org.apache.solr.request.SolrQueryRequest;
 import org.apache.solr.search.SyntaxError;
 
+/** Matches child documents based on parent doc criteria. */
 public class BlockJoinChildQParser extends BlockJoinParentQParser {
 
   public BlockJoinChildQParser(
@@ -33,23 +34,76 @@ public BlockJoinChildQParser(
   }
 
   @Override
-  protected Query createQuery(Query parentListQuery, Query query, String scoreMode) {
-    return new ToChildBlockJoinQuery(query, getBitSetProducer(parentListQuery));
+  protected Query createQuery(Query parentListQuery, Query fromQuery, String scoreMode) {
+    return new ToChildBlockJoinQuery(fromQuery, getBitSetProducer(parentListQuery));
   }
 
   @Override
-  protected String getParentFilterLocalParamName() {
+  protected String getLegacyParentFilterParamName() {
     return "of";
   }
 
   @Override
-  protected Query noClausesQuery() throws SyntaxError {
-    final Query parents = parseParentFilter();
+  protected Query noClausesQueryLegacy() throws SyntaxError {
+    final Query parents = parseLegacyParentFilter();
     final BooleanQuery notParents =
         new BooleanQuery.Builder()
             .add(new MatchAllDocsQuery(), Occur.MUST)
             .add(parents, Occur.MUST_NOT)
             .build();
     return new BitSetProducerQuery(getBitSetProducer(notParents));
   }
+
+  /**
+   * Parses the query using the {@code parentPath} local-param for the child parser.
+   *
+   * <p>For the {@code child} parser with {@code parentPath="/a/b/c"}:
+   *
+   * <pre>NEW: q={!child parentPath="/a/b/c"}p_title:dad
+   *
+   * OLD: q={!child of=$ff v=$vv}
+   *      ff=(*:* -{!prefix f="_nest_path_" v="/a/b/c/"})
+   *      vv=(+p_title:dad +{!field f="_nest_path_" v="/a/b/c"})</pre>
+   *
+   * <p>For {@code parentPath="/"}:
+   *
+   * <pre>NEW: q={!child parentPath="/"}p_title:dad
+   *
+   * OLD: q={!child of=$ff v=$vv}
+   *      ff=(*:* -_nest_path_:*)
+   *      vv=(+p_title:dad -_nest_path_:*)</pre>
+   *
+   * <p>The optional {@code childPath} local-param narrows the returned children to docs at exactly
+   * {@code parentPath/childPath}.
+   *
+   * @param parentPath the normalized parent path (starts with "/", no trailing slash except for
+   *     root "/")
+   * @param childPath optional path constraining the children relative to parentPath
+   */
+  @Override
+  protected Query parseUsingParentPath(String parentPath, String childPath) throws SyntaxError {
+    final BooleanQuery parsedParentQuery = parseImpl();
+
+    if (parsedParentQuery.clauses().isEmpty()) { // i.e. match all parents
+      // no block-join needed; just filter to certain children
+      return wrapWithChildPathConstraint(parentPath, childPath, new MatchAllDocsQuery());
+    }
+
+    // allParents filter: (*:* -{!prefix f="_nest_path_" v="<parentPath>/"})
+    // For root: (*:* -_nest_path_:*)
+    final Query allParentsFilter = buildAllParentsFilterFromPath(parentPath);
+
+    // constrain the parent query to only match docs at exactly parentPath
+    // (+<original_parent> +{!field f="_nest_path_" v="<parentPath>"})
+    // For root: (+<original_parent> -_nest_path_:*)
+    Query constrainedParentQuery = wrapWithParentPathConstraint(parentPath, parsedParentQuery);
+
+    Query joinQuery = createQuery(allParentsFilter, constrainedParentQuery, null);
+    // matches all children of matching parents
+    if (childPath == null) {
+      return joinQuery;
+    }
+    // need to constrain to certain children
+    return wrapWithChildPathConstraint(parentPath, childPath, joinQuery);
+  }
 }