relationalai 0.11.2__tar.gz → 0.11.3__tar.gz

{relationalai-0.11.2 → relationalai-0.11.3}/.gitignore

@@ -37,3 +37,4 @@ relationalai*.zip
 logs/
 .envrc
 metadata.json
+dev-notes/

{relationalai-0.11.2 → relationalai-0.11.3}/PKG-INFO

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

{relationalai-0.11.2 → relationalai-0.11.3}/pyproject.toml

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

{relationalai-0.11.2 → relationalai-0.11.3}/src/relationalai/clients/snowflake.py

@@ -2048,7 +2048,7 @@ Otherwise, remove it from your '{profile}' configuration profile.
             assert len(parsed) == 4, f"Invalid source: {source}"
             db, schema, entity, identity = parsed
             assert db and schema and entity and identity, f"Invalid source: {source}"
-            source_types[identity] = cast(SourceInfo, {"type": None, "state": ""})
+            source_types[identity] = cast(SourceInfo, {"type": None, "state": "", "columns_hash": None})
             partitioned_sources[db][schema].append(entity)
 
         # TODO: Move to NA layer
@@ -2057,6 +2057,7 @@ Otherwise, remove it from your '{profile}' configuration profile.
                 f"""SELECT
                     inf.FQN,
                     inf.KIND,
+                    inf.COLUMNS_HASH,
                     IFF(DATEDIFF(second, ds.created_at::TIMESTAMP, inf.LAST_DDL::TIMESTAMP) > 0, 'STALE', 'CURRENT') AS STATE
                 FROM (
                     SELECT (SELECT {app_name}.api.normalize_fq_ids(ARRAY_CONSTRUCT(FQ_OBJECT_NAME))[0]:identifier::string) as FQ_OBJECT_NAME,
@@ -2068,26 +2069,45 @@ Otherwise, remove it from your '{profile}' configuration profile.
                         (SELECT {app_name}.api.normalize_fq_ids(
                             ARRAY_CONSTRUCT(
                                 CASE
-                                    WHEN TABLE_CATALOG = UPPER(TABLE_CATALOG) THEN TABLE_CATALOG
-                                    ELSE '"' || TABLE_CATALOG || '"'
+                                    WHEN t.TABLE_CATALOG = UPPER(t.TABLE_CATALOG) THEN t.TABLE_CATALOG
+                                    ELSE '"' || t.TABLE_CATALOG || '"'
                                 END || '.' ||
                                 CASE
-                                    WHEN TABLE_SCHEMA = UPPER(TABLE_SCHEMA) THEN TABLE_SCHEMA
-                                    ELSE '"' || TABLE_SCHEMA || '"'
+                                    WHEN t.TABLE_SCHEMA = UPPER(t.TABLE_SCHEMA) THEN t.TABLE_SCHEMA
+                                    ELSE '"' || t.TABLE_SCHEMA || '"'
                                 END || '.' ||
                                 CASE
-                                    WHEN TABLE_NAME = UPPER(TABLE_NAME) THEN TABLE_NAME
-                                    ELSE '"' || TABLE_NAME || '"'
+                                    WHEN t.TABLE_NAME = UPPER(t.TABLE_NAME) THEN t.TABLE_NAME
+                                    ELSE '"' || t.TABLE_NAME || '"'
                                 END
                             )
                         )[0]:identifier::string) as FQN,
                         CONVERT_TIMEZONE('UTC', LAST_DDL) AS LAST_DDL,
-                        TABLE_TYPE as KIND
-                    FROM {db}.INFORMATION_SCHEMA.TABLES
-                    WHERE TABLE_CATALOG = {IdentityParser.to_sql_value(db)} AND ({" OR ".join(
-                        f"(TABLE_SCHEMA = {IdentityParser.to_sql_value(schema)} AND TABLE_NAME IN ({','.join(f'{IdentityParser.to_sql_value(table)}' for table in tables)}))"
+                        TABLE_TYPE as KIND,
+                        SHA2(LISTAGG(
+                            COLUMN_NAME ||
+                            CASE
+                                WHEN c.NUMERIC_PRECISION IS NOT NULL AND c.NUMERIC_SCALE IS NOT NULL
+                                    THEN c.DATA_TYPE || '(' || c.NUMERIC_PRECISION || ',' || c.NUMERIC_SCALE || ')'
+                                WHEN c.DATETIME_PRECISION IS NOT NULL
+                                    THEN c.DATA_TYPE || '(0,' || c.DATETIME_PRECISION || ')'
+                                WHEN c.CHARACTER_MAXIMUM_LENGTH IS NOT NULL
+                                    THEN c.DATA_TYPE || '(' || c.CHARACTER_MAXIMUM_LENGTH || ')'
+                                ELSE c.DATA_TYPE
+                            END ||
+                            IS_NULLABLE,
+                            ','
+                        ) WITHIN GROUP (ORDER BY COLUMN_NAME), 256) as COLUMNS_HASH
+                    FROM {db}.INFORMATION_SCHEMA.TABLES t
+                    JOIN {db}.INFORMATION_SCHEMA.COLUMNS c
+                        ON t.TABLE_CATALOG = c.TABLE_CATALOG
+                        AND t.TABLE_SCHEMA = c.TABLE_SCHEMA
+                        AND t.TABLE_NAME = c.TABLE_NAME
+                    WHERE t.TABLE_CATALOG = {IdentityParser.to_sql_value(db)} AND ({" OR ".join(
+                        f"(t.TABLE_SCHEMA = {IdentityParser.to_sql_value(schema)} AND t.TABLE_NAME IN ({','.join(f'{IdentityParser.to_sql_value(table)}' for table in tables)}))"
                         for schema, tables in schemas.items()
                     )})
+                    GROUP BY t.TABLE_CATALOG, t.TABLE_SCHEMA, t.TABLE_NAME, t.LAST_DDL, t.TABLE_TYPE
                 ) inf on inf.FQN = ds.FQ_OBJECT_NAME
             """
                 for db, schemas in partitioned_sources.items()
@@ -2102,6 +2122,7 @@ Otherwise, remove it from your '{profile}' configuration profile.
             assert fqn, f"Error parsing returned FQN: {row_fqn}"
 
             source_types[fqn]["type"] = "TABLE" if row["KIND"] == "BASE TABLE" else row["KIND"]
+            source_types[fqn]["columns_hash"] = row["COLUMNS_HASH"]
             source_types[fqn]["state"] = row["STATE"]
 
         return source_types
@@ -3058,10 +3079,13 @@ class DirectAccessResources(Resources):
         return self._retrieve_service_endpoint()
 
     def _retrieve_service_endpoint(self, enforce_update=False) -> str:
+        account = self.config.get("account")
+        app_name = self.config.get("rai_app_name")
+        service_endpoint_key = f"{account}.{app_name}.service_endpoint"
         if self._service_endpoint and not enforce_update:
             return self._service_endpoint
-        if self._endpoint_info.get("service_endpoint", "") and not enforce_update:
-            self._service_endpoint = str(self._endpoint_info.get("service_endpoint", ""))
+        if self._endpoint_info.get(service_endpoint_key, "") and not enforce_update:
+            self._service_endpoint = str(self._endpoint_info.get(service_endpoint_key, ""))
             return self._service_endpoint
 
         is_snowflake_notebook = isinstance(runtime_env, SnowbookEnvironment)
@@ -3073,7 +3097,7 @@ class DirectAccessResources(Resources):
         else:
             self._service_endpoint = f"https://{result[0]['SERVICE_ENDPOINT']}"
 
-        self._endpoint_info.set("service_endpoint", self._service_endpoint)
+        self._endpoint_info.set(service_endpoint_key, self._service_endpoint)
         # save the endpoint to `ENDPOINT_FILE` to avoid calling the endpoint with every
         # pyrel execution
         try:

{relationalai-0.11.2 → relationalai-0.11.3}/src/relationalai/clients/types.py

@@ -41,6 +41,7 @@ class EngineState(TypedDict):
 class SourceInfo(TypedDict):
     type: str|None
     state: str
+    columns_hash: str|None
     source: str
 
 

{relationalai-0.11.2 → relationalai-0.11.3}/src/relationalai/clients/use_index_poller.py

@@ -155,72 +155,179 @@ class UseIndexPoller:
             # Complete the subtask immediately since it's just informational
             progress.complete_sub_task("cache_usage")
 
+    def _get_stream_column_hashes(self, sources: List[str]) -> Dict[str, str]:
+        """
+        Query data_streams to get current column hashes for the given sources.
+
+        Returns a dict mapping FQN -> column hash.
+        """
+        from relationalai.clients.snowflake import PYREL_ROOT_DB
+
+        fqn_list = ", ".join([f"'{source}'" for source in sources])
+
+        hash_query = f"""
+        SELECT
+            FQ_OBJECT_NAME,
+            SHA2(
+                LISTAGG(
+                    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 || ')'
+                        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 {self.app_name}.api.data_streams,
+        LATERAL FLATTEN(input => COLUMNS) f
+        WHERE RAI_DATABASE = '{PYREL_ROOT_DB}' AND FQ_OBJECT_NAME IN ({fqn_list})
+        GROUP BY FQ_OBJECT_NAME;
+        """
+
+        hash_results = self.res._exec(hash_query)
+        return {row["FQ_OBJECT_NAME"]: row["STREAM_HASH"] for row in hash_results}
+
+    def _filter_truly_stale_sources(self, stale_sources: List[str]) -> List[str]:
+        """
+        Filter stale sources to only include those with mismatched column hashes.
+
+        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)
+        """
+        stream_hashes = self._get_stream_column_hashes(stale_sources)
+
+        truly_stale = []
+        for source in stale_sources:
+            source_hash = self.source_info[source].get("columns_hash")
+            stream_hash = stream_hashes.get(source)
+
+            # Debug prints to see hash comparison
+            # print(f"\n[DEBUG] Source: {source}")
+            # print(f"  Source table hash: {source_hash}")
+            # print(f"  Stream hash:       {stream_hash}")
+            # print(f"  Match: {source_hash == stream_hash}")
+            # print(f"  Action: {'KEEP (valid)' if stream_hash is not None and source_hash == stream_hash else 'DELETE (stale)'}")
+
+            if stream_hash is None or source_hash != stream_hash:
+                truly_stale.append(source)
+
+        # print(f"\n[DEBUG] Stale sources summary:")
+        # print(f"  Total candidates: {len(stale_sources)}")
+        # print(f"  Truly stale: {len(truly_stale)}")
+        # print(f"  Skipped (valid): {len(stale_sources) - len(truly_stale)}\n")
+
+        return truly_stale
+
+    def _add_deletion_subtasks(self, progress, sources: List[str]) -> None:
+        """Add progress subtasks for source deletion."""
+        if len(sources) <= MAX_INDIVIDUAL_SUBTASKS:
+            for i, source in enumerate(sources):
+                progress.add_sub_task(
+                    f"Removing stale stream {source} ({i+1}/{len(sources)})",
+                    task_id=f"stale_source_{i}"
+                )
+        else:
+            progress.add_sub_task(
+                f"Removing {len(sources)} stale data sources",
+                task_id="stale_sources_summary"
+            )
+
+    def _complete_deletion_subtasks(self, progress, sources: List[str], deleted_count: int) -> None:
+        """Complete progress subtasks for source deletion."""
+        if len(sources) <= MAX_INDIVIDUAL_SUBTASKS:
+            for i in range(len(sources)):
+                if f"stale_source_{i}" in progress._tasks:
+                    progress.complete_sub_task(f"stale_source_{i}")
+        else:
+            if "stale_sources_summary" in progress._tasks:
+                if deleted_count > 0:
+                    s = "s" if deleted_count > 1 else ""
+                    progress.update_sub_task(
+                        "stale_sources_summary",
+                        f"Removed {deleted_count} stale data source{s}"
+                    )
+                progress.complete_sub_task("stale_sources_summary")
+
     def _maybe_delete_stale(self, progress) -> None:
+        """Check for and delete stale data streams that need recreation."""
         with debugging.span("check_sources"):
-            # Source tables that have been altered/changed since the last stream creation
             stale_sources = [
                 source
                 for source, info in self.source_info.items()
                 if info["state"] == "STALE"
             ]
-        if stale_sources:
-            with DebuggingSpan("validate_sources"):
-                try:
-                    # Delete all stale streams, so use_index could recreate them again
-                    from relationalai.clients.snowflake import PYREL_ROOT_DB
-                    query = f"CALL {self.app_name}.api.delete_data_streams({stale_sources}, '{PYREL_ROOT_DB}');"
-
-                    # Add subtasks based on count
-                    if len(stale_sources) <= MAX_INDIVIDUAL_SUBTASKS:
-                        # Add individual subtasks for each stale source
-                        for i, source in enumerate(stale_sources):
-                            progress.add_sub_task(f"Removing stale stream {source} ({i+1}/{len(stale_sources)})", task_id=f"stale_source_{i}")
-                    else:
-                        # Add single summary subtask for many sources
-                        progress.add_sub_task(f"Removing {len(stale_sources)} stale data sources", task_id="stale_sources_summary")
-
-                    delete_response = self.res._exec(query)
-                    delete_json_str = delete_response[0]["DELETE_DATA_STREAMS"].lower()
-                    delete_data = json.loads(delete_json_str)
-                    deleted_count = delete_data.get("deleted", 0)
-                    diff = len(stale_sources) - deleted_count
-
-                    # Complete subtasks
-                    if len(stale_sources) <= MAX_INDIVIDUAL_SUBTASKS:
-                        # Complete all individual subtasks
-                        for i in range(len(stale_sources)):
-                            if f"stale_source_{i}" in progress._tasks:
-                                progress.complete_sub_task(f"stale_source_{i}")
-                    else:
-                        # Complete summary subtask
-                        if "stale_sources_summary" in progress._tasks:
-                            if deleted_count > 0:
-                                is_many = deleted_count > 1
-                                s = "s" if is_many else ""
-                                progress.update_sub_task("stale_sources_summary", f"Removed {deleted_count} stale data source{s}")
-                            progress.complete_sub_task("stale_sources_summary")
-
-                    if diff > 0:
-                        errors = delete_data.get("errors", None)
-                        if errors:
-                            raise Exception(f"Error(s) deleting streams with modified sources: {errors}")
-                except Exception as e:
-                    # Complete any remaining subtasks
-                    if len(stale_sources) <= MAX_INDIVIDUAL_SUBTASKS:
-                        for i in range(len(stale_sources)):
-                            if f"stale_source_{i}" in progress._tasks:
-                                progress.complete_sub_task(f"stale_source_{i}")
-                    else:
-                        if "stale_sources_summary" in progress._tasks:
-                            progress.update_sub_task("stale_sources_summary", f"❌ Failed to remove stale sources: {str(e)}")
-                            progress.complete_sub_task("stale_sources_summary")
 
-                    # The delete_data_streams procedure will raise an exception if the streams do not exist
-                    if "data streams do not exist" in str(e).lower():
-                        # Don't raise an error if streams don't exist - this is expected
-                        pass
-                    else:
-                        raise e from None
+        if not stale_sources:
+            return
+
+        with DebuggingSpan("validate_sources"):
+            try:
+                # Validate which sources truly need deletion by comparing column hashes
+                truly_stale = self._filter_truly_stale_sources(stale_sources)
+
+                if not truly_stale:
+                    return
+
+                # Delete truly stale streams
+                from relationalai.clients.snowflake import PYREL_ROOT_DB
+                query = f"CALL {self.app_name}.api.delete_data_streams({truly_stale}, '{PYREL_ROOT_DB}');"
+
+                self._add_deletion_subtasks(progress, truly_stale)
+
+                delete_response = self.res._exec(query)
+                delete_json_str = delete_response[0]["DELETE_DATA_STREAMS"].lower()
+                delete_data = json.loads(delete_json_str)
+                deleted_count = delete_data.get("deleted", 0)
+
+                self._complete_deletion_subtasks(progress, truly_stale, deleted_count)
+
+                # Check for errors
+                diff = len(truly_stale) - deleted_count
+                if diff > 0:
+                    errors = delete_data.get("errors", None)
+                    if errors:
+                        raise Exception(f"Error(s) deleting streams with modified sources: {errors}")
+
+            except Exception as e:
+                # Complete any remaining subtasks
+                self._complete_deletion_subtasks(progress, stale_sources, 0)
+                if "stale_sources_summary" in progress._tasks:
+                    progress.update_sub_task(
+                        "stale_sources_summary",
+                        f"❌ Failed to remove stale sources: {str(e)}"
+                    )
+
+                # Don't raise if streams don't exist - this is expected
+                if "data streams do not exist" not in str(e).lower():
+                    raise e from None
 
     def _poll_loop(self, progress) -> None:
         source_references = self.res._get_source_references(self.source_info)

{relationalai-0.11.2 → relationalai-0.11.3}/src/relationalai/early_access/builder/std/__init__.py

@@ -1,6 +1,6 @@
 import warnings
 
-from relationalai.semantics.std import range, hash, cast, dates, math, strings, decimals, integers, pragmas, \
+from relationalai.semantics.std import range, hash, cast, datetime as dates, math, strings, decimals, integers, pragmas, \
     constraints, uuid_to_string
 
 __all__ = [

{relationalai-0.11.2 → relationalai-0.11.3}/src/relationalai/early_access/dsl/bindings/csv.py

@@ -157,13 +157,13 @@ class CsvSourceModule:
     def _row_to_date_value_rule(column, row, value):
         parse_date = b.Relationship.builtins['parse_date']
         rez = b.Date.ref()
-        where(parse_date(value, 'Y-m-d', rez)).define(column(row, rez))
+        where(parse_date(value, 'yyyy-mm-dd', rez)).define(column(row, rez))
 
     @staticmethod
     def _row_to_date_time_value_rule(column, row, value):
         parse_datetime = b.Relationship.builtins['parse_datetime']
         rez = b.DateTime.ref()
-        where(parse_datetime(value, 'Y-m-d HH:MM:SS z', rez)).define(column(row, rez))
+        where(parse_datetime(value, 'yyy-mm-dd HH:MM:SS z', rez)).define(column(row, rez))
 
     @staticmethod
     def _row_to_decimal_value_rule(column, row, value):

{relationalai-0.11.2 → relationalai-0.11.3}/src/relationalai/semantics/lqp/executor.py

@@ -120,13 +120,15 @@ class LQPExecutor(e.Executor):
                     pyrel_errors[problem["props"]["pyrel_id"]].append(problem)
                 elif abort_on_error:
                     e = errors.RelQueryError(problem, source)
-                    supplementary_message = "Troubleshooting:\n" + \
-                        "  1. Please retry with a new name for your model. This can work around state-related issues.\n" + \
-                        "  2. If the error persists, please retry with the `use_lqp` flag set to `False`, for example:\n" + \
-                        "       `model = Model(..., use_lqp=False)`\n" + \
-                        "     This will switch the execution to the legacy backend, which may avoid the issue with some performance cost.\n"
 
-                    e.content = f"{e.content}{supplementary_message}"
+                    if code == 'SYSTEM_INTERNAL':
+                        supplementary_message = "Troubleshooting:\n" + \
+                            "  1. Please retry with a new name for your model. This can work around state-related issues.\n" + \
+                            "  2. If the error persists, please retry with the `use_lqp` flag set to `False`, for example:\n" + \
+                            "       `model = Model(..., use_lqp=False)`\n" + \
+                            "     This will switch the execution to the legacy backend, which may avoid the issue with some performance cost.\n"
+
+                        e.content = f"{e.content}{supplementary_message}"
                     all_errors.append(e)
             else:
                 if code == "ARITY_MISMATCH":

{relationalai-0.11.2 → relationalai-0.11.3}/src/relationalai/semantics/lqp/model2lqp.py

@@ -13,7 +13,7 @@ from relationalai.semantics.lqp.utils import TranslationCtx, gen_unique_var
 from relationalai.semantics.lqp.validators import assert_valid_input
 
 from decimal import Decimal as PyDecimal
-from datetime import datetime, date
+from datetime import datetime, date, timezone
 from typing import Tuple, cast, Union, Optional
 from warnings import warn
 import re
@@ -627,7 +627,8 @@ def to_lqp_value(value: ir.PyValue, value_type: ir.Type) -> lqp.Value:
     elif typ.type_name == lqp.TypeName.DATE and isinstance(value, date):
         val = lqp.DateValue(value=value, meta=None)
     elif typ.type_name == lqp.TypeName.DATETIME and isinstance(value, datetime):
-        val = lqp.DateTimeValue(value=value, meta=None)
+        utc_value = value.astimezone(timezone.utc) if value.tzinfo is not None else value # Convert to UTC cf. Iceberg
+        val = lqp.DateTimeValue(value=utc_value, meta=None)
     elif typ.type_name == lqp.TypeName.BOOLEAN and isinstance(value, bool):
         val = lqp.BooleanValue(value=value, meta=None)
     else:

{relationalai-0.11.2 → relationalai-0.11.3}/src/relationalai/semantics/lqp/passes.py

@@ -548,7 +548,7 @@ class PeriodMath(Pass):
                 return node
 
             if node.relation.name not in {
-                "year", "month", "week", "day", "hour", "minute", "second", "millisecond"
+                "year", "month", "week", "day", "hour", "minute", "second", "millisecond", "microsecond", "nanosecond"
             }:
                 return node
 

{relationalai-0.11.2 → relationalai-0.11.3}/src/relationalai/semantics/lqp/primitives.py

@@ -22,12 +22,18 @@ rel_to_lqp = {
     "sinh": "rel_primitive_sinh",
     "asin": "rel_primitive_asin",
     "asinh": "rel_primitive_asinh",
+    "tan": "rel_primitive_tan",
+    "tanh": "rel_primitive_tanh",
+    "atan": "rel_primitive_atan",
+    "atanh": "rel_primitive_atanh",
+    "cot": "rel_primitive_cot",
+    "acot": "rel_primitive_acot",
     "construct_date": "rel_primitive_construct_date",
     "construct_date_from_datetime": "rel_primitive_datetime_date_convert",
-    "construct_datetime": "rel_primitive_construct_datetime",
     "construct_datetime_ms_tz": "rel_primitive_construct_datetime",
     "hash": "rel_primitive_hash_tuple_uint128",
     "uuid_to_string": "rel_primitive_uuid_string",
+    "parse_uuid": "rel_primitive_parse_uuid",
     "parse_date": "rel_primitive_parse_date",
     "parse_datetime": "rel_primitive_parse_datetime",
     "parse_decimal": "rel_primitive_parse_decimal",
@@ -47,23 +53,41 @@ rel_to_lqp = {
     "replace": "rel_primitive_replace",
     "strip": "rel_primitive_trim",
     "date_year": "rel_primitive_date_year",
+    "date_quarter": "rel_primitive_date_quarterofyear",
     "date_month": "rel_primitive_date_month",
     "date_week": "rel_primitive_date_week",
     "date_day": "rel_primitive_date_day",
+    "date_dayofyear": "rel_primitive_date_dayofyear",
+    "date_weekday": "rel_primitive_date_dayofweek",
     "date_add": "rel_primitive_typed_add_date_period",
     "date_subtract": "rel_primitive_typed_subtract_date_period",
     "dates_period_days": "rel_primitive_date_days_between",
     "datetime_add": "rel_primitive_typed_add_datetime_period",
     "datetime_subtract": "rel_primitive_typed_subtract_datetime_period",
+    "datetime_year": "rel_primitive_datetime_year",
+    "datetime_quarter": "rel_primitive_datetime_quarterofyear",
+    "datetime_month": "rel_primitive_datetime_month",
     "datetime_week": "rel_primitive_datetime_week",
+    "datetime_day": "rel_primitive_datetime_day",
+    "datetime_dayofyear": "rel_primitive_datetime_dayofyear",
+    "datetime_hour": "rel_primitive_datetime_hour",
+    "datetime_minute": "rel_primitive_datetime_minute",
+    "datetime_second": "rel_primitive_datetime_second",
+    "datetime_weekday": "rel_primitive_datetime_dayofweek",
     "datetimes_period_milliseconds": "rel_primitive_datetime_milliseconds_between",
     "date_format": "rel_primitive_format_date",
     "datetime_format": "rel_primitive_format_datetime",
     "range": "rel_primitive_range",
     "natural_log": "rel_primitive_natural_log",
+    "log": "rel_primitive_log",
+    "log2": "rel_primitive_log2",
+    "log10": "rel_primitive_log10",
     "sqrt": "rel_primitive_sqrt",
     "isinf": "rel_primitive_isinf",
     "isnan": "rel_primitive_isnan",
+    "exp": "rel_primitive_natural_exp",
+    "erf": "rel_primitive_error_function",
+    "erfinv": "rel_primitive_error_function_inverse",
     # Division is monotype, but only on the input args. Until we distinguish between input
     # and output args, we can't use the same assertions for monotype-ness as the other ops.
     "/": "rel_primitive_divide_monotype",
@@ -101,18 +125,7 @@ rel_to_lqp_monotype = {
 # Insert extra terms where a raicode primitive expects more terms, and there are possible
 # defaults.
 def _extend_primitive_terms(name: str, terms: list[lqp.RelTerm], term_types: list[lqp.Type]) -> tuple[list[lqp.RelTerm], list[lqp.Type]]:
-    if name == "rel_primitive_construct_datetime" and len(terms) == 7:
-        # construct_datetime does not provide a timezone or milliseconds so we
-        # default to 0 milliseconds and UTC timezone.
-        terms = [*terms[:-1], mk_value(0), mk_value("UTC"), terms[-1]]
-        term_types = [
-            *term_types[:-1],
-            mk_type(lqp.TypeName.INT),
-            mk_type(lqp.TypeName.STRING),
-            term_types[-1],
-        ]
-
-    elif name == "rel_primitive_parse_decimal" and len(terms) == 2:
+    if name == "rel_primitive_parse_decimal" and len(terms) == 2:
         assert term_types
         py_precision = term_types[1].parameters[0].value
         bit_value = mk_value(digits_to_bits(py_precision))