sqlmesh 0.194.2.dev2__tar.gz → 0.194.2.dev4__tar.gz

{sqlmesh-0.194.2.dev2 → sqlmesh-0.194.2.dev4}/PKG-INFO

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

{sqlmesh-0.194.2.dev2 → sqlmesh-0.194.2.dev4}/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.dev2 → sqlmesh-0.194.2.dev4}/examples/sushi/models/customers.sql

@@ -37,8 +37,9 @@ LEFT JOIN (
       @ADD_ONE(1) AS another_column,
     FROM current_marketing_outer
   )
-  SELECT * FROM current_marketing
+  SELECT current_marketing.* FROM current_marketing WHERE current_marketing.customer_id != 100
 ) AS m
   ON o.customer_id = m.customer_id
 LEFT JOIN raw.demographics AS d
   ON o.customer_id = d.customer_id
+WHERE sushi.orders.customer_id > 0

{sqlmesh-0.194.2.dev2 → sqlmesh-0.194.2.dev4}/sqlmesh/_version.py

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

{sqlmesh-0.194.2.dev2 → sqlmesh-0.194.2.dev4}/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.dev2 → sqlmesh-0.194.2.dev4}/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.dev2 → sqlmesh-0.194.2.dev4}/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.dev2 → sqlmesh-0.194.2.dev4}/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.dev2 → sqlmesh-0.194.2.dev4}/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.dev2 → sqlmesh-0.194.2.dev4}/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.dev2 → sqlmesh-0.194.2.dev4}/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.dev2 → sqlmesh-0.194.2.dev4}/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.dev2 → sqlmesh-0.194.2.dev4}/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.dev2 → sqlmesh-0.194.2.dev4}/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.dev2 → sqlmesh-0.194.2.dev4}/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.dev2 → sqlmesh-0.194.2.dev4}/sqlmesh/lsp/reference.py

@@ -208,6 +208,17 @@ def get_model_definitions_for_a_path(
                                     target_range=target_range,
                                 )
                             )
+
+                            column_references = _process_column_references(
+                                scope=scope,
+                                reference_name=table.name,
+                                read_file=read_file,
+                                referenced_model_uri=document_uri,
+                                description="",
+                                reference_type="cte",
+                                cte_target_range=target_range,
+                            )
+                            references.extend(column_references)
                     continue
 
                 # For non-CTE tables, process as before (external model references)
@@ -276,6 +287,19 @@ def get_model_definitions_for_a_path(
                             target_range=yaml_target_range,
                         )
                     )
+
+                    column_references = _process_column_references(
+                        scope=scope,
+                        reference_name=normalized_reference_name,
+                        read_file=read_file,
+                        referenced_model_uri=referenced_model_uri,
+                        description=description,
+                        yaml_target_range=yaml_target_range,
+                        reference_type="external_model",
+                        default_catalog=lint_context.context.default_catalog,
+                        dialect=dialect,
+                    )
+                    references.extend(column_references)
                 else:
                     references.append(
                         LSPModelReference(
@@ -288,6 +312,18 @@ def get_model_definitions_for_a_path(
                         )
                     )
 
+                    column_references = _process_column_references(
+                        scope=scope,
+                        reference_name=normalized_reference_name,
+                        read_file=read_file,
+                        referenced_model_uri=referenced_model_uri,
+                        description=description,
+                        reference_type="model",
+                        default_catalog=lint_context.context.default_catalog,
+                        dialect=dialect,
+                    )
+                    references.extend(column_references)
+
     return references
 
 
@@ -735,6 +771,104 @@ def _position_within_range(position: Position, range: Range) -> bool:
     )
 
 
+def _get_column_table_range(column: exp.Column, read_file: t.List[str]) -> Range:
+    """
+    Get the range for a column's table reference, handling both simple and qualified table names.
+
+    Args:
+        column: The column expression
+        read_file: The file content as list of lines
+
+    Returns:
+        The Range covering the table reference in the column
+    """
+
+    table_parts = column.parts[:-1]
+
+    start_range = TokenPositionDetails.from_meta(table_parts[0].meta).to_range(read_file)
+    end_range = TokenPositionDetails.from_meta(table_parts[-1].meta).to_range(read_file)
+
+    return Range(
+        start=to_lsp_position(start_range.start),
+        end=to_lsp_position(end_range.end),
+    )
+
+
+def _process_column_references(
+    scope: t.Any,
+    reference_name: str,
+    read_file: t.List[str],
+    referenced_model_uri: URI,
+    description: t.Optional[str] = None,
+    yaml_target_range: t.Optional[Range] = None,
+    reference_type: t.Literal["model", "external_model", "cte"] = "model",
+    default_catalog: t.Optional[str] = None,
+    dialect: t.Optional[str] = None,
+    cte_target_range: t.Optional[Range] = None,
+) -> t.List[Reference]:
+    """
+    Process column references for a given table and create appropriate reference objects.
+
+    Args:
+        scope: The SQL scope to search for columns
+        reference_name: The full reference name (may include database/catalog)
+        read_file: The file content as list of lines
+        referenced_model_uri: URI of the referenced model
+        description: Markdown description for the reference
+        yaml_target_range: Target range for external models (YAML files)
+        reference_type: Type of reference - "model", "external_model", or "cte"
+        default_catalog: Default catalog for normalization
+        dialect: SQL dialect for normalization
+        cte_target_range: Target range for CTE references
+
+    Returns:
+        List of table references for column usages
+    """
+
+    references: t.List[Reference] = []
+    for column in scope.find_all(exp.Column):
+        if column.table:
+            if reference_type == "cte":
+                if column.table == reference_name:
+                    table_range = _get_column_table_range(column, read_file)
+                    references.append(
+                        LSPCteReference(
+                            uri=referenced_model_uri.value,
+                            range=table_range,
+                            target_range=cte_target_range,
+                        )
+                    )
+            else:
+                table_parts = [part.sql(dialect) for part in column.parts[:-1]]
+                table_ref = ".".join(table_parts)
+                normalized_reference_name = normalize_model_name(
+                    table_ref,
+                    default_catalog=default_catalog,
+                    dialect=dialect,
+                )
+                if normalized_reference_name == reference_name:
+                    table_range = _get_column_table_range(column, read_file)
+                    if reference_type == "external_model":
+                        references.append(
+                            LSPExternalModelReference(
+                                uri=referenced_model_uri.value,
+                                range=table_range,
+                                markdown_description=description,
+                                target_range=yaml_target_range,
+                            )
+                        )
+                    else:
+                        references.append(
+                            LSPModelReference(
+                                uri=referenced_model_uri.value,
+                                range=table_range,
+                                markdown_description=description,
+                            )
+                        )
+
+    return references
+
+
 def _get_yaml_model_range(path: Path, model_name: str) -> t.Optional[Range]:
     """
     Find the range of a specific model block in a YAML file.

{sqlmesh-0.194.2.dev2 → sqlmesh-0.194.2.dev4}/sqlmesh.egg-info/PKG-INFO

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

{sqlmesh-0.194.2.dev2 → sqlmesh-0.194.2.dev4}/sqlmesh.egg-info/SOURCES.txt

@@ -691,6 +691,7 @@ tests/lsp/test_reference_external_model.py
 tests/lsp/test_reference_macro.py
 tests/lsp/test_reference_macro_find_all.py
 tests/lsp/test_reference_macro_multi.py
+tests/lsp/test_reference_model_column_prefix.py
 tests/lsp/test_reference_model_find_all.py
 tests/schedulers/__init__.py
 tests/utils/__init__.py

{sqlmesh-0.194.2.dev2 → sqlmesh-0.194.2.dev4}/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.dev2 → sqlmesh-0.194.2.dev4}/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]: