relationalai 0.12.2__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/experimental/solvers.py

@@ -261,20 +261,7 @@ class SolverModel:
         remaining_timeout_minutes = calc_remaining_timeout_minutes(
             start_time, query_timeout_mins, config_file_path=config_file_path
         )
-        try:
-            job_id = solver._exec_job(payload, log_to_console=log_to_console, query_timeout_mins=remaining_timeout_minutes)
-        except Exception as e:
-            err_message = str(e).lower()
-            if isinstance(e, ResponseStatusException):
-                err_message = e.response.json().get("message", "")
-            if any(kw in err_message.lower() for kw in ENGINE_ERRORS + WORKER_ERRORS + ENGINE_NOT_READY_MSGS):
-                solver._auto_create_solver_async()
-                remaining_timeout_minutes = calc_remaining_timeout_minutes(
-                    start_time, query_timeout_mins, config_file_path=config_file_path
-                )
-                job_id = solver._exec_job(payload, log_to_console=log_to_console, query_timeout_mins=remaining_timeout_minutes)
-            else:
-                raise e
+        job_id = solver._exec_job(payload, log_to_console=log_to_console, query_timeout_mins=remaining_timeout_minutes)
 
         # 3. Extract result.
         remaining_timeout_minutes = calc_remaining_timeout_minutes(
@@ -660,12 +647,24 @@ class Solver:
         if self.engine is None:
             raise Exception("Engine not initialized.")
 
-        # Make sure the engine is ready.
-        if self.engine["state"] != "READY":
-            poll_with_specified_overhead(lambda: self._is_solver_ready(), 0.1)
-
         with debugging.span("job") as job_span:
-            job_id = self.provider.create_job_async(self.engine["name"], payload, query_timeout_mins=query_timeout_mins)
+            # Retry logic. If creating a job fails with an engine
+            # related error we will create/resume/... the engine and
+            # retry.
+            try:
+                job_id = self.provider.create_job_async(self.engine["name"], payload, query_timeout_mins=query_timeout_mins)
+            except Exception as e:
+                err_message = str(e).lower()
+                if isinstance(e, ResponseStatusException):
+                    err_message = e.response.json().get("message", "")
+                if any(kw in err_message.lower() for kw in ENGINE_ERRORS + WORKER_ERRORS + ENGINE_NOT_READY_MSGS):
+                    self._auto_create_solver_async()
+                    # Wait until the engine is ready.
+                    poll_with_specified_overhead(lambda: self._is_solver_ready(), 0.1)
+                    job_id = self.provider.create_job_async(self.engine["name"], payload, query_timeout_mins=query_timeout_mins)
+                else:
+                    raise e
+
             job_span["job_id"] = job_id
             debugging.event("job_created", job_span, job_id=job_id, engine_name=self.engine["name"], job_type=ENGINE_TYPE_SOLVER)
             if not isinstance(job_id, str):

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(
@@ -300,19 +309,41 @@ class LQPExecutor(e.Executor):
                 meta=None,
             )
 
+    def _compile_undefine_query(self, query_epoch: lqp_ir.Epoch) -> lqp_ir.Epoch:
+        fragment_ids = []
+
+        for write in query_epoch.writes:
+            if isinstance(write.write_type, lqp_ir.Define):
+                fragment_ids.append(write.write_type.fragment.id)
+
+        # Construct new Epoch with Undefine operations for all collected fragment IDs
+        undefine_writes = [
+            lqp_ir.Write(
+                write_type=lqp_ir.Undefine(fragment_id=frag_id, meta=None),
+                meta=None
+            )
+            for frag_id in fragment_ids
+        ]
+
+        return lqp_ir.Epoch(
+            writes=undefine_writes,
+            meta=None,
+        )
+
     def compile_lqp(self, model: ir.Model, task: ir.Task):
         configure = self._construct_configure()
 
         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,
@@ -321,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
@@ -334,11 +364,11 @@ class LQPExecutor(e.Executor):
         if model_txn is not None:
             epochs.append(model_txn.epochs[0])
 
-        epochs.append(query_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:
@@ -265,10 +265,12 @@ class ExtractCommon(Pass):
         for child in common_body:
             body_output_vars.update(ctx.info.task_outputs(child))
 
-        # Compute the union of input vars across all composites, intersected with output
+        # Compute the union of input vars across all non-extracted tasks (basically
+        # composites and binders left behind), intersected with output
         # vars of the common body
         exposed_vars = OrderedSet.from_iterable(ctx.info.task_inputs(sample)) & body_output_vars
-        for composite in composites:
+        non_extracted_tasks = (binders - common_body) | composites
+        for composite in non_extracted_tasks:
             if composite is sample:
                 continue
             # compute common input vars
@@ -323,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.
@@ -360,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/builtins.py

@@ -112,12 +112,12 @@ log10 = f.relation(
 
 log = f.relation(
     "log",
-    [f.input_field("a", types.Number), f.input_field("b", types.Number), f.field("c", types.Float)],
+    [f.input_field("base", types.Number), f.input_field("value", types.Number), f.field("result", types.Float)],
     overloads=[
-        f.relation("log", [f.input_field("a", types.Int64), f.input_field("b", types.Int64), f.field("c", types.Float)]),
-        f.relation("log", [f.input_field("a", types.Int128), f.input_field("b", types.Int128), f.field("c", types.Float)]),
-        f.relation("log", [f.input_field("a", types.Float), f.input_field("b", types.Float), f.field("c", types.Float)]),
-        f.relation("log", [f.input_field("a", types.GenericDecimal), f.input_field("b", types.GenericDecimal), f.field("c", types.Float)]),
+        f.relation("log", [f.input_field("base", types.Int64), f.input_field("value", types.Int64), f.field("result", types.Float)]),
+        f.relation("log", [f.input_field("base", types.Int128), f.input_field("value", types.Int128), f.field("result", types.Float)]),
+        f.relation("log", [f.input_field("base", types.Float), f.input_field("value", types.Float), f.field("result", types.Float)]),
+        f.relation("log", [f.input_field("base", types.GenericDecimal), f.input_field("value", types.GenericDecimal), f.field("result", types.Float)]),
 
     ],
 )
@@ -496,7 +496,7 @@ function = f.relation("function", [f.input_field("code", types.Symbol)])
 function_checked_annotation = f.annotation(function, [f.lit("checked")])
 function_annotation = f.annotation(function, [])
 
-# Indicates this relation should be tracked in telemetry. Only supported for Relationships.
+# 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
 # SCC evaluation, if any declarations bear the `track` annotation.
 track = f.relation("track", [