sqlmesh 0.209.1.dev65__py3-none-any.whl → 0.209.1.dev66__py3-none-any.whl

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.dev66'
+__version_tuple__ = version_tuple = (0, 209, 1, 'dev66')
 
 __commit_id__ = commit_id = None

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/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/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/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/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,
@@ -376,6 +376,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:
@@ -1074,32 +1081,39 @@ class EngineAdapter:
         """
         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/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):
@@ -394,29 +392,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 +1179,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/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))

sqlmesh/core/engine_adapter/mixins.py

@@ -1,7 +1,9 @@
 from __future__ import annotations
 
+import abc
 import logging
 import typing as t
+from dataclasses import dataclass
 
 from sqlglot import exp, parse_one
 from sqlglot.helper import seq_get
@@ -10,6 +12,7 @@ from sqlmesh.core.engine_adapter.base import EngineAdapter
 from sqlmesh.core.engine_adapter.shared import InsertOverwriteStrategy, SourceQuery
 from sqlmesh.core.node import IntervalUnit
 from sqlmesh.core.dialect import schema_
+from sqlmesh.core.schema_diff import TableAlterOperation
 from sqlmesh.utils.errors import SQLMeshError
 
 if t.TYPE_CHECKING:
@@ -340,35 +343,74 @@ class VarcharSizeWorkaroundMixin(EngineAdapter):
         return statement
 
 
-class ClusteredByMixin(EngineAdapter):
-    def _build_clustered_by_exp(
-        self,
-        clustered_by: t.List[exp.Expression],
-        **kwargs: t.Any,
-    ) -> t.Optional[exp.Cluster]:
-        return exp.Cluster(expressions=[c.copy() for c in clustered_by])
+@dataclass(frozen=True)
+class TableAlterClusterByOperation(TableAlterOperation, abc.ABC):
+    pass
+
 
-    def _parse_clustering_key(self, clustering_key: t.Optional[str]) -> t.List[exp.Expression]:
-        if not clustering_key:
-            return []
+@dataclass(frozen=True)
+class TableAlterChangeClusterKeyOperation(TableAlterClusterByOperation):
+    clustering_key: str
+    dialect: str
 
+    @property
+    def is_additive(self) -> bool:
+        return False
+
+    @property
+    def is_destructive(self) -> bool:
+        return False
+
+    @property
+    def _alter_actions(self) -> t.List[exp.Expression]:
+        return [exp.Cluster(expressions=self.cluster_key_expressions)]
+
+    @property
+    def cluster_key_expressions(self) -> t.List[exp.Expression]:
         # Note: Assumes `clustering_key` as a string like:
         # - "(col_a)"
         # - "(col_a, col_b)"
         # - "func(col_a, transform(col_b))"
-        parsed_cluster_key = parse_one(clustering_key, dialect=self.dialect)
-
+        parsed_cluster_key = parse_one(self.clustering_key, dialect=self.dialect)
         return parsed_cluster_key.expressions or [parsed_cluster_key.this]
 
-    def get_alter_expressions(
+
+@dataclass(frozen=True)
+class TableAlterDropClusterKeyOperation(TableAlterClusterByOperation):
+    @property
+    def is_additive(self) -> bool:
+        return False
+
+    @property
+    def is_destructive(self) -> bool:
+        return False
+
+    @property
+    def _alter_actions(self) -> t.List[exp.Expression]:
+        return [exp.Command(this="DROP", expression="CLUSTERING KEY")]
+
+
+class ClusteredByMixin(EngineAdapter):
+    def _build_clustered_by_exp(
+        self,
+        clustered_by: t.List[exp.Expression],
+        **kwargs: t.Any,
+    ) -> t.Optional[exp.Cluster]:
+        return exp.Cluster(expressions=[c.copy() for c in clustered_by])
+
+    def get_alter_operations(
         self,
         current_table_name: TableName,
         target_table_name: TableName,
         *,
         ignore_destructive: bool = False,
-    ) -> t.List[exp.Alter]:
-        expressions = super().get_alter_expressions(
-            current_table_name, target_table_name, ignore_destructive=ignore_destructive
+        ignore_additive: bool = False,
+    ) -> t.List[TableAlterOperation]:
+        operations = super().get_alter_operations(
+            current_table_name,
+            target_table_name,
+            ignore_destructive=ignore_destructive,
+            ignore_additive=ignore_additive,
         )
 
         # check for a change in clustering
@@ -390,32 +432,17 @@ class ClusteredByMixin(EngineAdapter):
                 if target_table_info.clustering_key and (
                     current_table_info.clustering_key != target_table_info.clustering_key
                 ):
-                    expressions.append(
-                        self._change_clustering_key_expr(
-                            current_table,
-                            self._parse_clustering_key(target_table_info.clustering_key),
+                    operations.append(
+                        TableAlterChangeClusterKeyOperation(
+                            target_table=current_table,
+                            clustering_key=target_table_info.clustering_key,
+                            dialect=self.dialect,
                         )
                     )
             elif current_table_info.is_clustered:
-                expressions.append(self._drop_clustering_key_expr(current_table))
-
-        return expressions
+                operations.append(TableAlterDropClusterKeyOperation(target_table=current_table))
 
-    def _change_clustering_key_expr(
-        self, table: exp.Table, cluster_by: t.List[exp.Expression]
-    ) -> exp.Alter:
-        return exp.Alter(
-            this=table,
-            kind="TABLE",
-            actions=[exp.Cluster(expressions=cluster_by)],
-        )
-
-    def _drop_clustering_key_expr(self, table: exp.Table) -> exp.Alter:
-        return exp.Alter(
-            this=table,
-            kind="TABLE",
-            actions=[exp.Command(this="DROP", expression="CLUSTERING KEY")],
-        )
+        return operations
 
 
 def logical_merge(