relationalai 0.12.8__py3-none-any.whl → 0.12.9__py3-none-any.whl

relationalai/semantics/internal/internal.py

@@ -40,7 +40,7 @@ _global_id = peekable(itertools.count(0))
 
 # Single context variable with default values
 _overrides = ContextVar("overrides", default = {})
-def overrides(key: str, default: bool | str | dict):
+def overrides(key: str, default: bool | str | dict | datetime | None):
     return _overrides.get().get(key, default)
 
 # Flag that users set in the config or directly on the model, but that can still be
@@ -60,6 +60,13 @@ def with_overrides(**kwargs):
     finally:
         _overrides.reset(token)
 
+# Intrinsic values to override for stable snapshots.
+def get_intrinsic_overrides() -> dict[str, Any]:
+    datetime_now = overrides('datetime_now', None)
+    if datetime_now is not None:
+        return {'datetime_now': datetime_now}
+    return {}
+
 #--------------------------------------------------
 # Root tracking
 #--------------------------------------------------
@@ -953,12 +960,25 @@ class Concept(Producer):
                 self._validate_identifier_relationship(rel)
         self._add_ref_scheme(*args)
 
-    def _add_ref_scheme(self, *args: Relationship|RelationshipReading):
-        self._reference_schemes.append(args)
-        # assumed that all Relationship|RelationshipReading are defined on the identified Concept
-        fields = tuple([arg.__getitem__(0) for arg in args])
-        uc = Unique(*fields, model=self._model)
-        require(uc.to_expressions())
+    def _add_ref_scheme(self, *rels: Relationship|RelationshipReading):
+        # thanks to prior validation we we can safely assume that
+        # * the input types are correct due to prior validation
+        # * all relationships are binary and defined on this concept
+
+        self._reference_schemes.append(rels)
+
+        # for every concept x every field f has at most one value y.
+        # f(x,y): x -> y holds
+        concept_fields = tuple([rel.__getitem__(0) for rel in rels])
+        for field in concept_fields:
+            concept_uc = Unique(field, model=self._model)
+            require(concept_uc.to_expressions())
+
+        # for any combination of field values there is at most one concept x.
+        # f₁(x,y₁) ∧ … ∧ fₙ(x,yₙ): {y₁,…,yₙ} → {x}
+        key_fields = tuple([rel.__getitem__(1) for rel in rels])
+        key_uc = Unique(*key_fields, model=self._model)
+        require(key_uc.to_expressions())
 
     def _validate_identifier_relationship(self, rel:Relationship|RelationshipReading):
         if rel._arity() != 2:
@@ -2603,6 +2623,7 @@ class Model():
         config_overrides = overrides('config', {})
         for k, v in config_overrides.items():
             self._config.set(k, v)
+        self._intrinsic_overrides = get_intrinsic_overrides()
         self._strict = cast(bool, overrides('strict', strict))
         self._use_lqp = overridable_flag('reasoner.rule.use_lqp', self._config, use_lqp, default=not self._use_sql)
         self._enable_otel_handler = overridable_flag('enable_otel_handler', self._config, enable_otel_handler, default=False)
@@ -2644,6 +2665,7 @@ class Model():
                     wide_outputs=self._wide_outputs,
                     connection=self._connection,
                     config=self._config,
+                    intrinsic_overrides=self._intrinsic_overrides,
                 )
             elif self._use_sql:
                 self._executor = SnowflakeExecutor(

relationalai/semantics/lqp/compiler.py

@@ -14,7 +14,7 @@ class Compiler(c.Compiler):
         super().__init__(lqp_passes())
         self.def_names = UniqueNames()
 
-    def do_compile(self, model: ir.Model, options:dict={}) -> tuple[Optional[tuple], lqp.Transaction]:
+    def do_compile(self, model: ir.Model, options:dict={}) -> tuple[Optional[tuple], lqp.Epoch]:
         fragment_id: bytes = options.get("fragment_id", bytes(404))
         # Reset the var context for each compilation
         # TODO: Change to unique var names per lookup

relationalai/semantics/lqp/constructors.py

@@ -59,3 +59,9 @@ def mk_pragma(name: str, terms: list[lqp.Var]) -> lqp.Pragma:
 
 def mk_attribute(name: str, args: list[lqp.Value]) -> lqp.Attribute:
     return lqp.Attribute(name=name, args=args, meta=None)
+
+def mk_transaction(
+    epochs: list[lqp.Epoch],
+    configure: lqp.Configure = lqp.construct_configure({}, None),
+) -> lqp.Transaction:
+    return lqp.Transaction(epochs=epochs, configure=configure, meta=None)

relationalai/semantics/lqp/executor.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 from collections import defaultdict
+from datetime import datetime, timezone
 import atexit
 import re
 
@@ -13,6 +14,7 @@ from relationalai.semantics.lqp import result_helpers
 from relationalai.semantics.metamodel import ir, factory as f, executor as e
 from relationalai.semantics.lqp.compiler import Compiler
 from relationalai.semantics.lqp.intrinsics import mk_intrinsic_datetime_now
+from relationalai.semantics.lqp.constructors import mk_transaction
 from relationalai.semantics.lqp.types import lqp_type_to_sql
 from lqp import print as lqp_print, ir as lqp_ir
 from lqp.parser import construct_configure
@@ -39,6 +41,9 @@ class LQPExecutor(e.Executor):
         wide_outputs: bool = False,
         connection: Session | None = None,
         config: Config | None = None,
+        # In order to facilitate snapshot testing, we allow overriding intrinsic definitions
+        # like the current time, which would otherwise change between runs.
+        intrinsic_overrides: dict = {},
     ) -> None:
         super().__init__()
         self.database = database
@@ -48,6 +53,7 @@ class LQPExecutor(e.Executor):
         self.compiler = Compiler()
         self.connection = connection
         self.config = config or Config()
+        self.intrinsic_overrides = intrinsic_overrides
         self._resources = None
         self._last_model = None
         self._last_sources_version = (-1, None)
@@ -311,19 +317,16 @@ class LQPExecutor(e.Executor):
         with debugging.span("compile_intrinsics") as span:
             span["compile_type"] = "intrinsics"
 
+            now = self.intrinsic_overrides.get('datetime_now', datetime.now(timezone.utc))
+
             debug_info = lqp_ir.DebugInfo(id_to_orig_name={}, meta=None)
             intrinsics_fragment = lqp_ir.Fragment(
                 id = lqp_ir.FragmentId(id=b"__pyrel_lqp_intrinsics", meta=None),
-                declarations = [
-                    mk_intrinsic_datetime_now(),
-                ],
+                declarations = [mk_intrinsic_datetime_now(now)],
                 debug_info = debug_info,
                 meta = None,
             )
 
-
-            span["lqp"] = lqp_print.to_string(intrinsics_fragment, {"print_names": True, "print_debug": False, "print_csv_filename": False})
-
             return lqp_ir.Epoch(
                 writes=[
                     lqp_ir.Write(write_type=lqp_ir.Define(fragment=intrinsics_fragment, meta=None), meta=None)
@@ -354,47 +357,38 @@ class LQPExecutor(e.Executor):
 
     def compile_lqp(self, model: ir.Model, task: ir.Task):
         configure = self._construct_configure()
+        # Merge the epochs into a single transaction. Long term the query bits should all
+        # go into a WhatIf action and the intrinsics could be fused with either of them. But
+        # for now we just use separate epochs.
+        epochs = []
+        epochs.append(self._compile_intrinsics())
 
-        model_txn = None
         if self._last_model != model:
             with debugging.span("compile", metamodel=model) as install_span:
                 install_span["compile_type"] = "model"
-                _, model_txn = self.compiler.compile(model, {"fragment_id": b"model"})
-                model_txn = txn_with_configure(model_txn, configure)
-                install_span["lqp"] = lqp_print.to_string(model_txn, {"print_names": True, "print_debug": False, "print_csv_filename": False})
+                _, model_epoch = self.compiler.compile(model, {"fragment_id": b"model"})
+                epochs.append(model_epoch)
                 self._last_model = model
 
-        with debugging.span("compile", metamodel=task) as compile_span:
-            compile_span["compile_type"] = "query"
+        with debugging.span("compile", metamodel=task) as txn_span:
             query = f.compute_model(f.logical([task]))
             options = {
                 "wide_outputs": self.wide_outputs,
                 "fragment_id": b"query",
             }
             result, final_model = self.compiler.compile_inner(query, options)
-            export_info, query_txn = result
-            query_txn = txn_with_configure(query_txn, configure)
-            compile_span["lqp"] = lqp_print.to_string(query_txn, {"print_names": True, "print_debug": False, "print_csv_filename": False})
+            export_info, query_epoch = result
 
-        # Merge the epochs into a single transactions. Long term the query bits should all
-        # go into a WhatIf action and the intrinsics could be fused with either of them. But
-        # for now we just use separate epochs.
-        epochs = []
+            epochs.append(query_epoch)
+            epochs.append(self._compile_undefine_query(query_epoch))
 
-        epochs.append(self._compile_intrinsics())
+            txn_span["compile_type"] = "query"
+            txn = mk_transaction(epochs=epochs, configure=configure)
+            txn_span["lqp"] = lqp_print.to_string(txn, {"print_names": True, "print_debug": False, "print_csv_filename": False})
 
-        if model_txn is not None:
-            epochs.append(model_txn.epochs[0])
-
-        query_txn_epoch = query_txn.epochs[0]
-        epochs.append(query_txn_epoch)
-        epochs.append(self._compile_undefine_query(query_txn_epoch))
-
-        txn = lqp_ir.Transaction(epochs=epochs, configure=configure, meta=None)
         validate_lqp(txn)
 
         txn_proto = convert_transaction(txn)
-        # TODO (azreika): Should export_info be encoded as part of the txn_proto? [RAI-40312]
         return final_model, export_info, txn_proto
 
     # TODO (azreika): This should probably be split up into exporting and other processing. There are quite a lot of arguments here...
@@ -462,12 +456,3 @@ class LQPExecutor(e.Executor):
             # If processing the results failed, revert to the previous model.
             self._last_model = previous_model
             raise e
-
-def txn_with_configure(txn: lqp_ir.Transaction, configure: lqp_ir.Configure) -> lqp_ir.Transaction:
-    """ Return a new transaction with the given configure. If the transaction already has
-    a configure, it is replaced. """
-    return lqp_ir.Transaction(
-        epochs=txn.epochs,
-        configure=configure,
-        meta=txn.meta,
-    )

relationalai/semantics/lqp/intrinsics.py

@@ -1,15 +1,16 @@
-from datetime import datetime, timezone
+from datetime import datetime
 
 from relationalai.semantics.lqp import ir as lqp
 from relationalai.semantics.lqp.constructors import mk_abstraction, mk_value, mk_type, mk_primitive
 from relationalai.semantics.lqp.utils import lqp_hash
 
-def mk_intrinsic_datetime_now() -> lqp.Def:
+# Constructs a definition of the current datetime.
+def mk_intrinsic_datetime_now(dt: datetime) -> lqp.Def:
     """Constructs a definition of the current datetime."""
     id = lqp_hash("__pyrel_lqp_intrinsic_datetime_now")
     out = lqp.Var(name="out", meta=None)
     out_type = mk_type(lqp.TypeName.DATETIME)
-    now = mk_value(lqp.DateTimeValue(value=datetime.now(timezone.utc), meta=None))
+    now = mk_value(lqp.DateTimeValue(value=dt, meta=None))
     datetime_now = mk_abstraction(
         [(out, out_type)],
         mk_primitive("rel_primitive_eq", [out, now]),

relationalai/semantics/lqp/model2lqp.py

@@ -19,8 +19,8 @@ from warnings import warn
 import re
 import uuid
 
-""" Main access point. Converts the model IR to an LQP transaction. """
-def to_lqp(model: ir.Model, fragment_name: bytes, ctx: TranslationCtx) -> tuple[Optional[tuple], lqp.Transaction]:
+# Main access point for translating metamodel to lqp. Converts the model IR to an LQP epoch.
+def to_lqp(model: ir.Model, fragment_name: bytes, ctx: TranslationCtx) -> tuple[Optional[tuple], lqp.Epoch]:
     assert_valid_input(model)
     decls: list[lqp.Declaration] = []
     reads: list[lqp.Read] = []
@@ -50,16 +50,10 @@ def to_lqp(model: ir.Model, fragment_name: bytes, ctx: TranslationCtx) -> tuple[
     fragment = lqp.Fragment(id=fragment_id, declarations=decls, meta=None, debug_info=debug_info)
     define_op = lqp.Define(fragment=fragment, meta=None)
 
-    txn = lqp.Transaction(
-        epochs=[
-            lqp.Epoch(
-                reads=reads,
-                writes=[lqp.Write(write_type=define_op, meta=None)],
-                meta=None
-            )
-        ],
-        configure=lqp.construct_configure({}, None),
-        meta=None,
+    txn = lqp.Epoch(
+        reads=reads,
+        writes=[lqp.Write(write_type=define_op, meta=None)],
+        meta=None
     )
 
     return (export_info, txn)

relationalai/semantics/lqp/passes.py

@@ -7,7 +7,7 @@ from relationalai.semantics.metamodel.util import FrozenOrderedSet
 from relationalai.semantics.metamodel.rewrite import Flatten
 
 from ..metamodel.rewrite import DischargeConstraints, DNFUnionSplitter, ExtractNestedLogicals, FormatOutputs
-from .rewrite import CDC, ExtractCommon, ExtractKeys, FunctionAnnotations, QuantifyVars, Splinter
+from .rewrite import CDC, ExtractCommon, ExtractKeys, FunctionAnnotations, QuantifyVars, Splinter, SplitMultiCheckRequires
 
 from relationalai.semantics.lqp.utils import output_names
 
@@ -18,6 +18,7 @@ import hashlib
 
 def lqp_passes() -> list[Pass]:
     return [
+        SplitMultiCheckRequires(),
         FunctionAnnotations(),
         DischargeConstraints(),
         Checker(),

relationalai/semantics/lqp/rewrite/__init__.py

@@ -1,7 +1,7 @@
 from .cdc import CDC
 from .extract_common import ExtractCommon
 from .extract_keys import ExtractKeys
-from .function_annotations import FunctionAnnotations
+from .function_annotations import FunctionAnnotations, SplitMultiCheckRequires
 from .quantify_vars import QuantifyVars
 from .splinter import Splinter
 
@@ -12,4 +12,5 @@ __all__ = [
     "FunctionAnnotations",
     "QuantifyVars",
     "Splinter",
+    "SplitMultiCheckRequires",
 ]

relationalai/semantics/lqp/rewrite/function_annotations.py

@@ -1,79 +1,114 @@
 from __future__ import annotations
 
-from dataclasses import dataclass
-from relationalai.semantics.metamodel import ir, compiler as c, visitor as v, builtins
-from relationalai.semantics.metamodel.util import OrderedSet, ordered_set
+from typing import Optional
+from relationalai.semantics.metamodel import builtins
+from relationalai.semantics.metamodel.ir import (
+    Node, Model, Require, Logical, Relation, Annotation, Update
+)
+from relationalai.semantics.metamodel.compiler import Pass
+from relationalai.semantics.metamodel.visitor import Rewriter, Visitor
+from relationalai.semantics.lqp.rewrite.functional_dependencies import (
+    is_valid_unique_constraint, normalized_fd
+)
 
+# In the future iterations of PyRel metamodel, `Require` nodes will have a single `Check`
+# (and no `errors`). Currently, however, the unique constraints may result in multiple
+# `Check` nodes and for simplicity we split them in to separate `Require` nodes. This step
+# will be removed in the future.
+#
+# Note that unique constraints always have an empty `domain` so apply the splitting only
+# to such `Require` nodes.
+class SplitMultiCheckRequires(Pass):
+    """
+    Pass splits unique Require nodes that have empty domain but multiple checks into multiple
+    Require nodes with single check each.
+    """
+
+    def rewrite(self, model: Model, options: dict = {}) -> Model:
+        return SplitMultiCheckRequiresRewriter().walk(model)
+
+
+class SplitMultiCheckRequiresRewriter(Rewriter):
+    """
+    Splits unique Require nodes that have empty domain but multiple checks into multiple
+    Require nodes with single check each.
+    """
+    def handle_require(self, node: Require, parent: Node):
 
-class FunctionAnnotations(c.Pass):
+        if isinstance(node.domain, Logical) and not node.domain.body and len(node.checks) > 1:
+            require_nodes = []
+            for check in node.checks:
+                single_check = self.walk(check, node)
+                require_nodes.append(
+                    node.reconstruct(node.engine, node.domain, (single_check,), node.annotations)
+                )
+            return require_nodes
+
+        return node
+
+
+class FunctionAnnotations(Pass):
     """
-    Pass marks all appropriate relations with `function` annotation.
-    Criteria:
-    - there is a Require node with `unique` builtin (appeared as a result of `require(unique(...))`)
-    - `unique` declared for all the fields in a derived relation expect the last
+    Pass marks all appropriate relations with `function` annotation. Collects functional
+    dependencies from unique Require nodes and uses this information to identify functional
+    relations.
     """
 
-    def rewrite(self, model: ir.Model, options: dict = {}) -> ir.Model:
-        collect_fd = CollectFunctionalRelationsVisitor()
-        new_model = collect_fd.walk(model)
-        # mark relations collected by previous visitor with `@function` annotation
-        return FunctionalAnnotationsVisitor(collect_fd.functional_relations).walk(new_model)
+    def rewrite(self, model: Model, options: dict = {}) -> Model:
+        collect_fds = CollectFDsVisitor()
+        collect_fds.visit_model(model, None)
+        annotated_model = FunctionalAnnotationsRewriter(collect_fds.functional_relations).walk(model)
+        return annotated_model
 
 
-@dataclass
-class CollectFunctionalRelationsVisitor(v.Rewriter):
+class CollectFDsVisitor(Visitor):
     """
-    Visitor collects all relations which should be marked with `functional` annotation.
+    Visitor collects all unique constraints.
     """
 
+    # Currently, only information about k-functional fd is collected.
     def __init__(self):
         super().__init__()
-        self.functional_relations = ordered_set()
-
-    def handle_check(self, node: ir.Check, parent: ir.Node):
-        check = self.walk(node.check, node)
-        assert isinstance(check, ir.Logical)
-        unique_vars = []
-        for item in check.body:
-            # collect vars from `unique` builtin
-            if isinstance(item, ir.Lookup) and item.relation.name == builtins.unique.name:
-                var_set = set()
-                for vargs in item.args:
-                    assert isinstance(vargs, tuple)
-                    var_set.update(vargs)
-                unique_vars.append(var_set)
-        functional_rel = []
-        # mark relations as functional when at least 1 `unique` builtin
-        if len(unique_vars) > 0:
-            for item in check.body:
-                if isinstance(item, ir.Lookup) and not item.relation.name == builtins.unique.name:
-                    for var_set in unique_vars:
-                        # when unique declared for all the fields except the last one in the relation mark it as functional
-                        if var_set == set(item.args[:-1]):
-                            functional_rel.append(item.relation)
-
-        self.functional_relations.update(functional_rel)
-        return node.reconstruct(check, node.error, node.annotations)
-
-
-@dataclass
-class FunctionalAnnotationsVisitor(v.Rewriter):
+        self.functional_relations:dict[Relation, int] = {}
+
+    def visit_require(self, node: Require, parent: Optional[Node]):
+        if is_valid_unique_constraint(node):
+            fd = normalized_fd(node)
+            assert fd is not None
+            if fd.is_structural:
+                relation = fd.structural_relation
+                k = fd.structural_rank
+                current_k = self.functional_relations.get(relation, 0)
+                self.functional_relations[relation] = max(current_k, k)
+
+
+class FunctionalAnnotationsRewriter(Rewriter):
     """
-    This visitor marks functional_relations with `function` annotation.
+    This visitor marks functional_relations with `@function(:checked [, k])` annotation.
     """
 
-    def __init__(self, functional_relations: OrderedSet):
+    def __init__(self, functional_relations: dict[Relation, int]):
         super().__init__()
-        self._functional_relations = functional_relations
+        self.functional_relations = functional_relations
+
+    def get_functional_annotation(self, rel: Relation) -> Optional[Annotation]:
+        k = self.functional_relations.get(rel, None)
+        if k is None:
+            return None
+        if k == 1:
+            return builtins.function_checked_annotation
+        return builtins.function_ranked_checked_annotation(k)
 
-    def handle_relation(self, node: ir.Relation, parent: ir.Node):
-        if node in self._functional_relations:
-            return node.reconstruct(node.name, node.fields, node.requires, node.annotations | [builtins.function_checked_annotation],
-                                    node.overloads)
+    def handle_relation(self, node: Relation, parent: Node):
+        function_annotation = self.get_functional_annotation(node)
+        if function_annotation:
+            return node.reconstruct(node.name, node.fields, node.requires,
+                                    node.annotations | [function_annotation], node.overloads)
         return node.reconstruct(node.name, node.fields, node.requires, node.annotations, node.overloads)
 
-    def handle_update(self, node: ir.Update, parent: ir.Node):
-        if node.relation in self._functional_relations:
+    def handle_update(self, node: Update, parent: Node):
+        function_annotation = self.get_functional_annotation(node.relation)
+        if function_annotation:
             return node.reconstruct(node.engine, node.relation, node.args, node.effect,
-                                    node.annotations | [builtins.function_checked_annotation])
+                                    node.annotations | [function_annotation])
         return node.reconstruct(node.engine, node.relation, node.args, node.effect, node.annotations)

relationalai/semantics/lqp/rewrite/functional_dependencies.py

@@ -0,0 +1,282 @@
+from __future__ import annotations
+from typing import Optional, Sequence
+from relationalai.semantics.internal import internal
+from relationalai.semantics.metamodel.ir import (
+    Require, Logical, Var, Relation, Lookup, ScalarType
+)
+from relationalai.semantics.metamodel import builtins
+
+
+"""
+Helper functions for converting `Require` nodes with unique constraints to functional
+dependencies. The main functionalities provided are:
+    1. Check whether a `Require` node is a valid unique constraint representation
+    2. Represent the uniqueness constraint as a functional dependency
+    3. Check if the functional dependency is structural i.e., can be represented with
+         `@function(k)` annotation on a single relation.
+
+=========================== Structure of unique constraints ================================
+A `Require` node represents a _unique constraint_ if it meets the following criteria:
+ * the `Require` node's `domain` is an empty `Logical` node
+ * the `Require` node's `checks` has a single `Check` node
+ * the single `Check` node has `Logical` task that is a list of `Lookup` tasks
+ * precisely one `Lookup` task in the `Check` uses the `unique` builtin relation name
+ * the `unique` lookup has precisely one argument, which is a `TupleArg` or a `tuple`
+   containing at least one `Var`
+ * all `Lookup` nodes use variables only (no constants)
+ * the variables used in the `unique` lookup are a subset of the variables used in other
+   lookups
+============================================================================================
+
+We use the following unique constraint as the running example.
+
+```
+Require
+  domain
+    Logical
+  checks:
+    Check
+      check:
+        Logical
+          Person(person::Person)
+          first_name(person::Person, firstname::String)
+          last_name(person::Person, lastname::String)
+          unique((firstname::String, lastname::String))
+      error:
+        ...
+```
+
+=========================== Semantics of unique constraints ================================
+A unique constraint states that the columns declared in the `unique` predicate must be
+unique in the result of the conjunctive query consisting of all remaining predicates.
+============================================================================================
+
+In the running example, the conjunctive query computes a table with 3 columns, the person id
+`person::Person`, the first name `firstname::String`, and the last name `lastname::String`.
+The uniqueness predicate `unique((firstname::String, lastname::String))` states that no person
+can have more than a single combination of first and last name.
+
+The unique constraint in the running example above corresponds to the following functional
+dependency.
+
+```
+Person(x) ∧ first_name(x, y) ∧ last_name(x, z): {y, z} -> {x}
+```
+
+------------------------------ Redundant Type Atoms ----------------------------------------
+At the time of writing, PyRel does not yet remove redundant unary atoms. For instance, in
+the running example, the atom `Person(person::Person)` is redundant because the type of the
+`person` variable is specified in the other two atoms `first_name` and `last_name`.
+Consequently, we identify redundant atoms and remove them from the definition of the
+corresponding functional dependency.
+
+Formally, a _guard_ atom is any `Lookup` node whose relation name is not `unique`. Now, a
+unary guard atom `T(x::T)` is _redundant_ if the uniqueness constraint has a non-unary guard
+atom `R(...,x::T,...)`.
+
+================================ Normalized FDs ============================================
+Now, the _(normalized)_ functional dependency_ corresponding to a unique constraint is an
+object of the form `φ: X → Y`, where :
+ 1. `φ` is the set of all non-redundant guard atoms.
+ 2. `X` is the set of variables used in the `unique` atom
+ 3. `Y` is the set of all other variables used in the constraint
+============================================================================================
+
+The normalized functional dependency corresponding to the unique constraints from the running
+example is :
+```
+first_name(person::Person, firstname::String) ∧ last_name(person::Person, lastname::String): {firstname:String, lastname:String} -> {person:Person}
+```
+Note that the unary atom `Person(person::Person)` is redundant and thus omitted from the
+decomposition.
+
+Some simple functional dependencies can, however, be expressed simply with `@function(k)`
+attribute of a single relation.  Specifically, a functional dependency `φ: X → Y` is
+_structural_ if φ consists of a single atom `R(x1,...,xm,y1,...,yk)` and `X = {x1,...,xm}`.
+"""
+
+#
+# Checks that an input `Require` node is a valid unique constraint. Returns `None` if not.
+# If yes, we return the decomposition of the unique constraint as a tuple
+# `(all_vars, unique_vars, guard)`, where
+# - `all_vars` is the list of all variables used in the constraint
+# - `unique_vars` is the list of variables used in the `unique` atom
+# - `guard` is the list of all other `Lookup` atoms
+#
+def _split_unique_require_node(node: Require) -> Optional[tuple[list[Var], list[Var], list[Lookup]]]:
+    if not isinstance(node.domain, Logical):
+        return None
+    if len(node.domain.body) != 0:
+        return None
+    if len(node.checks) != 1:
+        return None
+    check = node.checks[0]
+    if not isinstance(check.check, Logical):
+        return None
+
+    unique_atom: Optional[Lookup] = None
+    guard: list[Lookup] = []
+    for task in check.check.body:
+        if not isinstance(task, Lookup):
+            return None
+        if task.relation.name == builtins.unique.name:
+            if unique_atom is not None:
+                return None
+            unique_atom = task
+        else:
+            guard.append(task)
+
+    if unique_atom is None:
+        return None
+
+    # collect variables
+    all_vars: set[Var] = set()
+    for lookup in guard:
+        for arg in lookup.args:
+            if not isinstance(arg, Var):
+                return None
+            all_vars.add(arg)
+
+    unique_vars: set[Var] = set()
+    if len(unique_atom.args) != 1:
+        return None
+    if not isinstance(unique_atom.args[0], (internal.TupleArg, tuple)):
+        return None
+    if len(unique_atom.args[0]) == 0:
+        return None
+    for arg in unique_atom.args[0]:
+        if not isinstance(arg, Var):
+            return None
+        unique_vars.add(arg)
+
+    # check that unique vars are a subset of other vars
+    if not unique_vars.issubset(all_vars):
+        return None
+
+    return list(all_vars), list(unique_vars), guard
+
+
+def is_valid_unique_constraint(node: Require) -> bool:
+    """
+    Checks whether the input `Require` node is a valid unique constraint. See description at
+    the top of the file for details.
+    """
+    return _split_unique_require_node(node) is not None
+
+#
+# A unary guard atom `T(x::T)` is redundant if the constraint contains a non-unary atom
+# `R(...,x::T,...)`.  We discard all redundant guard atoms in the constructed fd.
+#
+def normalized_fd(node: Require) -> Optional[FunctionalDependency]:
+    """
+    If the input `Require` node is a uniqueness constraint, constructs its reduced
+    functional dependency `φ: X -> Y`, where `φ` contains all non-redundant guard atoms,
+    `X` are the variables used in the `unique` atom, and `Y` are the remaining variables.
+    Returns `None` if the input node is not a valid uniqueness constraint.
+    """
+    parts = _split_unique_require_node(node)
+    if parts is None:
+        return None
+    all_vars, unique_vars, guard_atoms = parts
+
+    # remove redundant lookups
+    redundant_guard_atoms: list[Lookup] = []
+    for atom in guard_atoms:
+        # the atom is unary A(x::T)
+        if len(atom.args) != 1:
+            continue
+        var = atom.args[0]
+        assert isinstance(var, Var)
+        # T is a scalar type (which includes entity types)
+        var_type = var.type
+        if not isinstance(var_type, ScalarType):
+            continue
+        # the atom is a entity typing T(x::T) i.e., T = A (and hence not a Boolean property)
+        var_type_name = var_type.name
+        rel_name = atom.relation.name
+        if rel_name != var_type_name:
+            continue
+        # Found an atom of the form T(x::T)
+        # check if there is another atom R(...,x::T,...)
+        for typed_atom in guard_atoms:
+            if len(typed_atom.args) == 1:
+                continue
+            if var in typed_atom.args:
+                redundant_guard_atoms.append(atom)
+                break
+
+    guard = [atom for atom in guard_atoms if atom not in redundant_guard_atoms]
+    keys = unique_vars
+    values = [v for v in all_vars if v not in keys]
+
+    return FunctionalDependency(guard, keys, values)
+
+class FunctionalDependency:
+    """
+    Represents a functional dependency of the form `φ: X -> Y`, where
+     - `φ` is a set of `Lookup` atoms
+     - `X` and `Y` are disjoint and covering sets of variables used in `φ`
+    """
+    def __init__(self, guard: Sequence[Lookup], keys: Sequence[Var], values: Sequence[Var]):
+        self.guard = frozenset(guard)
+        self.keys = frozenset(keys)
+        self.values = frozenset(values)
+        assert self.keys.isdisjoint(self.values), "Keys and values must be disjoint"
+
+        # for structural fd check
+        self._is_structural:bool = False
+        self._structural_relation:Optional[Relation] = None
+        self._structural_rank:Optional[int] = None
+
+        self._determine_is_structural()
+
+    # A functional dependency `φ: X → Y` is _k-functional_ if `φ` consists of a single atom
+    # `R(x1,...,xm,y1,...,yk)` and `X = {x1,...,xm}`. Not all functional dependencies are
+    # k-functional. For instance, `R(x, y, z): {y, z} → {x}` cannot be expressed with
+    # `@function`. neither can `R(x, y) ∧ P(x, z) : {x} → {y, z}`.
+    def _determine_is_structural(self):
+        if len(self.guard) != 1:
+            self._is_structural = False
+            return
+        atom = next(iter(self.guard))
+        atom_vars = atom.args
+        if len(atom_vars) <= len(self.keys): # @function(0) provides no information
+            self._is_structural = False
+            return
+        prefix_vars = atom_vars[:len(self.keys)]
+        if set(prefix_vars) != set(self.keys):
+            self._is_structural = False
+            return
+        self._is_structural = True
+        self._structural_relation = atom.relation
+        self._structural_rank = len(atom_vars) - len(self.keys)
+
+    @property
+    def is_structural(self) -> bool:
+        """
+        Whether the functional dependency is functional, i.e., can be represented
+        with `@function(k)` annotation on a single relation.
+        """
+        return self._is_structural
+
+    @property
+    def structural_relation(self) -> Relation:
+        """
+        The structural relation of a functional dependency. Raises ValueError if the functional
+        dependency is not structural.
+        """
+        if not self._is_structural:
+            raise ValueError("Functional dependency is not structural")
+        assert self._structural_relation is not None
+        return self._structural_relation
+
+    @property
+    def structural_rank(self) -> int:
+        """
+        The structural rank k of k-structural fd. Raises ValueError if the structural
+        dependency is not k-structural.
+        """
+        if not self._is_structural:
+            raise ValueError("Functional dependency is not structural")
+        assert self._structural_rank is not None
+        return self._structural_rank

relationalai/semantics/metamodel/builtins.py

@@ -495,6 +495,11 @@ output_keys_annotation = f.annotation(output_keys, [])
 function = f.relation("function", [f.input_field("code", types.Symbol)])
 function_checked_annotation = f.annotation(function, [f.lit("checked")])
 function_annotation = f.annotation(function, [])
+function_ranked = f.relation("function", [f.input_field("code", types.Symbol), f.input_field("rank", types.Int64)])
+def function_ranked_checked_annotation(k:int) -> ir.Annotation:
+    return f.annotation(function_ranked, [f.lit("checked"), f.lit(k)])
+def function_ranked_annotation(k:int) -> ir.Annotation:
+    return f.annotation(function_ranked, [f.lit(k)])
 
 # Indicates this relation should be tracked in telemetry. Supported for Relationships and Concepts.
 # `RAI_BackIR.with_relation_tracking` produces log messages at the start and end of each

relationalai/semantics/metamodel/rewrite/extract_nested_logicals.py

@@ -48,10 +48,10 @@ class LogicalExtractor(Rewriter):
         # variables (which is currently done by flatten), such as when the parent is a Match
         # or a Union, of if the logical has a Rank.
         if not (
-            node.hoisted and
+            logical.hoisted and
             not isinstance(parent, (ir.Match, ir.Union)) and
-            all(isinstance(v, ir.Var) for v in node.hoisted) and
-            not any(isinstance(c, ir.Rank) for c in node.body)
+            all(isinstance(v, ir.Var) for v in logical.hoisted) and
+            not any(isinstance(c, ir.Rank) for c in logical.body)
             ):
             return logical
 
@@ -61,10 +61,11 @@ class LogicalExtractor(Rewriter):
 
         # if there are aggregations, make sure we don't expose the projected and input vars,
         # but expose groupbys
-        for agg in collect_by_type(ir.Aggregate, node):
+        for agg in collect_by_type(ir.Aggregate, logical):
             exposed_vars.difference_update(agg.projection)
             exposed_vars.difference_update(helpers.aggregate_inputs(agg))
             exposed_vars.update(agg.group)
+
         # add the values (hoisted)
         exposed_vars.update(helpers.hoisted_vars(logical.hoisted))
 

relationalai/semantics/rel/compiler.py

@@ -12,7 +12,7 @@ from relationalai.semantics.metamodel.util import OrderedSet, group_by, NameCach
 from relationalai.semantics.rel import rel, rel_utils as u, builtins as rel_bt
 
 from ..metamodel.rewrite import (Flatten, ExtractNestedLogicals, DNFUnionSplitter, DischargeConstraints, FormatOutputs)
-from ..lqp.rewrite import CDC, ExtractCommon, ExtractKeys, FunctionAnnotations, QuantifyVars, Splinter
+from ..lqp.rewrite import CDC, ExtractCommon, ExtractKeys, FunctionAnnotations, QuantifyVars, Splinter, SplitMultiCheckRequires
 
 import math
 
@@ -24,6 +24,7 @@ import math
 class Compiler(c.Compiler):
     def __init__(self):
         super().__init__([
+            SplitMultiCheckRequires(),
             FunctionAnnotations(),
             DischargeConstraints(),
             Checker(),
@@ -696,7 +697,24 @@ class ModelToRel:
         rel_annos = cast(Tuple[rel.Annotation, ...], self.handle_list(filtered_annos))
         return rel_annos
 
+    # standard handling mistreats the integer arg of ranked `@function(:checked, k)`
+    def handle_ranked_function_annotation(self, n: ir.Annotation):
+        assert n.relation == bt.function_ranked and len(n.args) == 2
+        checked_lit = n.args[0]
+        rank_lit = n.args[1]
+        assert isinstance(checked_lit, ir.Literal) and isinstance(rank_lit, ir.Literal)
+        checked = rel.MetaValue(checked_lit.value)
+        rank = rank_lit.value
+        return rel.Annotation(
+            n.relation.name,
+            (checked, rank)
+        )
+
     def handle_annotation(self, n: ir.Annotation):
+        # special treatment for (ranked) @function(:checked, k)
+        if n.relation == bt.function_ranked:
+            return self.handle_ranked_function_annotation(n)
+
         # we know that annotations won't have vars, so we can ignore that type warning
         return rel.Annotation(
             n.relation.name,

relationalai/semantics/tests/test_snapshot_abstract.py

@@ -2,6 +2,7 @@ import logging
 import os
 import uuid
 import sys
+import datetime
 from abc import abstractmethod, ABC
 
 from relationalai.semantics.tests.logging import Capturer
@@ -47,6 +48,8 @@ class AbstractSnapshotTest(ABC):
                 'use_sql': use_sql,
                 'reasoner.rule.use_lqp': use_lqp,
                 'keep_model': False,
+                # fix the current time to keep snapshots stable
+                'datetime_now': datetime.datetime.fromisoformat("2025-12-01T12:00:00+00:00"),
             }
             if use_direct_access:
                 # for direct access we can not use user/password authentication

relationalai/util/otel_handler.py

@@ -20,6 +20,7 @@ from relationalai.debugging import logger, Span, filter_span_attrs, otel_traceid
 from relationalai.clients.snowflake import Resources
 
 MAX_PAYLOAD_SIZE = 25*1024 # 25KB
+MAX_ATTRIBUTE_LENGTH = 1000
 _otel_initialized = False
 
 
@@ -44,8 +45,6 @@ class CachedSpanExporter(SpanExporter):
 
     def get_spans(self):
         return self.spans
-
-
 class NativeAppSpanExporter(SpanExporter):
     def __init__(self, resource:Resources, app_name:str):
         self.resource = resource
@@ -252,6 +251,12 @@ def encode_otlp_attribute(k, v):
     try:
         valueObj = {}
         if isinstance(v, str):
+            # Truncate metamodel attribute value if it's too large
+            if k == "metamodel" and len(v) > MAX_ATTRIBUTE_LENGTH:
+                original_length = len(v)
+                v = v[:MAX_ATTRIBUTE_LENGTH] + f"... (truncated from {original_length} chars)"
+                logging.warning(f"{k} attribute truncated from {original_length} to {MAX_ATTRIBUTE_LENGTH} characters")
+
             valueObj = {
                 "stringValue": html.escape(v).replace("\n", "; ")
             }
@@ -369,7 +374,7 @@ def encode_spans_to_otlp_json(spans: Sequence[ReadableSpan], max_bytes: int) ->
     except Exception as e:
         logging.warning(f"Error encoding resource to OTLP JSON: {e}")
         return "", spans  # Return the unencoded spans if resource encoding fails
-    
+
     # TODO encode pyrel version for real
     header_str = f'{{"resourceSpans": [{{"resource":{resource_str}, "scopeSpans": [{{"scope":{{"name":"pyrel", "version":"v0.4.0"}},"spans":['
     footer_str = ']}]}]}'
@@ -378,7 +383,7 @@ def encode_spans_to_otlp_json(spans: Sequence[ReadableSpan], max_bytes: int) ->
     encoded_spans = []
     for span in spans:
         try:
-            span_str = encode_span_to_otlp_json(span)
+            span_str = encode_span_to_otlp_json(span)          
         except Exception as e:
             logging.warning(f"Error encoding span {span}: {e}")
             continue  # Skip this span if encoding fails
@@ -460,6 +465,7 @@ def enable_otel_export(client_resources: Resources, app_name):
     if _otel_initialized:
         logging.warning("OTel already initialized, skipping.")
         return
+    
     _otel_initialized = True
 
     if TRACE_PROVIDER is None:

{relationalai-0.12.8.dist-info → relationalai-0.12.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: relationalai
-Version: 0.12.8
+Version: 0.12.9
 Summary: RelationalAI Library and CLI
 Author-email: RelationalAI <support@relational.ai>
 License-File: LICENSE

{relationalai-0.12.8.dist-info → relationalai-0.12.9.dist-info}/RECORD

@@ -302,32 +302,33 @@ relationalai/semantics/devtools/compilation_manager.py,sha256=XBqG_nYWtK3s_J6MeC
 relationalai/semantics/devtools/extract_lqp.py,sha256=gxI3EvPUTPAkwgnkCKAkEm2vA6QkLfoM8AXXiVz0c34,3696
 relationalai/semantics/internal/__init__.py,sha256=JXrpFaL-fdZrvKpWTEn1UoLXITOoTGnAYwmgeiglhSk,774
 relationalai/semantics/internal/annotations.py,sha256=PkrRN-gHO2ksh1hDKB1VVIB39dONvLdTd8_Y0rCR3fE,367
-relationalai/semantics/internal/internal.py,sha256=xobU6wWXpgbcG1lQIO1fkgnSx7YzQ_Dqsqf7lBD9QuA,149008
+relationalai/semantics/internal/internal.py,sha256=hElTyxtnTfNsmX9kJZ2I5yU4yA3udFyu2xk-qq8G3T0,149986
 relationalai/semantics/internal/snowflake.py,sha256=8D6WYDFKtt8R-sc9o1Oxgtl6Xwehs2Txw_lKNBid7UA,13467
 relationalai/semantics/lqp/__init__.py,sha256=XgcQZxK-zz_LqPDVtwREhsIvjTuUIt4BZhIedCeMY-s,48
 relationalai/semantics/lqp/builtins.py,sha256=IWRYJ1J-HGEQqBn8QVOyjZvgEiq6W9tZ0nBLdHz5wjA,576
-relationalai/semantics/lqp/compiler.py,sha256=Nury1gPw_-Oi_mqT1-rhr13L4UmyIP2BGuotbuklQKA,949
-relationalai/semantics/lqp/constructors.py,sha256=iYpi6G8diBUNVITwj7-lfNob_kRqdM7eBTpx5uJcQ7s,2124
-relationalai/semantics/lqp/executor.py,sha256=LoExKB3NuF9JdkUqsshAAfbQS3E_OwSyTD_R0wjd7zM,21728
-relationalai/semantics/lqp/intrinsics.py,sha256=5d6z_C-5Anc97p4Jrlgt7og9gGei5N48EDRrnYXz4CA,842
+relationalai/semantics/lqp/compiler.py,sha256=oOGlN03NVvltKN5KSDOqvb0TsAER_igUe9CnOcHAuoY,943
+relationalai/semantics/lqp/constructors.py,sha256=KWXW3OxpZE8E-OYYjrjE_uFAXRekuGHn0TNSPPQyY7g,2336
+relationalai/semantics/lqp/executor.py,sha256=7Jk2eKlGZ0H4wXInjnHKZehDVGOq09W6zY1mFALwIyE,21160
+relationalai/semantics/lqp/intrinsics.py,sha256=oKPIcW8PYgU-yPTO21iSF00RBsFKPFFP5MICe6izjKk,871
 relationalai/semantics/lqp/ir.py,sha256=DUw0ltul0AS9CRjntNlmllWTwXpxMyYg4iJ9t7NFYMA,1791
-relationalai/semantics/lqp/model2lqp.py,sha256=4uydEMJhdp0yRC5bIsanXRCiVicEtmavQ_cwsiW7ouA,35414
-relationalai/semantics/lqp/passes.py,sha256=R83UEed22yM3MnWgSv2maY94wgblM2r8JhTZ2fWswIU,28471
+relationalai/semantics/lqp/model2lqp.py,sha256=mtxXXOMWTMrLYyB84x0OqdmwAACfQ7au1IhiKZ2_lqY,35262
+relationalai/semantics/lqp/passes.py,sha256=WNVuGxf1jU-UYyoEW5XvnREwJ-NW4_iMECW-Gaphaq8,28531
 relationalai/semantics/lqp/pragmas.py,sha256=FzzldrJEAZ1AIcEw6D-FfaVg3CoahRYgPCFo7xHfg1g,375
 relationalai/semantics/lqp/primitives.py,sha256=9Hjow-Yp06jt0xatuUrH1dw0ErnzknIr9K0TB_AwdjU,11029
 relationalai/semantics/lqp/result_helpers.py,sha256=oYpLoTBnzsiyOVIWA2rLMHlgs7P7BoEkqthQ2aMosnk,10123
 relationalai/semantics/lqp/types.py,sha256=3TZ61ybwNV8lDyUMujZIWNFz3Fgn4uifsJb8ExfoMDg,4508
 relationalai/semantics/lqp/utils.py,sha256=iOoS-f8kyFjrgAnpK4cWDvAA-WmPgDRggSKUXm_JdTc,6317
 relationalai/semantics/lqp/validators.py,sha256=YO_ciSgEVNILWUbkxIagKpIxI4oqV0fRSTO2Ok0rPJk,1526
-relationalai/semantics/lqp/rewrite/__init__.py,sha256=AR3JvxNMnUuGFcbu1qXEutnnYkex3XT64rSdjehjfR4,355
+relationalai/semantics/lqp/rewrite/__init__.py,sha256=3LxYHZm6-vaqs-5Co9DQ8awxk838f5huiR5OEaLc8Ww,411
 relationalai/semantics/lqp/rewrite/cdc.py,sha256=I6DeMOZScx-3UAVoSCMn9cuOgLzwdvJVKNwsgFa6R_k,10390
 relationalai/semantics/lqp/rewrite/extract_common.py,sha256=sbihURqk4wtc1ekDWXWltq9LrO42XTLfOHl5D6nT5vw,18371
 relationalai/semantics/lqp/rewrite/extract_keys.py,sha256=dSr5SVkYmrhiR0XPY5eRAnWD66dcZYgXdilXcERv634,18682
-relationalai/semantics/lqp/rewrite/function_annotations.py,sha256=otnxjxnVI3ByvPKdyG1SlGBaEKBej-9_M8Xc5GBtOeE,3523
+relationalai/semantics/lqp/rewrite/function_annotations.py,sha256=9ZzLASvXh_OgQ04eup0AyoMIh2HxWHkoRETLm1-XtWs,4660
+relationalai/semantics/lqp/rewrite/functional_dependencies.py,sha256=pQo7a7oS1wsep3ObdxPPaV962RlR0iBWzBmd7lCzCvQ,11564
 relationalai/semantics/lqp/rewrite/quantify_vars.py,sha256=wYMEXzCW_D_Y_1rSLvuAAqw9KN1oIOn_vIMxELzRVb4,11568
 relationalai/semantics/lqp/rewrite/splinter.py,sha256=oeDjP_F2PVLVexAKFn8w7CLtO9oy-R-tS2IOmzw_Ujk,3199
 relationalai/semantics/metamodel/__init__.py,sha256=I-XqQAGycD0nKkKYvnF3G9d0QK_1LIM4xXICw8g8fBA,805
-relationalai/semantics/metamodel/builtins.py,sha256=vMe0Lytebk0e0M6US82-gvg6j8wGy6YtdAIBy1m2-HA,38047
+relationalai/semantics/metamodel/builtins.py,sha256=lW8VdaSICyr8gxhFzaE-fD8wHSLBuErDOzntEC9FNL0,38407
 relationalai/semantics/metamodel/compiler.py,sha256=XBsAnbFwgZ_TcRry6yXGWLyw_MaO2WJDp1EnC_ubhps,4525
 relationalai/semantics/metamodel/dataflow.py,sha256=wfj1tARrR4yEAaTwUTrAcxEcz81VkUal4U_AX1esovk,3929
 relationalai/semantics/metamodel/dependency.py,sha256=iJLx-w_zqde7CtbGcXxLxZBdUKZYl7AUykezPI9ccck,33926
@@ -341,7 +342,7 @@ relationalai/semantics/metamodel/visitor.py,sha256=DFY0DACLhxlZ0e4p0vWqbK6ZJr_GW
 relationalai/semantics/metamodel/rewrite/__init__.py,sha256=9ONWFSdMPHkWpObDMSljt8DywhpFf4Ehsq1aT3fTPt8,344
 relationalai/semantics/metamodel/rewrite/discharge_constraints.py,sha256=0v613BqCLlo4sgWuZjcLSxxakp3d34mYWbG4ldhzGno,1949
 relationalai/semantics/metamodel/rewrite/dnf_union_splitter.py,sha256=ZXX190gCKXhdB-Iyi4MGowc4FS9P0PIJTtTT0LrTr6A,7970
-relationalai/semantics/metamodel/rewrite/extract_nested_logicals.py,sha256=M5sSsyM2KKtz6ZD0zXT7bwTsJA_bgPJupu6TwnHLdmE,3341
+relationalai/semantics/metamodel/rewrite/extract_nested_logicals.py,sha256=vQ0-7t_GORskB1ZG50KuzM4phm6YNPvehfFn3v_LbgI,3354
 relationalai/semantics/metamodel/rewrite/flatten.py,sha256=uw7pKBGdrGqGYZU9NewAjvqRuhJk7As49hA_Wcwfp2k,21918
 relationalai/semantics/metamodel/rewrite/format_outputs.py,sha256=n0IxC3RL3UMly6MWsq342EGfL2yGj3vOgVG_wg7kt-o,6225
 relationalai/semantics/metamodel/typer/__init__.py,sha256=E3ydmhWRdm-cAqWsNR24_Qd3NcwiHx8ElO2tzNysAXc,143
@@ -360,7 +361,7 @@ relationalai/semantics/reasoners/optimization/solvers_dev.py,sha256=lbw3c8Z6PlHR
 relationalai/semantics/reasoners/optimization/solvers_pb.py,sha256=ESwraHU9c4NCEVRZ16tnBZsUCmJg7lUhy-v0-GGq0qo,48000
 relationalai/semantics/rel/__init__.py,sha256=pMlVTC_TbQ45mP1LpzwFBBgPxpKc0H3uJDvvDXEWzvs,55
 relationalai/semantics/rel/builtins.py,sha256=kQToiELc4NnvCmXyFtu9CsGZNdTQtSzTB-nuyIfQcsM,1562
-relationalai/semantics/rel/compiler.py,sha256=7KmZ0X2DwsXoH5DwSYeqSFMUdBvrKUNRZX4e-hEBixg,42259
+relationalai/semantics/rel/compiler.py,sha256=-gyu_kL1p4Z-SXI2fwLXSbGfUy-ejQcKVrc66rVvOyg,43044
 relationalai/semantics/rel/executor.py,sha256=v-yHl9R8AV0AA2xnm5YZDzue83pr8j2Q97Ky1MKkU70,17309
 relationalai/semantics/rel/rel.py,sha256=9I_V6dQ83QRaLzq04Tt-KjBWhmNxNO3tFzeornBK4zc,15738
 relationalai/semantics/rel/rel_utils.py,sha256=EH-NBROA4vIJXajLKniapt4Dxt7cXSqY4NEjD-wD8Mc,9566
@@ -390,7 +391,7 @@ relationalai/semantics/std/std.py,sha256=Ql27y2Rs0d1kluktWi-t6_M_uYIxQUfO94GjlVf
 relationalai/semantics/std/strings.py,sha256=Q_7kvx5dud6gppNURHOi4SMvgZNPRuWwEKDIPSEIOJI,2702
 relationalai/semantics/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 relationalai/semantics/tests/logging.py,sha256=oJTrUS_Bq6WxqqO8QLtrjdkUB02Uu5erZ7FTl__-lNY,1432
-relationalai/semantics/tests/test_snapshot_abstract.py,sha256=1xJmyRPlC6ywPytFUh8V-TFqndAzlo5v0XggRTJBcys,6131
+relationalai/semantics/tests/test_snapshot_abstract.py,sha256=ob_5p43CQzz9nfB7Q9W1geKqwNmLyUmQx-mpJfTOwhg,6305
 relationalai/semantics/tests/test_snapshot_base.py,sha256=vlqqSyQf_IsDb7feDnkiHZKSCsJqDq0Ep4V3CKtKWns,466
 relationalai/semantics/tests/utils.py,sha256=h4GPNCJGmAWvwskGWxc523BtFEd2ayff4zfBNHapoCo,1825
 relationalai/std/__init__.py,sha256=U8-DpdOcxeGXVSf3LqJl9mSXKztNgB9iwropQcXp960,2178
@@ -422,7 +423,7 @@ relationalai/util/format.py,sha256=fLRovumUa2cu0_2gy3O5vaEbpND4p9_IIgr-vDaIGDc,3
 relationalai/util/graph.py,sha256=eT8s0yCiJIu6D1T1fjZsLSPCcuQb2Mzl6qnljtQ5TuA,1504
 relationalai/util/list_databases.py,sha256=xJZGHzE0VLaDItWo5XvQSx75OwV045h2rjCBBnhNB3o,152
 relationalai/util/otel_configuration.py,sha256=SV1SFqdKm8q-OD1TsmiIB0x5VxtAFsBRyTwD8zNtnQc,1066
-relationalai/util/otel_handler.py,sha256=G1om5NxMvOjc6GDS4_Qf5aVGt1EVqRnkhfmZPcc6ZUg,17681
+relationalai/util/otel_handler.py,sha256=2h3ROnra798RRRPLTlEBxEcj-jXXk1ri_l10RAFaiWk,18109
 relationalai/util/snowflake_handler.py,sha256=8HUo6eU5wPxa6m_EocYuEZD_XpVIh9EqBnGwaS06Usw,2942
 relationalai/util/span_format_test.py,sha256=1rU-M3RXhRt8vCX6rtuIJogEVkB164N3qiKcTmb-sl8,1345
 relationalai/util/span_tracker.py,sha256=SKj4UB43clUxWShq3lFChl3dZ4JGRhcnY_xAh-7Xzvg,7888
@@ -438,8 +439,8 @@ frontend/debugger/dist/index.html,sha256=0wIQ1Pm7BclVV1wna6Mj8OmgU73B9rSEGPVX-Wo
 frontend/debugger/dist/assets/favicon-Dy0ZgA6N.png,sha256=tPXOEhOrM4tJyZVJQVBO_yFgNAlgooY38ZsjyrFstgg,620
 frontend/debugger/dist/assets/index-Cssla-O7.js,sha256=MxgIGfdKQyBWgufck1xYggQNhW5nj6BPjCF6Wleo-f0,298886
 frontend/debugger/dist/assets/index-DlHsYx1V.css,sha256=21pZtAjKCcHLFjbjfBQTF6y7QmOic-4FYaKNmwdNZVE,60141
-relationalai-0.12.8.dist-info/METADATA,sha256=IGBDWxQWGYGQR1ZF-oDVSz-fj12UiuZrqdg7MgngzSA,2562
-relationalai-0.12.8.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-relationalai-0.12.8.dist-info/entry_points.txt,sha256=fo_oLFJih3PUgYuHXsk7RnCjBm9cqRNR--ab6DgI6-0,88
-relationalai-0.12.8.dist-info/licenses/LICENSE,sha256=pPyTVXFYhirkEW9VsnHIgUjT0Vg8_xsE6olrF5SIgpc,11343
-relationalai-0.12.8.dist-info/RECORD,,
+relationalai-0.12.9.dist-info/METADATA,sha256=r7ebl7OUAHSnHZxFdPUL8woKPut0wWKjJ6Z1wvHc6Ko,2562
+relationalai-0.12.9.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+relationalai-0.12.9.dist-info/entry_points.txt,sha256=fo_oLFJih3PUgYuHXsk7RnCjBm9cqRNR--ab6DgI6-0,88
+relationalai-0.12.9.dist-info/licenses/LICENSE,sha256=pPyTVXFYhirkEW9VsnHIgUjT0Vg8_xsE6olrF5SIgpc,11343
+relationalai-0.12.9.dist-info/RECORD,,