relationalai 0.12.3__tar.gz → 0.12.4__tar.gz

{relationalai-0.12.3 → relationalai-0.12.4}/PKG-INFO

@@ -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 → relationalai-0.12.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = 'relationalai'
-version = '0.12.3'
+version = '0.12.4'
 description = 'RelationalAI Library and CLI'
 readme="docs/pypi/README.md"
 authors = [

{relationalai-0.12.3 → relationalai-0.12.4}/src/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-0.12.3 → relationalai-0.12.4}/src/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-0.12.3 → relationalai-0.12.4}/src/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-0.12.3 → relationalai-0.12.4}/src/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-0.12.3 → relationalai-0.12.4}/src/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-0.12.3 → relationalai-0.12.4}/src/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-0.12.3 → relationalai-0.12.4}/src/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-0.12.3 → relationalai-0.12.4}/src/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