relationalai 0.11.2__py3-none-any.whl → 0.11.4__py3-none-any.whl

relationalai/semantics/sql/executor/duck_db.py

@@ -1,8 +1,10 @@
 from __future__ import annotations
 
 import duckdb
+import math
 from pandas import DataFrame
 from typing import Any, Union, Literal
+from scipy.special import erfinv as special_erfinv
 
 from relationalai.semantics.sql import Compiler
 from relationalai.semantics.sql.executor.result_helpers import format_duckdb_columns
@@ -18,10 +20,29 @@ class DuckDBExecutor(e.Executor):
         """ Execute the SQL query directly. """
         if format != "pandas":
             raise ValueError(f"Unsupported format: {format}")
+
         connection = duckdb.connect()
+
+        # Register scalar functions
+        connection.create_function("erf", self.erf)
+        connection.create_function("acot", self.acot)
+        connection.create_function("erfinv", self.erfinv)
+
         try:
             sql, _ = self.compiler.compile(model, {"is_duck_db": True})
             arrow_table = connection.query(sql).fetch_arrow_table()
             return format_duckdb_columns(arrow_table.to_pandas(), arrow_table.schema)
         finally:
             connection.close()
+
+    @staticmethod
+    def erf(x: float) -> float:
+        return math.erf(x)
+
+    @staticmethod
+    def erfinv(x: float) -> float:
+        return special_erfinv(x)
+
+    @staticmethod
+    def acot(x: float) -> float:
+        return math.atan(1 / x) if x != 0 else math.copysign(math.pi / 2, x)

relationalai/semantics/sql/executor/result_helpers.py

@@ -35,7 +35,14 @@ def format_columns(result_frame:pd.DataFrame, result_metadata:Sequence[ResultMet
                 result_frame[col] = series.astype(Int128Dtype())
             elif col_metadata.precision:
                 result_frame[col] = _cast_integer_column(series, col_metadata.precision)
+        # Handle Snowflake VARIANT columns that are actually numeric
+        elif FIELD_ID_TO_NAME[col_metadata.type_code] == "VARIANT":
+            series = result_frame[col]
 
+            if col_type == Int64:
+                result_frame[col] = series.astype("Int64")
+            elif col_type == Int128:
+                result_frame[col] = series.astype(Int128Dtype())
 
         # SQL may return None for nulls; replace with np.nan unless the column is FIXED, because
         # both Int64 and Int128 already deal with nulls using pd.NA

relationalai/semantics/sql/executor/snowflake.py

@@ -65,9 +65,15 @@ class SnowflakeExecutor(e.Executor):
                 update: bool = False) -> Union[pd.DataFrame, Any]:
         """ Execute the SQL query directly. """
 
+        warehouse = self.resources.config.get("warehouse", None)
+        default_dynamic_table_target_lag = (
+            self.resources.config.get("reasoner.rule.sql.default_dynamic_table_target_lag", None))
+
+        options = {"warehouse": warehouse, "default_dynamic_table_target_lag": default_dynamic_table_target_lag}
+
         if self._last_model != model:
             with debugging.span("compile", metamodel=model) as model_span:
-                model_sql, _ = self.compiler.compile(model)
+                model_sql, _ = self.compiler.compile(model, options)
                 model_span["compile_type"] = "model"
                 model_span["sql"] = model_sql
                 self._last_model = model
@@ -77,7 +83,8 @@ class SnowflakeExecutor(e.Executor):
             # compile into sql and keep the new_task, which is the task model after rewrites,
             # as it may contain results of type inference, which is useful for determining
             # how to format the outputs
-            query_sql, new_task = self.compiler.compile(f.compute_model(f.logical([task])), {"query_compilation": True})
+            query_options = {**options, "query_compilation": True}
+            query_sql, new_task = self.compiler.compile(f.compute_model(f.logical([task])), query_options)
             compile_span["compile_type"] = "query"
             compile_span["sql"] = query_sql
 

relationalai/semantics/sql/rewrite/denormalize.py

@@ -25,7 +25,6 @@ class Denormalize(c.Pass):
 
 @dataclass
 class OldDenormalize(visitor.Rewriter):
-    # TODO: use the new Rewriter when available.
 
     denormalized: dict[ir.Relation, ir.Relation] = field(default_factory=dict, init=False, hash=False, compare=False)
 
@@ -168,13 +167,12 @@ class OldDenormalize(visitor.Rewriter):
         """ Denormalize the relations that can be denormalized.
 
         Group together relations that are keyed by the same "entity". This method defines
-        entities as being types that haver a unary relation containing only that type. All
+        entities as being types that have a unary relation containing only that type. All
         relations whose first argument is this type are grouped together.
 
         Returns a tuple with 2 elements:
-        1. the new set of relations after denormalization
-        2. a dict from relations that were denormalized away to the new relation that took
-        its place.
+        1. The new set of relations after denormalization
+        2. A dict from relations that were denormalized away to the new relation that took its place.
         """
         new_relations = ordered_set()
         denormalized: dict[ir.Relation, ir.Relation] = dict()
@@ -184,7 +182,7 @@ class OldDenormalize(visitor.Rewriter):
         entity_relations: dict[ir.Type, ir.Relation] = dict()
 
         for r in relations:
-            if len(r.fields) == 1 and not types.is_builtin(r.fields[0].type):
+            if len(r.fields) == 1 and not types.is_builtin(r.fields[0].type) and not r.name == 'Error':
                 e = r.fields[0].type
                 entity_types.add(e)
                 entity_relations[e] = r

relationalai/semantics/sql/rewrite/recursive_union.py

@@ -49,9 +49,29 @@ class RecursiveUnion(c.Pass):
             new_body = [logical for logical in root_logical.body if logical not in recursive_logicals]
 
             # Step 4: Add unions for each recursive group
-            for group in recursive_groups.values():
-                if group:
-                    new_body.append(f.union(list(group)))
+            for rel_id, logical_group in recursive_groups.items():
+                split_group = ordered_set()
+
+                for logical in logical_group:
+                    # Count total ir.Update tasks in this logical
+                    update_count = sum(isinstance(t, ir.Update) for t in logical.body)
+
+                    # If there's only one, keep the original logical as-is
+                    if update_count == 1:
+                        split_group.add(logical)
+                        continue
+
+                    # Otherwise, keep only updates relevant to this relation (and non-update tasks)
+                    filtered_body = [
+                        t for t in logical.body
+                        if not isinstance(t, ir.Update) or t.relation.id == rel_id
+                    ]
+
+                    if filtered_body:
+                        split_group.add(f.logical(filtered_body))
+
+                if split_group:
+                    new_body.append(f.union(list(split_group)))
 
             return model.reconstruct(model.engines, model.relations, model.types, f.logical(new_body), model.annotations)
 

relationalai/semantics/sql/sql.py

@@ -6,7 +6,7 @@ from __future__ import annotations
 import datetime
 from dataclasses import dataclass
 from io import StringIO
-from typing import Optional, Union, Tuple, Any
+from typing import Optional, Union, Tuple, Any, Sequence
 from relationalai.semantics.metamodel.util import Printer as BasePrinter
 import json
 
@@ -43,17 +43,35 @@ class CreateTable(Node):
     table: Table
     if_not_exists: bool = False
 
+@dataclass(frozen=True)
+class CreateDynamicTable(Node):
+    name: str
+    query: Union[list[Select], CTE]
+    target_lag: str
+    warehouse: str
+
 @dataclass(frozen=True)
 class CreateView(Node):
     name: str
-    query: Union[Select, CTE]
+    query: Union[list[Select], CTE]
+
+@dataclass(frozen=True)
+class CreateFunction(Node):
+    name: str
+    inputs: list[Column]
+    return_type: str
+    body: str
+    language: str = "PYTHON"
+    runtime_version: str = "3.11"
+    handler: str = "compute"
+    packages: Optional[list[str]] = None
 
 @dataclass(frozen=True)
 class Insert(Node):
     table: str
     columns: list[str]
     values: list[Tuple[Any, ...]]
-    select: Optional[Select]
+    query: Optional[Union[Select, CTE]] = None
 
 @dataclass(frozen=True)
 class Update(Node):
@@ -69,11 +87,12 @@ class UpdateSet(Node):
 @dataclass(frozen=True)
 class Select(Node):
     distinct: bool
-    vars: list[Union[VarRef, RowNumberVar, int]]
-    froms: Union[list[From], Select]
+    vars: Optional[Sequence[Union[VarRef, RowNumberVar, int]]] = None
+    froms: Optional[Union[list[From], Select]] = None
     where: Optional[Where] = None
     joins: Optional[list[Join]] = None
     group_by: Optional[list[VarRef]] = None
+    order_by: Optional[list[VarRef]] = None
     limit: Optional[int] = None
     is_output: bool = False
 
@@ -86,11 +105,12 @@ class VarRef(Node):
     name: str
     column: Optional[str] = None
     alias: Optional[str] = None
+    type: Optional[str] = None
 
 @dataclass(frozen=True)
 class From(Node):
     table: str
-    alias: Optional[str]
+    alias: Optional[str] = None
 
 @dataclass(frozen=True)
 class Join(Node):
@@ -106,11 +126,16 @@ class LeftOuterJoin(Join):
 class FullOuterJoin(Join):
     pass
 
+@dataclass(frozen=True)
+class JoinWithoutCondition(Join):
+    pass
+
 @dataclass(frozen=True)
 class RowNumberVar(Node):
     order_by_vars: list[OrderByVar]
     partition_by_vars: list[str]
     alias: str
+    type: Optional[str] = None
 
 @dataclass(frozen=True)
 class OrderByVar(Node):
@@ -120,7 +145,7 @@ class OrderByVar(Node):
 # TODO: consider removing Where and make Select.where: Expr
 @dataclass(frozen=True)
 class Where(Node):
-    expression: Expr
+    expression: Optional[Expr] = None
 
 @dataclass(frozen=True)
 class RawSource(Node):
@@ -139,6 +164,7 @@ class CTE(Node):
     name: str
     columns: list[str]
     selects: list[Select]
+    distinct: bool = False
 
 #-------------------------------------------------
 # Expressions
@@ -216,10 +242,9 @@ class Printer(BasePrinter):
                     self._print(", ")
                 self._print_value(v, True)
         elif isinstance(value, str):
-            if quote_strings:
-                self._print(json.dumps(value))
-            else:
-                self._print(value)
+            value = 'NULL' if value.lower() == 'none' else value
+            value = json.dumps(value) if quote_strings else value
+            self._print(value)
         elif isinstance(value, bool):
             self._print(str(value).lower())
         elif isinstance(value, datetime.date):
@@ -229,6 +254,18 @@ class Printer(BasePrinter):
         else:
             self._print(str(value))
 
+    def _print_query(self, indent, node, union_type:str = "UNION ALL"):
+        queries = node.query if isinstance(node.query, list) else [node.query]
+        if len(queries) == 1:
+            self.print_node(queries[0], indent, True)
+        else:
+            for i, s in enumerate(queries):
+                self._nl()
+                if i != 0:
+                    self._indent_print_nl(indent + 2, union_type)
+                self.print_node(s, indent + 1, True)
+        self._print(";")
+
     def _get_table_name(self, name: str) -> str:
         return f'"{name}"' if self._is_reserved_name(name) else name
 
@@ -251,12 +288,31 @@ class Printer(BasePrinter):
         elif isinstance(node, CreateTable):
             clause = "IF NOT EXISTS " if node.if_not_exists else ""
             self._print(f"CREATE TABLE {clause}{node.table};")
+        elif isinstance(node, CreateDynamicTable):
+            self._print_nl(f"CREATE DYNAMIC TABLE {self._get_table_name(node.name)}")
+            self._indent_print_nl(indent+1, f"TARGET_LAG = '{node.target_lag}'")
+            self._indent_print_nl(indent+1, f"WAREHOUSE = '{node.warehouse}'")
+            self._print("AS ")
+            self._print_query(indent, node)
         elif isinstance(node, CreateView):
-            # TODO - crying a bit inside :(
-            self._print_nl(f"DROP TABLE IF EXISTS {self._get_table_name(node.name)};")
             self._print(f"CREATE VIEW {self._get_table_name(node.name)} AS ")
-            self.print_node(node.query, indent, True)
-            self._print(";")
+            self._print_query(indent, node, "UNION")
+        elif isinstance(node, CreateFunction):
+            self._print(f"CREATE OR REPLACE FUNCTION {self._get_table_name(node.name)} (")
+            self._join(node.inputs)
+            self._print_nl(")")
+            self._print_nl(f"RETURNS {node.return_type}")
+            self._print_nl(f"LANGUAGE {node.language}")
+            self._print_nl(f"RUNTIME_VERSION = '{node.runtime_version}'")
+            self._print_nl(f"HANDLER = '{node.handler}'")
+            if node.packages:
+                self._print("PACKAGES = (")
+                self._join(node.packages)
+                self._print_nl(")")
+            self._print_nl("AS ")
+            self._print_nl("$$")
+            self._print_nl(node.body)
+            self._print("$$;")
         elif isinstance(node, Insert):
             self._print(f"INSERT INTO {self._get_table_name(node.table)} ")
             if len(node.columns) > 0:
@@ -271,9 +327,9 @@ class Printer(BasePrinter):
                         self._print(" UNION ALL ")
                     self._print("SELECT ")
                     self._join(value)
-            if node.select is not None:
-                self.print_node(node.select, indent, True)
-            self._print(";")
+                self._print(";")
+            if node.query is not None:
+                self._print_query(indent, node)
         elif isinstance(node, Update):
             self._print(f"UPDATE {self._get_table_name(node.table)} SET ")
             self._join(node.set)
@@ -286,13 +342,16 @@ class Printer(BasePrinter):
             self._indent_print(indent, "SELECT ")
             if node.distinct and node.froms:
                 self._print("DISTINCT ")
-            self._join(node.vars, is_output=node.is_output or is_output)
+            if node.vars:
+                self._join(node.vars, is_output=node.is_output or is_output)
+            else:
+                self._print("*")
             if node.froms:
                 self._print(" FROM ")
                 if isinstance(node.froms, Select):
-                    # If `froms` is a `Select`, we need to print it inline
+                    # If `froms` is a `Select`, we need to print it inline, and we do not need to indent it
                     self._print("( ")
-                    self.print_node(node.froms, indent, True)
+                    self.print_node(node.froms, 0, True)
                     self._print(" )")
                 else:
                     self._join(node.froms)
@@ -304,6 +363,9 @@ class Printer(BasePrinter):
             if node.group_by:
                 self._print(" GROUP BY ")
                 self._join(node.group_by)
+            if node.order_by:
+                self._print(" ORDER BY ")
+                self._join(node.order_by)
             if node.limit:
                 self._print(f" LIMIT {node.limit}")
             if not inlined:
@@ -321,41 +383,48 @@ class Printer(BasePrinter):
                 if not inlined:
                     self._print(";")
         elif isinstance(node, VarRef):
+            # --- Handle column or name ---
             if node.column is None:
                 self._print(node.name)
+            elif node.column.lower() in ("any", "order"):
+                self._print(f'{node.name}."{node.column}"')
             else:
-                if node.column.lower() in ("any", "order"):
-                    self._print(f'{node.name}."{node.column}"')
-                else:
-                    self._print(f"{node.name}.{node.column}")
+                self._print(f"{node.name}.{node.column}")
+            # --- Add CAST if needed ---
+            if node.type:
+                self._print(f"::{node.type}")
+            # --- Handle alias ---
             if node.alias:
+                needs_quotes = any(c in node.alias for c in ['-', '?'])
                 if is_output:
                     self._print(f' as "{node.alias}"')
-                elif node.alias != node.column:
-                    if any(c in node.alias for c in ['-', '?']):
-                        self._print(f' as "{node.alias}"')
-                    else:
-                        self._print(f" as {node.alias}")
+                elif node.alias != node.column or node.type or needs_quotes:
+                    alias_str = f'"{node.alias}"' if needs_quotes else node.alias
+                    self._print(f" as {alias_str}")
         elif isinstance(node, RowNumberVar):
+            # --- ROW_NUMBER clause ---
             self._print("ROW_NUMBER() OVER (")
+            # --- Partition by (if present) ---
             if node.partition_by_vars:
                 self._print(" PARTITION BY ")
                 self._join(node.partition_by_vars)
+            # --- ORDER BY ---
             self._print(" ORDER BY ")
             self._join(node.order_by_vars)
-            if is_output:
-                self._print(f' ) as "{node.alias}"')
-            else:
-                self._print(f' ) as {node.alias}')
+            self._print(" )")
+            # --- Add CAST if needed ---
+            if node.type:
+                self._print(f"::{node.type}")
+            # --- Handle alias ---
+            alias_str = f' as "{node.alias}"' if is_output else f' as {node.alias}'
+            self._print(alias_str)
         elif isinstance(node, OrderByVar):
             self._print(node.var)
-            if node.is_ascending:
-                self._print(" ASC")
-            else:
-                self._print(" DESC")
+            direction = "ASC" if node.is_ascending else "DESC"
+            self._print(f" {direction}")
         elif isinstance(node, From):
             self._print(self._get_table_name(node.table))
-            if node.alias is not None:
+            if node.alias:
                 self._print(f" AS {node.alias}")
         elif isinstance(node, Join):
             join_type = (
@@ -366,13 +435,15 @@ class Printer(BasePrinter):
             self._print(f"{join_type} {self._get_table_name(node.table)}")
             if node.alias is not None:
                 self._print(f" AS {node.alias}")
-            self._print(" ON ")
-            if node.on is None:
-                self._print("TRUE")
-            else:
-                self.print_node(node.on, indent, True)
+            if not isinstance(node, JoinWithoutCondition):
+                self._print(" ON ")
+                if node.on is None:
+                    self._print("TRUE")
+                else:
+                    self.print_node(node.on, indent, True)
         elif isinstance(node, Where):
-            self._print(f" WHERE {node.expression}")
+            expr = node.expression if node.expression else 'FALSE'
+            self._print(f" WHERE {expr}")
         elif isinstance(node, RawSource):
             self._print(node.src)
 
@@ -390,7 +461,10 @@ class Printer(BasePrinter):
                     self._indent_print_nl(indent + 2, "UNION ALL")
                 self.print_node(s, indent + 1, True)
             self._nl()
-            self._print(f") SELECT * FROM {self._get_table_name(node.name)}")
+            self._print(") SELECT")
+            if node.distinct:
+                self._print(" DISTINCT")
+            self._print(f" * FROM {self._get_table_name(node.name)}")
             if not inlined:
                 self._print(";")
         # --------------------------------------------------

relationalai/semantics/std/__init__.py

@@ -3,7 +3,7 @@ from typing import Any
 
 from relationalai.semantics.internal import internal as i
 from .std import _Date, _DateTime, _Number, _String, _Integer, _make_expr
-from . import dates, math, strings, decimals, integers, floats, pragmas, constraints
+from . import datetime, math, strings, decimals, integers, floats, pragmas, constraints, re
 
 def range(*args: _Integer) -> i.Expression:
     # supports range(stop), range(start, stop), range(start, stop, step)
@@ -23,9 +23,12 @@ def hash(*args: Any, type=i.Hash) -> i.Expression:
         raise ValueError("hash expects at least one argument")
     return _make_expr("hash", i.TupleArg(args), type.ref("res"))
 
-def uuid_to_string(arg:_Integer) -> i.Expression:
+def uuid_to_string(arg: _Integer) -> i.Expression:
     return _make_expr("uuid_to_string", arg, i.String.ref("res"))
 
+def parse_uuid(arg: _String) -> i.Expression:
+    return _make_expr("parse_uuid", arg, i.Hash.ref("res"))
+
 def cast(type: i.Concept, arg: _Date|_DateTime|_Number|_String) -> i.Expression:
     return _make_expr("cast", i.TypeRef(type), arg, type.ref("res"))
 
@@ -37,13 +40,15 @@ __all__ = [
     "range",
     "hash",
     "cast",
-    "dates",
+    "datetime",
     "math",
     "strings",
+    "re",
     "decimals",
     "integers",
     "floats",
     "pragmas",
     "constraints",
-    "uuid_to_string"
+    "uuid_to_string",
+    "parse_uuid",
 ]