sqlmesh 0.209.1.dev65__tar.gz → 0.209.1.dev67__tar.gz

{sqlmesh-0.209.1.dev65 → sqlmesh-0.209.1.dev67}/PKG-INFO

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

{sqlmesh-0.209.1.dev65 → sqlmesh-0.209.1.dev67}/sqlmesh/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.209.1.dev65'
-__version_tuple__ = version_tuple = (0, 209, 1, 'dev65')
+__version__ = version = '0.209.1.dev67'
+__version_tuple__ = version_tuple = (0, 209, 1, 'dev67')
 
-__commit_id__ = commit_id = 'geb17e2447'
+__commit_id__ = commit_id = 'gf73cdfe49'

{sqlmesh-0.209.1.dev65 → sqlmesh-0.209.1.dev67}/sqlmesh/cli/main.py

@@ -450,6 +450,12 @@ def diff(ctx: click.Context, environment: t.Optional[str] = None) -> None:
     multiple=True,
     help="Allow destructive forward-only changes to models whose names match the expression.",
 )
+@click.option(
+    "--allow-additive-model",
+    type=str,
+    multiple=True,
+    help="Allow additive forward-only changes to models whose names match the expression.",
+)
 @click.option(
     "--effective-from",
     type=str,
@@ -548,6 +554,7 @@ def plan(
     restate_models = kwargs.pop("restate_model") or None
     select_models = kwargs.pop("select_model") or None
     allow_destructive_models = kwargs.pop("allow_destructive_model") or None
+    allow_additive_models = kwargs.pop("allow_additive_model") or None
     backfill_models = kwargs.pop("backfill_model") or None
     ignore_cron = kwargs.pop("ignore_cron") or None
     setattr(get_console(), "verbosity", Verbosity(verbose))
@@ -557,6 +564,7 @@ def plan(
         restate_models=restate_models,
         select_models=select_models,
         allow_destructive_models=allow_destructive_models,
+        allow_additive_models=allow_additive_models,
         backfill_models=backfill_models,
         ignore_cron=ignore_cron,
         **kwargs,

{sqlmesh-0.209.1.dev65 → sqlmesh-0.209.1.dev67}/sqlmesh/core/config/model.py

@@ -10,6 +10,8 @@ from sqlmesh.core.model.kind import (
     OnDestructiveChange,
     model_kind_validator,
     on_destructive_change_validator,
+    on_additive_change_validator,
+    OnAdditiveChange,
 )
 from sqlmesh.core.model.meta import FunctionCall
 from sqlmesh.core.node import IntervalUnit
@@ -34,6 +36,7 @@ class ModelDefaultsConfig(BaseConfig):
         storage_format: The storage format used to store the physical table, only applicable in certain engines.
             (eg. 'parquet', 'orc')
         on_destructive_change: What should happen when a forward-only model requires a destructive schema change.
+        on_additive_change: What should happen when a forward-only model requires an additive schema change.
         physical_properties: A key-value mapping of arbitrary properties that are applied to the model table / view in the physical layer.
         virtual_properties: A key-value mapping of arbitrary properties that are applied to the model view in the virtual layer.
         session_properties: A key-value mapping of properties specific to the target engine that are applied to the engine session.
@@ -56,6 +59,7 @@ class ModelDefaultsConfig(BaseConfig):
     table_format: t.Optional[str] = None
     storage_format: t.Optional[str] = None
     on_destructive_change: t.Optional[OnDestructiveChange] = None
+    on_additive_change: t.Optional[OnAdditiveChange] = None
     physical_properties: t.Optional[t.Dict[str, t.Any]] = None
     virtual_properties: t.Optional[t.Dict[str, t.Any]] = None
     session_properties: t.Optional[t.Dict[str, t.Any]] = None
@@ -71,6 +75,7 @@ class ModelDefaultsConfig(BaseConfig):
 
     _model_kind_validator = model_kind_validator
     _on_destructive_change_validator = on_destructive_change_validator
+    _on_additive_change_validator = on_additive_change_validator
 
     @field_validator("audits", mode="before")
     def _audits_validator(cls, v: t.Any) -> t.Any:

{sqlmesh-0.209.1.dev65 → sqlmesh-0.209.1.dev67}/sqlmesh/core/console.py

@@ -27,6 +27,7 @@ from rich.table import Table
 from rich.tree import Tree
 from sqlglot import exp
 
+from sqlmesh.core.schema_diff import TableAlterOperation
 from sqlmesh.core.test.result import ModelTextTestResult
 from sqlmesh.core.environment import EnvironmentNamingInfo, EnvironmentSummary
 from sqlmesh.core.linter.rule import RuleViolation
@@ -47,6 +48,7 @@ from sqlmesh.utils.errors import (
     PythonModelEvalError,
     NodeAuditsErrors,
     format_destructive_change_msg,
+    format_additive_change_msg,
 )
 from sqlmesh.utils.rich import strip_ansi_codes
 
@@ -327,13 +329,22 @@ class PlanBuilderConsole(BaseConsole, abc.ABC):
     def log_destructive_change(
         self,
         snapshot_name: str,
-        dropped_column_names: t.List[str],
-        alter_expressions: t.List[exp.Alter],
+        alter_operations: t.List[TableAlterOperation],
         dialect: str,
         error: bool = True,
     ) -> None:
         """Display a destructive change error or warning to the user."""
 
+    @abc.abstractmethod
+    def log_additive_change(
+        self,
+        snapshot_name: str,
+        alter_operations: t.List[TableAlterOperation],
+        dialect: str,
+        error: bool = True,
+    ) -> None:
+        """Display an additive change error or warning to the user."""
+
 
 class UnitTestConsole(abc.ABC):
     @abc.abstractmethod
@@ -759,8 +770,16 @@ class NoopConsole(Console):
     def log_destructive_change(
         self,
         snapshot_name: str,
-        dropped_column_names: t.List[str],
-        alter_expressions: t.List[exp.Alter],
+        alter_operations: t.List[TableAlterOperation],
+        dialect: str,
+        error: bool = True,
+    ) -> None:
+        pass
+
+    def log_additive_change(
+        self,
+        snapshot_name: str,
+        alter_operations: t.List[TableAlterOperation],
         dialect: str,
         error: bool = True,
     ) -> None:
@@ -2202,22 +2221,29 @@ class TerminalConsole(Console):
     def log_destructive_change(
         self,
         snapshot_name: str,
-        dropped_column_names: t.List[str],
-        alter_expressions: t.List[exp.Alter],
+        alter_operations: t.List[TableAlterOperation],
         dialect: str,
         error: bool = True,
     ) -> None:
         if error:
-            self._print(
-                format_destructive_change_msg(
-                    snapshot_name, dropped_column_names, alter_expressions, dialect
-                )
+            self._print(format_destructive_change_msg(snapshot_name, alter_operations, dialect))
+        else:
+            self.log_warning(
+                format_destructive_change_msg(snapshot_name, alter_operations, dialect, error)
             )
+
+    def log_additive_change(
+        self,
+        snapshot_name: str,
+        alter_operations: t.List[TableAlterOperation],
+        dialect: str,
+        error: bool = True,
+    ) -> None:
+        if error:
+            self._print(format_additive_change_msg(snapshot_name, alter_operations, dialect))
         else:
             self.log_warning(
-                format_destructive_change_msg(
-                    snapshot_name, dropped_column_names, alter_expressions, dialect, error
-                )
+                format_additive_change_msg(snapshot_name, alter_operations, dialect, error)
             )
 
     def log_error(self, message: str) -> None:

{sqlmesh-0.209.1.dev65 → sqlmesh-0.209.1.dev67}/sqlmesh/core/context.py

@@ -1279,6 +1279,7 @@ class GenericContext(BaseContext, t.Generic[C]):
         empty_backfill: t.Optional[bool] = None,
         forward_only: t.Optional[bool] = None,
         allow_destructive_models: t.Optional[t.Collection[str]] = None,
+        allow_additive_models: t.Optional[t.Collection[str]] = None,
         no_prompts: t.Optional[bool] = None,
         auto_apply: t.Optional[bool] = None,
         no_auto_categorization: t.Optional[bool] = None,
@@ -1322,6 +1323,7 @@ class GenericContext(BaseContext, t.Generic[C]):
             empty_backfill: Like skip_backfill, but also records processed intervals.
             forward_only: Whether the purpose of the plan is to make forward only changes.
             allow_destructive_models: Models whose forward-only changes are allowed to be destructive.
+            allow_additive_models: Models whose forward-only changes are allowed to be additive.
             no_prompts: Whether to disable interactive prompts for the backfill time range. Please note that
                 if this flag is set to true and there are uncategorized changes the plan creation will
                 fail. Default: False.
@@ -1360,6 +1362,7 @@ class GenericContext(BaseContext, t.Generic[C]):
             empty_backfill=empty_backfill,
             forward_only=forward_only,
             allow_destructive_models=allow_destructive_models,
+            allow_additive_models=allow_additive_models,
             no_auto_categorization=no_auto_categorization,
             effective_from=effective_from,
             include_unmodified=include_unmodified,
@@ -1411,6 +1414,7 @@ class GenericContext(BaseContext, t.Generic[C]):
         empty_backfill: t.Optional[bool] = None,
         forward_only: t.Optional[bool] = None,
         allow_destructive_models: t.Optional[t.Collection[str]] = None,
+        allow_additive_models: t.Optional[t.Collection[str]] = None,
         no_auto_categorization: t.Optional[bool] = None,
         effective_from: t.Optional[TimeLike] = None,
         include_unmodified: t.Optional[bool] = None,
@@ -1480,6 +1484,9 @@ class GenericContext(BaseContext, t.Generic[C]):
             "allow_destructive_models": list(allow_destructive_models)
             if allow_destructive_models is not None
             else None,
+            "allow_additive_models": list(allow_additive_models)
+            if allow_additive_models is not None
+            else None,
             "no_auto_categorization": no_auto_categorization,
             "effective_from": effective_from,
             "include_unmodified": include_unmodified,
@@ -1533,6 +1540,11 @@ class GenericContext(BaseContext, t.Generic[C]):
         else:
             expanded_destructive_models = None
 
+        if allow_additive_models:
+            expanded_additive_models = model_selector.expand_model_selections(allow_additive_models)
+        else:
+            expanded_additive_models = None
+
         if backfill_models:
             backfill_models = model_selector.expand_model_selections(backfill_models)
         else:
@@ -1642,6 +1654,7 @@ class GenericContext(BaseContext, t.Generic[C]):
             is_dev=is_dev,
             forward_only=forward_only,
             allow_destructive_models=expanded_destructive_models,
+            allow_additive_models=expanded_additive_models,
             environment_ttl=environment_ttl,
             environment_suffix_target=self.config.environment_suffix_target,
             environment_catalog_mapping=self.environment_catalog_mapping,

{sqlmesh-0.209.1.dev65 → sqlmesh-0.209.1.dev67}/sqlmesh/core/engine_adapter/athena.py

@@ -45,6 +45,7 @@ class AthenaEngineAdapter(PandasNativeFetchDFSupportMixin, RowDiffMixin):
     # >>> self._execute('/* test */ DESCRIBE foo')
     #     pyathena.error.OperationalError: FAILED: ParseException line 1:0 cannot recognize input near '/' '*' 'test'
     ATTACH_CORRELATION_ID = False
+    SUPPORTED_DROP_CASCADE_OBJECT_KINDS = ["DATABASE", "SCHEMA"]
 
     def __init__(
         self, *args: t.Any, s3_warehouse_location: t.Optional[str] = None, **kwargs: t.Any
@@ -314,13 +315,13 @@ class AthenaEngineAdapter(PandasNativeFetchDFSupportMixin, RowDiffMixin):
 
         return None
 
-    def drop_table(self, table_name: TableName, exists: bool = True) -> None:
+    def drop_table(self, table_name: TableName, exists: bool = True, **kwargs: t.Any) -> None:
         table = exp.to_table(table_name)
 
         if self._query_table_type(table) == "hive":
             self._truncate_table(table)
 
-        return super().drop_table(table_name=table, exists=exists)
+        return super().drop_table(table_name=table, exists=exists, **kwargs)
 
     def _truncate_table(self, table_name: TableName) -> None:
         table = exp.to_table(table_name)

{sqlmesh-0.209.1.dev65 → sqlmesh-0.209.1.dev67}/sqlmesh/core/engine_adapter/base.py

@@ -39,7 +39,7 @@ from sqlmesh.core.engine_adapter.shared import (
     set_catalog,
 )
 from sqlmesh.core.model.kind import TimeColumn
-from sqlmesh.core.schema_diff import SchemaDiffer
+from sqlmesh.core.schema_diff import SchemaDiffer, TableAlterOperation
 from sqlmesh.utils import (
     CorrelationId,
     columns_to_types_all_known,
@@ -108,6 +108,7 @@ class EngineAdapter:
     SUPPORTS_CLONING = False
     SUPPORTS_MANAGED_MODELS = False
     SUPPORTS_CREATE_DROP_CATALOG = False
+    SUPPORTED_DROP_CASCADE_OBJECT_KINDS: t.List[str] = []
     SCHEMA_DIFFER = SchemaDiffer()
     SUPPORTS_TUPLE_IN = True
     HAS_VIEW_BINDING = False
@@ -376,6 +377,13 @@ class EngineAdapter:
             target_columns_to_types = columns_to_types_from_df(t.cast(pd.DataFrame, query_or_df))
         if not source_columns and target_columns_to_types:
             source_columns = list(target_columns_to_types)
+        # source columns should only contain columns that are defined in the target. If there are extras then
+        # that means they are intended to be ignored and will be excluded
+        source_columns = (
+            [x for x in source_columns if x in target_columns_to_types]
+            if source_columns and target_columns_to_types
+            else None
+        )
         return target_columns_to_types, source_columns
 
     def recycle(self) -> None:
@@ -1037,14 +1045,14 @@ class EngineAdapter:
                 f"Can't drop data object '{data_object.to_table().sql(dialect=self.dialect)}' of type '{data_object.type.value}'"
             )
 
-    def drop_table(self, table_name: TableName, exists: bool = True) -> None:
+    def drop_table(self, table_name: TableName, exists: bool = True, **kwargs: t.Any) -> None:
         """Drops a table.
 
         Args:
             table_name: The name of the table to drop.
             exists: If exists, defaults to True.
         """
-        self._drop_object(name=table_name, exists=exists)
+        self._drop_object(name=table_name, exists=exists, **kwargs)
 
     def drop_managed_table(self, table_name: TableName, exists: bool = True) -> None:
         """Drops a managed table.
@@ -1060,6 +1068,7 @@ class EngineAdapter:
         name: TableName | SchemaName,
         exists: bool = True,
         kind: str = "TABLE",
+        cascade: bool = False,
         **drop_args: t.Any,
     ) -> None:
         """Drops an object.
@@ -1070,36 +1079,48 @@ class EngineAdapter:
             name: The name of the table to drop.
             exists: If exists, defaults to True.
             kind: What kind of object to drop. Defaults to TABLE
+            cascade: Whether or not to DROP ... CASCADE.
+                Note that this is ignored for :kind's that are not present in self.SUPPORTED_DROP_CASCADE_OBJECT_KINDS
             **drop_args: Any extra arguments to set on the Drop expression
         """
+        if cascade and kind.upper() in self.SUPPORTED_DROP_CASCADE_OBJECT_KINDS:
+            drop_args["cascade"] = cascade
+
         self.execute(exp.Drop(this=exp.to_table(name), kind=kind, exists=exists, **drop_args))
 
-    def get_alter_expressions(
+    def get_alter_operations(
         self,
         current_table_name: TableName,
         target_table_name: TableName,
         *,
         ignore_destructive: bool = False,
-    ) -> t.List[exp.Alter]:
+        ignore_additive: bool = False,
+    ) -> t.List[TableAlterOperation]:
         """
         Determines the alter statements needed to change the current table into the structure of the target table.
         """
-        return self.SCHEMA_DIFFER.compare_columns(
-            current_table_name,
-            self.columns(current_table_name),
-            self.columns(target_table_name),
-            ignore_destructive=ignore_destructive,
+        return t.cast(
+            t.List[TableAlterOperation],
+            self.SCHEMA_DIFFER.compare_columns(
+                current_table_name,
+                self.columns(current_table_name),
+                self.columns(target_table_name),
+                ignore_destructive=ignore_destructive,
+                ignore_additive=ignore_additive,
+            ),
         )
 
     def alter_table(
         self,
-        alter_expressions: t.List[exp.Alter],
+        alter_expressions: t.Union[t.List[exp.Alter], t.List[TableAlterOperation]],
     ) -> None:
         """
         Performs the alter statements to change the current table into the structure of the target table.
         """
         with self.transaction():
-            for alter_expression in alter_expressions:
+            for alter_expression in [
+                x.expression if isinstance(x, TableAlterOperation) else x for x in alter_expressions
+            ]:
                 self.execute(alter_expression)
 
     def create_view(

{sqlmesh-0.209.1.dev65 → sqlmesh-0.209.1.dev67}/sqlmesh/core/engine_adapter/base_postgres.py

@@ -24,6 +24,7 @@ class BasePostgresEngineAdapter(EngineAdapter):
     DEFAULT_BATCH_SIZE = 400
     COMMENT_CREATION_TABLE = CommentCreationTable.COMMENT_COMMAND_ONLY
     COMMENT_CREATION_VIEW = CommentCreationView.COMMENT_COMMAND_ONLY
+    SUPPORTED_DROP_CASCADE_OBJECT_KINDS = ["SCHEMA", "TABLE", "VIEW"]
 
     def columns(
         self, table_name: TableName, include_pseudo_columns: bool = False

{sqlmesh-0.209.1.dev65 → sqlmesh-0.209.1.dev67}/sqlmesh/core/engine_adapter/bigquery.py

@@ -12,6 +12,7 @@ from sqlmesh.core.engine_adapter.mixins import (
     InsertOverwriteWithMergeMixin,
     ClusteredByMixin,
     RowDiffMixin,
+    TableAlterClusterByOperation,
 )
 from sqlmesh.core.engine_adapter.shared import (
     CatalogSupport,
@@ -21,7 +22,7 @@ from sqlmesh.core.engine_adapter.shared import (
     set_catalog,
 )
 from sqlmesh.core.node import IntervalUnit
-from sqlmesh.core.schema_diff import SchemaDiffer
+from sqlmesh.core.schema_diff import SchemaDiffer, TableAlterOperation
 from sqlmesh.utils import optional_import, get_source_columns_to_types
 from sqlmesh.utils.date import to_datetime
 from sqlmesh.utils.errors import SQLMeshError
@@ -51,9 +52,6 @@ bigframes_pd = optional_import("bigframes.pandas")
 NestedField = t.Tuple[str, str, t.List[str]]
 NestedFieldsDict = t.Dict[str, t.List[NestedField]]
 
-# used to tag AST nodes to be specially handled in alter_table()
-_CLUSTERING_META_KEY = "__sqlmesh_update_table_clustering"
-
 
 @set_catalog()
 class BigQueryEngineAdapter(InsertOverwriteWithMergeMixin, ClusteredByMixin, RowDiffMixin):
@@ -68,6 +66,7 @@ class BigQueryEngineAdapter(InsertOverwriteWithMergeMixin, ClusteredByMixin, Row
     SUPPORTS_CLONING = True
     MAX_TABLE_COMMENT_LENGTH = 1024
     MAX_COLUMN_COMMENT_LENGTH = 1024
+    SUPPORTED_DROP_CASCADE_OBJECT_KINDS = ["SCHEMA"]
 
     SCHEMA_DIFFER = SchemaDiffer(
         compatible_types={
@@ -394,29 +393,31 @@ class BigQueryEngineAdapter(InsertOverwriteWithMergeMixin, ClusteredByMixin, Row
 
     def alter_table(
         self,
-        alter_expressions: t.List[exp.Alter],
+        alter_expressions: t.Union[t.List[exp.Alter], t.List[TableAlterOperation]],
     ) -> None:
         """
         Performs the alter statements to change the current table into the structure of the target table,
         and uses the API to add columns to structs, where SQL is not supported.
         """
+        if not alter_expressions:
+            return
+
+        cluster_by_operations, alter_statements = [], []
+        for e in alter_expressions:
+            if isinstance(e, TableAlterClusterByOperation):
+                cluster_by_operations.append(e)
+            elif isinstance(e, TableAlterOperation):
+                alter_statements.append(e.expression)
+            else:
+                alter_statements.append(e)
 
-        nested_fields, non_nested_expressions = self._split_alter_expressions(alter_expressions)
+        for op in cluster_by_operations:
+            self._update_clustering_key(op)
 
-        if nested_fields:
-            self._update_table_schema_nested_fields(nested_fields, alter_expressions[0].this)
+        nested_fields, non_nested_expressions = self._split_alter_expressions(alter_statements)
 
-        # this is easier than trying to detect exp.Cluster nodes
-        # or exp.Command nodes that contain the string "DROP CLUSTERING KEY"
-        clustering_change_operations = [
-            e for e in non_nested_expressions if _CLUSTERING_META_KEY in e.meta
-        ]
-        for op in clustering_change_operations:
-            non_nested_expressions.remove(op)
-            table, cluster_by = op.meta[_CLUSTERING_META_KEY]
-            assert isinstance(table, str) or isinstance(table, exp.Table)
-
-            self._update_clustering_key(table, cluster_by)
+        if nested_fields:
+            self._update_table_schema_nested_fields(nested_fields, alter_statements[0].this)
 
         if non_nested_expressions:
             super().alter_table(non_nested_expressions)
@@ -1179,35 +1180,27 @@ class BigQueryEngineAdapter(InsertOverwriteWithMergeMixin, ClusteredByMixin, Row
             for row in df.itertuples()
         ]
 
-    def _change_clustering_key_expr(
-        self, table: exp.Table, cluster_by: t.List[exp.Expression]
-    ) -> exp.Alter:
-        expr = super()._change_clustering_key_expr(table=table, cluster_by=cluster_by)
-        expr.meta[_CLUSTERING_META_KEY] = (table, cluster_by)
-        return expr
+    def _update_clustering_key(self, operation: TableAlterClusterByOperation) -> None:
+        cluster_key_expressions = getattr(operation, "cluster_key_expressions", [])
+        bq_table = self._get_table(operation.target_table)
 
-    def _drop_clustering_key_expr(self, table: exp.Table) -> exp.Alter:
-        expr = super()._drop_clustering_key_expr(table=table)
-        expr.meta[_CLUSTERING_META_KEY] = (table, None)
-        return expr
-
-    def _update_clustering_key(
-        self, table_name: TableName, cluster_by: t.Optional[t.List[exp.Expression]]
-    ) -> None:
-        cluster_by = cluster_by or []
-        bq_table = self._get_table(table_name)
-
-        rendered_columns = [c.sql(dialect=self.dialect) for c in cluster_by]
+        rendered_columns = [c.sql(dialect=self.dialect) for c in cluster_key_expressions]
         bq_table.clustering_fields = (
             rendered_columns or None
         )  # causes a drop of the key if cluster_by is empty or None
 
         self._db_call(self.client.update_table, table=bq_table, fields=["clustering_fields"])
 
-        if cluster_by:
+        if cluster_key_expressions:
             # BigQuery only applies new clustering going forward, so this rewrites the columns to apply the new clustering to historical data
             # ref: https://cloud.google.com/bigquery/docs/creating-clustered-tables#modifying-cluster-spec
-            self.execute(exp.update(table_name, {c: c for c in cluster_by}, where=exp.true()))
+            self.execute(
+                exp.update(
+                    operation.target_table,
+                    {c: c for c in cluster_key_expressions},
+                    where=exp.true(),
+                )
+            )
 
     def _normalize_decimal_value(self, col: exp.Expression, precision: int) -> exp.Expression:
         return exp.func("FORMAT", exp.Literal.string(f"%.{precision}f"), col)

{sqlmesh-0.209.1.dev65 → sqlmesh-0.209.1.dev67}/sqlmesh/core/engine_adapter/clickhouse.py

@@ -15,7 +15,7 @@ from sqlmesh.core.engine_adapter.shared import (
     CommentCreationView,
     InsertOverwriteStrategy,
 )
-from sqlmesh.core.schema_diff import SchemaDiffer
+from sqlmesh.core.schema_diff import SchemaDiffer, TableAlterOperation
 from sqlmesh.utils import get_source_columns_to_types
 
 if t.TYPE_CHECKING:
@@ -596,13 +596,15 @@ class ClickhouseEngineAdapter(EngineAdapterWithIndexSupport, LogicalMergeMixin):
 
     def alter_table(
         self,
-        alter_expressions: t.List[exp.Alter],
+        alter_expressions: t.Union[t.List[exp.Alter], t.List[TableAlterOperation]],
     ) -> None:
         """
         Performs the alter statements to change the current table into the structure of the target table.
         """
         with self.transaction():
-            for alter_expression in alter_expressions:
+            for alter_expression in [
+                x.expression if isinstance(x, TableAlterOperation) else x for x in alter_expressions
+            ]:
                 if self.engine_run_mode.is_cluster:
                     alter_expression.set(
                         "cluster", exp.OnCluster(this=exp.to_identifier(self.cluster))
@@ -614,6 +616,7 @@ class ClickhouseEngineAdapter(EngineAdapterWithIndexSupport, LogicalMergeMixin):
         name: TableName | SchemaName,
         exists: bool = True,
         kind: str = "TABLE",
+        cascade: bool = False,
         **drop_args: t.Any,
     ) -> None:
         """Drops an object.
@@ -626,7 +629,6 @@ class ClickhouseEngineAdapter(EngineAdapterWithIndexSupport, LogicalMergeMixin):
             kind: What kind of object to drop. Defaults to TABLE
             **drop_args: Any extra arguments to set on the Drop expression
         """
-        drop_args.pop("cascade", None)
         self.execute(
             exp.Drop(
                 this=exp.to_table(name),

{sqlmesh-0.209.1.dev65 → sqlmesh-0.209.1.dev67}/sqlmesh/core/engine_adapter/duckdb.py

@@ -37,6 +37,7 @@ class DuckDBEngineAdapter(LogicalMergeMixin, GetCurrentCatalogFromFunctionMixin,
     COMMENT_CREATION_TABLE = CommentCreationTable.COMMENT_COMMAND_ONLY
     COMMENT_CREATION_VIEW = CommentCreationView.COMMENT_COMMAND_ONLY
     SUPPORTS_CREATE_DROP_CATALOG = True
+    SUPPORTED_DROP_CASCADE_OBJECT_KINDS = ["SCHEMA", "TABLE", "VIEW"]
 
     @property
     def catalog_support(self) -> CatalogSupport: