run-cache 2.2.0__tar.gz → 2.2.2__tar.gz

{run_cache-2.2.0 → run_cache-2.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: run-cache
-Version: 2.2.0
+Version: 2.2.2
 Summary: dbt plugin that skips redundant model executions by caching results from previous runs
 Project-URL: Homepage, https://runcache.com
 License: Copyright (c) 2026 Fivetran, Inc.
@@ -46,8 +46,8 @@ Requires-Dist: humanize
 Requires-Dist: protobuf>=4.0.0
 Requires-Dist: pyperclip
 Requires-Dist: pytimeparse2
-Requires-Dist: query-cache-common==1.3.0
-Requires-Dist: query-cache-protobuf==1.2.0
+Requires-Dist: query-cache-common==1.4.0
+Requires-Dist: query-cache-protobuf==1.3.0
 Requires-Dist: rich
 Requires-Dist: ruamel-yaml
 Requires-Dist: sqlglot>=27.6.1

run_cache-2.2.2/src/dbt_run_cache/_version.py

@@ -0,0 +1 @@
+__version__ = "2.2.2"

{run_cache-2.2.0 → run_cache-2.2.2}/src/dbt_run_cache/adapters/base.py

@@ -37,6 +37,7 @@ from dbt_run_cache.utils import find_tables
 
 if t.TYPE_CHECKING:
     from dbt.contracts.graph.nodes import ManifestNode
+    from dbt.contracts.graph.manifest import SourceDefinition
 
 
 class BaseAdapterExtension(abc.ABC):
@@ -146,11 +147,6 @@ class BaseAdapterExtension(abc.ABC):
     def rollback(self) -> None:
         self.adapter.connections.rollback_if_open()
 
-    def table_(
-        self, table: str, schema: t.Optional[str], catalog: t.Optional[str], quoted: bool = True
-    ) -> exp.Table:
-        return exp.table_(table, db=schema, catalog=catalog, quoted=quoted)
-
     def get_last_modified_epoch(
         self, tables: t.Iterable[str | exp.Table]
     ) -> dict[str, t.Optional[int]]:
@@ -470,7 +466,7 @@ class BaseAdapterExtension(abc.ABC):
         This is for when the plugin creates new database objects after dbt has populated its relation cache, to ensure those
         objects are reflected / available to the remainder of the dbt invocation.
         """
-        relation = self._create_cachable_relation(node)
+        relation = self._node_to_relation(node)
         self.adapter.cache_added(relation)
 
     def relation_exists(self, relation: BaseRelation) -> bool:
@@ -519,24 +515,79 @@ class BaseAdapterExtension(abc.ABC):
 
         return data
 
-    def _create_cachable_relation(self, node: ManifestNode) -> BaseRelation:
-        """Create an adapter-specific Relation object suitable for putting into the Relation cache."""
-        quoting_policy: t.Dict[str, bool] = {}
+    def _node_to_normalized_identifiers(
+        self,
+        node: ManifestNode | SourceDefinition,
+        override_database: t.Optional[str] = None,
+        override_schema: t.Optional[str] = None,
+    ) -> t.Tuple[str, str, str, t.Dict[str, bool]]:
+        """Break a dbt manifest node into parts that can be force-quoted without first normalizing.
+
+        dbt supports quoting the catalog, schema and identifier portions independently whereas SQLGlot
+        tends to be all-or-none.
+
+        The output of this method can be used to construct both dbt Relation objects and SQLGlot exp.Table objects
+        that are consistent with each other.
+
+        :override_database and :override_schema can be used to override the values used for the database and schema portions without
+        changing the input node object
+
+        Returns a tuple of (database, schema, identifier, quote_policy). These are deliberately strings so that they can be used to construct
+        a Relation object, but they have been normalized according to the quote policy
+        """
+        quote_policy = {
+            **self.adapter.Relation.get_default_quote_policy().to_dict(omit_none=True),
+            **self.adapter.config.quoting,
+            **node.config.get("quoting", {}),
+        }
+
+        database = override_database or node.database or self.default_catalog
+        schema = override_schema or node.schema
+        identifier = str(node.alias if hasattr(node, "alias") else node.identifier)
+
+        # normalize any unquoted identifiers
+        if not quote_policy["database"] and database:
+            database = self._sql(self._normalize_identifier(database))
+
+        if not quote_policy["schema"] and schema:
+            schema = self._sql(self._normalize_identifier(schema))
+
+        if not quote_policy["identifier"] and identifier:
+            identifier = self._sql(self._normalize_identifier(identifier))
+
+        return database, schema, identifier, quote_policy
 
-        for policy in (
-            self.adapter.Relation.get_default_quote_policy().to_dict(omit_none=True),
-            self.adapter.config.quoting,
-            node.config.get("quoting", {}),
-        ):
-            quoting_policy.update(policy)
+    def _node_to_relation(self, node: ManifestNode | SourceDefinition) -> BaseRelation:
+        """Turn a dbt manifest node into an adapter-specific Relation object suitable for putting
+        into the Relation cache, while respecting the configured quote policy"""
+
+        database, schema, identifier, dbt_quote_policy = self._node_to_normalized_identifiers(node)
 
         return self.adapter.Relation.create(
-            database=node.database,
-            schema=node.schema,
-            identifier=node.identifier,
+            database=database,
+            schema=schema,
+            identifier=identifier,
             type=RelationType.Table,
-            quoting=quoting_policy,
+            quote_policy=dbt_quote_policy,
+        )
+
+    def _node_to_table(
+        self,
+        node: ManifestNode | SourceDefinition,
+        override_database: t.Optional[str] = None,
+        override_schema: t.Optional[str] = None,
+    ) -> exp.Table:
+        """Given a dbt node, convert it to a SQLGlot exp.Table object while applying correct quoting
+        and normalization per the dbt quote policy for this node.
+
+        Note that since dbt allows a mixture of quoted and unquoted parts and SQLGlot prefers all or nothing,
+        the produced SQLGlot exp.Table is semantically equivalent but not identical to the dbt Node.
+        This is achieved by normalizing any identifiers that are unquoted on the dbt side and then force-quoting everything
+        """
+        database, schema, identifier, _ = self._node_to_normalized_identifiers(
+            node, override_database=override_database, override_schema=override_schema
         )
+        return exp.table_(catalog=database, db=schema, table=identifier, quoted=True)
 
     def get_relation_table_type(
         self, node: ManifestNode, relation: BaseRelation
@@ -701,12 +752,16 @@ class BaseAdapterExtension(abc.ABC):
         # since _to_fqn() returns the table parts quoted, we have to normalize unquoted identifiers first
         # if we force-quote without normalizing then on engines like Snowflake we end up with identifiers
         # that should be uppercase stuck as lowercase because they were force-quoted
-        return self._normalize_and_quote_table(
-            exp.table_(
-                table_name,
-                db=table_schema,
-                catalog=table_catalog,
-            )
+        return quote_identifiers(
+            normalize_identifiers(
+                exp.table_(
+                    table_name,
+                    db=table_schema,
+                    catalog=table_catalog,
+                ),
+                dialect=self.dialect,
+            ),
+            dialect=self.dialect,
         )
 
     def _sql(self, expression: exp.Expr, copy: bool = False) -> str:
@@ -718,12 +773,10 @@ class BaseAdapterExtension(abc.ABC):
         """
         return expression.sql(dialect=self.dialect, copy=copy)
 
-    def _normalize_and_quote_table(self, table: t.Union[str, exp.Table]) -> exp.Table:
-        if isinstance(table, str):
-            table = exp.to_table(table, dialect=self.dialect)
-        return quote_identifiers(
-            normalize_identifiers(table, dialect=self.dialect), dialect=self.dialect
-        )
+    def _normalize_identifier(self, expr: t.Union[str, exp.Identifier]) -> exp.Identifier:
+        if isinstance(expr, str):
+            expr = exp.parse_identifier(expr, dialect=self.dialect)
+        return normalize_identifiers(expr, dialect=self.dialect)
 
     def _is_system_metadata_table(self, table: exp.Table) -> bool:
         """Is the specified table a known system metadata table/view?

{run_cache-2.2.0 → run_cache-2.2.2}/src/dbt_run_cache/adapters/snowflake.py

@@ -18,11 +18,6 @@ from dbt_run_cache.utils import set_invocation_context
 from query_cache_common.utils import extract_fqn_parts
 import re
 
-try:
-    from dbt.adapters.contracts.relation import RelationType
-except ImportError:
-    # dbt 1.7
-    from dbt.adapters.base.relation import RelationType
 
 if t.TYPE_CHECKING:
     from dbt.contracts.graph.nodes import ManifestNode
@@ -44,28 +39,6 @@ class SnowflakeAdapterExtension(BaseAdapterExtension):
     def current_timestamp_utc(self) -> datetime:
         return self.execute("SELECT SYSDATE()", fetch=True).rows[0][0].replace(tzinfo=timezone.utc)
 
-    def _create_cachable_relation(self, node: ManifestNode) -> BaseRelation:
-        from dbt.adapters.snowflake.relation import SnowflakeRelation
-
-        # when building its relation cache, the Snowflake adapter:
-        # - caches what it gets from Snowflake's INFORMATION_SCHEMA, which is usually uppercase
-        # - hardcodes the below quoting policy
-        # so if we are writing our own relations into the cache, we need to normalize them, or we get an ApproximateMatchError when trying to read them back
-        # ref: https://github.com/dbt-labs/dbt-adapters/blob/60fc903f705f447a7b58d0df6b33d7be7cd00690/dbt-snowflake/src/dbt/adapters/snowflake/impl.py#L321
-        quoting_policy = {"database": True, "schema": True, "identifier": True}
-
-        normalized = self._normalize_and_quote_table(
-            self.table_(catalog=node.database, schema=node.schema, table=node.alias, quoted=False)
-        )
-
-        return SnowflakeRelation.create(
-            database=normalized.catalog,
-            schema=normalized.db,
-            identifier=normalized.name,
-            type=RelationType.Table,
-            quoting_policy=quoting_policy,
-        )
-
     def get_relation_table_type(
         self, node: ManifestNode, relation: BaseRelation
     ) -> t.Optional[str]:

{run_cache-2.2.0 → run_cache-2.2.2}/src/dbt_run_cache/cli/explainer.py

@@ -106,6 +106,11 @@ class Explainer:
         for log_entry in no_decision_entries:
             self._explain_no_decision_node(log_entry)
 
+    def explain_to_str(self) -> str:
+        with self._console.capture() as capture:
+            self.explain()
+        return capture.get()
+
     def _explain_run_start(self, run_start_entry: RunStartEntry) -> None:
         self._print("Last run: ")
 

{run_cache-2.2.0 → run_cache-2.2.2}/src/dbt_run_cache/run_cache.py

@@ -1132,19 +1132,16 @@ class RunCache:
         return last_modified_epoch
 
     def _node_to_table(self, node: ManifestNode | SourceDefinition) -> exp.Table:
-        database = node.database
-        schema = node.schema
-        table_name = t.cast(str, node.alias if hasattr(node, "alias") else node.identifier)
-        table = self._adapter_ext.table_(table_name, schema, database, quoted=False)
-        return self._adapter_ext._normalize_and_quote_table(table)
+        return self._adapter_ext._node_to_table(node)
 
     def _node_to_deferred_table(self, node: ManifestNode) -> exp.Table:
         assert self._deferred_relation_resolver is not None
         database = self._deferred_relation_resolver.get_deferred_database(node) or node.database
         schema = self._deferred_relation_resolver.get_deferred_schema(node) or node.schema
-        table_name = node.alias if hasattr(node, "alias") else node.identifier
-        table = self._adapter_ext.table_(table_name, schema, database, quoted=False)
-        return self._adapter_ext._normalize_and_quote_table(table)
+
+        return self._adapter_ext._node_to_table(
+            node, override_database=database, override_schema=schema
+        )
 
     def _record_cache_hit(
         self,

run_cache-2.2.0/src/dbt_run_cache/_version.py

@@ -1 +0,0 @@
-__version__ = "2.2.0"