Align date branch patterns with geo branch

- Add @ prefix to LOAD fields in FT.AGGREGATE (bug fix)
- Extract duplicate date mappings into module-level constants:
  - SQLGLOT_TO_SQL_DATE_FUNCTIONS (string-based)
  - SQLGLOT_DATE_EXPR_TYPES (type-based)
- Add validation to reject negated date function conditions
- Add test for negated date function error
- Fix test expecting @category in LOAD args
- Remove duplicate test_parse_select_without_from
- Clean up unused variables in _build_command

Author: nkanu17

.ipynb_checkpoints/geo_examples_consolidated-checkpoint.ipynb

@@ -72,6 +72,30 @@ class DateFunctionSpec:
     "DATE_FORMAT": "timefmt",
 }
 
+# Mapping from sqlglot expression type names to SQL function names
+SQLGLOT_TO_SQL_DATE_FUNCTIONS = {
+    "Year": "YEAR",
+    "Month": "MONTH",
+    "Day": "DAY",
+    "DayOfWeek": "DAYOFWEEK",
+    "DayOfYear": "DAYOFYEAR",
+    "DayOfMonth": "DAY",  # DAY and DayOfMonth are equivalent
+    "Hour": "HOUR",
+    "Minute": "MINUTE",
+}
+
+# Mapping from sqlglot expression types to SQL function names (for type checking)
+SQLGLOT_DATE_EXPR_TYPES = {
+    exp.Year: "YEAR",
+    exp.Month: "MONTH",
+    exp.Day: "DAY",
+    exp.DayOfWeek: "DAYOFWEEK",
+    exp.DayOfYear: "DAYOFYEAR",
+    exp.DayOfMonth: "DAY",
+    exp.Hour: "HOUR",
+    exp.Minute: "MINUTE",
+}
+
 
 @dataclass
 class VectorSearchSpec:
@@ -413,20 +437,8 @@ def _process_date_expression(
             result: The ParsedQuery to update.
             alias: Optional alias for the result.
         """
-        # Map sqlglot expression types to SQL function names
-        sqlglot_to_sql = {
-            "Year": "YEAR",
-            "Month": "MONTH",
-            "Day": "DAY",
-            "DayOfWeek": "DAYOFWEEK",
-            "DayOfYear": "DAYOFYEAR",
-            "DayOfMonth": "DAY",  # DAY and DayOfMonth are equivalent
-            "Hour": "HOUR",
-            "Minute": "MINUTE",
-        }
-
         expr_type = type(expression).__name__
-        func_name = sqlglot_to_sql.get(expr_type)
+        func_name = SQLGLOT_TO_SQL_DATE_FUNCTIONS.get(expr_type)
 
         if func_name and expression.this:
             field_name = None
@@ -488,18 +500,6 @@ def _add_condition(
         field_name = None
         value = None
 
-        # Map sqlglot date expression types to function names
-        date_expr_types = {
-            exp.Year: "YEAR",
-            exp.Month: "MONTH",
-            exp.Day: "DAY",
-            exp.DayOfWeek: "DAYOFWEEK",
-            exp.DayOfYear: "DAYOFYEAR",
-            exp.DayOfMonth: "DAY",
-            exp.Hour: "HOUR",
-            exp.Minute: "MINUTE",
-        }
-
         # Get field name from left side
         if isinstance(expression.this, exp.Column):
             field_name = expression.this.name
@@ -512,9 +512,9 @@ def _add_condition(
                     field_name = first_arg.name
                     # Use function name as operator prefix
                     operator = f"{func_name}_{operator}"
-        elif type(expression.this) in date_expr_types:
+        elif type(expression.this) in SQLGLOT_DATE_EXPR_TYPES:
             # Built-in date expression like YEAR(field), MONTH(field), etc.
-            func_name = date_expr_types[type(expression.this)]
+            func_name = SQLGLOT_DATE_EXPR_TYPES[type(expression.this)]
             if expression.this.this and isinstance(expression.this.this, exp.Column):
                 field_name = expression.this.this.name
                 # Use function name as operator prefix

sql_redis/parser.py

@@ -8,7 +8,6 @@
 from sql_redis.parser import (
     SQL_TO_REDIS_DATE_FUNCTIONS,
     Condition,
-    ParsedQuery,
     SQLParser,
 )
 from sql_redis.query_builder import QueryBuilder
@@ -95,10 +94,6 @@ def _build_command(self, analyzed: AnalyzedQuery) -> TranslatedQuery:
         # Build query string from conditions
         query_string = self._build_query_string(analyzed)
 
-        # Build arguments
-        args: list[str] = []
-        params: dict[str, object] = {}
-
         if use_aggregate:
             return self._build_aggregate(analyzed, query_string)
         else:
@@ -260,7 +255,11 @@ def _build_aggregate(
         if load_fields:
             args.append("LOAD")
             args.append(str(len(load_fields)))
-            args.extend(sorted(load_fields))
+            # Redis expects property names prefixed with '@' in LOAD
+            args.extend(
+                f"@{field}" if not field.startswith("@") else field
+                for field in sorted(load_fields)
+            )
 
         # APPLY for computed fields
         for computed in analyzed.computed_fields:
@@ -288,6 +287,15 @@ def _build_aggregate(
         date_func_conditions = [
             c for c in parsed.conditions if self._is_date_function_condition(c)
         ]
+
+        # Validate: negated date function conditions are not supported
+        for condition in date_func_conditions:
+            if condition.negated:
+                raise ValueError(
+                    "Negated date function conditions (NOT YEAR(...), etc.) "
+                    "are not supported"
+                )
+
         # Track which date functions we've already computed (avoid duplicates)
         computed_date_funcs = {
             (df.function, df.field) for df in analyzed.date_functions

sql_redis/translator.py

@@ -276,7 +276,7 @@ def products_data(redis_client: redis.Redis, products_index: str):
     ]
 
     for i, product in enumerate(products):
-        key = f"product:{i+1}"
+        key = f"product:{i + 1}"
         redis_client.hset(key, mapping=product)
 
     return products_index
@@ -300,7 +300,7 @@ def vec_data(redis_client: redis.Redis, vec_index: str):
     binary_client = redis.Redis(host=host, port=port, decode_responses=False)
 
     for i, vec in enumerate(vectors):
-        key = f"vec:{i+1}"
+        key = f"vec:{i + 1}"
         binary_client.hset(key, mapping=vec)
 
     binary_client.close()
@@ -349,7 +349,7 @@ def items_data(redis_client: redis.Redis, items_index: str):
     ]
 
     for i, item in enumerate(items):
-        key = f"item:{i+1}"
+        key = f"item:{i + 1}"
         binary_client.hset(key, mapping=item)
 
     binary_client.close()

tests/conftest.py

@@ -2,7 +2,7 @@
 
 import pytest
 
-from sql_redis.analyzer import AnalyzedQuery, Analyzer
+from sql_redis.analyzer import Analyzer
 from sql_redis.parser import SQLParser
 
 

tests/test_analyzer.py

@@ -1,7 +1,5 @@
 """Tests for DATE/DATETIME literal parsing and conversion."""
 
-from datetime import datetime, timezone
-
 import pytest
 
 from sql_redis.parser import SQLParser

tests/test_date_fields.py

@@ -2,7 +2,7 @@
 
 import pytest
 
-from sql_redis.parser import DateFunctionSpec, SQLParser
+from sql_redis.parser import SQLParser
 
 
 class TestDateFunctionParsing:
@@ -204,3 +204,9 @@ def test_group_by_year_month(self, date_translator, date_index):
         assert "GROUPBY" in result.args
         assert "REDUCE" in result.args
         assert "COUNT" in result.args
+
+    def test_negated_date_function_raises_error(self, date_translator, date_index):
+        """NOT YEAR(...) should raise a clear error."""
+        sql = f"SELECT * FROM {date_index} WHERE NOT YEAR(created_at) = 2024"
+        with pytest.raises(ValueError, match="Negated date function"):
+            date_translator.translate(sql)

tests/test_date_functions.py

@@ -6,7 +6,7 @@
 import redis
 from testcontainers.redis import RedisContainer
 
-from sql_redis.executor import Executor, QueryResult
+from sql_redis.executor import Executor
 from sql_redis.schema import SchemaRegistry
 
 

tests/test_executor.py

@@ -2,7 +2,6 @@
 
 import struct
 
-import pytest
 import redis
 
 
@@ -279,9 +278,9 @@ def test_between_and_greater_than(
             row_dict = dict(zip(row[::2], row[1::2]))
             if "price" in row_dict:
                 price = float(row_dict["price"])
-                assert (
-                    100 <= price <= 500
-                ), f"Price {price} should be between 100 and 500"
+                assert 100 <= price <= 500, (
+                    f"Price {price} should be between 100 and 500"
+                )
 
 
 class TestTagFieldMultiValueSearch:

tests/test_redis_queries.py

@@ -1,8 +1,6 @@
 """Tests for the SQL parser component."""
 
-import pytest
-
-from sql_redis.parser import ParsedQuery, SQLParser
+from sql_redis.parser import SQLParser
 
 
 class TestSQLParserSelectClause:
@@ -664,14 +662,6 @@ def test_parse_from_values_clause(self):
         # FROM exists but has no Table - index stays empty
         assert result.index == ""
 
-    def test_parse_select_without_from(self):
-        """Parse SELECT without FROM clause."""
-        parser = SQLParser()
-        result = parser.parse("SELECT 1 + 1")
-
-        # No FROM clause at all
-        assert result.index == ""
-
     def test_parse_insert_statement(self):
         """Parse INSERT statement (no SELECT clause)."""
         parser = SQLParser()