sqlbuild 0.115.0__tar.gz → 0.117.0__tar.gz

{sqlbuild-0.115.0 → sqlbuild-0.117.0}/Cargo.lock

@@ -592,7 +592,7 @@ checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba"
 
 [[package]]
 name = "sqlbuild-rules-native"
-version = "0.115.0"
+version = "0.117.0"
 dependencies = [
  "fensu-policy",
  "globset",

{sqlbuild-0.115.0 → sqlbuild-0.117.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlbuild
-Version: 0.115.0
+Version: 0.117.0
 Requires-Dist: duckdb>=1.3.2
 Requires-Dist: filelock>=3.20.3
 Requires-Dist: orjson>=3.10.0

{sqlbuild-0.115.0 → sqlbuild-0.117.0}/crates/sqlbuild-rules-native/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sqlbuild-rules-native"
-version = "0.115.0"
+version = "0.117.0"
 edition.workspace = true
 license.workspace = true
 publish.workspace = true

{sqlbuild-0.115.0 → sqlbuild-0.117.0}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "maturin"
 
 [project]
 name = "sqlbuild"
-version = "0.115.0"
+version = "0.117.0"
 description = "Typed, test-first SQL pipelines with local E2E testing"
 readme = "README.md"
 requires-python = ">=3.12"
@@ -57,7 +57,6 @@ rivers = [
 [project.scripts]
 sqb = "sqlbuild.cli.entry.main.entry:main"
 sqlbuild = "sqlbuild.cli.entry.main.entry:main"
-dupscore = "scripts.dupscore.main.dupscore:dupscore"
 
 [dependency-groups]
 dev = [
@@ -78,7 +77,7 @@ dev = [
   "pytest-cov>=7.0.0",
   "pytest-xdist>=3.8.0",
   "ruff>=0.12.0",
-  "fensu>=0.22.0",
+  "fensu>=0.23.0",
   "testcontainers>=4.8.1",
   "ty>=0.0.1a19",
 ]
@@ -90,8 +89,6 @@ python-source = "src"
 features = ["extension-module"]
 include = [
   { path = "LICENSE", format = ["sdist", "wheel"] },
-  { path = "scripts/dupscore/**/*.py", format = ["sdist", "wheel"] },
-  { path = "scripts/dupscore/dupscore.toml", format = ["sdist", "wheel"] },
 ]
 
 [tool.commitizen]

{sqlbuild-0.115.0 → sqlbuild-0.117.0}/src/sqlbuild/adapter/contract/classes/base_adapter.py

@@ -389,6 +389,14 @@ class BaseAdapter(RetentionAdapterMixin, StrictAdapter):
         )
         return cursor.fetchone() is not None
 
+    def with_relation_age_metadata(
+        self,
+        *,
+        connection: Any,
+        relations: tuple[RelationInfo, ...],
+    ) -> tuple[RelationInfo, ...]:
+        return relations
+
     def list_relations(
         self,
         *,
@@ -626,6 +634,9 @@ class BaseAdapter(RetentionAdapterMixin, StrictAdapter):
     def render_rename(self, *, origin: str, destination: str) -> tuple[str, ...]:
         return (f"ALTER TABLE {origin} RENAME TO {destination}",)
 
+    def render_rename_view(self, *, origin: str, destination: str) -> tuple[str, ...]:
+        return (f"ALTER VIEW {origin} RENAME TO {destination}",)
+
     def render_swap(self, *, left: str, right: str) -> tuple[str, ...]:
         staging: str = self._with_replaced_relation_name(
             relation=left, name=f"{self._relation_name(left)}__swap_staging"
@@ -2342,6 +2353,21 @@ class BaseAdapter(RetentionAdapterMixin, StrictAdapter):
         del database, schema
         return ()
 
+    def render_create_janitor_event_table_sql(self, *, database: str | None, schema: str) -> str:
+        """Render DDL that creates the janitor audit event table when it is missing."""
+
+        from sqlbuild.executor.janitor_events.main.create_table_sql import (
+            build_janitor_events_create_table_sql,
+        )
+
+        return build_janitor_events_create_table_sql(
+            database=database,
+            schema=schema,
+            render_qualified_name=self.render_qualified_name,
+            render_framework_type=self.render_framework_type,
+            transient=self.state_tables_transient,
+        )
+
     def render_prune_fingerprint_history_sql(
         self,
         *,

{sqlbuild-0.115.0 → sqlbuild-0.117.0}/src/sqlbuild/adapter/contract/classes/duckdb_backed_adapter.py

@@ -97,6 +97,8 @@ class DuckDbBackedAdapter(UnkeyedDiffMixin, BaseAdapter):
         return False
 
     def supports_relation_age_metadata(self) -> bool:
+        """Return False because the DuckDB and MotherDuck catalogs record no relation timestamps."""
+
         return False
 
     def supports_table_freshness_metadata(self) -> bool:
@@ -1029,6 +1031,18 @@ class DuckDbBackedAdapter(UnkeyedDiffMixin, BaseAdapter):
         del database, schema
         return ()
 
+    def render_create_janitor_event_table_sql(self, *, database: str | None, schema: str) -> str:
+        from sqlbuild.executor.janitor_events.main.create_table_sql import (
+            build_janitor_events_create_table_sql,
+        )
+
+        return build_janitor_events_create_table_sql(
+            database=database,
+            schema=schema,
+            render_qualified_name=self.render_qualified_name,
+            render_framework_type=self.render_framework_type,
+        )
+
     def render_prune_fingerprint_history_sql(
         self,
         *,
@@ -1311,6 +1325,14 @@ class DuckDbBackedAdapter(UnkeyedDiffMixin, BaseAdapter):
             for row in rows
         )
 
+    def with_relation_age_metadata(
+        self,
+        *,
+        connection: Any,
+        relations: tuple[RelationInfo, ...],
+    ) -> tuple[RelationInfo, ...]:
+        return relations
+
     def list_functions(
         self,
         *,
@@ -1626,6 +1648,10 @@ class DuckDbBackedAdapter(UnkeyedDiffMixin, BaseAdapter):
         unqualified_destination: str = destination.rsplit(".", 1)[-1]
         return (f"ALTER TABLE {origin} RENAME TO {unqualified_destination}",)
 
+    def render_rename_view(self, *, origin: str, destination: str) -> tuple[str, ...]:
+        unqualified_destination: str = destination.rsplit(".", 1)[-1]
+        return (f"ALTER VIEW {origin} RENAME TO {unqualified_destination}",)
+
     def render_swap(self, *, left: str, right: str) -> tuple[str, ...]:
         staging: str = self._with_replaced_relation_name(
             relation=left, name=f"{self._relation_name(left)}__swap_staging"

{sqlbuild-0.115.0 → sqlbuild-0.117.0}/src/sqlbuild/adapter/contract/classes/schema.py

@@ -23,6 +23,16 @@ class SchemaMixin(ABC):
         """Return all relations in the given database/schema scope."""
         ...
 
+    @abstractmethod
+    def with_relation_age_metadata(
+        self,
+        *,
+        connection: Any,
+        relations: tuple[RelationInfo, ...],
+    ) -> tuple[RelationInfo, ...]:
+        """Return listed relations with age timestamps that listing does not read inline."""
+        ...
+
     @abstractmethod
     def list_functions(
         self,

{sqlbuild-0.115.0 → sqlbuild-0.117.0}/src/sqlbuild/adapter/contract/classes/strict_adapter.py

@@ -312,6 +312,11 @@ class StrictAdapter(
         """Render SQL statements that rename a relation."""
         ...
 
+    @abstractmethod
+    def render_rename_view(self, *, origin: str, destination: str) -> tuple[str, ...]:
+        """Render SQL statements that rename a view relation."""
+        ...
+
     @abstractmethod
     def render_swap(self, *, left: str, right: str) -> tuple[str, ...]:
         """Render SQL statements that swap two relations."""
@@ -875,6 +880,11 @@ class StrictAdapter(
         """Render optional audit result table index DDL statements."""
         ...
 
+    @abstractmethod
+    def render_create_janitor_event_table_sql(self, *, database: str | None, schema: str) -> str:
+        """Render DDL that creates the janitor audit event table when it is missing."""
+        ...
+
     @abstractmethod
     def render_prune_fingerprint_history_sql(
         self,

sqlbuild-0.117.0/src/sqlbuild/adapter/relations/_helpers/identifier_fitting.py

@@ -0,0 +1,35 @@
+"""Identifier-limit fitting implementations for generated relation names."""
+
+from __future__ import annotations
+
+import hashlib
+
+from sqlbuild.adapter.relations.constants import SHORTENED_LOGICAL_NAME_HASH_LENGTH
+from sqlbuild.errors.contracts.exceptions import SharedInputError
+
+
+def fit_artifact_logical_name_impl(
+    *, logical_name: str, fixed_prefix: str, identifier_limit: int, artifact_label: str
+) -> str:
+    """Fit a readable logical component with a deterministic hash suffix."""
+
+    max_logical_length: int = identifier_limit - len(fixed_prefix)
+    if max_logical_length < 1:
+        raise SharedInputError(
+            f"{artifact_label} prefix '{fixed_prefix}' does not fit within identifier "
+            f"limit {identifier_limit}"
+        )
+    if len(logical_name) <= max_logical_length:
+        return logical_name
+
+    suffix_length: int = SHORTENED_LOGICAL_NAME_HASH_LENGTH + 1
+    if max_logical_length <= suffix_length:
+        raise SharedInputError(
+            f"{artifact_label} name for '{logical_name}' cannot fit within identifier "
+            f"limit {identifier_limit}"
+        )
+    logical_hash: str = hashlib.sha256(logical_name.encode("utf-8")).hexdigest()[
+        :SHORTENED_LOGICAL_NAME_HASH_LENGTH
+    ]
+    prefix_length: int = max_logical_length - suffix_length
+    return f"{logical_name[:prefix_length]}_{logical_hash}"

{sqlbuild-0.115.0 → sqlbuild-0.117.0}/src/sqlbuild/adapter/relations/constants.py

@@ -1,3 +1,4 @@
 """Shared relation metadata limits."""
 
 METADATA_NAME_FILTER_LIMIT: int = 250
+SHORTENED_LOGICAL_NAME_HASH_LENGTH: int = 8

sqlbuild-0.117.0/src/sqlbuild/adapter/relations/main/fit_artifact_logical_name.py

@@ -0,0 +1,18 @@
+"""Generated relation name fitting entrypoint."""
+
+from __future__ import annotations
+
+from sqlbuild.adapter.relations._helpers.identifier_fitting import fit_artifact_logical_name_impl
+
+
+def fit_artifact_logical_name(
+    *, logical_name: str, fixed_prefix: str, identifier_limit: int, artifact_label: str
+) -> str:
+    """Fit a readable logical component after a fixed prefix within an identifier limit."""
+
+    return fit_artifact_logical_name_impl(
+        logical_name=logical_name,
+        fixed_prefix=fixed_prefix,
+        identifier_limit=identifier_limit,
+        artifact_label=artifact_label,
+    )

sqlbuild-0.117.0/src/sqlbuild/adapter/relations/main/relation_age_timestamp.py

@@ -0,0 +1,15 @@
+"""Relation catalog timestamp normalization entrypoint."""
+
+from __future__ import annotations
+
+from datetime import UTC, datetime
+
+
+def relation_age_timestamp_utc(value: object) -> datetime | None:
+    """Return one catalog timestamp as aware UTC, treating offset-free values as UTC."""
+
+    if not isinstance(value, datetime):
+        return None
+    if value.tzinfo is None or value.utcoffset() is None:
+        return value.replace(tzinfo=UTC)
+    return value.astimezone(UTC)

sqlbuild-0.117.0/src/sqlbuild/adapter/state_sql/_helpers/table_ddl.py

@@ -0,0 +1,32 @@
+"""Portable append-only state table DDL implementations."""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Mapping
+
+from sqlbuild.adapter.contract.types import FrameworkType
+from sqlbuild.sql_values.types import StateSqlValueType
+
+
+def render_state_table_create_sql_impl(
+    *,
+    qualified_name: str,
+    columns: tuple[str, ...],
+    column_types: Mapping[str, StateSqlValueType],
+    required_columns: frozenset[str],
+    render_framework_type: Callable[[FrameworkType], str],
+    transient: bool,
+) -> str:
+    """Render create-if-missing DDL for string, integer, and text-timestamp state columns."""
+
+    rendered_types: dict[StateSqlValueType, str] = {
+        StateSqlValueType.STRING: render_framework_type(FrameworkType.STRING),
+        StateSqlValueType.INTEGER: render_framework_type(FrameworkType.INTEGER),
+        StateSqlValueType.TEXT_TIMESTAMP: render_framework_type(FrameworkType.TIMESTAMP),
+    }
+    definitions: list[str] = []
+    for column in columns:
+        required: str = " NOT NULL" if column in required_columns else ""
+        definitions.append(f"{column} {rendered_types[column_types[column]]}{required}")
+    table_kind: str = "TRANSIENT TABLE" if transient else "TABLE"
+    return f"CREATE {table_kind} IF NOT EXISTS {qualified_name} ({', '.join(definitions)})"

sqlbuild-0.117.0/src/sqlbuild/adapter/state_sql/main/render_state_table_create_sql.py

@@ -0,0 +1,28 @@
+"""Public append-only state table DDL rendering operation."""
+
+from collections.abc import Callable, Mapping
+
+from sqlbuild.adapter.contract.types import FrameworkType
+from sqlbuild.adapter.state_sql._helpers.table_ddl import render_state_table_create_sql_impl
+from sqlbuild.sql_values.types import StateSqlValueType
+
+
+def render_state_table_create_sql(
+    *,
+    qualified_name: str,
+    columns: tuple[str, ...],
+    column_types: Mapping[str, StateSqlValueType],
+    required_columns: frozenset[str],
+    render_framework_type: Callable[[FrameworkType], str],
+    transient: bool = False,
+) -> str:
+    """Render create-if-missing DDL for one append-only state table."""
+
+    return render_state_table_create_sql_impl(
+        qualified_name=qualified_name,
+        columns=columns,
+        column_types=column_types,
+        required_columns=required_columns,
+        render_framework_type=render_framework_type,
+        transient=transient,
+    )

{sqlbuild-0.115.0 → sqlbuild-0.117.0}/src/sqlbuild/adapters/bigquery/classes/bigquery_adapter.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import json
 import logging
+from dataclasses import replace
 from datetime import date, datetime
 from decimal import Decimal
 from pathlib import Path
@@ -64,6 +65,7 @@ from sqlbuild.adapter.contract.types import (
 from sqlbuild.adapter.relations.main.get_columns_for_relations import (
     get_columns_for_relations_bulk,
 )
+from sqlbuild.adapter.relations.main.relation_age_timestamp import relation_age_timestamp_utc
 from sqlbuild.adapter.state_sql.main.render_insert_source_freshness_records_sql import (
     render_insert_source_freshness_records_sql,
 )
@@ -282,6 +284,18 @@ class BigQueryAdapter(MicrobatchMixin, UnkeyedDiffMixin, BaseAdapter):
         del database, schema
         return ()
 
+    def render_create_janitor_event_table_sql(self, *, database: str | None, schema: str) -> str:
+        from sqlbuild.executor.janitor_events.main.create_table_sql import (
+            build_janitor_events_create_table_sql,
+        )
+
+        return build_janitor_events_create_table_sql(
+            database=database,
+            schema=schema,
+            render_qualified_name=self.render_qualified_name,
+            render_framework_type=self.render_framework_type,
+        )
+
     def render_prune_fingerprint_history_sql(
         self,
         *,
@@ -350,7 +364,7 @@ class BigQueryAdapter(MicrobatchMixin, UnkeyedDiffMixin, BaseAdapter):
         )
 
     def supports_relation_age_metadata(self) -> bool:
-        return False
+        return True
 
     def supports_table_freshness_metadata(self) -> bool:
         return True
@@ -1825,6 +1839,10 @@ class BigQueryAdapter(MicrobatchMixin, UnkeyedDiffMixin, BaseAdapter):
         destination_name: str = self._strip_identifier_quotes(destination).split(".")[-1]
         return (f"ALTER TABLE {self._quote_identifier_path(origin)} RENAME TO {destination_name}",)
 
+    def render_rename_view(self, *, origin: str, destination: str) -> tuple[str, ...]:
+        del origin, destination
+        raise AdapterUserError(message="BigQuery does not support renaming views")
+
     def render_swap(self, *, left: str, right: str) -> tuple[str, ...]:
         raise AdapterUserError(message="BigQuery does not support atomic table swap")
 
@@ -2030,6 +2048,59 @@ class BigQueryAdapter(MicrobatchMixin, UnkeyedDiffMixin, BaseAdapter):
                     raise
         return tuple(relations)
 
+    def with_relation_age_metadata(
+        self,
+        *,
+        connection: _BigQueryConnection,
+        relations: tuple[RelationInfo, ...],
+    ) -> tuple[RelationInfo, ...]:
+        timestamps: dict[tuple[str | None, str, str], tuple[datetime | None, datetime | None]] = {}
+        dataset_key: tuple[str | None, str]
+        for dataset_key in sorted(
+            {(relation.database, str(relation.schema)) for relation in relations},
+            key=lambda key: (key[0] or "", key[1]),
+        ):
+            timestamps.update(
+                self._dataset_relation_timestamps(
+                    connection=connection, database=dataset_key[0], schema=dataset_key[1]
+                )
+            )
+        return tuple(
+            replace(
+                relation,
+                created_at=timestamps.get(self._age_key(relation), (None, None))[0],
+                last_altered_at=timestamps.get(self._age_key(relation), (None, None))[1],
+            )
+            for relation in relations
+        )
+
+    def _dataset_relation_timestamps(
+        self, *, connection: _BigQueryConnection, database: str | None, schema: str
+    ) -> dict[tuple[str | None, str, str], tuple[datetime | None, datetime | None]]:
+        dataset_id: str = self._build_dataset_id(database=database, schema=schema)
+        try:
+            cursor: _BigQueryCursor = self.execute(
+                connection=connection,
+                sql="SELECT table_id, TIMESTAMP_MILLIS(creation_time), "
+                f"TIMESTAMP_MILLIS(last_modified_time) FROM `{dataset_id}.__TABLES__`",
+            )
+            rows: list[tuple[Any, ...]] = cursor.fetchall()
+        except Exception as error:
+            if not self._is_google_not_found(error):
+                raise
+            return {}
+        return {
+            (database, schema, str(row[0])): (
+                relation_age_timestamp_utc(row[1]),
+                relation_age_timestamp_utc(row[2]),
+            )
+            for row in rows
+        }
+
+    @staticmethod
+    def _age_key(relation: RelationInfo) -> tuple[str | None, str, str]:
+        return (relation.database, str(relation.schema), relation.name)
+
     def list_functions(
         self,
         *,

{sqlbuild-0.115.0 → sqlbuild-0.117.0}/src/sqlbuild/adapters/databricks/classes/databricks_adapter.py

@@ -7,6 +7,7 @@ import csv
 import json
 import logging
 import re
+from dataclasses import replace
 from datetime import date, datetime
 from decimal import Decimal
 from pathlib import Path
@@ -63,6 +64,7 @@ from sqlbuild.adapter.contract.types import (
 from sqlbuild.adapter.relations.main.get_columns_for_relations import (
     get_columns_for_relations_bulk,
 )
+from sqlbuild.adapter.relations.main.relation_age_timestamp import relation_age_timestamp_utc
 from sqlbuild.adapter.state_sql.main.render_insert_source_freshness_records_sql import (
     render_insert_source_freshness_records_sql,
 )
@@ -376,6 +378,18 @@ class DatabricksAdapter(MicrobatchMixin, UnkeyedDiffMixin, BaseAdapter):
         del database, schema
         return ()
 
+    def render_create_janitor_event_table_sql(self, *, database: str | None, schema: str) -> str:
+        from sqlbuild.executor.janitor_events.main.create_table_sql import (
+            build_janitor_events_create_table_sql,
+        )
+
+        return build_janitor_events_create_table_sql(
+            database=database,
+            schema=schema,
+            render_qualified_name=self.render_qualified_name,
+            render_framework_type=self.render_framework_type,
+        )
+
     def render_prune_fingerprint_history_sql(
         self,
         *,
@@ -1257,7 +1271,7 @@ class DatabricksAdapter(MicrobatchMixin, UnkeyedDiffMixin, BaseAdapter):
         return True
 
     def supports_relation_age_metadata(self) -> bool:
-        return False
+        return True
 
     def recommended_max_sql_length(self) -> int | None:
         return 256_000
@@ -1394,8 +1408,8 @@ class DatabricksAdapter(MicrobatchMixin, UnkeyedDiffMixin, BaseAdapter):
             return ()
         information_schema: str = self._information_schema(database)
         query: str = (
-            f"SELECT table_name, table_schema, table_type FROM {information_schema}.tables "
-            "WHERE 1=1"
+            "SELECT table_name, table_schema, table_type, created, last_altered "
+            f"FROM {information_schema}.tables WHERE 1=1"
         )
         query += self._build_in_filter(column="table_schema", values=schemas)
         if names:
@@ -1406,14 +1420,64 @@ class DatabricksAdapter(MicrobatchMixin, UnkeyedDiffMixin, BaseAdapter):
             rows: list[tuple[Any, ...]] = cursor.fetchall()
         finally:
             cursor.close()
+        return tuple(self._listed_relation(database=database, row=row) for row in rows)
+
+    def _listed_relation(self, *, database: str, row: tuple[Any, ...]) -> RelationInfo:
+        relation_type: str = self._normalize_relation_type(str(row[2]))
+        is_view: bool = relation_type == RelationType.VIEW
+        return RelationInfo(
+            database=database,
+            schema=str(row[1]).lower(),
+            name=str(row[0]).lower(),
+            relation_type=relation_type,
+            created_at=relation_age_timestamp_utc(row[3]) if is_view else None,
+            last_altered_at=relation_age_timestamp_utc(row[4]) if is_view else None,
+        )
+
+    def with_relation_age_metadata(
+        self,
+        *,
+        connection: Any,
+        relations: tuple[RelationInfo, ...],
+    ) -> tuple[RelationInfo, ...]:
+        """Read data-write ages for non-view relations; information_schema tracks only DDL."""
+
         return tuple(
-            RelationInfo(
-                database=database,
-                schema=str(row[1]).lower(),
-                name=str(row[0]).lower(),
-                relation_type=self._normalize_relation_type(str(row[2])),
-            )
-            for row in rows
+            relation
+            if relation.relation_type == RelationType.VIEW
+            else self._with_delta_detail_ages(connection=connection, relation=relation)
+            for relation in relations
+        )
+
+    def _with_delta_detail_ages(self, *, connection: Any, relation: RelationInfo) -> RelationInfo:
+        unknown_age: RelationInfo = replace(relation, created_at=None, last_altered_at=None)
+        if relation.database is None or relation.schema is None:
+            return unknown_age
+        target: str = ".".join(
+            self.render_identifier(part)
+            for part in (relation.database, relation.schema, relation.name)
+        )
+        cursor: Any = connection.cursor()
+        try:
+            cursor.execute(f"DESCRIBE DETAIL {target}")
+            row: tuple[Any, ...] | None = cursor.fetchone()
+            description: tuple[Any, ...] | None = cursor.description
+        except Exception:
+            return unknown_age
+        finally:
+            cursor.close()
+        if row is None or description is None:
+            return unknown_age
+        detail: dict[str, object] = {
+            str(column[0]).lower(): value for column, value in zip(description, row, strict=False)
+        }
+        last_modified: datetime | None = relation_age_timestamp_utc(detail.get("lastmodified"))
+        if last_modified is None:
+            return unknown_age
+        return replace(
+            relation,
+            created_at=relation_age_timestamp_utc(detail.get("createdat")),
+            last_altered_at=last_modified,
         )
 
     def list_functions(
@@ -1833,6 +1897,9 @@ class DatabricksAdapter(MicrobatchMixin, UnkeyedDiffMixin, BaseAdapter):
     def render_rename(self, *, origin: str, destination: str) -> tuple[str, ...]:
         return (f"ALTER TABLE {origin} RENAME TO {destination}",)
 
+    def render_rename_view(self, *, origin: str, destination: str) -> tuple[str, ...]:
+        return (f"ALTER VIEW {origin} RENAME TO {destination}",)
+
     def render_swap(self, *, left: str, right: str) -> tuple[str, ...]:
         raise AdapterUserError(message="Databricks does not support atomic table swap")
 

{sqlbuild-0.115.0 → sqlbuild-0.117.0}/src/sqlbuild/adapters/postgres/classes/postgres_adapter.py

@@ -110,6 +110,8 @@ class PostgresAdapter(MicrobatchMixin, UnkeyedDiffMixin, BaseAdapter):
         return False
 
     def supports_relation_age_metadata(self) -> bool:
+        """Return False because the Postgres catalog records no relation timestamps."""
+
         return False
 
     def supports_table_freshness_metadata(self) -> bool:
@@ -307,6 +309,14 @@ class PostgresAdapter(MicrobatchMixin, UnkeyedDiffMixin, BaseAdapter):
             for row in cursor.fetchall()
         )
 
+    def with_relation_age_metadata(
+        self,
+        *,
+        connection: Any,
+        relations: tuple[RelationInfo, ...],
+    ) -> tuple[RelationInfo, ...]:
+        return relations
+
     def list_functions(
         self,
         *,
@@ -1582,6 +1592,18 @@ class PostgresAdapter(MicrobatchMixin, UnkeyedDiffMixin, BaseAdapter):
             f"ON {table_name} (run_id, invocation_id, result_id)",
         )
 
+    def render_create_janitor_event_table_sql(self, *, database: str | None, schema: str) -> str:
+        from sqlbuild.executor.janitor_events.main.create_table_sql import (
+            build_janitor_events_create_table_sql,
+        )
+
+        return build_janitor_events_create_table_sql(
+            database=database,
+            schema=schema,
+            render_qualified_name=self.render_qualified_name,
+            render_framework_type=self.render_framework_type,
+        )
+
     def render_read_latest_source_freshness_sql(
         self,
         *,
@@ -1881,6 +1903,10 @@ class PostgresAdapter(MicrobatchMixin, UnkeyedDiffMixin, BaseAdapter):
         destination_name: str = destination.split(".")[-1]
         return (f"ALTER TABLE {origin} RENAME TO {destination_name}",)
 
+    def render_rename_view(self, *, origin: str, destination: str) -> tuple[str, ...]:
+        destination_name: str = destination.split(".")[-1]
+        return (f"ALTER VIEW {origin} RENAME TO {destination_name}",)
+
     def load_seed(
         self,
         *,