relationalai 0.11.4__py3-none-any.whl → 0.12.1__py3-none-any.whl

relationalai/clients/use_index_poller.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from typing import Iterable, Dict, Optional, List, cast, TYPE_CHECKING
 import json
 import logging
@@ -5,7 +7,11 @@ import uuid
 
 from relationalai import debugging
 from relationalai.clients.cache_store import GraphIndexCache
-from relationalai.clients.util import get_pyrel_version, poll_with_specified_overhead
+from relationalai.clients.util import (
+    get_pyrel_version,
+    normalize_datetime,
+    poll_with_specified_overhead,
+)
 from relationalai.errors import (
     ERPNotRunningError,
     EngineProvisioningFailed,
@@ -29,6 +35,7 @@ from relationalai.tools.constants import WAIT_FOR_STREAM_SYNC, Generation
 # Set up logger for this module
 logger = logging.getLogger(__name__)
 
+
 try:
     from rich.console import Console
     from rich.table import Table
@@ -63,49 +70,49 @@ POLL_MAX_DELAY = 2.5  # Maximum delay between polls in seconds
 # This query calculates a hash of column metadata (name, type, precision, scale, nullable)
 # to detect if source table schema has changed since stream was created
 STREAM_COLUMN_HASH_QUERY = """
-SELECT
-    FQ_OBJECT_NAME,
-    SHA2(
-        LISTAGG(
-            value:name::VARCHAR ||
+WITH stream_columns AS (
+    SELECT
+        fq_object_name,
+        HASH(
+            value:name::VARCHAR,
             CASE
-                WHEN value:precision IS NOT NULL AND value:scale IS NOT NULL
-                    THEN CASE value:type::VARCHAR
-                            WHEN 'FIXED' THEN 'NUMBER'
-                            WHEN 'REAL' THEN 'FLOAT'
-                            WHEN 'TEXT' THEN 'TEXT'
-                            ELSE value:type::VARCHAR
-                        END || '(' || value:precision || ',' || value:scale || ')'
-                WHEN value:precision IS NOT NULL AND value:scale IS NULL
-                    THEN CASE value:type::VARCHAR
-                            WHEN 'FIXED' THEN 'NUMBER'
-                            WHEN 'REAL' THEN 'FLOAT'
-                            WHEN 'TEXT' THEN 'TEXT'
-                            ELSE value:type::VARCHAR
-                        END || '(0,' || value:precision || ')'
-                WHEN value:length IS NOT NULL
-                    THEN CASE value:type::VARCHAR
-                            WHEN 'FIXED' THEN 'NUMBER'
-                            WHEN 'REAL' THEN 'FLOAT'
-                            WHEN 'TEXT' THEN 'TEXT'
-                            ELSE value:type::VARCHAR
-                        END || '(' || value:length || ')'
+                WHEN value:precision IS NOT NULL AND value:scale IS NOT NULL THEN CASE value:type::VARCHAR
+                    WHEN 'FIXED' THEN 'NUMBER'
+                    WHEN 'REAL' THEN 'FLOAT'
+                    WHEN 'TEXT' THEN 'TEXT'
+                    ELSE value:type::VARCHAR
+                END || '(' || value:precision || ',' || value:scale || ')'
+                WHEN value:precision IS NOT NULL AND value:scale IS NULL THEN CASE value:type::VARCHAR
+                    WHEN 'FIXED' THEN 'NUMBER'
+                    WHEN 'REAL' THEN 'FLOAT'
+                    WHEN 'TEXT' THEN 'TEXT'
+                    ELSE value:type::VARCHAR
+                END || '(0,' || value:precision || ')'
+                WHEN value:length IS NOT NULL THEN CASE value:type::VARCHAR
+                    WHEN 'FIXED' THEN 'NUMBER'
+                    WHEN 'REAL' THEN 'FLOAT'
+                    WHEN 'TEXT' THEN 'TEXT'
+                    ELSE value:type::VARCHAR
+                END || '(' || value:length || ')'
                 ELSE CASE value:type::VARCHAR
-                        WHEN 'FIXED' THEN 'NUMBER'
-                        WHEN 'REAL' THEN 'FLOAT'
-                        WHEN 'TEXT' THEN 'TEXT'
-                        ELSE value:type::VARCHAR
-                    END
-            END ||
-            CASE WHEN value:nullable::BOOLEAN THEN 'YES' ELSE 'NO' END,
-            ','
-        ) WITHIN GROUP (ORDER BY value:name::VARCHAR),
-        256
-    ) AS STREAM_HASH
-FROM {app_name}.api.data_streams,
-LATERAL FLATTEN(input => COLUMNS) f
-WHERE RAI_DATABASE = '{rai_database}' AND FQ_OBJECT_NAME IN ({fqn_list})
-GROUP BY FQ_OBJECT_NAME;
+                    WHEN 'FIXED' THEN 'NUMBER'
+                    WHEN 'REAL' THEN 'FLOAT'
+                    WHEN 'TEXT' THEN 'TEXT'
+                    ELSE value:type::VARCHAR
+                END
+            END,
+            IFF(value:nullable::BOOLEAN, 'YES', 'NO')
+        ) AS column_signature
+    FROM {app_name}.api.data_streams,
+        LATERAL FLATTEN(input => columns)
+    WHERE rai_database = '{rai_database}'
+        AND fq_object_name IN ({fqn_list})
+)
+SELECT
+    fq_object_name AS FQ_OBJECT_NAME,
+    HEX_ENCODE(HASH_AGG(column_signature)) AS STREAM_HASH
+FROM stream_columns
+GROUP BY fq_object_name;
 """
 
 
@@ -296,9 +303,10 @@ class UseIndexPoller:
         Returns:
             List of truly stale sources that need to be deleted/recreated
 
-        A source is truly stale if:
-        - The stream doesn't exist (needs to be created), OR
-        - The column hashes don't match (needs to be recreated)
+        A source is truly stale if any of the following apply:
+        - The stream doesn't exist (needs to be created)
+        - The source table was recreated after the stream (table creation timestamp is newer)
+        - The column hashes don't match (schema drift needs cleanup)
         """
         stream_hashes = self._get_stream_column_hashes(stale_sources, progress)
 
@@ -306,14 +314,30 @@ class UseIndexPoller:
         for source in stale_sources:
             source_hash = self.source_info[source].get("columns_hash")
             stream_hash = stream_hashes.get(source)
+            table_created_at_raw = self.source_info[source].get("table_created_at")
+            stream_created_at_raw = self.source_info[source].get("stream_created_at")
+
+            table_created_at = normalize_datetime(table_created_at_raw)
+            stream_created_at = normalize_datetime(stream_created_at_raw)
+
+            recreated_table = False
+            if table_created_at is not None and stream_created_at is not None:
+                # If the source table was recreated (new creation timestamp) but kept
+                # the same column definitions, we still need to recycle the stream so
+                # that Snowflake picks up the new table instance.
+                recreated_table = table_created_at > stream_created_at
 
             # Log hash comparison for debugging
             logger.debug(f"Source: {source}")
             logger.debug(f"  Source table hash: {source_hash}")
             logger.debug(f"  Stream hash: {stream_hash}")
             logger.debug(f"  Match: {source_hash == stream_hash}")
+            if recreated_table:
+                logger.debug("  Table appears to have been recreated (table_created_at > stream_created_at)")
+                logger.debug(f"    table_created_at: {table_created_at}")
+                logger.debug(f"    stream_created_at: {stream_created_at}")
 
-            if stream_hash is None or source_hash != stream_hash:
+            if stream_hash is None or source_hash != stream_hash or recreated_table:
                 logger.debug("  Action: DELETE (stale)")
                 truly_stale.append(source)
             else:
@@ -376,7 +400,7 @@ class UseIndexPoller:
             stale_sources = [
                 source
                 for source, info in self.source_info.items()
-                if info["state"] == "STALE"
+                if info.get("state") == "STALE"
             ]
 
         if not stale_sources:
@@ -763,7 +787,7 @@ class UseIndexPoller:
                     # Log the error for debugging
                     logger.warning(f"Failed to enable change tracking on {fqn}: {e}")
                     failed_tables.append((fqn, str(e)))
-                    
+
                     # Handle errors based on subtask type
                     if len(tables_to_process) <= MAX_INDIVIDUAL_SUBTASKS:
                         # Mark the individual subtask as failed and complete it

relationalai/clients/util.py

@@ -80,6 +80,15 @@ def escape_for_f_string(code: str) -> str:
 def escape_for_sproc(code: str) -> str:
     return code.replace("$$", "\\$\\$")
 
+
+def normalize_datetime(value: object) -> datetime | None:
+    """Return a timezone-aware UTC datetime or None."""
+    if not isinstance(value, datetime):
+        return None
+    if value.tzinfo is None:
+        return value.replace(tzinfo=timezone.utc)
+    return value.astimezone(timezone.utc)
+
 # @NOTE: `overhead_rate` should fall between 0.05 and 0.5 depending on how time sensitive / expensive the operation in question is.
 def poll_with_specified_overhead(
     f,

relationalai/dsl.py

@@ -22,6 +22,7 @@ import sys
 from pandas import DataFrame
 
 from relationalai.environments import runtime_env, SnowbookEnvironment
+from relationalai.tools.constants import QUERY_ATTRIBUTES_HEADER
 
 from .clients.client import Client
 
@@ -34,9 +35,7 @@ from .errors import FilterAsValue, Errors, InvalidPropertySetException, Multiple
 #--------------------------------------------------
 
 RESERVED_PROPS = ["add", "set", "persist", "unpersist"]
-
 MAX_QUERY_ATTRIBUTE_LENGTH = 255
-QUERY_ATTRIBUTES_HEADER = "X-Query-Attributes"
 
 Value = Union[
     "Expression",

relationalai/early_access/metamodel/rewrite/__init__.py

@@ -1,5 +1,7 @@
-from relationalai.semantics.metamodel.rewrite import Splinter, RewriteListTypes, GarbageCollectNodes, Flatten, \
-    DNFUnionSplitter, ExtractKeys, ExtractNestedLogicals, FDConstraints, flatten
+from relationalai.semantics.metamodel.rewrite import Flatten, \
+    DNFUnionSplitter, ExtractNestedLogicals, flatten
+from relationalai.semantics.lqp.rewrite import Splinter,  \
+    ExtractKeys, FDConstraints
 
-__all__ = ["Splinter", "RewriteListTypes", "GarbageCollectNodes", "Flatten", "DNFUnionSplitter", "ExtractKeys",
+__all__ = ["Splinter", "Flatten", "DNFUnionSplitter", "ExtractKeys",
            "ExtractNestedLogicals", "FDConstraints", "flatten"]

relationalai/early_access/rel/rewrite/__init__.py

@@ -1,4 +1,4 @@
-from relationalai.semantics.rel.rewrite import CDC, ExtractCommon, QuantifyVars
+from relationalai.semantics.lqp.rewrite import CDC, ExtractCommon, QuantifyVars
 
 __all__ = [
     "CDC",

relationalai/environments/snowbook.py

@@ -20,7 +20,16 @@ class SnowbookEnvironment(NotebookRuntimeEnvironment, SessionEnvironment):
 
     def __init__(self):
         super().__init__()
-        self.runner = "container" if "snowflake.connector.auth" in sys.modules else "warehouse"
+        # Detect runner type based on module presence:
+        # - Warehouse runtime has '_snowflake' module
+        # - Container runtime has 'snowflake._legacy' module
+        if "_snowflake" in sys.modules:
+            self.runner = "warehouse"
+        elif "snowflake._legacy" in sys.modules:
+            self.runner = "container"
+        else:
+            # Fallback to original check
+            self.runner = "container" if "snowflake.connector.auth" in sys.modules else "warehouse"
 
     @classmethod
     def detect(cls):

relationalai/errors.py

@@ -2397,17 +2397,18 @@ class UnsupportedColumnTypesWarning(RAIWarning):
 """)
 
 class QueryTimeoutExceededException(RAIException):
-    def __init__(self, timeout_mins: int, config_file_path: str | None = None):
+    def __init__(self, timeout_mins: int, query_id: str | None = None, config_file_path: str | None = None):
         self.timeout_mins = timeout_mins
-        self.message = f"Query execution time exceeded the specified timeout of {timeout_mins} minutes."
         self.name = "Query Timeout Exceeded"
+        self.message = f"Query execution time exceeded the specified timeout of {self.timeout_mins} minutes."
+        self.query_id = query_id or ""
         self.config_file_path = config_file_path or ""
         self.content = self.format_message()
         super().__init__(self.message, self.name, self.content)
 
     def format_message(self):
         return textwrap.dedent(f"""
-        {self.message}
+        Query execution time exceeded the specified timeout of {self.timeout_mins} minutes{f' for query with ID: {self.query_id}' if self.query_id else ''}.
 
         Consider increasing the 'query_timeout_mins' parameter in your configuration file{f' (stored in {self.config_file_path})' if self.config_file_path else ''} to allow more time for query execution.
         """)
@@ -2432,3 +2433,23 @@ class AzureUnsupportedQueryTimeoutException(RAIException):
         Please remove the 'query_timeout_mins' from your configuration file{f' (stored in {self.config_file_path})' if self.config_file_path else ''} when running on platform Azure.
         """)
 
+class AzureLegacyDependencyMissingException(RAIException):
+    def __init__(self):
+        self.message = "The Azure platform requires the 'legacy' extras to be installed."
+        self.name = "Azure Legacy Dependency Missing"
+        self.content = self.format_message()
+        super().__init__(self.message, self.name, self.content)
+
+    def format_message(self):
+        return textwrap.dedent("""
+        The Azure platform requires the 'rai-sdk' package, which is not installed.
+
+        To use the Azure platform, please install the legacy extras:
+
+            pip install relationalai[legacy]
+
+        Or if upgrading an existing installation:
+
+            pip install --upgrade relationalai[legacy]
+        """)
+

relationalai/semantics/internal/annotations.py

@@ -5,3 +5,4 @@ external = Relationship.builtins["external"]
 concept_population = Relationship.builtins["concept_population"]
 function = Relationship.builtins["function"]
 from_cdc = Relationship.builtins["from_cdc"]
+track = Relationship.builtins["track"]

relationalai/semantics/internal/internal.py

@@ -2338,6 +2338,7 @@ class Fragment():
             self._define.extend(parent._define)
             self._order_by.extend(parent._order_by)
             self._limit = parent._limit
+            self._meta.update(parent._meta)
 
     def _add_items(self, items:PySequence[Any], to_attr:list[Any]):
         # TODO: ensure that you are _either_ a select, require, or then
@@ -2416,9 +2417,26 @@ class Fragment():
         return f
 
     def meta(self, **kwargs: Any) -> Fragment:
+        """Add metadata to the query.
+        
+        Metadata can be used for debugging and observability purposes.
+        
+        Args:
+            **kwargs: Metadata key-value pairs
+        
+        Returns:
+            Fragment: Returns self for method chaining
+            
+        Example:
+            select(Person.name).meta(workload_name="test", priority=1, enabled=True)
+        """
+        if not kwargs:
+            raise ValueError("meta() requires at least one argument")
+            
         self._meta.update(kwargs)
         return self
 
+
     def annotate(self, *annos:Expression|Relationship|ir.Annotation) -> Fragment:
         self._annotations.extend(annos)
         return self
@@ -2497,7 +2515,7 @@ class Fragment():
         # @TODO for now we set tag to None but we need to work out how to properly propagate user-provided tag here
         with debugging.span("query", tag=None, dsl=str(self), **with_source(self), meta=self._meta) as query_span:
             query_task = qb_model._compiler.fragment(self)
-            results = qb_model._to_executor().execute(ir_model, query_task)
+            results = qb_model._to_executor().execute(ir_model, query_task, meta=self._meta)
             query_span["results"] = results
             # For local debugging mostly
             dry_run = qb_model._dry_run or bool(qb_model._config.get("compiler.dry_run", False))
@@ -2524,7 +2542,7 @@ class Fragment():
         # @TODO for now we set tag to None but we need to work out how to properly propagate user-provided tag here
         with debugging.span("query", tag=None, dsl=str(clone), **with_source(clone), meta=clone._meta) as query_span:
             query_task = qb_model._compiler.fragment(clone)
-            results = qb_model._to_executor().execute(ir_model, query_task, format="snowpark")
+            results = qb_model._to_executor().execute(ir_model, query_task, format="snowpark", meta=clone._meta)
             query_span["alt_format_results"] = results
             return results
 
@@ -2541,7 +2559,8 @@ class Fragment():
         clone._source = runtime_env.get_source_pos()
         with debugging.span("query", dsl=str(clone), **with_source(clone), meta=clone._meta):
             query_task = qb_model._compiler.fragment(clone)
-            qb_model._to_executor().execute(ir_model, query_task, result_cols=result_cols, export_to=table._fqn, update=update)
+            qb_model._to_executor().execute(ir_model, query_task, result_cols=result_cols, export_to=table._fqn, update=update, meta=clone._meta)
+    
 
 #--------------------------------------------------
 # Select / Where

relationalai/semantics/lqp/builtins.py

@@ -11,4 +11,5 @@ adhoc_annotation = f.annotation(adhoc, [])
 annotations_to_emit = FrozenOrderedSet([
     adhoc.name,
     builtins.function.name,
+    builtins.track.name,
 ])

relationalai/semantics/lqp/executor.py

@@ -21,8 +21,8 @@ from relationalai.clients.config import Config
 from relationalai.clients.snowflake import APP_NAME
 from relationalai.clients.types import TransactionAsyncResponse
 from relationalai.clients.util import IdentityParser
-from relationalai.tools.constants import USE_DIRECT_ACCESS
-
+from relationalai.tools.constants import USE_DIRECT_ACCESS, QUERY_ATTRIBUTES_HEADER
+from relationalai.tools.query_utils import prepare_metadata_for_headers
 
 class LQPExecutor(e.Executor):
     """Executes LQP using the RAI client."""
@@ -267,7 +267,7 @@ class LQPExecutor(e.Executor):
         if ivm_flag:
             config_dict['ivm.maintenance_level'] = lqp_ir.Value(value=ivm_flag, meta=None)
         return construct_configure(config_dict, None)
-    
+
     def _compile_intrinsics(self) -> lqp_ir.Epoch:
         """Construct an epoch that defines a number of built-in definitions used by the
         emitter."""
@@ -344,6 +344,10 @@ class LQPExecutor(e.Executor):
         df, errs = result_helpers.format_results(raw_results, cols)
         self.report_errors(errs)
 
+        # Rename columns if wide outputs is enabled
+        if self.wide_outputs and len(cols) - len(extra_cols) == len(df.columns):
+            df.columns = cols[: len(df.columns)]
+
         # Process exports
         if export_to and not self.dry_run:
             assert cols, "No columns found in the output"
@@ -362,7 +366,7 @@ class LQPExecutor(e.Executor):
 
     def execute(self, model: ir.Model, task: ir.Task, format: Literal["pandas", "snowpark"] = "pandas",
                 result_cols: Optional[list[str]] = None, export_to: Optional[str] = None,
-                update: bool = False) -> DataFrame:
+                update: bool = False, meta: dict[str, Any] | None = None) -> DataFrame:
         self.prepare_data()
         previous_model = self._last_model
 
@@ -374,6 +378,9 @@ class LQPExecutor(e.Executor):
         if format != "pandas":
             raise ValueError(f"Unsupported format: {format}")
 
+        # Format meta as headers
+        json_meta = prepare_metadata_for_headers(meta)
+        headers = {QUERY_ATTRIBUTES_HEADER: json_meta} if json_meta else {}
         raw_results = self.resources.exec_lqp(
             self.database,
             self.engine,
@@ -383,6 +390,7 @@ class LQPExecutor(e.Executor):
             # transactions are serialized.
             readonly=False,
             nowait_durable=True,
+            headers=headers,
         )
         assert isinstance(raw_results, TransactionAsyncResponse)
 

relationalai/semantics/lqp/model2lqp.py

@@ -102,6 +102,7 @@ def _get_export_reads(export_ids: list[tuple[lqp.RelationId, int, lqp.Type]]) ->
         data_columns=csv_columns,
         compression="gzip",
         partition_size=200,
+        syntax_escapechar='"',  # To follow Snowflake's expected format
         meta=None,
     )
     reads.append(lqp.Read(read_type=lqp.Export(config=export_csv_config, meta=None), meta=None))

relationalai/semantics/lqp/passes.py

@@ -2,13 +2,12 @@ from relationalai.semantics.metamodel.compiler import Pass
 from relationalai.semantics.metamodel import ir, builtins as rel_builtins, factory as f, visitor
 from relationalai.semantics.metamodel.typer import Checker, InferTypes, typer
 from relationalai.semantics.metamodel import helpers, types
-from relationalai.semantics.metamodel.rewrite import (Splinter, ExtractNestedLogicals, ExtractKeys, FDConstraints,
-                                                      DNFUnionSplitter, DischargeConstraints)
 from relationalai.semantics.metamodel.util import FrozenOrderedSet
 
 from relationalai.semantics.metamodel.rewrite import Flatten
-# TODO: Move this into metamodel.rewrite
-from relationalai.semantics.rel.rewrite import QuantifyVars, CDC, ExtractCommon
+
+from ..metamodel.rewrite import DischargeConstraints, DNFUnionSplitter, ExtractNestedLogicals
+from .rewrite import CDC, ExtractCommon, ExtractKeys, FDConstraints, QuantifyVars, Splinter
 
 from relationalai.semantics.lqp.utils import output_names
 

relationalai/semantics/{rel → lqp}/rewrite/__init__.py

@@ -1,9 +1,15 @@
 from .cdc import CDC
 from .extract_common import ExtractCommon
+from .extract_keys import ExtractKeys
+from .fd_constraints import FDConstraints
 from .quantify_vars import QuantifyVars
+from .splinter import Splinter
 
 __all__ = [
     "CDC",
     "ExtractCommon",
+    "ExtractKeys",
+    "FDConstraints",
     "QuantifyVars",
+    "Splinter",
 ]

relationalai/semantics/metamodel/builtins.py

@@ -496,6 +496,17 @@ 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.
+# `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", [
+    # BackIR evaluation expects 2 parameters on the track annotation: the tracking
+    # library name and tracking relation name, which appear as log metadata fields.
+    f.input_field("library", types.Symbol),
+    f.input_field("relation", types.Symbol)
+])
+track_annotation = f.annotation(track, [])
+
 # All ir nodes marked by this annotation will be removed from the final metamodel before compilation.
 # Specifically it happens in `Flatten` pass when rewrites for `require` happen
 discharged = f.relation("discharged", [])
@@ -672,7 +683,7 @@ def _compute_builtin_overloads() -> list[ir.Relation]:
     return overloads
 
 # manually maintain the list of relations that are actually annotations
-builtin_annotations = [external, export, concept_population, from_cdc, from_cast]
+builtin_annotations = [external, export, concept_population, from_cdc, from_cast, track]
 builtin_annotations_by_name = dict((r.name, r) for r in builtin_annotations)
 
 builtin_relations = _compute_builtin_relations()

relationalai/semantics/metamodel/executor.py

@@ -56,5 +56,6 @@ class Executor():
             rich.print(f"[black]{df}[/black]")
         if not df.empty:
             for col in extra_cols:
-                df = df.drop(col, axis=1)
+                if col in df.columns:
+                    df = df.drop(col, axis=1)
         return df

relationalai/semantics/metamodel/rewrite/__init__.py

@@ -1,12 +1,6 @@
-from .splinter import Splinter
-from .list_types import RewriteListTypes
-from .gc_nodes import GarbageCollectNodes
-from .flatten import Flatten
+from .discharge_constraints import DischargeConstraints
 from .dnf_union_splitter import DNFUnionSplitter
-from .extract_keys import ExtractKeys
 from .extract_nested_logicals import ExtractNestedLogicals
-from .fd_constraints import FDConstraints
-from .discharge_constraints import DischargeConstraints
+from .flatten import Flatten
 
-__all__ = ["Splinter", "RewriteListTypes", "GarbageCollectNodes", "Flatten", "DNFUnionSplitter", "ExtractKeys",
-           "ExtractNestedLogicals", "FDConstraints", "DischargeConstraints"]
+__all__ = ["DischargeConstraints", "DNFUnionSplitter", "ExtractNestedLogicals", "Flatten"]

relationalai/semantics/metamodel/rewrite/flatten.py

@@ -558,22 +558,23 @@ class Flatten(Pass):
     def rewrite_wide_output(self, output: ir.Output):
         assert(output.keys)
 
-        # only prefix keys that are not already in the output
-        prefix_keys = []
+        # only append keys that are not already in the output
+        suffix_keys = []
         for key in output.keys:
             if all([val is not key for _, val in output.aliases]):
-                prefix_keys.append(key)
+                suffix_keys.append(key)
 
         aliases: OrderedSet[Tuple[str, ir.Value]] = ordered_set()
-        # add the keys to the output
-        for key in prefix_keys:
-            aliases.add((key.name, key))
 
         # add the remaining args, unless it is already a key
         for name, val in output.aliases:
-            if not isinstance(val, ir.Var) or val not in prefix_keys:
+            if not isinstance(val, ir.Var) or val not in suffix_keys:
                 aliases.add((name, val))
 
+        # add the keys to the output
+        for key in suffix_keys:
+            aliases.add((key.name, key))
+
         # TODO - we are assuming that the Rel compiler will translate nullable lookups
         # properly, returning a `Missing` if necessary, like this:
         # (nested_192(_adult, _adult_name) or (not nested_192(_adult, _) and _adult_name = Missing)) and