sqlmesh 0.194.2.dev1__tar.gz → 0.194.2.dev3__tar.gz

{sqlmesh-0.194.2.dev1 → sqlmesh-0.194.2.dev3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlmesh
-Version: 0.194.2.dev1
+Version: 0.194.2.dev3
 Summary: Next-generation data transformation framework
 Author-email: "TobikoData Inc." <engineering@tobikodata.com>
 License:                                  Apache License

{sqlmesh-0.194.2.dev1 → sqlmesh-0.194.2.dev3}/examples/sushi/config.py

@@ -128,12 +128,17 @@ required_approvers_config = Config(
 )
 
 
-environment_suffix_config = Config(
+environment_suffix_table_config = Config(
     default_connection=DuckDBConnectionConfig(),
     model_defaults=model_defaults,
     environment_suffix_target=EnvironmentSuffixTarget.TABLE,
 )
 
+environment_suffix_catalog_config = environment_suffix_table_config.model_copy(
+    update={
+        "environment_suffix_target": EnvironmentSuffixTarget.CATALOG,
+    }
+)
 
 CATALOGS = {
     "in_memory": ":memory:",

{sqlmesh-0.194.2.dev1 → sqlmesh-0.194.2.dev3}/sqlmesh/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.194.2.dev1'
-__version_tuple__ = version_tuple = (0, 194, 2, 'dev1')
+__version__ = version = '0.194.2.dev3'
+__version_tuple__ = version_tuple = (0, 194, 2, 'dev3')

{sqlmesh-0.194.2.dev1 → sqlmesh-0.194.2.dev3}/sqlmesh/core/config/common.py

@@ -10,9 +10,22 @@ from sqlmesh.utils.pydantic import field_validator
 
 
 class EnvironmentSuffixTarget(str, Enum):
+    # Intended to create virtual environments in their own schemas, with names like "<model_schema_name>__<env name>". The view name is untouched.
+    # For example, a model named 'sqlmesh_example.full_model' created in an environment called 'dev'
+    # would have its virtual layer view created as 'sqlmesh_example__dev.full_model'
     SCHEMA = "schema"
+
+    # Intended to create virtual environments in the same schema as their production counterparts by adjusting the table name.
+    # For example, a model named 'sqlmesh_example.full_model' created in an environment called 'dev'
+    # would have its virtual layer view created as "sqlmesh_example.full_model__dev"
     TABLE = "table"
 
+    # Intended to create virtual environments in their own catalogs to preserve the schema and view name of the models
+    # For example, a model named 'sqlmesh_example.full_model' created in an environment called 'dev'
+    # with a default catalog of "warehouse" would have its virtual layer view created as "warehouse__dev.sqlmesh_example.full_model"
+    # note: this only works for engines that can query across catalogs
+    CATALOG = "catalog"
+
     @property
     def is_schema(self) -> bool:
         return self == EnvironmentSuffixTarget.SCHEMA
@@ -21,6 +34,10 @@ class EnvironmentSuffixTarget(str, Enum):
     def is_table(self) -> bool:
         return self == EnvironmentSuffixTarget.TABLE
 
+    @property
+    def is_catalog(self) -> bool:
+        return self == EnvironmentSuffixTarget.CATALOG
+
     @classproperty
     def default(cls) -> EnvironmentSuffixTarget:
         return EnvironmentSuffixTarget.SCHEMA

{sqlmesh-0.194.2.dev1 → sqlmesh-0.194.2.dev3}/sqlmesh/core/config/root.py

@@ -242,6 +242,15 @@ class Config(BaseConfig):
                 },
             )
 
+        if (
+            self.environment_suffix_target == EnvironmentSuffixTarget.CATALOG
+            and self.environment_catalog_mapping
+        ):
+            raise ConfigError(
+                f"'environment_suffix_target: catalog' is mutually exclusive with 'environment_catalog_mapping'.\n"
+                "Please specify one or the other"
+            )
+
         if self.environment_catalog_mapping:
             _normalize_identifiers("environment_catalog_mapping")
         if self.physical_schema_mapping:

{sqlmesh-0.194.2.dev1 → sqlmesh-0.194.2.dev3}/sqlmesh/core/constants.py

@@ -7,6 +7,7 @@ import typing as t
 from pathlib import Path
 
 SQLMESH = "sqlmesh"
+SQLMESH_MANAGED = "sqlmesh_managed"
 SQLMESH_PATH = Path.home() / ".sqlmesh"
 
 PROD = "prod"

{sqlmesh-0.194.2.dev1 → sqlmesh-0.194.2.dev3}/sqlmesh/core/engine_adapter/base.py

@@ -101,6 +101,7 @@ class EngineAdapter:
     SUPPORTS_VIEW_SCHEMA = True
     SUPPORTS_CLONING = False
     SUPPORTS_MANAGED_MODELS = False
+    SUPPORTS_CREATE_DROP_CATALOG = False
     SCHEMA_DIFFER = SchemaDiffer()
     SUPPORTS_TUPLE_IN = True
     HAS_VIEW_BINDING = False
@@ -1217,6 +1218,22 @@ class EngineAdapter:
             **kwargs,
         )
 
+    def create_catalog(self, catalog_name: str | exp.Identifier) -> None:
+        return self._create_catalog(exp.parse_identifier(catalog_name, dialect=self.dialect))
+
+    def _create_catalog(self, catalog_name: exp.Identifier) -> None:
+        raise SQLMeshError(
+            f"Unable to create catalog '{catalog_name.sql(dialect=self.dialect)}' as automatic catalog management is not implemented in the {self.dialect} engine."
+        )
+
+    def drop_catalog(self, catalog_name: str | exp.Identifier) -> None:
+        return self._drop_catalog(exp.parse_identifier(catalog_name, dialect=self.dialect))
+
+    def _drop_catalog(self, catalog_name: exp.Identifier) -> None:
+        raise SQLMeshError(
+            f"Unable to drop catalog '{catalog_name.sql(dialect=self.dialect)}' as automatic catalog management is not implemented in the {self.dialect} engine."
+        )
+
     def columns(
         self, table_name: TableName, include_pseudo_columns: bool = False
     ) -> t.Dict[str, exp.DataType]:

{sqlmesh-0.194.2.dev1 → sqlmesh-0.194.2.dev3}/sqlmesh/core/engine_adapter/duckdb.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import typing as t
 from sqlglot import exp
+from pathlib import Path
 
 from sqlmesh.core.engine_adapter.mixins import (
     GetCurrentCatalogFromFunctionMixin,
@@ -35,6 +36,7 @@ class DuckDBEngineAdapter(LogicalMergeMixin, GetCurrentCatalogFromFunctionMixin,
     )
     COMMENT_CREATION_TABLE = CommentCreationTable.COMMENT_COMMAND_ONLY
     COMMENT_CREATION_VIEW = CommentCreationView.COMMENT_COMMAND_ONLY
+    SUPPORTS_CREATE_DROP_CATALOG = True
 
     @property
     def catalog_support(self) -> CatalogSupport:
@@ -44,6 +46,18 @@ class DuckDBEngineAdapter(LogicalMergeMixin, GetCurrentCatalogFromFunctionMixin,
         """Sets the catalog name of the current connection."""
         self.execute(exp.Use(this=exp.to_identifier(catalog)))
 
+    def _create_catalog(self, catalog_name: exp.Identifier) -> None:
+        db_filename = f"{catalog_name.output_name}.db"
+        self.execute(
+            exp.Attach(this=exp.alias_(exp.Literal.string(db_filename), catalog_name), exists=True)
+        )
+
+    def _drop_catalog(self, catalog_name: exp.Identifier) -> None:
+        db_file_path = Path(f"{catalog_name.output_name}.db")
+        self.execute(exp.Detach(this=catalog_name, exists=True))
+        if db_file_path.exists():
+            db_file_path.unlink()
+
     def _df_to_source_queries(
         self,
         df: DF,

{sqlmesh-0.194.2.dev1 → sqlmesh-0.194.2.dev3}/sqlmesh/core/engine_adapter/shared.py

@@ -173,9 +173,16 @@ class DataObject(PydanticModel):
 
 
 class CatalogSupport(Enum):
+    # The engine has no concept of catalogs
     UNSUPPORTED = 1
+
+    # The engine has a concept of catalogs, but they are isolated from each other and cannot reference each others tables
     SINGLE_CATALOG_ONLY = 2
+
+    # The engine supports multiple catalogs but some operations require a SET CATALOG query to set the active catalog before proceeding
     REQUIRES_SET_CATALOG = 3
+
+    # The engine supports multiple catalogs and can unambiguously target a specific catalog when performing operations (without running SET CATALOG first)
     FULL_SUPPORT = 4
 
     @property

{sqlmesh-0.194.2.dev1 → sqlmesh-0.194.2.dev3}/sqlmesh/core/engine_adapter/snowflake.py

@@ -9,6 +9,7 @@ from sqlglot.helper import ensure_list
 from sqlglot.optimizer.normalize_identifiers import normalize_identifiers
 from sqlglot.optimizer.qualify_columns import quote_identifiers
 
+import sqlmesh.core.constants as c
 from sqlmesh.core.dialect import to_schema
 from sqlmesh.core.engine_adapter.mixins import (
     GetCurrentCatalogFromFunctionMixin,
@@ -43,6 +44,7 @@ if t.TYPE_CHECKING:
         "_get_data_objects": CatalogSupport.REQUIRES_SET_CATALOG,
         "create_schema": CatalogSupport.REQUIRES_SET_CATALOG,
         "drop_schema": CatalogSupport.REQUIRES_SET_CATALOG,
+        "drop_catalog": CatalogSupport.REQUIRES_SET_CATALOG,  # needs a catalog to issue a query to information_schema.databases even though the result is global
     }
 )
 class SnowflakeEngineAdapter(GetCurrentCatalogFromFunctionMixin, ClusteredByMixin, RowDiffMixin):
@@ -52,6 +54,7 @@ class SnowflakeEngineAdapter(GetCurrentCatalogFromFunctionMixin, ClusteredByMixi
     SUPPORTS_CLONING = True
     SUPPORTS_MANAGED_MODELS = True
     CURRENT_CATALOG_EXPRESSION = exp.func("current_database")
+    SUPPORTS_CREATE_DROP_CATALOG = True
     SCHEMA_DIFFER = SchemaDiffer(
         parameterized_type_defaults={
             exp.DataType.build("BINARY", dialect=DIALECT).this: [(8388608,)],
@@ -123,6 +126,36 @@ class SnowflakeEngineAdapter(GetCurrentCatalogFromFunctionMixin, ClusteredByMixi
     def catalog_support(self) -> CatalogSupport:
         return CatalogSupport.FULL_SUPPORT
 
+    def _create_catalog(self, catalog_name: exp.Identifier) -> None:
+        props = exp.Properties(
+            expressions=[exp.SchemaCommentProperty(this=exp.Literal.string(c.SQLMESH_MANAGED))]
+        )
+        self.execute(
+            exp.Create(
+                this=exp.Table(this=catalog_name), kind="DATABASE", exists=True, properties=props
+            )
+        )
+
+    def _drop_catalog(self, catalog_name: exp.Identifier) -> None:
+        # only drop the catalog if it was created by SQLMesh, which is indicated by its comment matching {c.SQLMESH_MANAGED}
+        exists_check = (
+            exp.select(exp.Literal.number(1))
+            .from_(exp.to_table("information_schema.databases"))
+            .where(
+                exp.and_(
+                    exp.column("database_name").eq(exp.Literal.string(catalog_name)),
+                    exp.column("comment").eq(exp.Literal.string(c.SQLMESH_MANAGED)),
+                )
+            )
+        )
+        normalize_identifiers(exists_check, dialect=self.dialect)
+        if self.fetchone(exists_check, quote_identifiers=True) is not None:
+            self.execute(exp.Drop(this=exp.Table(this=catalog_name), kind="DATABASE", exists=True))
+        else:
+            logger.warning(
+                f"Not dropping database {catalog_name.sql(dialect=self.dialect)} because there is no indication it is '{c.SQLMESH_MANAGED}'"
+            )
+
     def _create_table(
         self,
         table_name_or_schema: t.Union[exp.Schema, TableName],

{sqlmesh-0.194.2.dev1 → sqlmesh-0.194.2.dev3}/sqlmesh/core/environment.py

@@ -43,6 +43,10 @@ class EnvironmentNamingInfo(PydanticModel):
     normalize_name: bool = True
     gateway_managed: bool = False
 
+    @property
+    def is_dev(self) -> bool:
+        return self.name.lower() != c.PROD
+
     @field_validator("name", mode="before")
     @classmethod
     def _sanitize_name(cls, v: str) -> str:

{sqlmesh-0.194.2.dev1 → sqlmesh-0.194.2.dev3}/sqlmesh/core/snapshot/definition.py

@@ -274,13 +274,19 @@ class QualifiedViewName(PydanticModel, frozen=True):
     def catalog_for_environment(
         self, environment_naming_info: EnvironmentNamingInfo, dialect: DialectType = None
     ) -> t.Optional[str]:
-        if environment_naming_info.catalog_name_override:
+        catalog_name: t.Optional[str] = None
+        if environment_naming_info.is_dev and environment_naming_info.suffix_target.is_catalog:
+            catalog_name = f"{self.catalog}__{environment_naming_info.name}"
+        elif environment_naming_info.catalog_name_override:
             catalog_name = environment_naming_info.catalog_name_override
+
+        if catalog_name:
             return (
                 normalize_identifiers(catalog_name, dialect=dialect).name
                 if environment_naming_info.normalize_name
                 else catalog_name
             )
+
         return self.catalog
 
     def schema_for_environment(
@@ -295,10 +301,7 @@ class QualifiedViewName(PydanticModel, frozen=True):
             if normalize:
                 schema = normalize_identifiers(schema, dialect=dialect).name
 
-        if (
-            environment_naming_info.name.lower() != c.PROD
-            and environment_naming_info.suffix_target.is_schema
-        ):
+        if environment_naming_info.is_dev and environment_naming_info.suffix_target.is_schema:
             env_name = environment_naming_info.name
             if normalize:
                 env_name = normalize_identifiers(env_name, dialect=dialect).name
@@ -311,10 +314,7 @@ class QualifiedViewName(PydanticModel, frozen=True):
         self, environment_naming_info: EnvironmentNamingInfo, dialect: DialectType = None
     ) -> str:
         table = self.table
-        if (
-            environment_naming_info.name.lower() != c.PROD
-            and environment_naming_info.suffix_target.is_table
-        ):
+        if environment_naming_info.is_dev and environment_naming_info.suffix_target.is_table:
             env_name = environment_naming_info.name
             if environment_naming_info.normalize_name:
                 env_name = normalize_identifiers(env_name, dialect=dialect).name

{sqlmesh-0.194.2.dev1 → sqlmesh-0.194.2.dev3}/sqlmesh/core/snapshot/evaluator.py

@@ -251,6 +251,8 @@ class SnapshotEvaluator:
 
         # A schema can be shared across multiple engines, so we need to group by gateway
         for gateway, tables in tables_by_gateway.items():
+            if environment_naming_info.suffix_target.is_catalog:
+                self._create_catalogs(tables=tables, gateway=gateway)
             self._create_schemas(tables=tables, gateway=gateway)
 
         deployability_index = deployability_index or DeployabilityIndex.all_deployable()
@@ -1114,6 +1116,18 @@ class SnapshotEvaluator:
             blocking=blocking,
         )
 
+    def _create_catalogs(
+        self,
+        tables: t.Iterable[t.Union[exp.Table, str]],
+        gateway: t.Optional[str] = None,
+    ) -> None:
+        # attempt to create catalogs for the virtual layer if possible
+        adapter = self.get_adapter(gateway)
+        if adapter.SUPPORTS_CREATE_DROP_CATALOG:
+            unique_catalogs = {t.catalog for t in [exp.to_table(maybe_t) for maybe_t in tables]}
+            for catalog_name in unique_catalogs:
+                adapter.create_catalog(catalog_name)
+
     def _create_schemas(
         self,
         tables: t.Iterable[t.Union[exp.Table, str]],

{sqlmesh-0.194.2.dev1 → sqlmesh-0.194.2.dev3}/sqlmesh/core/state_sync/common.py

@@ -30,7 +30,9 @@ def cleanup_expired_views(
     console: t.Optional[Console] = None,
 ) -> None:
     expired_schema_environments = [
-        environment for environment in environments if environment.suffix_target.is_schema
+        environment
+        for environment in environments
+        if environment.suffix_target.is_schema or environment.suffix_target.is_catalog
     ]
     expired_table_environments = [
         environment for environment in environments if environment.suffix_target.is_table
@@ -42,8 +44,10 @@ def cleanup_expired_views(
             return engine_adapters.get(gateway, default_adapter)
         return default_adapter
 
+    catalogs_to_drop: t.Set[t.Tuple[EngineAdapter, str]] = set()
+
     # Drop the schemas for the expired environments
-    for engine_adapter, expired_catalog, expired_schema in {
+    for engine_adapter, expired_catalog, expired_schema, suffix_target in {
         (
             (engine_adapter := get_adapter(environment.gateway_managed, snapshot.model_gateway)),
             snapshot.qualified_view_name.catalog_for_environment(
@@ -52,6 +56,7 @@ def cleanup_expired_views(
             snapshot.qualified_view_name.schema_for_environment(
                 environment.naming_info, dialect=engine_adapter.dialect
             ),
+            environment.suffix_target,
         )
         for environment in expired_schema_environments
         for snapshot in environment.snapshots
@@ -64,6 +69,10 @@ def cleanup_expired_views(
                 ignore_if_not_exists=True,
                 cascade=True,
             )
+
+            if suffix_target.is_catalog and expired_catalog:
+                catalogs_to_drop.add((engine_adapter, expired_catalog))
+
             if console:
                 console.update_cleanup_progress(schema.sql(dialect=engine_adapter.dialect))
         except Exception as e:
@@ -96,6 +105,21 @@ def cleanup_expired_views(
             else:
                 raise SQLMeshError(message) from e
 
+    # Drop any catalogs that were associated with a snapshot where the engine adapter supports dropping catalogs
+    # catalogs_to_drop is only populated when environment_suffix_target is set to 'catalog'
+    for engine_adapter, catalog in catalogs_to_drop:
+        if engine_adapter.SUPPORTS_CREATE_DROP_CATALOG:
+            try:
+                engine_adapter.drop_catalog(catalog)
+                if console:
+                    console.update_cleanup_progress(catalog)
+            except Exception as e:
+                message = f"Failed to drop the expired environment catalog '{catalog}': {e}"
+                if warn_on_delete_failure:
+                    logger.warning(message)
+                else:
+                    raise SQLMeshError(message) from e
+
 
 def transactional() -> t.Callable[[t.Callable], t.Callable]:
     def decorator(func: t.Callable) -> t.Callable:

{sqlmesh-0.194.2.dev1 → sqlmesh-0.194.2.dev3}/sqlmesh.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlmesh
-Version: 0.194.2.dev1
+Version: 0.194.2.dev3
 Summary: Next-generation data transformation framework
 Author-email: "TobikoData Inc." <engineering@tobikodata.com>
 License:                                  Apache License

{sqlmesh-0.194.2.dev1 → sqlmesh-0.194.2.dev3}/tests/conftest.py

@@ -105,12 +105,25 @@ class DuckDBMetadata:
 
     @property
     def schemas(self) -> t.List[str]:
+        return self.schemas_in_catalog(self.engine_adapter.get_current_catalog() or "")
+
+    def schemas_in_catalog(self, catalog_name: str) -> t.List[str]:
         return self._get_single_col(
-            f"SELECT schema_name FROM information_schema.schemata WHERE catalog_name = '{self.engine_adapter.get_current_catalog()}' and {self._system_schema_filter('schema_name')}",
+            f"SELECT schema_name FROM information_schema.schemata WHERE catalog_name = '{catalog_name}' and {self._system_schema_filter('schema_name')}",
             "schema_name",
             self.engine_adapter,
         )
 
+    @property
+    def catalogs(self) -> t.Set[str]:
+        return set(
+            self._get_single_col(
+                f"SELECT database_name FROM duckdb_databases() WHERE internal=false",
+                "database_name",
+                self.engine_adapter,
+            )
+        )
+
     def _system_schema_filter(self, col: str) -> str:
         return f"{col} not in ('information_schema', 'pg_catalog', 'main')"
 

{sqlmesh-0.194.2.dev1 → sqlmesh-0.194.2.dev3}/tests/core/engine_adapter/integration/__init__.py

@@ -205,6 +205,9 @@ class TestContext:
         self._schemas: t.List[
             str
         ] = []  # keep track of any schemas returned from self.schema() / self.table() so we can drop them at the end
+        self._catalogs: t.List[
+            str
+        ] = []  # keep track of any catalogs created via self.create_catalog() so we can drop them at the end
 
     @property
     def test_type(self) -> str:
@@ -685,6 +688,8 @@ class TestContext:
             except Exception:
                 pass
 
+        self._catalogs.append(catalog_name)
+
     def drop_catalog(self, catalog_name: str):
         if self.dialect == "bigquery":
             return  # bigquery cannot create/drop catalogs
@@ -707,6 +712,9 @@ class TestContext:
                 schema_name=schema_name, ignore_if_not_exists=True, cascade=True
             )
 
+        for catalog_name in set(self._catalogs):
+            self.drop_catalog(catalog_name)
+
         self.engine_adapter.close()
 
     def upsert_sql_model(self, model_definition: str) -> t.Tuple[Context, SqlModel]:

{sqlmesh-0.194.2.dev1 → sqlmesh-0.194.2.dev3}/tests/core/engine_adapter/integration/test_integration_snowflake.py

@@ -181,7 +181,7 @@ def test_mutating_clustered_by_forward_only(
     assert not metadata.is_clustered
 
 
-def test_create_iceberg_table(ctx: TestContext, engine_adapter: SnowflakeEngineAdapter) -> None:
+def test_create_iceberg_table(ctx: TestContext) -> None:
     # Note: this test relies on a default Catalog and External Volume being configured in Snowflake
     # ref: https://docs.snowflake.com/en/user-guide/tables-iceberg-configure-catalog-integration#set-a-default-catalog-at-the-account-database-or-schema-level
     # ref: https://docs.snowflake.com/en/user-guide/tables-iceberg-configure-external-volume#set-a-default-external-volume-at-the-account-database-or-schema-level
@@ -271,3 +271,39 @@ def test_snowpark_concurrency(ctx: TestContext) -> None:
     query = exp.select("*").from_(table)
     df = ctx.engine_adapter.fetchdf(query, quote_identifiers=True)
     assert len(df) == 10
+
+
+def test_create_drop_catalog(ctx: TestContext, engine_adapter: SnowflakeEngineAdapter):
+    non_sqlmesh_managed_catalog = ctx.add_test_suffix("external_catalog")
+    sqlmesh_managed_catalog = ctx.add_test_suffix("env_dev")
+
+    initial_catalog = engine_adapter.get_current_catalog()
+    assert initial_catalog
+
+    ctx.create_catalog(
+        non_sqlmesh_managed_catalog
+    )  # create via TestContext so the sqlmesh_managed comment doesnt get added
+    ctx._catalogs.append(sqlmesh_managed_catalog)  # so it still gets cleaned up if the test fails
+
+    engine_adapter.create_catalog(
+        sqlmesh_managed_catalog
+    )  # create via EngineAdapter so the sqlmesh_managed comment is added
+
+    def fetch_database_names() -> t.Set[str]:
+        engine_adapter.set_current_catalog(initial_catalog)
+        return {
+            str(r[0])
+            for r in engine_adapter.fetchall(
+                f"select database_name from information_schema.databases where database_name like '%{ctx.test_id}'"
+            )
+        }
+
+    assert fetch_database_names() == {non_sqlmesh_managed_catalog, sqlmesh_managed_catalog}
+
+    engine_adapter.drop_catalog(
+        non_sqlmesh_managed_catalog
+    )  # no-op: catalog is not SQLMesh-managed
+    assert fetch_database_names() == {non_sqlmesh_managed_catalog, sqlmesh_managed_catalog}
+
+    engine_adapter.drop_catalog(sqlmesh_managed_catalog)  # works, catalog is SQLMesh-managed
+    assert fetch_database_names() == {non_sqlmesh_managed_catalog}

{sqlmesh-0.194.2.dev1 → sqlmesh-0.194.2.dev3}/tests/core/engine_adapter/test_duckdb.py

@@ -89,3 +89,17 @@ def test_temporary_table(make_mocked_engine_adapter: t.Callable, duck_conn):
     assert to_sql_calls(adapter) == [
         'CREATE TEMPORARY TABLE IF NOT EXISTS "test_table" ("a" INT, "b" INT)',
     ]
+
+
+def test_create_catalog(make_mocked_engine_adapter: t.Callable) -> None:
+    adapter: DuckDBEngineAdapter = make_mocked_engine_adapter(DuckDBEngineAdapter)
+    adapter.create_catalog(exp.to_identifier("foo"))
+
+    assert to_sql_calls(adapter) == ["ATTACH IF NOT EXISTS 'foo.db' AS \"foo\""]
+
+
+def test_drop_catalog(make_mocked_engine_adapter: t.Callable) -> None:
+    adapter: DuckDBEngineAdapter = make_mocked_engine_adapter(DuckDBEngineAdapter)
+    adapter.drop_catalog(exp.to_identifier("foo"))
+
+    assert to_sql_calls(adapter) == ['DETACH DATABASE IF EXISTS "foo"']

{sqlmesh-0.194.2.dev1 → sqlmesh-0.194.2.dev3}/tests/core/engine_adapter/test_snowflake.py

@@ -814,3 +814,22 @@ def test_create_view_with_schema_and_grants(
         # materialized view - COPY GRANTS goes before the column list
         """CREATE OR REPLACE MATERIALIZED VIEW "target_materialized_view" COPY GRANTS ("ID", "NAME") COMMENT='materialized **view** from integration test' AS SELECT 1 AS "ID", 'foo' AS "NAME\"""",
     ]
+
+
+def test_create_catalog(snowflake_mocked_engine_adapter: SnowflakeEngineAdapter) -> None:
+    adapter = snowflake_mocked_engine_adapter
+    adapter.create_catalog(exp.to_identifier("foo"))
+
+    assert to_sql_calls(adapter) == [
+        "CREATE DATABASE IF NOT EXISTS \"foo\" COMMENT='sqlmesh_managed'"
+    ]
+
+
+def test_drop_catalog(snowflake_mocked_engine_adapter: SnowflakeEngineAdapter) -> None:
+    adapter = snowflake_mocked_engine_adapter
+    adapter.drop_catalog(exp.to_identifier("foo"))
+
+    assert to_sql_calls(adapter) == [
+        """SELECT 1 FROM "INFORMATION_SCHEMA"."DATABASES" WHERE "DATABASE_NAME" = 'foo' AND "COMMENT" = 'sqlmesh_managed'""",
+        'DROP DATABASE IF EXISTS "foo"',
+    ]

{sqlmesh-0.194.2.dev1 → sqlmesh-0.194.2.dev3}/tests/core/test_config.py

@@ -16,6 +16,7 @@ from sqlmesh.core.config import (
     BigQueryConnectionConfig,
     MotherDuckConnectionConfig,
     BuiltInSchedulerConfig,
+    EnvironmentSuffixTarget,
 )
 from sqlmesh.core.config.connection import DuckDBAttachOptions, RedshiftConnectionConfig
 from sqlmesh.core.config.feature_flag import DbtFeatureFlag, FeatureFlag
@@ -1055,3 +1056,51 @@ def test_loader_for_migrated_dbt_project(tmp_path: Path):
     )
 
     assert config.loader == MigratedDbtProjectLoader
+
+
+def test_environment_suffix_target_catalog(tmp_path: Path) -> None:
+    config_path = tmp_path / "config.yaml"
+    config_path.write_text("""
+    gateways:
+      warehouse:
+        connection:
+          type: duckdb
+                           
+    default_gateway: warehouse
+
+    model_defaults:
+      dialect: duckdb
+                           
+    environment_suffix_target: catalog                          
+""")
+
+    config = load_config_from_paths(
+        Config,
+        project_paths=[config_path],
+    )
+
+    assert config.environment_suffix_target == EnvironmentSuffixTarget.CATALOG
+    assert not config.environment_catalog_mapping
+
+    config_path.write_text("""
+    gateways:
+      warehouse:
+        connection:
+          type: duckdb
+                           
+    default_gateway: warehouse
+
+    model_defaults:
+      dialect: duckdb
+                           
+    environment_suffix_target: catalog             
+
+    environment_catalog_mapping:
+      '.*': "foo"
+""")
+
+    with pytest.raises(ConfigError, match=r"mutually exclusive"):
+        config = load_config_from_paths(
+            Config,
+            project_paths=[config_path],
+        )