如何在Python中处理Solr的Facet Pivot查询数据？

Got it, let's walk through how to work with this nested hierarchical Facet Pivot data from Solr. The structure you're dealing with is a nested list of objects where each level can have its own child pivot entries—so we can use recursive or iterative approaches to traverse, extract, or filter the data based on your needs.

Step 1: Fetch and Parse the Solr Response #

First, let's assume you're using the requests library to pull the data from Solr and parse the JSON response into a Python dictionary:

import requests

# Replace with your actual Solr core URL and query parameters
solr_query_url = "http://your-solr-host:8983/solr/your-core/select?q=*:*&rows=0&facet=on&facet.limit=-1&facet.mincount=0&facet.pivot=brand,series,sub_series"

# Fetch and parse the response
response = requests.get(solr_query_url)
solr_data = response.json()

# Extract the facet pivot data (targeting the specific pivot path)
pivot_hierarchy = solr_data.get("facet_pivot", {}).get("brand,series,sub_series", [])

Step 2: Traverse the Nested Pivot Structure #

If you just want to visualize or print the hierarchical data, a recursive function is intuitive for handling the nested levels:

def traverse_pivot(pivot_items, depth=0):
    indent = "  " * depth
    for item in pivot_items:
        # Print current level's field, value, and count
        print(f"{indent}* {item['field']}: {item['value']} (count: {item['count']})")
        # Recursively process child pivot entries if they exist
        if "pivot" in item and item["pivot"]:
            traverse_pivot(item["pivot"], depth + 1)

# Run the traversal
traverse_pivot(pivot_hierarchy)

Iterative Alternative (For Large Datasets) #

If your pivot data is extremely deep, recursion might hit Python's recursion limit. Use an iterative approach with a stack instead:

def iterative_pivot_traversal(pivot_items):
    # Use a stack to track items and their depth; reverse to maintain order
    stack = [(item, 0) for item in reversed(pivot_items)]
    while stack:
        item, depth = stack.pop()
        indent = "  " * depth
        print(f"{indent}* {item['field']}: {item['value']} (count: {item['count']})")
        # Push child pivot items to the stack (reversed to process in original order)
        if "pivot" in item and item["pivot"]:
            for sub_item in reversed(item["pivot"]):
                stack.append((sub_item, depth + 1))

# Run the iterative traversal
iterative_pivot_traversal(pivot_hierarchy)

Step 3: Flatten the Hierarchy for Analysis #

If you need to convert the nested structure into a flat list of complete paths (e.g., brand → series → sub_series with counts), use this recursive function to build full paths:

def flatten_pivot_hierarchy(pivot_items, current_path=None):
    flattened_paths = []
    if current_path is None:
        current_path = []
    
    for item in pivot_items:
        # Extend the current path with the current item's details
        updated_path = current_path + [(item["field"], item["value"], item["count"])]
        
        # If there are no child pivots, add the full path to results
        if not item.get("pivot"):
            flattened_paths.append(updated_path)
        else:
            # Recursively process child pivots and merge results
            flattened_paths.extend(flatten_pivot_hierarchy(item["pivot"], updated_path))
    
    return flattened_paths

# Get the flattened data
flat_paths = flatten_pivot_hierarchy(pivot_hierarchy)

# Print the flattened paths in a readable format
for path in flat_paths:
    path_string = " → ".join([f"{field}: {value} (count: {count})" for field, value, count in path])
    print(path_string)

Step 4: Filter the Pivot Data #

To extract specific subsets (e.g., all entries under the brand "A. Lange & Sohne"), use a filter function:

def filter_pivot_by_field_value(pivot_items, target_field, target_value):
    filtered_results = []
    for item in pivot_items:
        # Match the target field and value
        if item["field"] == target_field and item["value"] == target_value:
            filtered_results.append(item)
            # Include child pivots if present
            if item.get("pivot"):
                filtered_results.extend(item["pivot"])
        # Recursively check child pivots for matches
        elif item.get("pivot"):
            filtered_results.extend(filter_pivot_by_field_value(item["pivot"], target_field, target_value))
    return filtered_results

# Filter for entries under the brand "A. Lange & Sohne"
filtered_data = filter_pivot_by_field_value(pivot_hierarchy, "brand", "A. Lange & Sohne")

# Print the filtered data
traverse_pivot(filtered_data)

All these approaches can be adjusted to fit your specific use case—whether you're visualizing the hierarchy, analyzing counts, or extracting specific segments of the data.

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