如何在Solr中实现层级条件的LIKE搜索？求非重构替代方案

Great question! Let's break this down clearly:

First off, Solr doesn’t support that exact LIKE '%~{id}~%' pattern efficiently—wildcard queries starting with % are performance killers in Solr, as they can’t leverage indexed prefixes and force a full field scan. But you absolutely don’t need to rebuild your entire hierarchy structure to get the same parent-child aggregation behavior. Here are the most practical, low-effort solutions:

1. Precompute a multi-value "ancestor IDs" field (Recommended) #

This is the simplest and fastest approach. Instead of relying on fuzzy matching against HierarchyKey, add a new multi-value field to your Solr schema (e.g., ancestor_ids) that stores all ancestor IDs of the current node, including the node itself.

For example, if your HierarchyKey is ~1~2~3~, the ancestor_ids field would hold ["1", "2", "3"].

• Implementation: When importing data into Solr, split the HierarchyKey string on ~, filter out empty values, and populate the ancestor_ids multi-value field.
• Querying: To get all descendants (and the parent node itself), run an exact match query: ancestor_ids:{your_target_id}. This uses Solr’s efficient indexed multi-value lookups and is lightning fast.

2. Use NGram tokenization on HierarchyKey #

If you can’t add a new field, configure Solr to tokenize the HierarchyKey into fragments that include the ~{id}~ pattern, allowing you to match nodes where the ID appears anywhere in the hierarchy.

Here’s how to set up the field type in your schema:

<fieldType name="hierarchy_tokenized" class="solr.TextField">
  <analyzer type="index">
    <!-- Split HierarchyKey on ~ to isolate individual IDs -->
    <tokenizer class="solr.PatternTokenizerFactory" pattern="~" />
    <!-- Generate n-grams to capture IDs with surrounding ~ (adjust min/max size to match your ID lengths) -->
    <filter class="solr.NGramFilterFactory" minGramSize="2" maxGramSize="12" />
    <!-- Reattach ~ to each token to ensure we match exact ~id~ patterns -->
    <filter class="solr.PatternReplaceFilterFactory" pattern="(.*)" replacement="~$1~" />
  </analyzer>
  <analyzer type="query">
    <!-- For queries, use exact matching of the ~id~ pattern -->
    <tokenizer class="solr.KeywordTokenizerFactory" />
  </analyzer>
</fieldType>

Then define your field:

<field name="HierarchyKey" type="hierarchy_tokenized" indexed="true" stored="true" />

• Querying: Use HierarchyKey:"~{your_target_id}~" to find all nodes where the ID appears in the hierarchy. Note this is less performant than the multi-value field approach, but it avoids modifying your core data structure.

3. Recursive Graph Queries (Solr 8.0+) #

If you can add a simple parent_id field (storing just the direct parent ID of each node), Solr’s built-in graph query support lets you recursively fetch all descendants.

• Implementation: Parse the HierarchyKey to extract the direct parent ID (e.g., for ~1~2~3~, the parent ID is 2), then populate a parent_id field in your documents.
• Querying: Use the graph query syntax to traverse the hierarchy:

  {!graph from=parent_id to=id start={your_target_id}}*:*
  

This query starts at your target ID and recursively fetches all nodes linked via the parent_id → id relationship.

4. Prefix Query (If your hierarchy is ordered) #

If your HierarchyKey strictly follows a parent-to-child order (e.g., ~1~ → ~1~2~ → ~1~2~3~), you can use a prefix query instead of a wildcard. For example, to get all descendants of ID 1, use:

HierarchyKey:~1~*

This works because all child nodes will have a HierarchyKey starting with ~1~. It’s efficient since Solr can use prefix indexes, but it only works if your hierarchy path is strictly ordered (no arbitrary nesting paths).

内容的提问来源于stack exchange，提问作者BVernon