Multiprefix/test

docs/api/query.rst

@@ -231,3 +231,23 @@ MultiVectorQuery
    :inherited-members:
    :show-inheritance:
    :exclude-members: add_filter,get_args,highlight,return_field,summarize
+
+
+SQLQuery
+========
+
+.. currentmodule:: redisvl.query
+
+
+.. autoclass:: SQLQuery
+   :members:
+   :show-inheritance:
+
+.. note::
+   SQLQuery requires the optional ``sql-redis`` package. Install with:
+   ``pip install redisvl[sql-redis]``
+
+.. note::
+   SQLQuery translates SQL SELECT statements into Redis FT.SEARCH or FT.AGGREGATE commands.
+   The SQL syntax supports WHERE clauses, field selection, ordering, and parameterized queries
+   for vector similarity searches.

docs/user_guide/index.md

@@ -23,4 +23,5 @@ User guides provide helpful resources for using RedisVL and its different compon
 09_svs_vamana
 10_embeddings_cache
 11_advanced_queries
+12_sql_to_redis_queries
 ```

examples/multi_prefix_example.py

@@ -0,0 +1,140 @@
+"""
+Example: Multi-prefix index workaround
+
+This script demonstrates how to:
+1. Manually create a multi-prefix index using execute_command
+2. Connect to it using SearchIndex.from_existing()
+3. Load data with different prefixes using the keys parameter
+4. Query and verify results come from both prefixes
+"""
+
+import redis
+from redisvl.index import SearchIndex
+from redisvl.query import VectorQuery
+from redisvl.redis.utils import array_to_buffer
+
+# Connect to Redis
+client = redis.Redis(host="localhost", port=6379, decode_responses=True)
+
+INDEX_NAME = "user_simple"
+
+# Clean up any existing index
+try:
+    client.ft(INDEX_NAME).dropindex(delete_documents=True)
+except Exception:
+    pass
+
+# 1. Manually create the multi-prefix index
+print("Creating multi-prefix index...")
+client.execute_command(
+    "FT.CREATE", INDEX_NAME,
+    "ON", "HASH",
+    "PREFIX", "2", "prefix_1:", "prefix_2:",
+    "SCHEMA",
+    "user", "TAG",
+    "credit_score", "TAG",
+    "job", "TEXT",
+    "age", "NUMERIC",
+    "user_embedding", "VECTOR", "FLAT", "6",
+        "TYPE", "FLOAT32",
+        "DIM", "3",
+        "DISTANCE_METRIC", "COSINE"
+)
+print("Index created with prefixes: prefix_1:, prefix_2:")
+
+# 2. Connect using from_existing
+index = SearchIndex.from_existing(INDEX_NAME, redis_client=client)
+print(f"Connected to index. Prefixes: {index.schema.index.prefix}")
+
+# 3. Prepare test data
+data_prefix_1 = [
+    {
+        "user": "john",
+        "credit_score": "high",
+        "job": "engineer",
+        "age": 30,
+        "user_embedding": array_to_buffer([0.1, 0.2, 0.3], dtype="float32"),
+    },
+    {
+        "user": "jane",
+        "credit_score": "medium",
+        "job": "doctor",
+        "age": 35,
+        "user_embedding": array_to_buffer([0.2, 0.3, 0.4], dtype="float32"),
+    },
+]
+
+data_prefix_2 = [
+    {
+        "user": "bob",
+        "credit_score": "low",
+        "job": "teacher",
+        "age": 40,
+        "user_embedding": array_to_buffer([0.3, 0.4, 0.5], dtype="float32"),
+    },
+    {
+        "user": "alice",
+        "credit_score": "high",
+        "job": "lawyer",
+        "age": 45,
+        "user_embedding": array_to_buffer([0.4, 0.5, 0.6], dtype="float32"),
+    },
+]
+
+# 4. Load data with explicit keys for each prefix
+print("\nLoading data with prefix_1...")
+keys_p1 = ["prefix_1:doc1", "prefix_1:doc2"]
+index.load(data_prefix_1, keys=keys_p1)
+print(f"Loaded keys: {keys_p1}")
+
+print("\nLoading data with prefix_2...")
+keys_p2 = ["prefix_2:doc1", "prefix_2:doc2"]
+index.load(data_prefix_2, keys=keys_p2)
+print(f"Loaded keys: {keys_p2}")
+
+# 5. Query and verify we get results from both prefixes
+print("\n" + "="*50)
+print("Running vector search...")
+print("="*50)
+
+query = VectorQuery(
+    vector=[0.2, 0.3, 0.4],
+    vector_field_name="user_embedding",
+    return_fields=["user", "credit_score", "job", "age"],
+    num_results=10,
+)
+
+results = index.query(query)
+
+print(f"\nFound {len(results)} results:\n")
+
+prefix_1_count = 0
+prefix_2_count = 0
+
+for r in results:
+    key = r.get("id", "")
+    if key.startswith("prefix_1:"):
+        prefix_1_count += 1
+    elif key.startswith("prefix_2:"):
+        prefix_2_count += 1
+    print(f"  Key: {key}")
+    print(f"    User: {r.get('user')}, Job: {r.get('job')}, Age: {r.get('age')}")
+    print()
+
+# 6. Verify both prefixes are represented
+print("="*50)
+print("VERIFICATION")
+print("="*50)
+print(f"Results from prefix_1: {prefix_1_count}")
+print(f"Results from prefix_2: {prefix_2_count}")
+
+if prefix_1_count > 0 and prefix_2_count > 0:
+    print("\n✅ SUCCESS: Query returned results from BOTH prefixes!")
+else:
+    print("\n❌ FAILED: Expected results from both prefixes")
+
+# Cleanup
+print("\nCleaning up...")
+client.ft(INDEX_NAME).dropindex(delete_documents=True)
+print("Done!")
+

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "redisvl"
-version = "0.13.2"
+version = "0.14.0"
 description = "Python client library and CLI for using Redis as a vector database"
 authors = [{ name = "Redis Inc.", email = "applied.ai@redis.com" }]
 requires-python = ">=3.9.2,<3.14"
@@ -51,6 +51,9 @@ bedrock = [
 pillow = [
     "pillow>=11.3.0",
 ]
+sql-redis = [
+    "sql-redis>=0.1.2",
+]
 
 [project.urls]
 Homepage = "https://github.com/redis/redis-vl-python"
@@ -64,6 +67,9 @@ rvl = "redisvl.cli.runner:main"
 requires = ["hatchling"]
 build-backend = "hatchling.build"
 
+[tool.hatch.metadata]
+allow-direct-references = true
+
 [dependency-groups]
 dev = [
     "black>=25.1.0,<26",

redisvl/index/index.py

@@ -31,6 +31,7 @@
 
 from redisvl.query.hybrid import HybridQuery
 from redisvl.query.query import VectorQuery
+from redisvl.query.sql import SQLQuery
 from redisvl.redis.utils import (
     _keys_share_hash_tag,
     async_cluster_create_index,
@@ -644,8 +645,11 @@ def create(self, overwrite: bool = False, drop: bool = False) -> None:
             self.delete(drop=drop)
 
         try:
+            # Handle prefix as either a single string or a list of strings
+            prefix = self.schema.index.prefix
+            prefix_list = prefix if isinstance(prefix, list) else [prefix]
             definition = IndexDefinition(
-                prefix=[self.schema.index.prefix], index_type=self._storage.type
+                prefix=prefix_list, index_type=self._storage.type
             )
             # Extract stopwords from schema
             stopwords = self.schema.index.stopwords
@@ -917,6 +921,49 @@ def _aggregate(self, aggregation_query: AggregationQuery) -> List[Dict[str, Any]
             storage_type=self.schema.index.storage_type,
         )
 
+    def _sql_query(self, sql_query: SQLQuery) -> List[Dict[str, Any]]:
+        """Execute a SQL query and return results.
+
+        Args:
+            sql_query: The SQLQuery object containing the SQL statement.
+
+        Returns:
+            List of dictionaries containing the query results.
+
+        Raises:
+            ImportError: If sql-redis package is not installed.
+        """
+        try:
+            from sql_redis.executor import Executor
+            from sql_redis.schema import SchemaRegistry
+        except ImportError:
+            raise ImportError(
+                "sql-redis is required for SQL query support. "
+                "Install it with: pip install redisvl[sql-redis]"
+            )
+
+        registry = SchemaRegistry(self._redis_client)
+        registry.load_all()  # Loads index schemas from Redis
+
+        executor = Executor(self._redis_client, registry)
+
+        # Execute the query with any params
+        result = executor.execute(sql_query.sql, params=sql_query.params)
+
+        # Decode bytes to strings in the results (Redis may return bytes)
+        decoded_rows = []
+        for row in result.rows:
+            decoded_row = {}
+            for key, value in row.items():
+                # Decode key if bytes
+                str_key = key.decode("utf-8") if isinstance(key, bytes) else key
+                # Decode value if bytes
+                str_value = value.decode("utf-8") if isinstance(value, bytes) else value
+                decoded_row[str_key] = str_value
+            decoded_rows.append(decoded_row)
+
+        return decoded_rows
+
     def aggregate(self, *args, **kwargs) -> "AggregateResult":
         """Perform an aggregation operation against the index.
 
@@ -1118,7 +1165,7 @@ def _query(self, query: BaseQuery) -> List[Dict[str, Any]]:
         return process_results(results, query=query, schema=self.schema)
 
     def query(
-        self, query: Union[BaseQuery, AggregationQuery, HybridQuery]
+        self, query: Union[BaseQuery, AggregationQuery, HybridQuery, SQLQuery]
     ) -> List[Dict[str, Any]]:
         """Execute a query on the index.
 
@@ -1146,6 +1193,8 @@ def query(
         """
         if isinstance(query, AggregationQuery):
             return self._aggregate(query)
+        elif isinstance(query, SQLQuery):
+            return self._sql_query(query)
         elif isinstance(query, HybridQuery):
             return self._hybrid_search(query)
         else:
@@ -1528,8 +1577,11 @@ async def create(self, overwrite: bool = False, drop: bool = False) -> None:
             await self.delete(drop)
 
         try:
+            # Handle prefix as either a single string or a list of strings
+            prefix = self.schema.index.prefix
+            prefix_list = prefix if isinstance(prefix, list) else [prefix]
             definition = IndexDefinition(
-                prefix=[self.schema.index.prefix], index_type=self._storage.type
+                prefix=prefix_list, index_type=self._storage.type
             )
             # Extract stopwords from schema
             stopwords = self.schema.index.stopwords

redisvl/query/__init__.py

@@ -15,6 +15,7 @@
     VectorQuery,
     VectorRangeQuery,
 )
+from redisvl.query.sql import SQLQuery
 
 __all__ = [
     "BaseQuery",
@@ -29,4 +30,5 @@
     "AggregateHybridQuery",
     "MultiVectorQuery",
     "Vector",
+    "SQLQuery",
 ]