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

sqlmesh/dbt/manifest.py

@@ -11,7 +11,7 @@ from collections import defaultdict
 from functools import cached_property
 from pathlib import Path
 
-from dbt import constants as dbt_constants, flags
+from dbt import flags
 
 from sqlmesh.dbt.util import DBT_VERSION
 from sqlmesh.utils.conversions import make_serializable
@@ -19,6 +19,8 @@ from sqlmesh.utils.conversions import make_serializable
 # Override the file name to prevent dbt commands from invalidating the cache.
 
 if DBT_VERSION >= (1, 6, 0):
+    from dbt import constants as dbt_constants
+
     dbt_constants.PARTIAL_PARSE_FILE_NAME = "sqlmesh_partial_parse.msgpack"  # type: ignore
 else:
     from dbt.parser import manifest as dbt_manifest  # type: ignore
@@ -47,7 +49,7 @@ from sqlmesh.core.config import ModelDefaultsConfig
 from sqlmesh.dbt.builtin import BUILTIN_FILTERS, BUILTIN_GLOBALS, OVERRIDDEN_MACROS
 from sqlmesh.dbt.common import Dependencies
 from sqlmesh.dbt.model import ModelConfig
-from sqlmesh.dbt.package import HookConfig, MacroConfig
+from sqlmesh.dbt.package import HookConfig, MacroConfig, MaterializationConfig
 from sqlmesh.dbt.seed import SeedConfig
 from sqlmesh.dbt.source import SourceConfig
 from sqlmesh.dbt.target import TargetConfig
@@ -61,6 +63,7 @@ from sqlmesh.utils.jinja import (
     extract_call_names,
     jinja_call_arg_name,
 )
+from sqlglot.helper import ensure_list
 
 if t.TYPE_CHECKING:
     from dbt.contracts.graph.manifest import Macro, Manifest
@@ -75,6 +78,7 @@ SeedConfigs = t.Dict[str, SeedConfig]
 SourceConfigs = t.Dict[str, SourceConfig]
 MacroConfigs = t.Dict[str, MacroConfig]
 HookConfigs = t.Dict[str, HookConfig]
+MaterializationConfigs = t.Dict[str, MaterializationConfig]
 
 
 IGNORED_PACKAGES = {"elementary"}
@@ -135,6 +139,7 @@ class ManifestHelper:
 
         self._on_run_start_per_package: t.Dict[str, HookConfigs] = defaultdict(dict)
         self._on_run_end_per_package: t.Dict[str, HookConfigs] = defaultdict(dict)
+        self._materializations: MaterializationConfigs = {}
 
     def tests(self, package_name: t.Optional[str] = None) -> TestConfigs:
         self._load_all()
@@ -164,6 +169,10 @@ class ManifestHelper:
         self._load_all()
         return self._on_run_end_per_package[package_name or self._project_name]
 
+    def materializations(self) -> MaterializationConfigs:
+        self._load_all()
+        return self._materializations
+
     @property
     def all_macros(self) -> t.Dict[str, t.Dict[str, MacroInfo]]:
         self._load_all()
@@ -213,6 +222,7 @@ class ManifestHelper:
         self._calls = {k: (v, False) for k, v in (self._call_cache.get("") or {}).items()}
 
         self._load_macros()
+        self._load_materializations()
         self._load_sources()
         self._load_tests()
         self._load_models_and_seeds()
@@ -250,11 +260,14 @@ class ManifestHelper:
 
     def _load_macros(self) -> None:
         for macro in self._manifest.macros.values():
+            if macro.name.startswith("materialization_"):
+                continue
+
             if macro.name.startswith("test_"):
                 macro.macro_sql = _convert_jinja_test_to_macro(macro.macro_sql)
 
             dependencies = Dependencies(macros=_macro_references(self._manifest, macro))
-            if not macro.name.startswith("materialization_") and not macro.name.startswith("test_"):
+            if not macro.name.startswith("test_"):
                 dependencies = dependencies.union(
                     self._extra_dependencies(macro.macro_sql, macro.package_name)
                 )
@@ -281,6 +294,32 @@ class ManifestHelper:
                 if pos > 0 and name[pos + 2 :] in adapter_macro_names:
                     macro_config.info.is_top_level = True
 
+    def _load_materializations(self) -> None:
+        for macro in self._manifest.macros.values():
+            if macro.name.startswith("materialization_"):
+                # Extract name and adapter ( "materialization_{name}_{adapter}" or "materialization_{name}_default")
+                name_parts = macro.name.split("_")
+                if len(name_parts) >= 3:
+                    mat_name = "_".join(name_parts[1:-1])
+                    adapter = name_parts[-1]
+
+                    dependencies = Dependencies(macros=_macro_references(self._manifest, macro))
+                    macro.macro_sql = _strip_jinja_materialization_tags(macro.macro_sql)
+                    dependencies = dependencies.union(
+                        self._extra_dependencies(macro.macro_sql, macro.package_name)
+                    )
+
+                    materialization_config = MaterializationConfig(
+                        name=mat_name,
+                        adapter=adapter,
+                        definition=macro.macro_sql,
+                        dependencies=dependencies,
+                        path=Path(macro.original_file_path),
+                    )
+
+                    key = f"{mat_name}_{adapter}"
+                    self._materializations[key] = materialization_config
+
     def _load_tests(self) -> None:
         for node in self._manifest.nodes.values():
             if node.resource_type != "test":
@@ -317,15 +356,17 @@ class ManifestHelper:
             )
 
             test_model = _test_model(node)
+            node_config = _node_base_config(node)
+            node_config["name"] = _build_test_name(node, dependencies)
 
             test = TestConfig(
                 sql=sql,
                 model_name=test_model,
                 test_kwargs=node.test_metadata.kwargs if hasattr(node, "test_metadata") else {},
                 dependencies=dependencies,
-                **_node_base_config(node),
+                **node_config,
             )
-            self._tests_per_package[node.package_name][node.name.lower()] = test
+            self._tests_per_package[node.package_name][node.unique_id] = test
             if test_model:
                 self._tests_by_owner[test_model].append(test)
 
@@ -338,10 +379,12 @@ class ManifestHelper:
                 continue
 
             macro_references = _macro_references(self._manifest, node)
-            tests = (
+            all_tests = (
                 self._tests_by_owner[node.name]
                 + self._tests_by_owner[f"{node.package_name}.{node.name}"]
             )
+            # Only include non-standalone tests (tests that don't reference other models)
+            tests = [test for test in all_tests if not test.is_standalone]
             node_config = _node_base_config(node)
 
             node_name = node.name
@@ -357,6 +400,12 @@ class ManifestHelper:
                 dependencies = dependencies.union(
                     self._extra_dependencies(sql, node.package_name, track_all_model_attrs=True)
                 )
+                for hook in [*node_config.get("pre-hook", []), *node_config.get("post-hook", [])]:
+                    dependencies = dependencies.union(
+                        self._extra_dependencies(
+                            hook["sql"], node.package_name, track_all_model_attrs=True
+                        )
+                    )
                 dependencies = dependencies.union(
                     self._flatten_dependencies_from_macros(dependencies.macros, node.package_name)
                 )
@@ -659,7 +708,7 @@ def _macro_references(
         return result
 
     for macro_node_id in node.depends_on.macros:
-        if not macro_node_id:
+        if not macro_node_id or macro_node_id == "None":
             continue
 
         macro_node = manifest.macros[macro_node_id]
@@ -697,7 +746,12 @@ def _test_model(node: ManifestNode) -> t.Optional[str]:
     attached_node = getattr(node, "attached_node", None)
     if attached_node:
         pieces = attached_node.split(".")
-        return pieces[-1] if pieces[0] in ["model", "seed"] else None
+        if pieces[0] in ["model", "seed"]:
+            # versioned models have format "model.package.model_name.v1" (4 parts)
+            if len(pieces) == 4:
+                return f"{pieces[2]}_{pieces[3]}"
+            return pieces[-1]
+        return None
 
     key_name = getattr(node, "file_key_name", None)
     if key_name:
@@ -730,3 +784,77 @@ def _convert_jinja_test_to_macro(test_jinja: str) -> str:
     macro = macro_tag + test_jinja[match.span()[-1] :]
 
     return re.sub(ENDTEST_REGEX, lambda m: m.group(0).replace("endtest", "endmacro"), macro)
+
+
+def _strip_jinja_materialization_tags(materialization_jinja: str) -> str:
+    MATERIALIZATION_TAG_REGEX = r"\s*{%-?\s*materialization\s+[^%]*%}\s*\n?"
+    ENDMATERIALIZATION_REGEX = r"{%-?\s*endmaterialization\s*-?%}\s*\n?"
+
+    if not re.match(MATERIALIZATION_TAG_REGEX, materialization_jinja):
+        return materialization_jinja
+
+    materialization_jinja = re.sub(
+        MATERIALIZATION_TAG_REGEX,
+        "",
+        materialization_jinja,
+        flags=re.IGNORECASE,
+    )
+
+    materialization_jinja = re.sub(
+        ENDMATERIALIZATION_REGEX,
+        "",
+        materialization_jinja,
+        flags=re.IGNORECASE,
+    )
+
+    return materialization_jinja.strip()
+
+
+def _build_test_name(node: ManifestNode, dependencies: Dependencies) -> str:
+    """
+    Build a user-friendly test name that includes the test's model/source, column,
+    and args for tests with custom user names. Needed because dbt only generates these
+    names for tests that do not specify the "name" field in their YAML definition.
+
+    Name structure
+    - Model test:  [namespace]_[test name]_[model name]_[column name]__[arg values]
+    - Source test: [namespace]_source_[test name]_[source name]_[table name]_[column name]__[arg values]
+    """
+    # standalone test
+    if not hasattr(node, "test_metadata"):
+        return node.name
+
+    model_name = _test_model(node)
+    source_name = None
+    if not model_name and dependencies.sources:
+        # extract source and table names
+        source_parts = list(dependencies.sources)[0].split(".")
+        source_name = "_".join(source_parts) if len(source_parts) == 2 else source_parts[-1]
+    entity_name = model_name or source_name or ""
+    entity_name = f"_{entity_name}" if entity_name else ""
+
+    name_prefix = ""
+    if namespace := getattr(node.test_metadata, "namespace", None):
+        name_prefix += f"{namespace}_"
+    if source_name and not model_name:
+        name_prefix += "source_"
+
+    metadata_kwargs = node.test_metadata.kwargs
+    arg_val_parts = []
+    for arg, val in sorted(metadata_kwargs.items()):
+        if arg == "model":
+            continue
+        if isinstance(val, dict):
+            val = list(val.values())
+        val = [re.sub("[^0-9a-zA-Z_]+", "_", str(v)) for v in ensure_list(val)]
+        arg_val_parts.extend(val)
+    unique_args = "__".join(arg_val_parts) if arg_val_parts else ""
+    unique_args = f"_{unique_args}" if unique_args else ""
+
+    auto_name = f"{name_prefix}{node.test_metadata.name}{entity_name}{unique_args}"
+
+    if node.name == auto_name:
+        return node.name
+
+    custom_prefix = name_prefix if source_name and not model_name else ""
+    return f"{custom_prefix}{node.name}{entity_name}{unique_args}"

sqlmesh/dbt/model.py

@@ -31,6 +31,7 @@ from sqlmesh.core.model.kind import (
     OnAdditiveChange,
     on_destructive_change_validator,
     on_additive_change_validator,
+    DbtCustomKind,
 )
 from sqlmesh.dbt.basemodel import BaseModelConfig, Materialization, SnapshotStrategy
 from sqlmesh.dbt.common import SqlStr, sql_str_validator
@@ -40,6 +41,7 @@ from sqlmesh.utils.pydantic import field_validator
 if t.TYPE_CHECKING:
     from sqlmesh.core.audit.definition import ModelAudit
     from sqlmesh.dbt.context import DbtContext
+    from sqlmesh.dbt.package import MaterializationConfig
 
 logger = logging.getLogger(__name__)
 
@@ -170,6 +172,22 @@ class ModelConfig(BaseModelConfig):
             return "*"
         return ensure_list(v)
 
+    @field_validator("updated_at", mode="before")
+    @classmethod
+    def _validate_updated_at(cls, v: t.Optional[str]) -> t.Optional[str]:
+        """
+        Extract column name if updated_at contains a cast.
+
+        SCDType2ByTimeKind and SCDType2ByColumnKind expect a column, and the casting is done later.
+        """
+        if v is None:
+            return None
+        parsed = d.parse_one(v)
+        if isinstance(parsed, exp.Cast) and isinstance(parsed.this, exp.Column):
+            return parsed.this.name
+
+        return v
+
     @field_validator("sql", mode="before")
     @classmethod
     def _validate_sql(cls, v: t.Union[str, SqlStr]) -> SqlStr:
@@ -197,6 +215,14 @@ class ModelConfig(BaseModelConfig):
             ):
                 granularity = v["granularity"]
                 raise ConfigError(f"Unexpected granularity '{granularity}' in partition_by '{v}'.")
+            if "data_type" in v and v["data_type"].lower() not in (
+                "timestamp",
+                "date",
+                "datetime",
+                "int64",
+            ):
+                data_type = v["data_type"]
+                raise ConfigError(f"Unexpected data_type '{data_type}' in partition_by '{v}'.")
             return {"data_type": "date", "granularity": "day", **v}
         raise ConfigError(f"Invalid format for partition_by '{v}'")
 
@@ -444,6 +470,19 @@ class ModelConfig(BaseModelConfig):
         if materialization == Materialization.DYNAMIC_TABLE:
             return ManagedKind()
 
+        if materialization == Materialization.CUSTOM:
+            if custom_materialization := self._get_custom_materialization(context):
+                return DbtCustomKind(
+                    materialization=self.materialized,
+                    adapter=custom_materialization.adapter,
+                    dialect=self.dialect(context),
+                    definition=custom_materialization.definition,
+                )
+
+            raise ConfigError(
+                f"Unknown materialization '{self.materialized}'. Custom materializations must be defined in your dbt project."
+            )
+
         raise ConfigError(f"{materialization.value} materialization not supported.")
 
     def _big_query_partition_by_expr(self, context: DbtContext) -> exp.Expression:
@@ -483,6 +522,18 @@ class ModelConfig(BaseModelConfig):
             dialect="bigquery",
         )
 
+    def _get_custom_materialization(self, context: DbtContext) -> t.Optional[MaterializationConfig]:
+        materializations = context.manifest.materializations()
+        name, target_adapter = self.materialized, context.target.dialect
+
+        adapter_specific_key = f"{name}_{target_adapter}"
+        default_key = f"{name}_default"
+        if adapter_specific_key in materializations:
+            return materializations[adapter_specific_key]
+        if default_key in materializations:
+            return materializations[default_key]
+        return None
+
     @property
     def sqlmesh_config_fields(self) -> t.Set[str]:
         return super().sqlmesh_config_fields | {
@@ -510,39 +561,59 @@ class ModelConfig(BaseModelConfig):
         physical_properties: t.Dict[str, t.Any] = {}
 
         if self.partition_by:
-            partitioned_by = []
-            if isinstance(self.partition_by, list):
-                for p in self.partition_by:
-                    try:
-                        partitioned_by.append(d.parse_one(p, dialect=model_dialect))
-                    except SqlglotError as e:
-                        raise ConfigError(
-                            f"Failed to parse model '{self.canonical_name(context)}' partition_by field '{p}' in '{self.path}': {e}"
-                        ) from e
-            elif isinstance(self.partition_by, dict):
-                if context.target.dialect == "bigquery":
-                    partitioned_by.append(self._big_query_partition_by_expr(context))
-                else:
-                    logger.warning(
-                        "Ignoring partition_by config for model '%s' targeting %s. The format of the config field is only supported for BigQuery.",
-                        self.name,
-                        context.target.dialect,
-                    )
+            if isinstance(kind, (ViewKind, EmbeddedKind)):
+                logger.warning(
+                    "Ignoring partition_by config for model '%s'; partition_by is not supported for %s.",
+                    self.name,
+                    "views" if isinstance(kind, ViewKind) else "ephemeral models",
+                )
+            elif context.target.dialect == "snowflake":
+                logger.warning(
+                    "Ignoring partition_by config for model '%s' targeting %s. The partition_by config is not supported for Snowflake.",
+                    self.name,
+                    context.target.dialect,
+                )
+            else:
+                partitioned_by = []
+                if isinstance(self.partition_by, list):
+                    for p in self.partition_by:
+                        try:
+                            partitioned_by.append(d.parse_one(p, dialect=model_dialect))
+                        except SqlglotError as e:
+                            raise ConfigError(
+                                f"Failed to parse model '{self.canonical_name(context)}' partition_by field '{p}' in '{self.path}': {e}"
+                            ) from e
+                elif isinstance(self.partition_by, dict):
+                    if context.target.dialect == "bigquery":
+                        partitioned_by.append(self._big_query_partition_by_expr(context))
+                    else:
+                        logger.warning(
+                            "Ignoring partition_by config for model '%s' targeting %s. The format of the config field is only supported for BigQuery.",
+                            self.name,
+                            context.target.dialect,
+                        )
 
-            if partitioned_by:
-                optional_kwargs["partitioned_by"] = partitioned_by
+                if partitioned_by:
+                    optional_kwargs["partitioned_by"] = partitioned_by
 
         if self.cluster_by:
-            if isinstance(kind, ViewKind):
+            if isinstance(kind, (ViewKind, EmbeddedKind)):
                 logger.warning(
-                    "Ignoring cluster_by config for model '%s'; cluster_by is not supported for views.",
+                    "Ignoring cluster_by config for model '%s'; cluster_by is not supported for %s.",
                     self.name,
+                    "views" if isinstance(kind, ViewKind) else "ephemeral models",
                 )
             else:
                 clustered_by = []
                 for c in self.cluster_by:
                     try:
-                        clustered_by.append(d.parse_one(c, dialect=model_dialect))
+                        cluster_expr = exp.maybe_parse(
+                            c, into=exp.Cluster, prefix="CLUSTER BY", dialect=model_dialect
+                        )
+                        for expr in cluster_expr.expressions:
+                            clustered_by.append(
+                                expr.this if isinstance(expr, exp.Ordered) else expr
+                            )
                     except SqlglotError as e:
                         raise ConfigError(
                             f"Failed to parse model '{self.canonical_name(context)}' cluster_by field '{c}' in '{self.path}': {e}"
@@ -644,11 +715,20 @@ class ModelConfig(BaseModelConfig):
             if physical_properties:
                 model_kwargs["physical_properties"] = physical_properties
 
+        kind = self.model_kind(context)
+
+        # A falsy grants config (None or {}) is considered as unmanaged per dbt semantics
+        if self.grants and kind.supports_grants:
+            model_kwargs["grants"] = self.grants
+
         allow_partials = model_kwargs.pop("allow_partials", None)
         if allow_partials is None:
             # Set allow_partials to True for dbt models to preserve the original semantics.
             allow_partials = True
 
+        # pop begin for all models so we don't pass it through for non-incremental materializations
+        # (happens if model config is microbatch but project config overrides)
+        begin = model_kwargs.pop("begin", None)
         if kind.is_incremental:
             if self.batch_size and isinstance(self.batch_size, str):
                 if "interval_unit" in model_kwargs:
@@ -658,7 +738,7 @@ class ModelConfig(BaseModelConfig):
                 else:
                     model_kwargs["interval_unit"] = self.batch_size
                     self.batch_size = None
-            if begin := model_kwargs.pop("begin", None):
+            if begin:
                 if "start" in model_kwargs:
                     get_console().log_warning(
                         f"Both 'begin' and 'start' are set for model '{self.canonical_name(context)}'. 'start' will be used."
@@ -687,7 +767,7 @@ class ModelConfig(BaseModelConfig):
             extract_dependencies_from_query=False,
             allow_partials=allow_partials,
             virtual_environment_mode=virtual_environment_mode,
-            dbt_name=self.node_name,
+            dbt_node_info=self.node_info,
             **optional_kwargs,
             **model_kwargs,
         )

sqlmesh/dbt/package.py

@@ -37,6 +37,16 @@ class HookConfig(PydanticModel):
     dependencies: Dependencies
 
 
+class MaterializationConfig(PydanticModel):
+    """Class to contain custom materialization configuration."""
+
+    name: str
+    adapter: str
+    definition: str
+    dependencies: Dependencies
+    path: Path
+
+
 class Package(PydanticModel):
     """Class to contain package configuration"""
 
@@ -47,6 +57,7 @@ class Package(PydanticModel):
     models: t.Dict[str, ModelConfig]
     variables: t.Dict[str, t.Any]
     macros: t.Dict[str, MacroConfig]
+    materializations: t.Dict[str, MaterializationConfig]
     on_run_start: t.Dict[str, HookConfig]
     on_run_end: t.Dict[str, HookConfig]
     files: t.Set[Path]
@@ -94,6 +105,7 @@ class PackageLoader:
         models = _fix_paths(self._context.manifest.models(package_name), package_root)
         seeds = _fix_paths(self._context.manifest.seeds(package_name), package_root)
         macros = _fix_paths(self._context.manifest.macros(package_name), package_root)
+        materializations = _fix_paths(self._context.manifest.materializations(), package_root)
         on_run_start = _fix_paths(self._context.manifest.on_run_start(package_name), package_root)
         on_run_end = _fix_paths(self._context.manifest.on_run_end(package_name), package_root)
         sources = self._context.manifest.sources(package_name)
@@ -114,13 +126,16 @@ class PackageLoader:
             seeds=seeds,
             variables=package_variables,
             macros=macros,
+            materializations=materializations,
             files=config_paths,
             on_run_start=on_run_start,
             on_run_end=on_run_end,
         )
 
 
-T = t.TypeVar("T", TestConfig, ModelConfig, MacroConfig, SeedConfig, HookConfig)
+T = t.TypeVar(
+    "T", TestConfig, ModelConfig, MacroConfig, MaterializationConfig, SeedConfig, HookConfig
+)
 
 
 def _fix_paths(configs: t.Dict[str, T], package_root: Path) -> t.Dict[str, T]:

sqlmesh/dbt/profile.py

@@ -60,7 +60,7 @@ class Profile:
             if not context.profile_name:
                 raise ConfigError(f"{project_file.stem} must include project name.")
 
-        profile_filepath = cls._find_profile(context.project_root)
+        profile_filepath = cls._find_profile(context.project_root, context.profiles_dir)
         if not profile_filepath:
             raise ConfigError(f"{cls.PROFILE_FILE} not found.")
 
@@ -68,8 +68,8 @@ class Profile:
         return Profile(profile_filepath, target_name, target)
 
     @classmethod
-    def _find_profile(cls, project_root: Path) -> t.Optional[Path]:
-        dir = os.environ.get("DBT_PROFILES_DIR", "")
+    def _find_profile(cls, project_root: Path, profiles_dir: t.Optional[Path]) -> t.Optional[Path]:
+        dir = os.environ.get("DBT_PROFILES_DIR", profiles_dir or "")
         path = Path(project_root, dir, cls.PROFILE_FILE)
         if path.exists():
             return path

sqlmesh/dbt/project.py

@@ -99,16 +99,21 @@ class Project:
             package = package_loader.load(path.parent)
             packages[package.name] = package
 
+        # Variable resolution precedence:
+        # 1. Variable overrides
+        # 2. Package-scoped variables in the root project's dbt_project.yml
+        # 3. Global project variables in the root project's dbt_project.yml
+        # 4. Variables in the package's dbt_project.yml
         all_project_variables = {**(project_yaml.get("vars") or {}), **(variable_overrides or {})}
         for name, package in packages.items():
-            package_vars = all_project_variables.get(name)
-
-            if isinstance(package_vars, dict):
-                package.variables.update(package_vars)
-
-            if name == context.project_name:
-                package.variables.update(all_project_variables)
+            if isinstance(all_project_variables.get(name), dict):
+                project_vars_copy = all_project_variables.copy()
+                package_scoped_vars = project_vars_copy.pop(name)
+                package.variables.update(project_vars_copy)
+                package.variables.update(package_scoped_vars)
             else:
+                package.variables.update(all_project_variables)
+            if variable_overrides:
                 package.variables.update(variable_overrides)
 
         return Project(context, profile, packages)

sqlmesh/dbt/seed.py

@@ -92,7 +92,7 @@ class SeedConfig(BaseModelConfig):
             audit_definitions=audit_definitions,
             virtual_environment_mode=virtual_environment_mode,
             start=self.start or context.sqlmesh_config.model_defaults.start,
-            dbt_name=self.node_name,
+            dbt_node_info=self.node_info,
             **kwargs,
         )
 

sqlmesh/dbt/source.py

@@ -36,6 +36,7 @@ class SourceConfig(GeneralConfig):
     # DBT configuration fields
     name: str = ""
     source_name_: str = Field("", alias="source_name")
+    fqn_: t.List[str] = Field(default_factory=list, alias="fqn")
     database: t.Optional[str] = None
     schema_: t.Optional[str] = Field(None, alias="schema")
     identifier: t.Optional[str] = None
@@ -64,6 +65,10 @@ class SourceConfig(GeneralConfig):
     def config_name(self) -> str:
         return f"{self.source_name_}.{self.name}"
 
+    @property
+    def fqn(self) -> str:
+        return ".".join(self.fqn_)
+
     def canonical_name(self, context: DbtContext) -> str:
         if self._canonical_name is None:
             source = context.get_callable_macro("source")
@@ -74,7 +79,7 @@ class SourceConfig(GeneralConfig):
                 relation = source(self.source_name_, self.name)
             except Exception as e:
                 raise ConfigError(
-                    f"'source' macro failed for '{self.config_name}' with exeception '{e}'."
+                    f"'source' macro failed for '{self.config_name}' with exception '{e}'."
                 )
 
             relation = relation.quote(

sqlmesh/dbt/target.py

@@ -45,10 +45,24 @@ IncrementalKind = t.Union[
 
 # We only serialize a subset of fields in order to avoid persisting sensitive information
 SERIALIZABLE_FIELDS = {
-    "type",
+    # core
     "name",
-    "database",
     "schema_",
+    "type",
+    "threads",
+    # snowflake
+    "database",
+    "warehouse",
+    "user",
+    "role",
+    "account",
+    # postgres/redshift
+    "dbname",
+    "host",
+    "port",
+    # bigquery
+    "project",
+    "dataset",
 }
 
 SCHEMA_DIFFER_OVERRIDES = {
@@ -587,12 +601,17 @@ class BigQueryConfig(TargetConfig):
         if not isinstance(data, dict):
             return data
 
-        data["schema"] = data.get("schema") or data.get("dataset")
-        if not data["schema"]:
+        # dbt treats schema and dataset interchangeably
+        schema = data.get("schema") or data.get("dataset")
+        if not schema:
             raise ConfigError("Either schema or dataset must be set")
-        data["database"] = data.get("database") or data.get("project")
-        if not data["database"]:
+        data["dataset"] = data["schema"] = schema
+
+        # dbt treats database and project interchangeably
+        database = data.get("database") or data.get("project")
+        if not database:
             raise ConfigError("Either database or project must be set")
+        data["database"] = data["project"] = database
 
         return data