relationalai 0.12.3__py3-none-any.whl → 0.12.4__py3-none-any.whl

relationalai/clients/snowflake.py

@@ -83,6 +83,7 @@ FIELD_MAP = {
 VALID_IMPORT_STATES = ["PENDING", "PROCESSING", "QUARANTINED", "LOADED"]
 ENGINE_ERRORS = ["engine is suspended", "create/resume", "engine not found", "no engines found", "engine was deleted"]
 ENGINE_NOT_READY_MSGS = ["engine is in pending", "engine is provisioning"]
+DATABASE_ERRORS = ["database not found"]
 PYREL_ROOT_DB = 'pyrel_root_db'
 
 TERMINAL_TXN_STATES = ["COMPLETED", "ABORTED"]
@@ -281,6 +282,8 @@ def _sanitize_user_name(user: str) -> str:
 def _is_engine_issue(response_message: str) -> bool:
     return any(kw in response_message.lower() for kw in ENGINE_ERRORS + ENGINE_NOT_READY_MSGS)
 
+def _is_database_issue(response_message: str) -> bool:
+    return any(kw in response_message.lower() for kw in DATABASE_ERRORS)
 
 
 #--------------------------------------------------
@@ -298,6 +301,7 @@ class Resources(ResourcesBase):
         dry_run: bool = False,
         reset_session: bool = False,
         generation: Generation | None = None,
+        language: str = "rel",
     ):
         super().__init__(profile, config=config)
         self._token_handler: TokenHandler | None = None
@@ -315,6 +319,8 @@ class Resources(ResourcesBase):
         # self.sources contains fully qualified Snowflake table/view names
         self.sources: set[str] = set()
         self._sproc_models = None
+        self.database = ""
+        self.language = language
         atexit.register(self.cancel_pending_transactions)
 
     @property
@@ -452,6 +458,7 @@ class Resources(ResourcesBase):
             rai_app = self.config.get("rai_app_name", "")
             current_role = self.config.get("role")
             engine = self.get_default_engine_name()
+            engine_size = self.config.get_default_engine_size()
             assert isinstance(rai_app, str), f"rai_app_name must be a string, not {type(rai_app)}"
             assert isinstance(engine, str), f"engine must be a string, not {type(engine)}"
             print("\n")
@@ -460,9 +467,15 @@ class Resources(ResourcesBase):
             if re.search(f"database '{rai_app}' does not exist or not authorized.".lower(), orig_message):
                 exception = SnowflakeAppMissingException(rai_app, current_role)
                 raise exception from None
-            if any(keyword in orig_message for keyword in ENGINE_ERRORS):
+            if _is_engine_issue(orig_message) or _is_database_issue(orig_message):
                 try:
-                    self.auto_create_engine(engine)
+                    self._poll_use_index(
+                        app_name=self.get_app_name(),
+                        sources=self.sources,
+                        model=self.database,
+                        engine_name=engine,
+                        engine_size=engine_size
+                    )
                     return self._exec(code, params, raw=raw, help=help)
                 except EngineNameValidationException as e:
                     raise EngineNameValidationException(engine) from e
@@ -767,7 +780,7 @@ Otherwise, remove it from your '{profile}' configuration profile.
             keep_database = not force and self.config.get("reuse_model", True)
             with debugging.span("release_index", name=name, keep_database=keep_database, language=language):
                 #TODO add headers to release_index
-                response = self._exec(f"call {APP_NAME}.api.release_index('{name}', OBJECT_CONSTRUCT('keep_database', {keep_database}, 'language', '{language}'));")
+                response = self._exec(f"call {APP_NAME}.api.release_index('{name}', OBJECT_CONSTRUCT('keep_database', {keep_database}, 'language', '{language}', 'user_agent', '{get_pyrel_version(self.generation)}'));")
                 if response:
                     result = next(iter(response))
                     obj = json.loads(result["RELEASE_INDEX"])
@@ -788,14 +801,13 @@ Otherwise, remove it from your '{profile}' configuration profile.
             headers = debugging.gen_current_propagation_headers()
             self._exec(f"call {APP_NAME}.api.clone_database('{target_name}', '{source_name}', {nowait_durable}, {headers});")
 
-    def poll_use_index(
+    def _poll_use_index(
         self,
         app_name: str,
         sources: Iterable[str],
         model: str,
         engine_name: str,
         engine_size: str | None = None,
-        language: str = "rel",
         program_span_id: str | None = None,
         headers: Dict | None = None,
     ):
@@ -806,12 +818,36 @@ Otherwise, remove it from your '{profile}' configuration profile.
             model,
             engine_name,
             engine_size,
-            language,
+            self.language,
             program_span_id,
             headers,
             self.generation
         ).poll()
 
+    def maybe_poll_use_index(
+        self,
+        app_name: str,
+        sources: Iterable[str],
+        model: str,
+        engine_name: str,
+        engine_size: str | None = None,
+        program_span_id: str | None = None,
+        headers: Dict | None = None,
+    ):
+        """Only call _poll_use_index if there are sources to process."""
+        sources_list = list(sources)
+        self.database = model
+        if sources_list:
+            return self._poll_use_index(
+                app_name=app_name,
+                sources=sources_list,
+                model=model,
+                engine_name=engine_name,
+                engine_size=engine_size,
+                program_span_id=program_span_id,
+                headers=headers,
+            )
+
     #--------------------------------------------------
     # Models
     #--------------------------------------------------
@@ -1868,9 +1904,19 @@ Otherwise, remove it from your '{profile}' configuration profile.
             )
         except Exception as e:
             err_message = str(e).lower()
-            if _is_engine_issue(err_message):
-                self.auto_create_engine(engine, headers=headers)
-                self._exec_async_v2(
+            if _is_engine_issue(err_message) or _is_database_issue(err_message):
+                engine_name = engine or self.get_default_engine_name()
+                engine_size = self.config.get_default_engine_size()
+                self._poll_use_index(
+                    app_name=self.get_app_name(),
+                    sources=self.sources,
+                    model=database,
+                    engine_name=engine_name,
+                    engine_size=engine_size,
+                    headers=headers,
+                )
+
+                return self._exec_async_v2(
                     database, engine, raw_code_b64, inputs, readonly, nowait_durable,
                     headers=headers, bypass_index=bypass_index, language='lqp',
                     query_timeout_mins=query_timeout_mins,
@@ -1908,8 +1954,17 @@ Otherwise, remove it from your '{profile}' configuration profile.
             )
         except Exception as e:
             err_message = str(e).lower()
-            if _is_engine_issue(err_message):
-                self.auto_create_engine(engine, headers=headers)
+            if _is_engine_issue(err_message) or _is_database_issue(err_message):
+                engine_name = engine or self.get_default_engine_name()
+                engine_size = self.config.get_default_engine_size()
+                self._poll_use_index(
+                    app_name=self.get_app_name(),
+                    sources=self.sources,
+                    model=database,
+                    engine_name=engine_name,
+                    engine_size=engine_size,
+                    headers=headers,
+                )
                 return self._exec_async_v2(
                     database,
                     engine,
@@ -2972,13 +3027,12 @@ class SnowflakeClient(Client):
 
         query_attrs_dict = json.loads(headers.get("X-Query-Attributes", "{}")) if headers else {}
         with debugging.span("poll_use_index", sources=self.resources.sources, model=model, engine=engine_name, **query_attrs_dict):
-            self.poll_use_index(
+            self.maybe_poll_use_index(
                 app_name=app_name,
                 sources=self.resources.sources,
                 model=model,
                 engine_name=engine_name,
                 engine_size=engine_size,
-                language="rel",
                 program_span_id=program_span_id,
                 headers=headers
             )
@@ -2989,29 +3043,24 @@ class SnowflakeClient(Client):
         if isolated and not self.keep_model:
             atexit.register(self.delete_database)
 
-    # Polling for use_index
-    # if data is ready, break the loop
-    # if data is not ready, print the status of the tables or engines
-    # if data is not ready and there are errors, collect the errors and raise exceptions
-    def poll_use_index(
+    def maybe_poll_use_index(
         self,
         app_name: str,
         sources: Iterable[str],
         model: str,
         engine_name: str,
         engine_size: str | None = None,
-        language: str = "rel",
         program_span_id: str | None = None,
         headers: Dict | None = None,
     ):
+        """Only call _poll_use_index if there are sources to process."""
         assert isinstance(self.resources, Resources)
-        return self.resources.poll_use_index(
+        return self.resources.maybe_poll_use_index(
             app_name=app_name,
             sources=sources,
             model=model,
             engine_name=engine_name,
             engine_size=engine_size,
-            language=language,
             program_span_id=program_span_id,
             headers=headers
         )
@@ -3136,6 +3185,7 @@ class DirectAccessResources(Resources):
         dry_run: bool = False,
         reset_session: bool = False,
         generation: Optional[Generation] = None,
+        language: str = "rel",
     ):
         super().__init__(
             generation=generation,
@@ -3144,11 +3194,13 @@ class DirectAccessResources(Resources):
             connection=connection,
             reset_session=reset_session,
             dry_run=dry_run,
+            language=language,
         )
         self._endpoint_info = ConfigStore(ENDPOINT_FILE)
         self._service_endpoint = ""
         self._direct_access_client = None
         self.generation = generation
+        self.database = ""
 
     @property
     def service_endpoint(self) -> str:
@@ -3226,9 +3278,18 @@ class DirectAccessResources(Resources):
 
                     # fix engine on engine error and retry
                     # Skip auto-retry if skip_auto_create is True to avoid recursion
-                    if _is_engine_issue(message) and not skip_auto_create:
-                        engine = payload.get("engine_name", "") if payload else ""
-                        self.auto_create_engine(engine)
+                    if (_is_engine_issue(message) and not skip_auto_create) or _is_database_issue(message):
+                        engine_name = payload.get("caller_engine_name", "") if payload else ""
+                        engine_name = engine_name or self.get_default_engine_name()
+                        engine_size = self.config.get_default_engine_size()
+                        self._poll_use_index(
+                            app_name=self.get_app_name(),
+                            sources=self.sources,
+                            model=self.database,
+                            engine_name=engine_name,
+                            engine_size=engine_size,
+                            headers=headers,
+                        )
                         response = _send_request()
             except requests.exceptions.ConnectionError as e:
                 if "NameResolutionError" in str(e):
@@ -3356,14 +3417,13 @@ class DirectAccessResources(Resources):
 
             return response.json()
 
-    def poll_use_index(
+    def _poll_use_index(
         self,
         app_name: str,
         sources: Iterable[str],
         model: str,
         engine_name: str,
         engine_size: str | None = None,
-        language: str = "rel",
         program_span_id: str | None = None,
         headers: Dict | None = None,
     ):
@@ -3374,12 +3434,36 @@ class DirectAccessResources(Resources):
             model=model,
             engine_name=engine_name,
             engine_size=engine_size,
-            language=language,
+            language=self.language,
             program_span_id=program_span_id,
             headers=headers,
             generation=self.generation,
         ).poll()
 
+    def maybe_poll_use_index(
+        self,
+        app_name: str,
+        sources: Iterable[str],
+        model: str,
+        engine_name: str,
+        engine_size: str | None = None,
+        program_span_id: str | None = None,
+        headers: Dict | None = None,
+    ):
+        """Only call _poll_use_index if there are sources to process."""
+        sources_list = list(sources)
+        self.database = model
+        if sources_list:
+            return self._poll_use_index(
+                app_name=app_name,
+                sources=sources_list,
+                model=model,
+                engine_name=engine_name,
+                engine_size=engine_size,
+                program_span_id=program_span_id,
+                headers=headers,
+            )
+
     def _check_exec_async_status(self, txn_id: str, headers: Dict[str, str] | None = None) -> bool:
         """Check whether the given transaction has completed."""
 
@@ -3522,7 +3606,12 @@ class DirectAccessResources(Resources):
             with debugging.span("release_index", name=name, keep_database=keep_database, language=language):
                 response = self.request(
                     "release_index",
-                    payload={"model_name": name, "keep_database": keep_database, "language": language},
+                    payload={
+                        "model_name": name,
+                        "keep_database": keep_database,
+                        "language": language,
+                        "user_agent": get_pyrel_version(self.generation),
+                    },
                     headers=prop_hdrs,
                 )
                 if (

relationalai/clients/use_index_poller.py

@@ -527,6 +527,9 @@ class UseIndexPoller:
                 else:
                     self.should_check_cdc = False
 
+                if engines and self.init_engine_async:
+                    self.init_engine_async = False
+
                 break_loop = False
                 has_stream_errors = False
                 has_general_errors = False

relationalai/semantics/internal/snowflake.py

@@ -264,12 +264,11 @@ class Table():
         else:
             me = self._rel._field_refs[0]
             b.where(self).define(concept(me))
-        # if there are no keys all the fields must be properties
-        rel_func = b.Relationship if keys else b.Property
+        # All the fields are treated as properties
         for field in self._rel._fields[1:]:
             field_name = sanitize_identifier(field.name.lower())
             if field_name not in key_dict:
-                r = rel_func(
+                r = b.Property(
                     f"{{{concept}}} has {{{field_name}:{field.type_str}}}",
                     parent=concept,
                     short_name=field_name,

relationalai/semantics/lqp/executor.py

@@ -56,7 +56,15 @@ class LQPExecutor(e.Executor):
                 resource_class = rai.clients.snowflake.Resources
                 if self.config.get("use_direct_access", USE_DIRECT_ACCESS):
                     resource_class = rai.clients.snowflake.DirectAccessResources
-                self._resources = resource_class(dry_run=self.dry_run, config=self.config, generation=rai.Generation.QB, connection=self.connection)
+                # NOTE: language="lqp" is not strictly required for LQP execution, but it
+                # will significantly improve performance.
+                self._resources = resource_class(
+                    dry_run=self.dry_run,
+                    config=self.config,
+                    generation=rai.Generation.QB,
+                    connection=self.connection,
+                    language="lqp",
+                )
                 if not self.dry_run:
                     self.engine = self._resources.get_default_engine_name()
                     if not self.keep_model:
@@ -88,13 +96,12 @@ class LQPExecutor(e.Executor):
         assert self.engine is not None
 
         with debugging.span("poll_use_index", sources=sources, model=model, engine=engine_name):
-            resources.poll_use_index(
+            resources.maybe_poll_use_index(
                 app_name=app_name,
                 sources=sources,
                 model=model,
                 engine_name=self.engine,
                 engine_size=engine_size,
-                language="lqp",
                 program_span_id=program_span_id,
             )
 
@@ -280,6 +287,8 @@ class LQPExecutor(e.Executor):
         """Construct an epoch that defines a number of built-in definitions used by the
         emitter."""
         with debugging.span("compile_intrinsics") as span:
+            span["compile_type"] = "intrinsics"
+
             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),
@@ -290,7 +299,7 @@ class LQPExecutor(e.Executor):
                 meta = None,
             )
 
-            span["compile_type"] = "intrinsics"
+
             span["lqp"] = lqp_print.to_string(intrinsics_fragment, {"print_names": True, "print_debug": False, "print_csv_filename": False})
 
             return lqp_ir.Epoch(
@@ -327,13 +336,14 @@ class LQPExecutor(e.Executor):
         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["compile_type"] = "model"
                 install_span["lqp"] = lqp_print.to_string(model_txn, {"print_names": True, "print_debug": False, "print_csv_filename": False})
                 self._last_model = model
 
         with debugging.span("compile", metamodel=task) as compile_span:
+            compile_span["compile_type"] = "query"
             query = f.compute_model(f.logical([task]))
             options = {
                 "wide_outputs": self.wide_outputs,
@@ -342,7 +352,6 @@ class LQPExecutor(e.Executor):
             result, final_model = self.compiler.compile_inner(query, options)
             export_info, query_txn = result
             query_txn = txn_with_configure(query_txn, configure)
-            compile_span["compile_type"] = "query"
             compile_span["lqp"] = lqp_print.to_string(query_txn, {"print_names": True, "print_debug": False, "print_csv_filename": False})
 
         # Merge the epochs into a single transactions. Long term the query bits should all
@@ -356,14 +365,10 @@ class LQPExecutor(e.Executor):
             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)
-
-        # Revalidate now that we've joined all the epochs.
         validate_lqp(txn)
 
         txn_proto = convert_transaction(txn)

relationalai/semantics/lqp/model2lqp.py

@@ -62,7 +62,6 @@ def to_lqp(model: ir.Model, fragment_name: bytes, ctx: TranslationCtx) -> tuple[
         meta=None,
     )
 
-    lqp.validate_lqp(txn)
     return (export_info, txn)
 
 def _effect_bindings(effect: Union[ir.Output, ir.Update]) -> list[ir.Value]:

relationalai/semantics/lqp/rewrite/extract_common.py

@@ -2,8 +2,7 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 from typing import Optional
-from relationalai.semantics.metamodel.rewrite import flatten
-from relationalai.semantics.metamodel import ir, factory as f, helpers
+from relationalai.semantics.metamodel import ir, factory as f, helpers, visitor
 from relationalai.semantics.metamodel.compiler import Pass, group_tasks
 from relationalai.semantics.metamodel.util import OrderedSet, ordered_set
 from relationalai.semantics.metamodel import dependency
@@ -52,7 +51,7 @@ class ExtractCommon(Pass):
     #--------------------------------------------------
     def rewrite(self, model: ir.Model, options:dict={}) -> ir.Model:
         # create the  context
-        ctx = ExtractCommon.Context(model)
+        ctx = ExtractCommon.Context(model, options)
 
         # rewrite the root
         replacement = self.handle(model.root, ctx)
@@ -76,9 +75,10 @@ class ExtractCommon(Pass):
     #--------------------------------------------------
 
     class Context():
-        def __init__(self, model: ir.Model):
+        def __init__(self, model: ir.Model, options: dict):
             self.rewrite_ctx = helpers.RewriteContext()
             self.info = dependency.analyze(model.root)
+            self.options = options
 
     def handle(self, task: ir.Task, ctx: Context):
         # currently we only extract if it's a sequence of Logicals, but we could in the
@@ -107,7 +107,7 @@ class ExtractCommon(Pass):
         # extracted logic).
         plan = None
         if len(binders) > 1 and composites_and_effects:
-            extractables = flatten.extractables(composites_and_effects)
+            extractables = self._get_extractables(ctx, composites_and_effects)
             # only makes sense to extract common if at least one nested composite will be
             # extracted during Flatten
             if extractables:
@@ -325,7 +325,6 @@ class ExtractCommon(Pass):
 
         return ExtractCommon.ExtractionPlan(common_body, remaining, exposed_vars, local_dependencies, distribute_common_reference)
 
-
     def _compute_local_dependencies(self, ctx: Context, binders: OrderedSet[ir.Task], composite: ir.Task, exposed_vars: OrderedSet[ir.Var]):
         """
         The tasks in common_body will be extracted into a logical that will expose the exposed_vars.
@@ -362,3 +361,24 @@ class ExtractCommon(Pass):
                         if inputs:
                             vars_needed.update(inputs - vars_exposed)
         return local_body
+
+    def _get_extractables(self, ctx: Context, composites: OrderedSet[ir.Task]):
+        """
+        Extractables are tasks that will eventually be extracted by the Flatten pass later.
+        Given a set of tasks, return the extractable ones.
+        """
+        def _extractable(t: ir.Task):
+            # With GNF outputs (i.e., wide_outputs = False), the output tasks will be
+            # extracted into separate top-level single-column outputs.
+            if isinstance(t, ir.Output) and not ctx.options.get("wide_outputs", False):
+                return True
+
+            extractable_types = (ir.Update, ir.Aggregate, ir.Match, ir.Union, ir.Rank)
+            return isinstance(t, ir.Logical) and len(visitor.collect_by_type(extractable_types, t)) > 0
+
+        extractables = []
+        for t in composites:
+            if _extractable(t):
+                extractables.append(t)
+
+        return extractables

relationalai/semantics/metamodel/dependency.py

@@ -96,8 +96,12 @@ class DependencyInfo():
             # start with the cluster dependencies, because cluster represents the task we
             # care about
             queue.extend(cluster.dependencies)
+            seen = set()
             while queue:
                 cluster = queue.pop()
+                if cluster.id in seen:
+                    continue
+                seen.add(cluster.id)
                 deps.update(cluster.content)
                 queue.extend(cluster.dependencies)
 
@@ -625,12 +629,14 @@ class BindingAnalysis(visitor.Visitor):
                     # TODO: this is similar to what's done below in visit_lookup, modularize
                     if builtins.is_eq(child.relation):
                         x, y = child.args[0], child.args[1]
+                        # Compute input/output vars of the equality
                         if isinstance(x, ir.Var) and not isinstance(y, ir.Var):
-                            grounds.add(x)
-                            self.output(child, x)
+                            # Variable x is potentially grounded by other expressions at
+                            # level in the Logical. If it is, then we should mark it as
+                            # input (which is done later).
+                            potentially_grounded.add((child, x, x))
                         elif not isinstance(x, ir.Var) and isinstance(y, ir.Var):
-                            grounds.add(y)
-                            self.output(child, y)
+                            potentially_grounded.add((child, y, y))
                         elif isinstance(x, ir.Var) and isinstance(y, ir.Var):
                             # mark as potentially grounded, if any is grounded in other atoms then we later ground both
                             potentially_grounded.add((child, x, y))
@@ -779,22 +785,19 @@ class BindingAnalysis(visitor.Visitor):
         if builtins.is_eq(node.relation):
             # Most cases are covered already at the parent level if the equality is part of
             # a Logical. The remaining cases are when the equality is a child of a
-            # non-Logical.
+            # non-Logical, or if its variables are not ground elsewhere in the Logical.
             if self.info.task_inputs(node) or self.info.task_outputs(node):
                 # already covered
                 pass
             else:
                 x, y = node.args[0], node.args[1]
-                if isinstance(x, ir.Var) and not isinstance(y, ir.Var):
-                    self.output(node, x)
-                elif not isinstance(x, ir.Var) and isinstance(y, ir.Var):
-                    self.output(node, y)
-                elif isinstance(x, ir.Var) and isinstance(y, ir.Var):
-                    grounds = self._grounded[-1] if self._grounded else ordered_set()
+                grounds = self._grounded[-1] if self._grounded else ordered_set()
+                if isinstance(x, ir.Var):
                     if x in grounds:
                         self.input(node, x)
                     else:
                         self.output(node, x)
+                if isinstance(y, ir.Var):
                     if y in grounds:
                         self.input(node, y)
                     else:

relationalai/semantics/metamodel/rewrite/flatten.py

@@ -3,7 +3,7 @@ from dataclasses import dataclass
 from typing import cast, Optional, TypeVar
 from typing import Tuple
 
-from relationalai.semantics.metamodel import builtins, ir, factory as f, helpers, types, visitor
+from relationalai.semantics.metamodel import builtins, ir, factory as f, helpers, types
 from relationalai.semantics.metamodel.compiler import Pass, group_tasks
 from relationalai.semantics.metamodel.util import OrderedSet, ordered_set, NameCache
 from relationalai.semantics.metamodel import dependency
@@ -611,18 +611,6 @@ def set_union(s1: Optional[OrderedSet[T]], s2: Optional[OrderedSet[T]]) -> list:
         return s2.get_list()
     return []
 
-def extractable(t: ir.Task):
-    """
-    Whether this task is a Logical that will be extracted as a top level by this
-    pass, because it has an aggregation, effects, match, union, etc.
-    """
-    extractable_types = (ir.Update, ir.Aggregate, ir.Match, ir.Union, ir.Rank)
-    return isinstance(t, ir.Logical) and len(visitor.collect_by_type(extractable_types, t)) > 0
-
-def extractables(composites: OrderedSet[ir.Task]):
-    """ Filter the set of composites, keeping only the extractable ones. """
-    return list(filter(extractable, composites))
-
 def negate(lookup: ir.Lookup, values: int):
     """
     Return a negation of this reference, where the last `values` arguments are to

relationalai/semantics/reasoners/graph/core.py

@@ -353,14 +353,16 @@ class Graph():
     @cached_property
     def Node(self) -> Concept:
         """Lazily define and cache the self.Node concept."""
-        return self._user_node_concept or self._model.Concept(self._NodeConceptStr)
-
+        _Node = self._user_node_concept or self._model.Concept(self._NodeConceptStr)
+        _Node.annotate(annotations.track("graphs", "Node"))
+        return _Node
 
     @cached_property
     def Edge(self):
         """Lazily define and cache the self.Edge concept and friends,
         by passing through to self._EdgeComplex."""
         _Edge, _, _, _ = self._EdgeComplex
+        _Edge.annotate(annotations.track("graphs", "Edge"))
         return _Edge
 
     @cached_property
@@ -594,6 +596,7 @@ class Graph():
         consuming the `Edge` concept's `EdgeSrc` and `EdgeDst` relationships.
         """
         _edge_rel = self._model.Relationship(f"{{src:{self._NodeConceptStr}}} has edge to {{dst:{self._NodeConceptStr}}}")
+        _edge_rel.annotate(annotations.track("graphs", "_edge"))
 
         Edge, EdgeSrc, EdgeDst = self.Edge, self.EdgeSrc, self.EdgeDst
         src, dst = self.Node.ref(), self.Node.ref()
@@ -620,6 +623,7 @@ class Graph():
         consuming the `Edge` concept's `EdgeSrc`, `EdgeDst`, and `EdgeWeight` relationships.
         """
         _weight_rel = self._model.Relationship(f"{{src:{self._NodeConceptStr}}} has edge to {{dst:{self._NodeConceptStr}}} with weight {{weight:Float}}")
+        _weight_rel.annotate(annotations.track("graphs", "_weight"))
 
         Edge, EdgeSrc, EdgeDst, EdgeWeight = self.Edge, self.EdgeSrc, self.EdgeDst, self.EdgeWeight
         src, dst, weight = self.Node.ref(), self.Node.ref(), Float.ref()
@@ -3920,17 +3924,31 @@ class Graph():
 
 
     @include_in_docs
-    def triangle(self):
+    def triangle(self, *, full: Optional[bool] = None):
         """Returns a ternary relationship containing all triangles in the graph.
 
         Unlike `unique_triangle`, this relationship contains all permutations
         of the nodes for each triangle found.
 
+        Parameters
+        ----------
+        full : bool, optional
+            If ``True``, computes triangles for all triplets of nodes in the graph.
+            This computation can be expensive for large graphs. Must be set to ``True``
+            to compute the full triangle relationship.
+            Default is ``None``.
+
         Returns
         -------
         Relationship
             A ternary relationship where each tuple represents a triangle.
 
+        Raises
+        ------
+        ValueError
+            If ``full`` is not provided.
+            If ``full`` is not ``True``.
+
         Relationship Schema
         -------------------
         ``triangle(node_a, node_b, node_c)``
@@ -3970,7 +3988,7 @@ class Graph():
         >>>
         >>> # 3. Select all triangles and inspect
         >>> a,b,c = Node.ref("a"), Node.ref("b"), Node.ref("c")
-        >>> triangle = graph.triangle()
+        >>> triangle = graph.triangle(full=True)
         >>> select(a.id, b.id, c.id).where(triangle(a, b, c)).inspect()
         ▰▰▰▰ Setup complete
            id  id2  id3
@@ -3999,7 +4017,7 @@ class Graph():
         >>>
         >>> # 3. Select all triangles and inspect
         >>> a,b,c = Node.ref("a"), Node.ref("b"), Node.ref("c")
-        >>> triangle = graph.triangle()
+        >>> triangle = graph.triangle(full=True)
         >>> select(a.id, b.id, c.id).where(triangle(a, b, c)).inspect()
         ▰▰▰▰ Setup complete
            id  id2  id3
@@ -4017,15 +4035,22 @@ class Graph():
         triangle_count
 
         """
-        warnings.warn(
-            (
-                "`triangle` presently always computes all triangles "
-                "in the graph. To provide better control over the computed subset, "
-                "`triangle`'s interface may soon change."
-            ),
-            FutureWarning,
-            stacklevel=2
-        )
+        # Validate full parameter
+        if full is None:
+            raise ValueError(
+                "Computing triangle for all triplets can be expensive. To confirm "
+                "that you would like to compute the full triangle relationship, "
+                "please call `triangle(full=True)`. "
+                "(Domain constraints are not available for `triangle` at this time. "
+                "If you need domain constraints for `triangle`, please reach out.)"
+            )
+
+        if full is not True:
+            raise ValueError(
+                f"Invalid value (`{full}`) for 'full' parameter. Use `full=True` "
+                "to compute the full triangle relationship. "
+            )
+
         return self._triangle
 
     @cached_property
@@ -4052,15 +4077,29 @@ class Graph():
 
 
     @include_in_docs
-    def unique_triangle(self):
+    def unique_triangle(self, *, full: Optional[bool] = None):
         """Returns a ternary relationship containing all unique triangles in the graph.
 
+        Parameters
+        ----------
+        full : bool, optional
+            If ``True``, computes unique triangles for all triplets of nodes in the graph.
+            This computation can be expensive for large graphs. Must be set to ``True``
+            to compute the full unique_triangle relationship.
+            Default is ``None``.
+
         Returns
         -------
         Relationship
             A ternary relationship where each tuple represents a unique
             triangle.
 
+        Raises
+        ------
+        ValueError
+            If ``full`` is not provided.
+            If ``full`` is not ``True``.
+
         Relationship Schema
         -------------------
         ``unique_triangle(node_a, node_b, node_c)``
@@ -4117,7 +4156,7 @@ class Graph():
         >>>
         >>> # 3. Select the unique triangles and inspect
         >>> a,b,c = Node.ref("a"), Node.ref("b"), Node.ref("c")
-        >>> unique_triangle = graph.unique_triangle()
+        >>> unique_triangle = graph.unique_triangle(full=True)
         >>> select(a.id, b.id, c.id).where(unique_triangle(a, b, c)).inspect()
         ▰▰▰▰ Setup complete
            id  id2  id3
@@ -4146,7 +4185,7 @@ class Graph():
         >>>
         >>> # 3. Select the unique triangles and inspect
         >>> a,b,c = Node.ref("a"), Node.ref("b"), Node.ref("c")
-        >>> unique_triangle = graph.unique_triangle()
+        >>> unique_triangle = graph.unique_triangle(full=True)
         >>> select(a.id, b.id, c.id).where(unique_triangle(a, b, c)).inspect()
         ▰▰▰▰ Setup complete
            id  id2  id3
@@ -4160,15 +4199,22 @@ class Graph():
         triangle_count
 
         """
-        warnings.warn(
-            (
-                "`unique_triangle` presently always computes all unique triangles "
-                "in the graph. To provide better control over the computed subset, "
-                "`unique_triangle`'s interface may soon change."
-            ),
-            FutureWarning,
-            stacklevel=2
-        )
+        # Validate full parameter
+        if full is None:
+            raise ValueError(
+                "Computing unique_triangle for all triplets can be expensive. To confirm "
+                "that you would like to compute the full unique_triangle relationship, "
+                "please call `unique_triangle(full=True)`. "
+                "(Domain constraints are not available for `unique_triangle` at this time. "
+                "If you need domain constraints for `unique_triangle`, please reach out.)"
+            )
+
+        if full is not True:
+            raise ValueError(
+                f"Invalid value (`{full}`) for 'full' parameter. Use `full=True` "
+                "to compute the full unique_triangle relationship."
+            )
+
         return self._unique_triangle
 
     @cached_property

relationalai/semantics/rel/executor.py

@@ -54,7 +54,15 @@ class RelExecutor(e.Executor):
                 resource_class = rai.clients.snowflake.Resources
                 if self.config.get("use_direct_access", USE_DIRECT_ACCESS):
                     resource_class = rai.clients.snowflake.DirectAccessResources
-                self._resources = resource_class(dry_run=self.dry_run, config=self.config, generation=rai.Generation.QB, connection=self.connection)
+                # NOTE: language="rel" is required for Rel execution. It is the default, but
+                # we set it explicitly here to be sure.
+                self._resources = resource_class(
+                    dry_run=self.dry_run,
+                    config=self.config,
+                    generation=rai.Generation.QB,
+                    connection=self.connection,
+                    language="rel",
+                )
                 if not self.dry_run:
                     self.engine = self._resources.get_default_engine_name()
                     if not self.keep_model:
@@ -85,13 +93,12 @@ class RelExecutor(e.Executor):
         assert self.engine is not None
 
         with debugging.span("poll_use_index", sources=sources, model=model, engine=engine_name):
-            resources.poll_use_index(
+            resources.maybe_poll_use_index(
                 app_name=app_name,
                 sources=sources,
                 model=model,
                 engine_name=self.engine,
                 engine_size=engine_size,
-                language="rel",
                 program_span_id=program_span_id,
                 headers=headers,
             )
@@ -249,25 +256,26 @@ class RelExecutor(e.Executor):
         # Format meta as headers
         json_meta = prepare_metadata_for_headers(meta)
         headers = {QUERY_ATTRIBUTES_HEADER: json_meta} if json_meta else {}
-        
+
         self.check_graph_index(headers)
         resources= self.resources
 
         rules_code = ""
         if self._last_model != model:
             with debugging.span("compile", metamodel=model) as install_span:
+                install_span["compile_type"] = "model"
                 base = textwrap.dedent("""
                     declare pyrel_error_attrs(err in ::std::common::UInt128, attr in ::std::common::String, v) requires true
 
                 """)
                 rules_code = base + self.compiler.compile(model, {"wide_outputs": self.wide_outputs})
-                install_span["compile_type"] = "model"
                 install_span["rel"] = rules_code
                 rules_code = resources.create_models_code([("pyrel_qb_0", rules_code)])
                 self._last_model = model
 
 
         with debugging.span("compile", metamodel=task) as compile_span:
+            compile_span["compile_type"] = "query"
             base = textwrap.dedent("""
                 def output(:pyrel_error, err, attr, val):
                     pyrel_error_attrs(err, attr, val)
@@ -276,7 +284,6 @@ class RelExecutor(e.Executor):
             task_model = f.compute_model(f.logical([task]))
             task_code, task_model = self.compiler.compile_inner(task_model, {"no_declares": True, "wide_outputs": self.wide_outputs})
             task_code = base + task_code
-            compile_span["compile_type"] = "query"
             compile_span["rel"] = task_code
 
         full_code = textwrap.dedent(f"""

relationalai/semantics/sql/executor/snowflake.py

@@ -73,19 +73,19 @@ class SnowflakeExecutor(e.Executor):
 
         if self._last_model != model:
             with debugging.span("compile", metamodel=model) as model_span:
-                model_sql, _ = self.compiler.compile(model, options)
                 model_span["compile_type"] = "model"
+                model_sql, _ = self.compiler.compile(model, options)
                 model_span["sql"] = model_sql
                 self._last_model = model
                 self._last_model_sql = model_sql
 
         with debugging.span("compile", metamodel=task) as compile_span:
+            compile_span["compile_type"] = "query"
             # 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_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
 
         if self.dry_run:

{relationalai-0.12.3.dist-info → relationalai-0.12.4.dist-info}/METADATA

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

{relationalai-0.12.3.dist-info → relationalai-0.12.4.dist-info}/RECORD

@@ -28,9 +28,9 @@ relationalai/clients/export_procedure.py.jinja,sha256=nhvVcs5hQyWExFDuROQbi1VyYz
 relationalai/clients/hash_util.py,sha256=pZVR1FX3q4G_19p_r6wpIR2tIM8_WUlfAR7AVZJjIYM,1495
 relationalai/clients/profile_polling.py,sha256=pUH7WKH4nYDD0SlQtg3wsWdj0K7qt6nZqUw8jTthCBs,2565
 relationalai/clients/result_helpers.py,sha256=wDSD02Ngx6W-YQqBIGKnpXD4Ju3pA1e9Nz6ORRI6SRI,17808
-relationalai/clients/snowflake.py,sha256=c5z7sh9wXeMaAm0JiyrOZlHJFK_hbS76ml8Ed6kWxKo,159579
+relationalai/clients/snowflake.py,sha256=qybrFowe_s3bAPOsFCh-j-ARpdivW3g6_4HjlcN_Fvw,163091
 relationalai/clients/types.py,sha256=eNo6akcMTbnBFbBbHd5IgVeY-zuAgtXlOs8Bo1SWmVU,2890
-relationalai/clients/use_index_poller.py,sha256=gxQDK-iaA9iz5-rkNWQjptZSxgdwv8WXIKC4HB44cHo,46291
+relationalai/clients/use_index_poller.py,sha256=OFeTJ3fF98UoVk6MA8v8ri8WPbmmCquyA4T8MD_T1Xc,46398
 relationalai/clients/util.py,sha256=NJC8fnrWHR01NydwESPSetIHRWf7jQJURYpaWJjmDyE,12311
 relationalai/early_access/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 relationalai/early_access/builder/__init__.py,sha256=mrR-aGLPquUGc_e9-DOkVCCCo8QRE5A56GTTtgILNa4,993
@@ -257,15 +257,15 @@ relationalai/semantics/devtools/extract_lqp.py,sha256=gxI3EvPUTPAkwgnkCKAkEm2vA6
 relationalai/semantics/internal/__init__.py,sha256=JXrpFaL-fdZrvKpWTEn1UoLXITOoTGnAYwmgeiglhSk,774
 relationalai/semantics/internal/annotations.py,sha256=P_nRpBm4wLmE_8L0VO3TDORL1p2flXaPOVDC0GG7KsQ,306
 relationalai/semantics/internal/internal.py,sha256=Vh4LFatRA8xO6sIBxRSlbAv6HOMJPU65t2c_ZEh9lug,148972
-relationalai/semantics/internal/snowflake.py,sha256=DR6rgbPawen2ZOFegRuPkXt8aQUfciiCYzDI74u1Iwc,13036
+relationalai/semantics/internal/snowflake.py,sha256=3t_GVU61WRUtVrOCpTJ7RlVTZLm0DPpMKU7Q66IiatY,12966
 relationalai/semantics/lqp/__init__.py,sha256=XgcQZxK-zz_LqPDVtwREhsIvjTuUIt4BZhIedCeMY-s,48
 relationalai/semantics/lqp/builtins.py,sha256=bRmQ6fdceWU-4xf4l-W-YiuyDxJTPey1s6O4xlyW6iM,540
 relationalai/semantics/lqp/compiler.py,sha256=Nury1gPw_-Oi_mqT1-rhr13L4UmyIP2BGuotbuklQKA,949
 relationalai/semantics/lqp/constructors.py,sha256=8U4eUL8-m1wYRQnws_YWC1coGquTugVH5YC0Zek6VT8,2309
-relationalai/semantics/lqp/executor.py,sha256=tKs4J7EWzqGm-qp4kCWBPG_uoafzoLODsCJTKRZUsG4,20439
+relationalai/semantics/lqp/executor.py,sha256=P5_YITIGUfLlkblzzOB1CdprxhuVYA5pn5kow50Mnik,20636
 relationalai/semantics/lqp/intrinsics.py,sha256=Pb1mLIme7Q-5Y-CVacUOEvapfhKs076bgtRNi3f0ayY,833
 relationalai/semantics/lqp/ir.py,sha256=DUw0ltul0AS9CRjntNlmllWTwXpxMyYg4iJ9t7NFYMA,1791
-relationalai/semantics/lqp/model2lqp.py,sha256=M---RMVLEollI4aGHFh-2klR4y6C88vPKCHFd6tPNz8,31753
+relationalai/semantics/lqp/model2lqp.py,sha256=V0Gavuk1eBsZaCP9YSq6r-XSwfqpVGo1KABkk6XObuE,31727
 relationalai/semantics/lqp/passes.py,sha256=nLppoHvIQkGP6VuG56OAZ1oOrYhEqpR_0w91gfJ7t_s,27540
 relationalai/semantics/lqp/pragmas.py,sha256=FzzldrJEAZ1AIcEw6D-FfaVg3CoahRYgPCFo7xHfg1g,375
 relationalai/semantics/lqp/primitives.py,sha256=Gbh6cohoAArhqEJTN_TgIRc7wmtdxXt231NRW0beEj0,10898
@@ -275,7 +275,7 @@ relationalai/semantics/lqp/utils.py,sha256=x8dcfVoyqzCznNFtI4qSNSL-vWcdxzC-QrnFJ
 relationalai/semantics/lqp/validators.py,sha256=YO_ciSgEVNILWUbkxIagKpIxI4oqV0fRSTO2Ok0rPJk,1526
 relationalai/semantics/lqp/rewrite/__init__.py,sha256=NQMkrZMUrLksScGXs0EiZTT-In5VltvswfeB4kCkeZM,337
 relationalai/semantics/lqp/rewrite/cdc.py,sha256=I6DeMOZScx-3UAVoSCMn9cuOgLzwdvJVKNwsgFa6R_k,10390
-relationalai/semantics/lqp/rewrite/extract_common.py,sha256=N__2wqebrJI04OFhi4msohcm8wSRUtSUNxYs60IGn4M,17443
+relationalai/semantics/lqp/rewrite/extract_common.py,sha256=sbihURqk4wtc1ekDWXWltq9LrO42XTLfOHl5D6nT5vw,18371
 relationalai/semantics/lqp/rewrite/extract_keys.py,sha256=dSr5SVkYmrhiR0XPY5eRAnWD66dcZYgXdilXcERv634,18682
 relationalai/semantics/lqp/rewrite/fd_constraints.py,sha256=a4jetchlOfm2rb3QD0Nil0bvermpBx1up7p1uNgcJHg,3503
 relationalai/semantics/lqp/rewrite/quantify_vars.py,sha256=wYMEXzCW_D_Y_1rSLvuAAqw9KN1oIOn_vIMxELzRVb4,11568
@@ -284,7 +284,7 @@ relationalai/semantics/metamodel/__init__.py,sha256=I-XqQAGycD0nKkKYvnF3G9d0QK_1
 relationalai/semantics/metamodel/builtins.py,sha256=vGzNGTqD1q4Yn2K1Rx6D47t_CUZDbp-16ndE56RiT70,35965
 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=1bqSZw3OJffcsLYozR7zs_9ROIcK33f2zU8jIA7JOlI,33699
+relationalai/semantics/metamodel/dependency.py,sha256=iJLx-w_zqde7CtbGcXxLxZBdUKZYl7AUykezPI9ccck,33926
 relationalai/semantics/metamodel/executor.py,sha256=_pm--QNvAjd-GgiMKMrpkPZ2eE0H1IM5ZB0l1DGkRs0,2614
 relationalai/semantics/metamodel/factory.py,sha256=Vk3ASwWan08mfGehoOOwMixuU_mEbG2vNl8JLSCJ2OU,12581
 relationalai/semantics/metamodel/helpers.py,sha256=aeXWkS-iKfLqqXtlMjQZyqIIiIsG9dqP4cQA3cUmM08,15403
@@ -296,14 +296,14 @@ relationalai/semantics/metamodel/rewrite/__init__.py,sha256=aPgZuRGpULwPVWtENUEH
 relationalai/semantics/metamodel/rewrite/discharge_constraints.py,sha256=0v613BqCLlo4sgWuZjcLSxxakp3d34mYWbG4ldhzGno,1949
 relationalai/semantics/metamodel/rewrite/dnf_union_splitter.py,sha256=dlyD868Pg424BLowY4A0gOmSziSy1U-dYGXZEE3SW8E,7956
 relationalai/semantics/metamodel/rewrite/extract_nested_logicals.py,sha256=0aKMoniIzq-uAm1iItRQEUxGGDYVnT8pWZxFXWlOk50,3366
-relationalai/semantics/metamodel/rewrite/flatten.py,sha256=diBVspq0MLu6tP2lwMs5TcLImF_2AUDbzhMKRYfrPxg,28449
+relationalai/semantics/metamodel/rewrite/flatten.py,sha256=W3zoUWY2UVOO_d-vyLZYb4y61wcM99ceJJFCuz_Rz-Q,27891
 relationalai/semantics/metamodel/typer/__init__.py,sha256=E3ydmhWRdm-cAqWsNR24_Qd3NcwiHx8ElO2tzNysAXc,143
 relationalai/semantics/metamodel/typer/checker.py,sha256=frY0gilDO6skbDiYFiIpDUOWyt9s9jAJsRBs848DcG0,19184
 relationalai/semantics/metamodel/typer/typer.py,sha256=jBo0CwY6G0qKBzqoAmQ09dPtcPDHvCiutolnwbV4gus,62294
 relationalai/semantics/reasoners/__init__.py,sha256=Tu4U26rrkBIzAk3a4tXRJaeD5mAtK9Z7JXh2c6VJ-J4,249
 relationalai/semantics/reasoners/graph/README.md,sha256=QgKEXTllp5PO-yK8oDfMx1PNTYF2uVoneMRKsWTY5GU,23953
 relationalai/semantics/reasoners/graph/__init__.py,sha256=jSXR6J05SQZdjxQ5Y-ovqFqGTAXCOWeQDcvpfoBYgDA,1282
-relationalai/semantics/reasoners/graph/core.py,sha256=xkHPJJeFb63BemltBHq8VJD2ThqClyF1paDV05zSnGU,349862
+relationalai/semantics/reasoners/graph/core.py,sha256=8-YVdxz20zj3pzTD14sWanif5zRbe9PbNuXRhGXeSXI,351965
 relationalai/semantics/reasoners/graph/design/beyond_demand_transform.md,sha256=Givh0W6B6Hlow6TpmK-8adpEYd8b3O_WmdgMOQIyKs0,55749
 relationalai/semantics/reasoners/graph/paths/README.md,sha256=ydm6CzMN_vOOgq7a6_hBCiyGi3D6g5gxAbf4OXbQbDE,3433
 relationalai/semantics/reasoners/graph/paths/__init__.py,sha256=oCoDJVg4moGe0tNMNeRn7XQqa1AIEZGlxAiaD5bBahg,211
@@ -376,7 +376,7 @@ relationalai/semantics/reasoners/optimization/solvers_pb.py,sha256=ryNARpyph3uvr
 relationalai/semantics/rel/__init__.py,sha256=pMlVTC_TbQ45mP1LpzwFBBgPxpKc0H3uJDvvDXEWzvs,55
 relationalai/semantics/rel/builtins.py,sha256=qu4yZvLovn4Vn2x44D4XugqGD6Qo5xLxj_RKA34cpF4,1527
 relationalai/semantics/rel/compiler.py,sha256=hiLIaZzhVU5VMtU6rdo3tH2pmKMEtXvh6AHh94CvRAg,42203
-relationalai/semantics/rel/executor.py,sha256=mRBNyw6qHgmF3aOnM4aTIxBHCn4yaho4nQlMYM08pIA,15883
+relationalai/semantics/rel/executor.py,sha256=PfCm9tsY_HVYnw7Zo7RMR7GisQ9-5W-Hy6kqK4jFfpU,16133
 relationalai/semantics/rel/rel.py,sha256=9I_V6dQ83QRaLzq04Tt-KjBWhmNxNO3tFzeornBK4zc,15738
 relationalai/semantics/rel/rel_utils.py,sha256=F14Ch8mn45J8SmM7HZnIHUNqDnb3WQLnkEGLme04iBk,9386
 relationalai/semantics/snowflake/__init__.py,sha256=BW_zvPQBWGTAtY6cluG6tDDG-QmU_jRb-F7PeCpDhIU,134
@@ -386,7 +386,7 @@ relationalai/semantics/sql/sql.py,sha256=7nUnm0RbHlOGSGQbnFrgzPYdmnoppifQ5jylR5W
 relationalai/semantics/sql/executor/__init__.py,sha256=F3HqQPJVP9wgV3rkwI5jy1_QBCD_3qj2IGxbdT_pX9k,120
 relationalai/semantics/sql/executor/duck_db.py,sha256=laI0jquMNNhj1pcFlaqxYAvvnCmSuvzzkibfjMz7liY,1909
 relationalai/semantics/sql/executor/result_helpers.py,sha256=kVfspHHuzyq4SNklrtvhYte1wqRFzct-dAKin_lOmR4,3215
-relationalai/semantics/sql/executor/snowflake.py,sha256=d6HAb-nxGXUAYFDec7E2YPkIGAqQWwoet0mtFFWeBMk,5861
+relationalai/semantics/sql/executor/snowflake.py,sha256=p7jLfDtqGgM8GEjHBGqdm_PbxEIQn0cmI_msEj9F0Xo,5861
 relationalai/semantics/sql/rewrite/__init__.py,sha256=AT1WR0rqQHQ7E06NLoVym0zrZpBVPqK85uRFNJUTDp4,254
 relationalai/semantics/sql/rewrite/denormalize.py,sha256=gPF0s1edthoHfuBIdS9-hnEaX5RFYBdtOlK5iAfB5CA,9040
 relationalai/semantics/sql/rewrite/double_negation.py,sha256=QXynhjwfPW52Hpdo78VWPNk2TXe_mMTWYN470in51z8,1710
@@ -453,8 +453,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.3.dist-info/METADATA,sha256=9hO6-mtkEsNmxmxcGprjapISmqOolWYWqxaeFUkC2Yg,2562
-relationalai-0.12.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-relationalai-0.12.3.dist-info/entry_points.txt,sha256=fo_oLFJih3PUgYuHXsk7RnCjBm9cqRNR--ab6DgI6-0,88
-relationalai-0.12.3.dist-info/licenses/LICENSE,sha256=pPyTVXFYhirkEW9VsnHIgUjT0Vg8_xsE6olrF5SIgpc,11343
-relationalai-0.12.3.dist-info/RECORD,,
+relationalai-0.12.4.dist-info/METADATA,sha256=SRoHgqRMSESO_6_I1ZTQOyI3iGl-3gtN64rQcupY7Ww,2562
+relationalai-0.12.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+relationalai-0.12.4.dist-info/entry_points.txt,sha256=fo_oLFJih3PUgYuHXsk7RnCjBm9cqRNR--ab6DgI6-0,88
+relationalai-0.12.4.dist-info/licenses/LICENSE,sha256=pPyTVXFYhirkEW9VsnHIgUjT0Vg8_xsE6olrF5SIgpc,11343
+relationalai-0.12.4.dist-info/RECORD,,