Computed Index in Apache Solr: What, Why, and How to Use It?

Introduction

Apache Solr is a powerful search platform widely used for enterprise search applications, e-commerce sites, and big data analytics. While Solr is known for its full-text search capabilities, it also allows computed indexing, where certain fields are precomputed before indexing. This technique enhances query performance, supports dynamic field calculations, and simplifies complex queries.

In this blog, we will explore:

✅ What is a Computed Index in Solr?
✅ Why is it useful?
✅ How to implement it?
✅ A real-world e-commerce example.

------------------------------------------------------------------------------------------------------------------

What is a Computed Index in Solr?

A computed index refers to a field whose value is dynamically calculated based on other fields before being indexed. Instead of computing these values at query time, Solr precomputes and stores them in the index, ensuring faster search results.

For example, if we have a product catalog with price and discount percentage, we can precompute the final price instead of calculating it during every search query.

Example:

............................................................................................................................................................

Raw Data:

{

    "id": "P001",

    "name": "Laptop",

    "price": 1000,

    "discount_percentage": 10

}

Computed Field (final_price)

final_price = price - (price * discount_percentage / 100)


→ final_price = 1000 - (1000 * 10 / 100) = 900

This final_price is stored directly in Solr, eliminating the need to 
compute it during searches.

..........................................................................
final_price =


Why Use Computed Indexing in Solr?
Using computed fields in Solr offers several benefits:
🚀 1. Improves Query Performance
Precomputing values ensures that queries do not need to perform 
calculations, making searches significantly faster.
🔄 2. Reduces Query Complexity
Instead of applying filters on multiple fields(e.g., price and discount_percentage)
we can  filter directly on final_price.
⚡ 3. Optimizes Sorting and Faceting
Sorting and faceting on precomputed fields is much faster than computing
 values dynamically at query time.
📊 4. Custom Ranking & Scoring
You can define custom ranking based on precomputed metrics such as 
weighted scores, engagement rates, or computed product relevance.

How to Implement Computed Indexing in Solr?
Method 1: Using Solr Update Request Processor (URP)
Solr provides Update Request Processors (URP) that allow modifying or 
computing fields before indexing.
Step 1: Define Computed Field in schema.xml
Modify the Solr schema to include the computed field:

<field name="price" type="float" indexed="true" stored="true"/>
<field name="discount_percentage" type="float" indexed="true" stored="true"/>
<field name="final_price" type="float" indexed="true" stored="true"/>


Step 2: Use Solr Update Processor to Compute the Value
Modify solrconfig.xml to include an Update Request Processor:
<updateRequestProcessorChain name="compute-final-price">
    <processor class="solr.StatelessScriptUpdateProcessorFactory">
        <str name="script">
            if (doc["price"] && doc["discount_percentage"]) {
                doc["final_price"] = doc["price"].value - 
               (doc["price"].value * doc["discount_percentage"].value / 100);
            }
        </str>
    </processor>
    <processor class="solr.RunUpdateProcessorFactory"/>
</updateRequestProcessorChain>

👉 This script calculates final_price before indexing the document.

Step 3: Apply Update Processor in solrconfig.xml
Ensure Solr applies this processor to all incoming documents:

<requestHandler name="/update" class="solr.UpdateRequestHandler">
    <lst name="defaults">
        <str name="update.chain">compute-final-price</str>
    </lst>
</requestHandler>


Method 2: Using Copy Fields
If the computation is simple (like duplicating values), you can use the 
copyField method in schema.xml.

<field name="original_price" type="float" indexed="true" stored="true"/>
<field name="discounted_price" type="float" indexed="true" stored="true"/>
<copyField source="original_price" dest="discounted_price"/>

However, this method is limited since it does not support mathematical 
transformations.

Live Scenario: E-Commerce Discount Calculation
Use Case:
An e-commerce website needs to display the final price of products after 
applying discounts. Instead of computing it dynamically on every search, 
Solr precomputes and stores the final_price.
Solution Using Computed Indexing:

The raw data includes price and discount_percentage.
Solr precomputes final_price = price - (price * discount_percentage / 100).
Users can filter, sort, and search directly on final_price instead of 
computing it at runtime.

Example Query:
To find all products under $500, we can simply query:

q=final_price:[* TO 500]

This is faster than querying:

q=price:[* TO 500] AND discount_percentage:[* TO 50]

By precomputing final_price, Solr reduces query complexity and improves response time.

Conclusion
Computed indexing in Solr helps optimize performance by precomputing 
field values before storing them. Using Update Processors or 
Copy Fields, we can create derived fields that speed up searches,
 improve filtering, and enhance ranking.
Key Takeaways:
✅ Use Computed Indexing for Preprocessing – Compute values 
before indexing, not at query time.

✅ Boost Query Performance – Avoid expensive calculations 
during searches.

✅ Optimize Sorting & Filtering – Work with precomputed values 
for better efficiency.

Next Steps:
👉 Try implementing a computed index in your Solr project! 🚀

👉 Need help? Drop your questions in the comments! 💬
Would you like a step-by-step Solr configuration guide? Let me know! 😊