relationalai 0.11.3__py3-none-any.whl → 0.12.0__py3-none-any.whl

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

@@ -55,6 +55,17 @@ class CreateView(Node):
     name: str
     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
@@ -286,6 +297,22 @@ class Printer(BasePrinter):
         elif isinstance(node, CreateView):
             self._print(f"CREATE VIEW {self._get_table_name(node.name)} AS ")
             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:

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 datetime, 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)
@@ -43,6 +43,7 @@ __all__ = [
     "datetime",
     "math",
     "strings",
+    "re",
     "decimals",
     "integers",
     "floats",

relationalai/semantics/std/datetime.py

@@ -153,6 +153,10 @@ class datetime:
                           std.cast_to_int64(day), std.cast_to_int64(hour), std.cast_to_int64(minute),
                           std.cast_to_int64(second), std.cast_to_int64(millisecond), tz, b.DateTime.ref("res"))
 
+    @classmethod
+    def now(cls) -> b.Expression:
+        return _make_expr("datetime_now", b.DateTime.ref("res"))
+
     @classmethod
     def year(cls, datetime: _DateTime, tz: dt.tzinfo|_String|None = None) -> b.Expression:
         tz = _extract_tz(datetime, tz)

relationalai/semantics/std/re.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+from relationalai.semantics.internal import internal as i
+from relationalai.semantics.metamodel.util import OrderedSet
+from .std import _Integer, _String, _make_expr
+from typing import Literal, Any
+from .. import std
+
+
+def escape(regex: _String) -> i.Expression:
+    return _make_expr("escape_regex_metachars", regex, i.String.ref())
+
+class Match(i.Producer):
+
+    def __init__(self, regex: _String, string: _String, pos: _Integer = 0, _type: Literal["search", "fullmatch", "match"] = "match"):
+        super().__init__(i.find_model([regex, string, pos]))
+        self.regex = regex
+        self.string = string
+        self.pos = pos
+
+        if _type == "match":
+            self._expr = _regex_match_all(self.regex, self.string, std.cast_to_int64(self.pos + 1))
+            self._offset, self._full_match = self._expr._arg_ref(2), self._expr._arg_ref(3)
+        elif _type == "search":
+            raise NotImplementedError("`search` is not implemented")
+        elif _type == "fullmatch":
+            _exp = _regex_match_all(self.regex, self.string, std.cast_to_int64(self.pos + 1))
+            self._offset, self._full_match = _exp._arg_ref(2), _exp._arg_ref(3)
+            self._expr = self._full_match == std.strings.substring(self.string, std.cast_to_int64(self.pos), std.strings.len(self.string))
+
+    def group(self, index: _Integer = 0) -> i.Producer:
+        if index == 0:
+            return self._full_match
+        else:
+            return _make_expr("capture_group_by_index", self.regex, self.string, std.cast_to_int64(self.pos + 1), std.cast_to_int64(index), i.String.ref("res"))
+
+    def group_by_name(self, name: _String) -> i.Producer:
+        return _make_expr("capture_group_by_name", self.regex, self.string, std.cast_to_int64(self.pos + 1), name, i.String.ref("res"))
+
+    def start(self) -> i.Expression:
+        return self._offset - 1
+
+    def end(self) -> i.Expression:
+        return std.strings.len(self.group(0)) + self.start() - 1
+
+    def span(self) -> tuple[i.Producer, i.Producer]:
+        return self.start(), self.end()
+
+    def _to_keys(self) -> OrderedSet[Any]:
+        return i.find_keys(self._expr)
+
+    def _compile_lookup(self, compiler:i.Compiler, ctx:i.CompilerContext):
+        compiler.lookup(self.regex, ctx)
+        compiler.lookup(self.string, ctx)
+        compiler.lookup(self.pos, ctx)
+        return compiler.lookup(self._expr, ctx)
+
+    def __getattr__(self, name: str) -> Any:
+        return object.__getattribute__(self, name)
+
+    def __setattr__(self, name: str, value: Any) -> None:
+        object.__setattr__(self, name, value)
+
+
+def match(regex: _String, string: _String) -> Match:
+    return Match(regex, string)
+
+def search(regex: _String, string: _String, pos: _Integer = 0) -> Match:
+    return Match(regex, string, pos, _type="search")
+
+def fullmatch(regex: _String, string: _String, pos: _Integer = 0) -> Match:
+    return Match(regex, string, pos, _type="fullmatch")
+
+def findall(regex: _String, string: _String) -> tuple[i.Producer, i.Producer]:
+    exp = _regex_match_all(regex, string)
+    ix, match = exp._arg_ref(2), exp._arg_ref(3)
+    rank = i.rank(i.asc(ix, match))
+    return rank, match
+
+def _regex_match_all(regex: _String, string: _String, pos: _Integer|None = None) -> i.Expression:
+    if pos is None:
+        pos = i.Int64.ref()
+    return _make_expr("regex_match_all", regex, string, pos, i.String.ref())

relationalai/semantics/std/strings.py

@@ -15,7 +15,7 @@ def concat(s0: _String, s1: _String, *args: _String) -> b.Expression:
     return res
 
 def len(s: _String) -> b.Expression:
-    return _make_expr("num_chars", s, b.Int128.ref("res"))
+    return _make_expr("num_chars", s, b.Int64.ref("res"))
 
 def startswith(s0: _String, s1: _String) -> b.Expression:
     return _make_expr("starts_with", s0, s1)

relationalai/tools/cli.py

@@ -16,8 +16,10 @@ from InquirerPy.base.control import Choice
 from relationalai.clients.util import IdentityParser
 from .cli_controls import divider, Spinner
 from . import cli_controls as controls
-from relationalai.clients import azure
-from typing import Sequence, cast, Any, List
+from typing import Sequence, cast, Any, List, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from relationalai.clients import azure
 from relationalai.errors import RAIException
 from relationalai.loaders.types import LoadType, UnsupportedTypeError
 from relationalai.loaders.csv import CSVLoader
@@ -1150,9 +1152,14 @@ def import_source_flow(provider: ResourcesBase) -> Sequence[ImportSource]:
 
     if isinstance(provider, snowflake.Resources):
         return snowflake_import_source_flow(provider)
-    elif isinstance(provider, azure.Resources):
-        return azure_import_source_flow(provider)
     else:
+        # Lazy import for azure to avoid optional dependency issues
+        try:
+            from relationalai.clients import azure
+            if isinstance(provider, azure.Resources):
+                return azure_import_source_flow(provider)
+        except ImportError:
+            pass
         raise Exception(f"No import source flow available for {provider_type.__module__}.{provider_type.__name__}")
 
 def snowflake_import_source_flow(provider: snowflake.Resources) -> Sequence[ImportSource]: