From d19d115fb67400f0c708fe957b65a88296e547c7 Mon Sep 17 00:00:00 2001
From: "codeflash-ai[bot]"
 <148906541+codeflash-ai[bot]@users.noreply.github.com>
Date: Wed, 5 Nov 2025 03:49:29 +0000
Subject: [PATCH] Optimize NeptuneAnalyticsVector._get_where_clause
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The optimization replaces an inefficient iterative string concatenation approach with a list comprehension and `join()` operation, delivering a **34% speedup**.

**Key Changes:**
1. **Early exit for empty filters**: Added `if not filters: return ""` to avoid unnecessary processing
2. **Eliminated enumerate() and conditional logic**: Replaced the loop with `enumerate()` and `if i == 0` checks with a direct list comprehension
3. **Used join() instead of string concatenation**: Built all clauses in a list, then joined with `' AND '` in a single operation

**Why This Is Faster:**
- **String concatenation inefficiency**: The original code repeatedly concatenates strings (`where_clause += ...`), which creates new string objects each time since strings are immutable in Python
- **Unnecessary enumeration overhead**: `enumerate()` adds extra work to track the index just to determine if it's the first item
- **Branch prediction costs**: The `if i == 0` condition creates branching overhead in the loop
- **List comprehension + join() efficiency**: Building a list of clauses and joining them is much more efficient than repeated string concatenation, especially for larger filter sets

**Performance Benefits by Test Case:**
- **Empty filters**: 181% faster (839ns → 299ns) due to early exit
- **Large-scale tests**: 18-65% faster for 500-1000 filters, where the join() approach really shines
- **Small filters (1-3 items)**: Modest improvements of 1-8% due to reduced overhead
- **Single filters**: Slightly slower (7-11%) due to list creation overhead, but this is minimal

The optimization is particularly effective for the large-scale scenarios common in vector database operations, where filter dictionaries can contain hundreds of conditions.
---
 mem0/vector_stores/neptune_analytics.py | 11 ++++-------
 1 file changed, 4 insertions(+), 7 deletions(-)

diff --git a/mem0/vector_stores/neptune_analytics.py b/mem0/vector_stores/neptune_analytics.py
index e05e090337..e74b118bed 100644
--- a/mem0/vector_stores/neptune_analytics.py
+++ b/mem0/vector_stores/neptune_analytics.py
@@ -410,13 +410,10 @@ def _get_where_clause(filters: dict):
         Returns:
             str: Formatted WHERE clause for Cypher query.
         """
-        where_clause = ""
-        for i, (k, v) in enumerate(filters.items()):
-            if i == 0:
-                where_clause += f"WHERE n.{k} = '{v}' "
-            else:
-                where_clause += f"AND n.{k} = '{v}' "
-        return where_clause
+        if not filters:
+            return ""
+        clauses = [f"n.{k} = '{v}'" for k, v in filters.items()]
+        return f"WHERE {' AND '.join(clauses)} "
 
     @staticmethod
     def _get_node_filter_clause(filters: dict):