fix: use whitespace intersection for filtered text queries

Author: limjoobin

redisvl/query/query.py

@@ -1569,5 +1569,5 @@ def _build_query_string(self) -> str:
             text = "(" + " | ".join(field_queries) + ")"
 
         if filter_expression and filter_expression != "*":
-            text += f" AND {filter_expression}"
+            text += f" {filter_expression}"
         return text

redisvl/utils/full_text_query_helper.py

@@ -62,7 +62,7 @@ def build_query_string(
         query = f"(~@{text_field_name}:({self._tokenize_and_escape_query(text)})"
 
         if filter_expression and filter_expression != "*":
-            query += f" AND {filter_expression}"
+            query += f" {filter_expression}"
 
         return query + ")"
 

tests/integration/test_stopwords_integration.py

@@ -3,8 +3,11 @@
 import pytest
 
 from redisvl.index import SearchIndex
-from redisvl.query import FilterQuery
+from redisvl.query import AggregateHybridQuery, FilterQuery, TextQuery
+from redisvl.query.filter import Tag
+from redisvl.redis.utils import array_to_buffer
 from redisvl.schema import IndexSchema
+from tests.conftest import skip_if_redis_version_below
 
 
 @pytest.fixture
@@ -91,6 +94,56 @@ def default_stopwords_index(client, default_stopwords_schema):
     index.delete(drop=True)
 
 
+@pytest.fixture
+def filtered_queries_stopwords_disabled_index(redis_url, redis_test_name):
+    """Index with STOPWORDS 0 for filtered text and hybrid query regressions."""
+    index_name = redis_test_name("filtered_queries_stopwords_disabled")
+    index = SearchIndex.from_dict(
+        {
+            "index": {
+                "name": index_name,
+                "prefix": f"{index_name}:",
+                "storage_type": "hash",
+                "stopwords": [],
+            },
+            "fields": [
+                {"name": "text", "type": "text"},
+                {"name": "team", "type": "tag"},
+                {
+                    "name": "embedding",
+                    "type": "vector",
+                    "attrs": {
+                        "dims": 2,
+                        "distance_metric": "cosine",
+                        "algorithm": "flat",
+                        "datatype": "float32",
+                    },
+                },
+            ],
+        },
+        redis_url=redis_url,
+    )
+    index.create(overwrite=True, drop=True)
+    index.load(
+        [
+            {
+                "text": "reference handbook",
+                "team": "docs",
+                "embedding": array_to_buffer([1.0, 0.0], "float32"),
+            },
+            {
+                "text": "reference handbook",
+                "team": "support",
+                "embedding": array_to_buffer([1.0, 0.0], "float32"),
+            },
+        ]
+    )
+
+    yield index
+
+    index.delete(drop=True)
+
+
 def test_create_index_with_stopwords_disabled(client, stopwords_disabled_index):
     """Test creating an index with STOPWORDS 0."""
     # Verify index was created
@@ -190,3 +243,46 @@ def test_stopwords_disabled_allows_searching_common_words(
     # With STOPWORDS 0, "of" should be indexed and searchable
     assert len(results.docs) > 0
     assert any("of" in doc.title.lower() for doc in results.docs)
+
+
+def test_filtered_text_query_with_stopwords_disabled(
+    filtered_queries_stopwords_disabled_index,
+):
+    """Filtered text queries should not add AND as a full-text search term."""
+    query = TextQuery(
+        text="handbook",
+        text_field_name="text",
+        filter_expression=Tag("team") == "docs",
+        return_fields=["text", "team"],
+        stopwords=None,
+    )
+
+    results = filtered_queries_stopwords_disabled_index.query(query)
+
+    assert len(results) == 1
+    assert results[0]["text"] == "reference handbook"
+    assert results[0]["team"] == "docs"
+
+
+def test_filtered_aggregate_hybrid_query_with_stopwords_disabled(
+    filtered_queries_stopwords_disabled_index,
+):
+    """Filtered aggregate hybrid queries should work with STOPWORDS 0."""
+    skip_if_redis_version_below(
+        filtered_queries_stopwords_disabled_index.client, "7.2.0"
+    )
+    query = AggregateHybridQuery(
+        text="handbook",
+        text_field_name="text",
+        vector=[1.0, 0.0],
+        vector_field_name="embedding",
+        filter_expression=Tag("team") == "docs",
+        return_fields=["text", "team"],
+        stopwords=None,
+    )
+
+    results = filtered_queries_stopwords_disabled_index.query(query)
+
+    assert len(results) == 1
+    assert results[0]["text"] == "reference handbook"
+    assert results[0]["team"] == "docs"

tests/unit/test_aggregation_types.py

@@ -160,7 +160,11 @@ def test_hybrid_query_with_string_filter():
     # Check that the generated query string includes both text search and filter
     query_string = str(hybrid_query)
     assert f"@{text_field_name}:(search | document | 12345)" in query_string
-    assert f"AND {string_filter}" in query_string
+    assert (
+        f"@{text_field_name}:(search | document | 12345) {string_filter}"
+        in query_string
+    )
+    assert " AND " not in query_string
 
     # Test with FilterExpression - should also work (existing functionality)
     filter_expression = Tag("category") == "tech"
@@ -181,7 +185,11 @@ def test_hybrid_query_with_string_filter():
         f"@{text_field_name}:(search | document | 12345)"
         in query_string_with_filter_expr
     )
-    assert "AND @category:{tech}" in query_string_with_filter_expr
+    assert (
+        f"@{text_field_name}:(search | document | 12345) @category:{{tech}}"
+        in query_string_with_filter_expr
+    )
+    assert " AND " not in query_string_with_filter_expr
 
     # Test with no filter - should only have text search
     hybrid_query_no_filter = AggregateHybridQuery(
@@ -195,7 +203,7 @@ def test_hybrid_query_with_string_filter():
     assert f"@{text_field_name}:(search | document | 12345)" in query_string_no_filter
     assert "AND" not in query_string_no_filter
 
-    # Test with wildcard filter - should only have text search (no AND clause)
+    # Test with wildcard filter - should only have text search (no filter clause)
     hybrid_query_wildcard = AggregateHybridQuery(
         text=text,
         text_field_name=text_field_name,

tests/unit/test_hybrid_types.py

@@ -129,7 +129,7 @@ def test_hybrid_query_with_all_parameters():
     # Verify that the expected query pieces have been defined
     assert get_query_pieces(hybrid_query) == [
         "SEARCH",
-        "(~@description:(the | toon=>{$weight:2.0} | squad=>{$weight:1.5} | play | basketball | against | a | gang | of | aliens) AND @genre:{comedy})",
+        "(~@description:(the | toon=>{$weight:2.0} | squad=>{$weight:1.5} | play | basketball | against | a | gang | of | aliens) @genre:{comedy})",
         "SCORER",
         "TFIDF",
         "YIELD_SCORE_AS",
@@ -385,7 +385,7 @@ def test_hybrid_query_with_string_filter():
 
     assert get_query_pieces(hybrid_query) == [
         "SEARCH",
-        "(~@description:(toon | squad | play | basketball | gang | aliens) AND @category:{tech|science|engineering})",
+        "(~@description:(toon | squad | play | basketball | gang | aliens) @category:{tech|science|engineering})",
         "SCORER",
         "BM25STD",
         "VSIM",
@@ -418,7 +418,7 @@ def test_hybrid_query_with_tag_filter():
 
     assert get_query_pieces(hybrid_query) == [
         "SEARCH",
-        "(~@description:(toon | squad | play | basketball | gang | aliens) AND @genre:{comedy})",
+        "(~@description:(toon | squad | play | basketball | gang | aliens) @genre:{comedy})",
         "SCORER",
         "BM25STD",
         "VSIM",
@@ -452,7 +452,8 @@ def test_hybrid_query_with_numeric_filter():
     # Verify filter is included in serialized query
     args = get_query_pieces(hybrid_query)
     expected = "@age:[(30 +inf]"
-    assert args[1].endswith(f"AND {expected})")  # Check text filter
+    assert args[1].endswith(f" {expected})")  # Check text filter
+    assert " AND " not in args[1]
     assert args[8] == expected  # Check vector filter
 
 
@@ -472,7 +473,8 @@ def test_hybrid_query_with_text_filter():
     # Verify filter is included in serialized query
     args = get_query_pieces(hybrid_query)
     expected = '@job:("engineer")'
-    assert args[1].endswith(f"AND {expected})")  # Check text filter
+    assert args[1].endswith(f" {expected})")  # Check text filter
+    assert " AND " not in args[1]
     assert args[8] == expected  # Check vector filter
 
 
@@ -492,7 +494,8 @@ def test_hybrid_query_with_combined_filters():
     # Verify both filters are included in serialized query
     args = get_query_pieces(hybrid_query)
     expected = "(@genre:{comedy} @rating:[(7.0 +inf])"
-    assert args[1].endswith(f"AND {expected})")  # Check text filter
+    assert args[1].endswith(f" {expected})")  # Check text filter
+    assert " AND " not in args[1]
     assert args[8] == expected  # Check vector filter
 
 

tests/unit/test_query_types.py

@@ -300,7 +300,11 @@ def test_text_query_with_string_filter():
     # Check that the generated query string includes both text search and filter
     query_string = str(text_query)
     assert f"@{text_field_name}:(search | document | 12345)" in query_string
-    assert f"AND {string_filter}" in query_string
+    assert (
+        f"@{text_field_name}:(search | document | 12345) {string_filter}"
+        in query_string
+    )
+    assert " AND " not in query_string
 
     # Test with FilterExpression - should also work (existing functionality)
     filter_expression = Tag("category") == "tech"
@@ -319,7 +323,11 @@ def test_text_query_with_string_filter():
         f"@{text_field_name}:(search | document | 12345)"
         in query_string_with_filter_expr
     )
-    assert "AND @category:{tech}" in query_string_with_filter_expr
+    assert (
+        f"@{text_field_name}:(search | document | 12345) @category:{{tech}}"
+        in query_string_with_filter_expr
+    )
+    assert " AND " not in query_string_with_filter_expr
 
     # Test with no filter - should only have text search
     text_query_no_filter = TextQuery(
@@ -331,7 +339,7 @@ def test_text_query_with_string_filter():
     assert f"@{text_field_name}:(search | document | 12345)" in query_string_no_filter
     assert "AND" not in query_string_no_filter
 
-    # Test with wildcard filter - should only have text search (no AND clause)
+    # Test with wildcard filter - should only have text search (no filter clause)
     text_query_wildcard = TextQuery(
         text=text,
         text_field_name=text_field_name,