sqlmesh 0.217.1.dev1__py3-none-any.whl → 0.227.2.dev20__py3-none-any.whl

sqlmesh/core/state_sync/db/interval.py

@@ -15,10 +15,10 @@ from sqlmesh.core.state_sync.db.utils import (
 from sqlmesh.core.snapshot import (
     SnapshotIntervals,
     SnapshotIdLike,
+    SnapshotIdAndVersionLike,
     SnapshotNameVersionLike,
     SnapshotTableCleanupTask,
     SnapshotNameVersion,
-    SnapshotInfoLike,
     Snapshot,
 )
 from sqlmesh.core.snapshot.definition import Interval
@@ -60,6 +60,7 @@ class IntervalState:
             "is_removed": exp.DataType.build("boolean"),
             "is_compacted": exp.DataType.build("boolean"),
             "is_pending_restatement": exp.DataType.build("boolean"),
+            "last_altered_ts": exp.DataType.build("bigint"),
         }
 
     def add_snapshots_intervals(self, snapshots_intervals: t.Sequence[SnapshotIntervals]) -> None:
@@ -68,11 +69,11 @@ class IntervalState:
 
     def remove_intervals(
         self,
-        snapshot_intervals: t.Sequence[t.Tuple[SnapshotInfoLike, Interval]],
+        snapshot_intervals: t.Sequence[t.Tuple[SnapshotIdAndVersionLike, Interval]],
         remove_shared_versions: bool = False,
     ) -> None:
         intervals_to_remove: t.Sequence[
-            t.Tuple[t.Union[SnapshotInfoLike, SnapshotIntervals], Interval]
+            t.Tuple[t.Union[SnapshotIdAndVersionLike, SnapshotIntervals], Interval]
         ] = snapshot_intervals
         if remove_shared_versions:
             name_version_mapping = {s.name_version: interval for s, interval in snapshot_intervals}
@@ -215,13 +216,23 @@ class IntervalState:
             for start_ts, end_ts in snapshot.intervals:
                 new_intervals.append(
                     _interval_to_df(
-                        snapshot, start_ts, end_ts, is_dev=False, is_compacted=is_compacted
+                        snapshot,
+                        start_ts,
+                        end_ts,
+                        is_dev=False,
+                        is_compacted=is_compacted,
+                        last_altered_ts=snapshot.last_altered_ts,
                     )
                 )
             for start_ts, end_ts in snapshot.dev_intervals:
                 new_intervals.append(
                     _interval_to_df(
-                        snapshot, start_ts, end_ts, is_dev=True, is_compacted=is_compacted
+                        snapshot,
+                        start_ts,
+                        end_ts,
+                        is_dev=True,
+                        is_compacted=is_compacted,
+                        last_altered_ts=snapshot.dev_last_altered_ts,
                     )
                 )
 
@@ -236,6 +247,7 @@ class IntervalState:
                         is_dev=False,
                         is_compacted=is_compacted,
                         is_pending_restatement=True,
+                        last_altered_ts=snapshot.last_altered_ts,
                     )
                 )
 
@@ -284,6 +296,7 @@ class IntervalState:
                 is_dev,
                 is_removed,
                 is_pending_restatement,
+                last_altered_ts,
             ) in rows:
                 interval_ids.add(interval_id)
                 merge_key = (name, version, dev_version, identifier)
@@ -318,8 +331,10 @@ class IntervalState:
                 else:
                     if is_dev:
                         intervals[merge_key].add_dev_interval(start, end)
+                        intervals[merge_key].update_dev_last_altered_ts(last_altered_ts)
                     else:
                         intervals[merge_key].add_interval(start, end)
+                        intervals[merge_key].update_last_altered_ts(last_altered_ts)
                         # Remove all pending restatement intervals recorded before the current interval has been added
                         intervals[
                             pending_restatement_interval_merge_key
@@ -340,6 +355,7 @@ class IntervalState:
                 "is_dev",
                 "is_removed",
                 "is_pending_restatement",
+                "last_altered_ts",
             )
             .from_(exp.to_table(self.intervals_table).as_("intervals"))
             .order_by(
@@ -431,7 +447,9 @@ class IntervalState:
 
 
 def _intervals_to_df(
-    snapshot_intervals: t.Sequence[t.Tuple[t.Union[SnapshotInfoLike, SnapshotIntervals], Interval]],
+    snapshot_intervals: t.Sequence[
+        t.Tuple[t.Union[SnapshotIdAndVersionLike, SnapshotIntervals], Interval]
+    ],
     is_dev: bool,
     is_removed: bool,
 ) -> pd.DataFrame:
@@ -451,13 +469,14 @@ def _intervals_to_df(
 
 
 def _interval_to_df(
-    snapshot: t.Union[SnapshotInfoLike, SnapshotIntervals],
+    snapshot: t.Union[SnapshotIdAndVersionLike, SnapshotIntervals],
     start_ts: int,
     end_ts: int,
     is_dev: bool = False,
     is_removed: bool = False,
     is_compacted: bool = False,
     is_pending_restatement: bool = False,
+    last_altered_ts: t.Optional[int] = None,
 ) -> t.Dict[str, t.Any]:
     return {
         "id": random_id(),
@@ -472,4 +491,5 @@ def _interval_to_df(
         "is_removed": is_removed,
         "is_compacted": is_compacted,
         "is_pending_restatement": is_pending_restatement,
+        "last_altered_ts": last_altered_ts,
     }

sqlmesh/core/state_sync/db/migrator.py

@@ -30,7 +30,6 @@ from sqlmesh.core.state_sync.base import (
     MIN_SCHEMA_VERSION,
     MIN_SQLMESH_VERSION,
 )
-from sqlmesh.core.state_sync.base import StateSync
 from sqlmesh.core.state_sync.db.environment import EnvironmentState
 from sqlmesh.core.state_sync.db.interval import IntervalState
 from sqlmesh.core.state_sync.db.snapshot import SnapshotState
@@ -85,7 +84,7 @@ class StateMigrator:
 
     def migrate(
         self,
-        state_sync: StateSync,
+        schema: t.Optional[str],
         skip_backup: bool = False,
         promoted_snapshots_only: bool = True,
     ) -> None:
@@ -94,7 +93,7 @@ class StateMigrator:
         migration_start_ts = time.perf_counter()
 
         try:
-            migrate_rows = self._apply_migrations(state_sync, skip_backup)
+            migrate_rows = self._apply_migrations(schema, skip_backup)
 
             if not migrate_rows and major_minor(SQLMESH_VERSION) == versions.minor_sqlmesh_version:
                 return
@@ -153,7 +152,7 @@ class StateMigrator:
 
     def _apply_migrations(
         self,
-        state_sync: StateSync,
+        schema: t.Optional[str],
         skip_backup: bool,
     ) -> bool:
         versions = self.version_state.get_versions()
@@ -184,10 +183,10 @@ class StateMigrator:
 
         for migration in migrations:
             logger.info(f"Applying migration {migration}")
-            migration.migrate_schemas(state_sync)
+            migration.migrate_schemas(engine_adapter=self.engine_adapter, schema=schema)
             if state_table_exist:
                 # No need to run DML for the initial migration since all tables are empty
-                migration.migrate_rows(state_sync)
+                migration.migrate_rows(engine_adapter=self.engine_adapter, schema=schema)
 
         snapshot_count_after = self.snapshot_state.count()
 
@@ -229,6 +228,7 @@ class StateMigrator:
                 "updated_ts": updated_ts,
                 "unpaused_ts": unpaused_ts,
                 "unrestorable": unrestorable,
+                "forward_only": forward_only,
             }
             for where in (
                 snapshot_id_filter(
@@ -237,10 +237,16 @@ class StateMigrator:
                 if snapshots is not None
                 else [None]
             )
-            for name, identifier, raw_snapshot, updated_ts, unpaused_ts, unrestorable in fetchall(
+            for name, identifier, raw_snapshot, updated_ts, unpaused_ts, unrestorable, forward_only in fetchall(
                 self.engine_adapter,
                 exp.select(
-                    "name", "identifier", "snapshot", "updated_ts", "unpaused_ts", "unrestorable"
+                    "name",
+                    "identifier",
+                    "snapshot",
+                    "updated_ts",
+                    "unpaused_ts",
+                    "unrestorable",
+                    "forward_only",
                 )
                 .from_(self.snapshot_state.snapshots_table)
                 .where(where)

sqlmesh/core/state_sync/db/snapshot.py

@@ -14,7 +14,6 @@ from sqlmesh.core.state_sync.db.utils import (
     snapshot_id_filter,
     fetchone,
     fetchall,
-    create_batches,
 )
 from sqlmesh.core.environment import Environment
 from sqlmesh.core.model import SeedModel, ModelKindName
@@ -30,6 +29,12 @@ from sqlmesh.core.snapshot import (
     SnapshotId,
     SnapshotFingerprint,
 )
+from sqlmesh.core.state_sync.common import (
+    RowBoundary,
+    ExpiredSnapshotBatch,
+    ExpiredBatchRange,
+    LimitBoundary,
+)
 from sqlmesh.utils.migration import index_text_type, blob_text_type
 from sqlmesh.utils.date import now_timestamp, TimeLike, to_timestamp
 from sqlmesh.utils import unique
@@ -43,9 +48,6 @@ logger = logging.getLogger(__name__)
 
 class SnapshotState:
     SNAPSHOT_BATCH_SIZE = 1000
-    # Use a smaller batch size for expired snapshots to account for fetching
-    # of all snapshots that share the same version.
-    EXPIRED_SNAPSHOT_BATCH_SIZE = 200
 
     def __init__(
         self,
@@ -166,53 +168,62 @@ class SnapshotState:
         self,
         environments: t.Iterable[Environment],
         current_ts: int,
-        ignore_ttl: bool = False,
-    ) -> t.List[SnapshotTableCleanupTask]:
-        """Aggregates the id's of the expired snapshots and creates a list of table cleanup tasks.
-
-        Expired snapshots are snapshots that have exceeded their time-to-live
-        and are no longer in use within an environment.
-
-        Returns:
-            The set of expired snapshot ids.
-            The list of table cleanup tasks.
-        """
-        all_cleanup_targets = []
-        for _, cleanup_targets in self._get_expired_snapshots(
-            environments=environments,
-            current_ts=current_ts,
-            ignore_ttl=ignore_ttl,
-        ):
-            all_cleanup_targets.extend(cleanup_targets)
-        return all_cleanup_targets
-
-    def _get_expired_snapshots(
-        self,
-        environments: t.Iterable[Environment],
-        current_ts: int,
-        ignore_ttl: bool = False,
-    ) -> t.Iterator[t.Tuple[t.Set[SnapshotId], t.List[SnapshotTableCleanupTask]]]:
-        expired_query = exp.select("name", "identifier", "version").from_(self.snapshots_table)
+        ignore_ttl: bool,
+        batch_range: ExpiredBatchRange,
+    ) -> t.Optional[ExpiredSnapshotBatch]:
+        expired_query = exp.select("name", "identifier", "version", "updated_ts").from_(
+            self.snapshots_table
+        )
 
         if not ignore_ttl:
             expired_query = expired_query.where(
                 (exp.column("updated_ts") + exp.column("ttl_ms")) <= current_ts
             )
 
+        expired_query = expired_query.where(batch_range.where_filter)
+
+        promoted_snapshot_ids = {
+            snapshot.snapshot_id
+            for environment in environments
+            for snapshot in (
+                environment.snapshots
+                if environment.finalized_ts is not None
+                # If the environment is not finalized, check both the current snapshots and the previous finalized snapshots
+                else [*environment.snapshots, *(environment.previous_finalized_snapshots or [])]
+            )
+        }
+
+        if promoted_snapshot_ids:
+            not_in_conditions = [
+                exp.not_(condition)
+                for condition in snapshot_id_filter(
+                    self.engine_adapter,
+                    promoted_snapshot_ids,
+                    batch_size=self.SNAPSHOT_BATCH_SIZE,
+                )
+            ]
+            expired_query = expired_query.where(exp.and_(*not_in_conditions))
+
+        expired_query = expired_query.order_by(
+            exp.column("updated_ts"), exp.column("name"), exp.column("identifier")
+        )
+
+        if isinstance(batch_range.end, LimitBoundary):
+            expired_query = expired_query.limit(batch_range.end.batch_size)
+
+        rows = fetchall(self.engine_adapter, expired_query)
+
+        if not rows:
+            return None
+
         expired_candidates = {
             SnapshotId(name=name, identifier=identifier): SnapshotNameVersion(
                 name=name, version=version
             )
-            for name, identifier, version in fetchall(self.engine_adapter, expired_query)
+            for name, identifier, version, _ in rows
         }
         if not expired_candidates:
-            return
-
-        promoted_snapshot_ids = {
-            snapshot.snapshot_id
-            for environment in environments
-            for snapshot in environment.snapshots
-        }
+            return None
 
         def _is_snapshot_used(snapshot: SnapshotIdAndVersion) -> bool:
             return (
@@ -220,57 +231,73 @@ class SnapshotState:
                 or snapshot.snapshot_id not in expired_candidates
             )
 
-        unique_expired_versions = unique(expired_candidates.values())
-        version_batches = create_batches(
-            unique_expired_versions, batch_size=self.EXPIRED_SNAPSHOT_BATCH_SIZE
+        # Extract cursor values from last row for pagination
+        last_row = rows[-1]
+        last_row_boundary = RowBoundary(
+            updated_ts=last_row[3],
+            name=last_row[0],
+            identifier=last_row[1],
         )
-        for versions_batch in version_batches:
-            snapshots = self._get_snapshots_with_same_version(versions_batch)
-
-            snapshots_by_version = defaultdict(set)
-            snapshots_by_dev_version = defaultdict(set)
-            for s in snapshots:
-                snapshots_by_version[(s.name, s.version)].add(s.snapshot_id)
-                snapshots_by_dev_version[(s.name, s.dev_version)].add(s.snapshot_id)
-
-            expired_snapshots = [s for s in snapshots if not _is_snapshot_used(s)]
-            all_expired_snapshot_ids = {s.snapshot_id for s in expired_snapshots}
-
-            cleanup_targets: t.List[t.Tuple[SnapshotId, bool]] = []
-            for snapshot in expired_snapshots:
-                shared_version_snapshots = snapshots_by_version[(snapshot.name, snapshot.version)]
-                shared_version_snapshots.discard(snapshot.snapshot_id)
-
-                shared_dev_version_snapshots = snapshots_by_dev_version[
-                    (snapshot.name, snapshot.dev_version)
-                ]
-                shared_dev_version_snapshots.discard(snapshot.snapshot_id)
-
-                if not shared_dev_version_snapshots:
-                    dev_table_only = bool(shared_version_snapshots)
-                    cleanup_targets.append((snapshot.snapshot_id, dev_table_only))
-
-            snapshot_ids_to_cleanup = [snapshot_id for snapshot_id, _ in cleanup_targets]
-            for snapshot_id_batch in create_batches(
-                snapshot_ids_to_cleanup, batch_size=self.SNAPSHOT_BATCH_SIZE
-            ):
-                snapshot_id_batch_set = set(snapshot_id_batch)
-                full_snapshots = self._get_snapshots(snapshot_id_batch_set)
-                cleanup_tasks = [
+        # The returned batch_range represents the actual range of rows in this batch
+        result_batch_range = ExpiredBatchRange(
+            start=batch_range.start,
+            end=last_row_boundary,
+        )
+
+        unique_expired_versions = unique(expired_candidates.values())
+        expired_snapshot_ids: t.Set[SnapshotId] = set()
+        cleanup_tasks: t.List[SnapshotTableCleanupTask] = []
+
+        snapshots = self._get_snapshots_with_same_version(unique_expired_versions)
+
+        snapshots_by_version = defaultdict(set)
+        snapshots_by_dev_version = defaultdict(set)
+        for s in snapshots:
+            snapshots_by_version[(s.name, s.version)].add(s.snapshot_id)
+            snapshots_by_dev_version[(s.name, s.dev_version)].add(s.snapshot_id)
+
+        expired_snapshots = [s for s in snapshots if not _is_snapshot_used(s)]
+        all_expired_snapshot_ids = {s.snapshot_id for s in expired_snapshots}
+
+        cleanup_targets: t.List[t.Tuple[SnapshotId, bool]] = []
+        for snapshot in expired_snapshots:
+            shared_version_snapshots = snapshots_by_version[(snapshot.name, snapshot.version)]
+            shared_version_snapshots.discard(snapshot.snapshot_id)
+
+            shared_dev_version_snapshots = snapshots_by_dev_version[
+                (snapshot.name, snapshot.dev_version)
+            ]
+            shared_dev_version_snapshots.discard(snapshot.snapshot_id)
+
+            if not shared_dev_version_snapshots:
+                dev_table_only = bool(shared_version_snapshots)
+                cleanup_targets.append((snapshot.snapshot_id, dev_table_only))
+
+        snapshot_ids_to_cleanup = [snapshot_id for snapshot_id, _ in cleanup_targets]
+        full_snapshots = self._get_snapshots(snapshot_ids_to_cleanup)
+        for snapshot_id, dev_table_only in cleanup_targets:
+            if snapshot_id in full_snapshots:
+                cleanup_tasks.append(
                     SnapshotTableCleanupTask(
                         snapshot=full_snapshots[snapshot_id].table_info,
                         dev_table_only=dev_table_only,
                     )
-                    for snapshot_id, dev_table_only in cleanup_targets
-                    if snapshot_id in full_snapshots
-                ]
-                all_expired_snapshot_ids -= snapshot_id_batch_set
-                yield snapshot_id_batch_set, cleanup_tasks
+                )
+                expired_snapshot_ids.add(snapshot_id)
+                all_expired_snapshot_ids.discard(snapshot_id)
+
+        # Add any remaining expired snapshots that don't require cleanup
+        if all_expired_snapshot_ids:
+            expired_snapshot_ids.update(all_expired_snapshot_ids)
+
+        if expired_snapshot_ids or cleanup_tasks:
+            return ExpiredSnapshotBatch(
+                expired_snapshot_ids=expired_snapshot_ids,
+                cleanup_tasks=cleanup_tasks,
+                batch_range=result_batch_range,
+            )
 
-            if all_expired_snapshot_ids:
-                # Remaining expired snapshots for which there are no tables
-                # to cleanup
-                yield all_expired_snapshot_ids, []
+        return None
 
     def delete_snapshots(self, snapshot_ids: t.Iterable[SnapshotIdLike]) -> None:
         """Deletes snapshots.
@@ -337,6 +364,7 @@ class SnapshotState:
                 name=name,
                 identifier=identifier,
                 version=version,
+                kind_name=kind_name or None,
                 dev_version=dev_version,
                 fingerprint=fingerprint,
             )
@@ -344,9 +372,11 @@ class SnapshotState:
                 snapshot_names=snapshot_names,
                 batch_size=self.SNAPSHOT_BATCH_SIZE,
             )
-            for name, identifier, version, dev_version, fingerprint in fetchall(
+            for name, identifier, version, kind_name, dev_version, fingerprint in fetchall(
                 self.engine_adapter,
-                exp.select("name", "identifier", "version", "dev_version", "fingerprint")
+                exp.select(
+                    "name", "identifier", "version", "kind_name", "dev_version", "fingerprint"
+                )
                 .from_(self.snapshots_table)
                 .where(where)
                 .and_(unexpired_expr),
@@ -661,6 +691,7 @@ class SnapshotState:
                     "name",
                     "identifier",
                     "version",
+                    "kind_name",
                     "dev_version",
                     "fingerprint",
                 )
@@ -677,10 +708,11 @@ class SnapshotState:
                 name=name,
                 identifier=identifier,
                 version=version,
+                kind_name=kind_name or None,
                 dev_version=dev_version,
                 fingerprint=SnapshotFingerprint.parse_raw(fingerprint),
             )
-            for name, identifier, version, dev_version, fingerprint in snapshot_rows
+            for name, identifier, version, kind_name, dev_version, fingerprint in snapshot_rows
         ]
 
 

sqlmesh/core/table_diff.py

@@ -367,8 +367,8 @@ class TableDiff:
                 column_type = matched_columns[name]
                 qualified_column = exp.column(name, table)
 
-                if column_type.is_type(*exp.DataType.FLOAT_TYPES):
-                    return exp.func("ROUND", qualified_column, exp.Literal.number(self.decimals))
+                if column_type.is_type(*exp.DataType.REAL_TYPES):
+                    return self.adapter._normalize_decimal_value(qualified_column, self.decimals)
                 if column_type.is_type(*exp.DataType.NESTED_TYPES):
                     return self.adapter._normalize_nested_value(qualified_column)
 

sqlmesh/core/test/definition.py

@@ -100,8 +100,11 @@ class ModelTest(unittest.TestCase):
         self._validate_and_normalize_test()
 
         if self.engine_adapter.default_catalog:
-            self._fixture_catalog: t.Optional[exp.Identifier] = exp.parse_identifier(
-                self.engine_adapter.default_catalog, dialect=self._test_adapter_dialect
+            self._fixture_catalog: t.Optional[exp.Identifier] = normalize_identifiers(
+                exp.parse_identifier(
+                    self.engine_adapter.default_catalog, dialect=self._test_adapter_dialect
+                ),
+                dialect=self._test_adapter_dialect,
             )
         else:
             self._fixture_catalog = None
@@ -451,6 +454,9 @@ class ModelTest(unittest.TestCase):
         query = outputs.get("query")
         partial = outputs.pop("partial", None)
 
+        if ctes is None and query is None:
+            _raise_error("Incomplete test, outputs must contain 'query' or 'ctes'", self.path)
+
         def _normalize_rows(
             values: t.List[Row] | t.Dict,
             name: str,
@@ -641,16 +647,16 @@ class ModelTest(unittest.TestCase):
             return self._execute(query)
 
         rows = values["rows"]
+        columns_str: t.Optional[t.List[str]] = None
         if columns:
+            columns_str = [str(c) for c in columns]
             referenced_columns = list(dict.fromkeys(col for row in rows for col in row))
             _raise_if_unexpected_columns(columns, referenced_columns)
 
             if partial:
-                columns = referenced_columns
+                columns_str = [c for c in columns_str if c in referenced_columns]
 
-        return pd.DataFrame.from_records(
-            rows, columns=[str(c) for c in columns] if columns else None
-        )
+        return pd.DataFrame.from_records(rows, columns=columns_str)
 
     def _add_missing_columns(
         self, query: exp.Query, all_columns: t.Optional[t.Collection[str]] = None
@@ -801,7 +807,7 @@ class PythonModelTest(ModelTest):
             actual_df.reset_index(drop=True, inplace=True)
             expected = self._create_df(values, columns=self.model.columns_to_types, partial=partial)
 
-            self.assert_equal(expected, actual_df, sort=False, partial=partial)
+            self.assert_equal(expected, actual_df, sort=True, partial=partial)
 
     def _execute_model(self) -> pd.DataFrame:
         """Executes the python model and returns a DataFrame."""
@@ -919,8 +925,7 @@ def generate_test(
                 cte_output = test._execute(cte_query)
                 ctes[cte.alias] = (
                     pandas_timestamp_to_pydatetime(
-                        cte_output.apply(lambda col: col.map(_normalize_df_value)),
-                        cte_query.named_selects,
+                        df=cte_output.apply(lambda col: col.map(_normalize_df_value)),
                     )
                     .replace({np.nan: None})
                     .to_dict(orient="records")

sqlmesh/core/test/discovery.py

@@ -20,6 +20,10 @@ class ModelTestMetadata(PydanticModel):
     def fully_qualified_test_name(self) -> str:
         return f"{self.path}::{self.test_name}"
 
+    @property
+    def model_name(self) -> str:
+        return self.body.get("model", "")
+
     def __hash__(self) -> int:
         return self.fully_qualified_test_name.__hash__()
 

sqlmesh/dbt/adapter.py

@@ -115,30 +115,39 @@ class BaseAdapter(abc.ABC):
         """Returns the value quoted according to the quote policy."""
         return self.quote(value) if getattr(self.quote_policy, component_type, False) else value
 
-    def dispatch(self, name: str, package: t.Optional[str] = None) -> t.Callable:
+    def dispatch(
+        self,
+        macro_name: str,
+        macro_namespace: t.Optional[str] = None,
+    ) -> t.Callable:
         """Returns a dialect-specific version of a macro with the given name."""
         target_type = self.jinja_globals["target"]["type"]
-        macro_suffix = f"__{name}"
+        macro_suffix = f"__{macro_name}"
 
         def _relevance(package_name_pair: t.Tuple[t.Optional[str], str]) -> t.Tuple[int, int]:
             """Lower scores more relevant."""
-            macro_package, macro_name = package_name_pair
+            macro_package, name = package_name_pair
 
-            package_score = 0 if macro_package == package else 1
+            package_score = 0 if macro_package == macro_namespace else 1
             name_score = 1
 
-            if macro_name.startswith("default"):
+            if name.startswith("default"):
                 name_score = 2
-            elif macro_name.startswith(target_type):
+            elif name.startswith(target_type):
                 name_score = 0
 
             return name_score, package_score
 
         jinja_env = self.jinja_macros.build_environment(**self.jinja_globals).globals
-        packages_to_check: t.List[t.Optional[str]] = [
-            package,
-            *(k for k in jinja_env if k.startswith("dbt")),
-        ]
+
+        packages_to_check: t.List[t.Optional[str]] = [None]
+        if macro_namespace is not None:
+            if macro_namespace in jinja_env:
+                packages_to_check = [self.jinja_macros.root_package_name, macro_namespace]
+
+        # Add dbt packages as fallback
+        packages_to_check.extend(k for k in jinja_env if k.startswith("dbt"))
+
         candidates = {}
         for macro_package in packages_to_check:
             macros = jinja_env.get(macro_package, {}) if macro_package else jinja_env
@@ -156,7 +165,7 @@ class BaseAdapter(abc.ABC):
             sorted_candidates = sorted(candidates, key=_relevance)
             return candidates[sorted_candidates[0]]
 
-        raise ConfigError(f"Macro '{name}', package '{package}' was not found.")
+        raise ConfigError(f"Macro '{macro_name}', package '{macro_namespace}' was not found.")
 
     def type(self) -> str:
         return self.project_dialect or ""