initial commit

Author: abrookins

pyproject.toml

@@ -0,0 +1,21 @@
+[project]
+name = "sql-redis"
+version = "0.1.0"
+description = "SQL to Redis command translation utility"
+requires-python = ">=3.11"
+dependencies = []
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0.0",
+    "testcontainers[redis]>=4.0.0",
+    "redis>=5.0.0",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+

sql_redis/__init__.py

@@ -0,0 +1,6 @@
+"""SQL to Redis command translation utility."""
+
+from sql_redis.translator import translate_sql
+
+__all__ = ["translate_sql"]
+

sql_redis/analyzer.py

@@ -0,0 +1,65 @@
+"""SQL analyzer component - resolves field types from schema."""
+
+from dataclasses import dataclass, field
+
+from sql_redis.parser import ParsedQuery, AggregationSpec, ComputedField, Condition
+
+
+@dataclass
+class VectorSearchAnalysis:
+    """Analyzed vector search details."""
+    field: str
+    k: int
+    alias: str
+
+
+@dataclass
+class AnalyzedQuery:
+    """Result of analyzing a parsed SQL query with schema context."""
+    
+    parsed: ParsedQuery = field(default_factory=ParsedQuery)
+    field_types: dict[str, str] = field(default_factory=dict)
+    aggregations: list[AggregationSpec] = field(default_factory=list)
+    computed_fields: list[ComputedField] = field(default_factory=list)
+    groupby_fields: list[str] = field(default_factory=list)
+    is_global_aggregation: bool = False
+    vector_search: VectorSearchAnalysis | None = None
+    has_prefilter: bool = False
+    
+    def get_field_type(self, field_name: str) -> str | None:
+        """Get the type of a field."""
+        return self.field_types.get(field_name)
+    
+    def get_conditions_by_type(self, field_type: str) -> list[Condition]:
+        """Get conditions for fields of a specific type."""
+        return [
+            c for c in self.parsed.conditions
+            if self.field_types.get(c.field) == field_type
+        ]
+
+
+class Analyzer:
+    """Analyzes parsed SQL queries with schema context."""
+    
+    def __init__(self, schemas: dict[str, dict[str, str]]):
+        """Initialize analyzer with schema registry data.
+        
+        Args:
+            schemas: Dict mapping index names to field->type dicts.
+        """
+        self._schemas = schemas
+    
+    def analyze(self, parsed: ParsedQuery) -> AnalyzedQuery:
+        """Analyze a parsed query, resolving field types.
+        
+        Args:
+            parsed: The parsed SQL query.
+            
+        Returns:
+            An AnalyzedQuery with field types resolved.
+            
+        Raises:
+            ValueError: If the index or a field is unknown.
+        """
+        raise NotImplementedError("Analyzer.analyze is not yet implemented")
+

sql_redis/parser.py

@@ -0,0 +1,89 @@
+"""SQL parser component using sqlglot."""
+
+from dataclasses import dataclass, field
+
+import sqlglot
+from sqlglot import exp
+
+
+@dataclass
+class AggregationSpec:
+    """Specification for an aggregation function."""
+    function: str
+    field: str | None = None
+    alias: str | None = None
+
+
+@dataclass
+class ComputedField:
+    """Specification for a computed/APPLY field."""
+    expression: str
+    alias: str
+
+
+@dataclass
+class VectorSearchSpec:
+    """Specification for vector search."""
+    field: str
+    alias: str
+    k: int | None = None
+
+
+@dataclass
+class Condition:
+    """A WHERE condition."""
+    field: str
+    operator: str
+    value: object
+    negated: bool = False
+
+
+@dataclass
+class ParsedQuery:
+    """Result of parsing a SQL query."""
+    index: str = ""
+    fields: list[str] = field(default_factory=list)
+    conditions: list[Condition] = field(default_factory=list)
+    boolean_operator: str = "AND"
+    aggregations: list[AggregationSpec] = field(default_factory=list)
+    computed_fields: list[ComputedField] = field(default_factory=list)
+    vector_search: VectorSearchSpec | None = None
+    groupby_fields: list[str] = field(default_factory=list)
+    orderby_fields: list[tuple[str, str]] = field(default_factory=list)  # (field, ASC|DESC)
+    limit: int | None = None
+    offset: int | None = None
+
+
+class SQLParser:
+    """Parses SQL into a ParsedQuery structure."""
+
+    def parse(self, sql: str) -> ParsedQuery:
+        """Parse a SQL statement into a ParsedQuery.
+
+        Args:
+            sql: The SQL statement to parse.
+
+        Returns:
+            A ParsedQuery containing the extracted components.
+        """
+        ast = sqlglot.parse_one(sql)
+        result = ParsedQuery()
+
+        # Extract FROM clause (index name)
+        from_clause = ast.find(exp.From)
+        if from_clause:
+            table = from_clause.find(exp.Table)
+            if table:
+                result.index = table.name
+
+        # Extract SELECT fields
+        select = ast.find(exp.Select)
+        if select:
+            for expression in select.expressions:
+                if isinstance(expression, exp.Column):
+                    result.fields.append(expression.name)
+                elif isinstance(expression, exp.Star):
+                    result.fields.append("*")
+
+        return result
+

sql_redis/query_builder.py

@@ -0,0 +1,162 @@
+"""RediSearch query builder - generates query syntax from analyzed queries."""
+
+
+class QueryBuilder:
+    """Builds RediSearch query syntax from conditions."""
+    
+    def build_text_condition(
+        self, 
+        field: str | list[str], 
+        operator: str, 
+        value: str,
+        negated: bool = False
+    ) -> str:
+        """Build query syntax for TEXT field conditions.
+        
+        Args:
+            field: Field name or list of field names for multi-field search.
+            operator: One of =, MATCH, LIKE, FUZZY.
+            value: The search term or pattern.
+            negated: If True, prefix with - for negation.
+            
+        Returns:
+            RediSearch query syntax like @field:term or @field:"phrase".
+        """
+        raise NotImplementedError("build_text_condition is not yet implemented")
+    
+    def build_tag_condition(
+        self,
+        field: str,
+        operator: str,
+        value: str | list[str]
+    ) -> str:
+        """Build query syntax for TAG field conditions.
+        
+        Args:
+            field: Field name.
+            operator: One of =, !=, IN.
+            value: Tag value or list of values for IN.
+            
+        Returns:
+            RediSearch query syntax like @field:{value} or @field:{v1|v2}.
+        """
+        raise NotImplementedError("build_tag_condition is not yet implemented")
+    
+    def build_numeric_condition(
+        self,
+        field: str,
+        operator: str,
+        value: int | float | tuple[int | float, int | float]
+    ) -> str:
+        """Build query syntax for NUMERIC field conditions.
+        
+        Args:
+            field: Field name.
+            operator: One of =, !=, <, <=, >, >=, BETWEEN.
+            value: Numeric value or (min, max) tuple for BETWEEN.
+            
+        Returns:
+            RediSearch query syntax like @field:[min max].
+        """
+        raise NotImplementedError("build_numeric_condition is not yet implemented")
+    
+    def build_vector_condition(
+        self,
+        field: str,
+        k: int,
+        alias: str,
+        prefilter: str | None = None
+    ) -> str:
+        """Build query syntax for VECTOR KNN search.
+        
+        Args:
+            field: Vector field name.
+            k: Number of nearest neighbors.
+            alias: Alias for the distance score.
+            prefilter: Optional pre-filter query string.
+            
+        Returns:
+            RediSearch query syntax like =>[KNN k @field $BLOB AS alias].
+        """
+        raise NotImplementedError("build_vector_condition is not yet implemented")
+    
+    def build_geo_filter(
+        self,
+        field: str,
+        lon: float,
+        lat: float,
+        radius: float,
+        unit: str = "km"
+    ) -> str:
+        """Build GEOFILTER clause for GEO fields.
+        
+        Args:
+            field: GEO field name.
+            lon: Longitude.
+            lat: Latitude.
+            radius: Search radius.
+            unit: Distance unit (km, m, mi, ft).
+            
+        Returns:
+            GEOFILTER clause like "GEOFILTER field lon lat radius unit".
+        """
+        raise NotImplementedError("build_geo_filter is not yet implemented")
+    
+    def build_geo_distance_apply(
+        self,
+        field: str,
+        lon: float,
+        lat: float,
+        alias: str,
+        unit: str = "m"
+    ) -> str:
+        """Build APPLY geodistance expression.
+        
+        Args:
+            field: GEO field name.
+            lon: Longitude.
+            lat: Latitude.
+            alias: Alias for the distance result.
+            unit: Distance unit for conversion.
+            
+        Returns:
+            APPLY clause like 'APPLY "geodistance(@field, lon, lat)" AS alias'.
+        """
+        raise NotImplementedError("build_geo_distance_apply is not yet implemented")
+    
+    def combine_conditions(
+        self,
+        conditions: list[str],
+        operator: str = "AND"
+    ) -> str:
+        """Combine multiple condition strings with boolean operator.
+        
+        Args:
+            conditions: List of query condition strings.
+            operator: Boolean operator (AND, OR).
+            
+        Returns:
+            Combined query string.
+        """
+        raise NotImplementedError("combine_conditions is not yet implemented")
+    
+    def build_query_string(
+        self,
+        text_conditions: list[tuple] | None = None,
+        numeric_conditions: list[tuple] | None = None,
+        tag_conditions: list[tuple] | None = None,
+        field_types: dict[str, str] | None = None
+    ) -> str:
+        """Build complete query string from conditions.
+        
+        Args:
+            text_conditions: List of (field, operator, value) tuples.
+            numeric_conditions: List of (field, operator, value) tuples.
+            tag_conditions: List of (field, operator, value) tuples.
+            field_types: Dict mapping field names to types.
+            
+        Returns:
+            Complete RediSearch query string.
+        """
+        raise NotImplementedError("build_query_string is not yet implemented")
+