sqlmesh 0.219.0__py3-none-any.whl → 0.219.1.dev2__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.219.0'
-__version_tuple__ = version_tuple = (0, 219, 0)
+__version__ = version = '0.219.1.dev2'
+__version_tuple__ = version_tuple = (0, 219, 1, 'dev2')
 
 __commit_id__ = commit_id = None

sqlmesh/core/context.py

@@ -1429,6 +1429,7 @@ class GenericContext(BaseContext, t.Generic[C]):
         explain: t.Optional[bool] = None,
         ignore_cron: t.Optional[bool] = None,
         min_intervals: t.Optional[int] = None,
+        always_include_local_changes: t.Optional[bool] = None,
     ) -> PlanBuilder:
         """Creates a plan builder.
 
@@ -1467,6 +1468,8 @@ class GenericContext(BaseContext, t.Generic[C]):
             diff_rendered: Whether the diff should compare raw vs rendered models
             min_intervals: Adjust the plan start date on a per-model basis in order to ensure at least this many intervals are covered
                 on every model when checking for missing intervals
+            always_include_local_changes: Usually when restatements are present, local changes in the filesystem are ignored.
+                However, it can be desirable to deploy changes + restatements in the same plan, so this flag overrides the default behaviour.
 
         Returns:
             The plan builder.
@@ -1583,13 +1586,20 @@ class GenericContext(BaseContext, t.Generic[C]):
                 "Selector did not return any models. Please check your model selection and try again."
             )
 
+        if always_include_local_changes is None:
+            # default behaviour - if restatements are detected; we operate entirely out of state and ignore local changes
+            force_no_diff = restate_models is not None or (
+                backfill_models is not None and not backfill_models
+            )
+        else:
+            force_no_diff = not always_include_local_changes
+
         snapshots = self._snapshots(models_override)
         context_diff = self._context_diff(
             environment or c.PROD,
             snapshots=snapshots,
             create_from=create_from,
-            force_no_diff=restate_models is not None
-            or (backfill_models is not None and not backfill_models),
+            force_no_diff=force_no_diff,
             ensure_finalized_snapshots=self.config.plan.use_finalized_state,
             diff_rendered=diff_rendered,
             always_recreate_environment=self.config.plan.always_recreate_environment,
@@ -1644,6 +1654,14 @@ class GenericContext(BaseContext, t.Generic[C]):
         elif forward_only is None:
             forward_only = self.config.plan.forward_only
 
+        # When handling prod restatements, only clear intervals from other model versions if we are using full virtual environments
+        # If we are not, then there is no point, because none of the data in dev environments can be promoted by definition
+        restate_all_snapshots = (
+            expanded_restate_models is not None
+            and not is_dev
+            and self.config.virtual_environment_mode.is_full
+        )
+
         return self.PLAN_BUILDER_TYPE(
             context_diff=context_diff,
             start=start,
@@ -1651,6 +1669,7 @@ class GenericContext(BaseContext, t.Generic[C]):
             execution_time=execution_time,
             apply=self.apply,
             restate_models=expanded_restate_models,
+            restate_all_snapshots=restate_all_snapshots,
             backfill_models=backfill_models,
             no_gaps=no_gaps,
             skip_backfill=skip_backfill,

sqlmesh/core/plan/builder.py

@@ -65,6 +65,9 @@ class PlanBuilder:
         restate_models: A list of models for which the data should be restated for the time range
             specified in this plan. Note: models defined outside SQLMesh (external) won't be a part
             of the restatement.
+        restate_all_snapshots: If restatements are present, this flag indicates whether or not the intervals
+            being restated should be cleared from state for other versions of this model (typically, versions that are present in other environments).
+            If set to None, the default behaviour is to not clear anything unless the target environment is prod.
         backfill_models: A list of fully qualified model names for which the data should be backfilled as part of this plan.
         no_gaps:  Whether to ensure that new snapshots for nodes that are already a
             part of the target environment have no data gaps when compared against previous
@@ -103,6 +106,7 @@ class PlanBuilder:
         execution_time: t.Optional[TimeLike] = None,
         apply: t.Optional[t.Callable[[Plan], None]] = None,
         restate_models: t.Optional[t.Iterable[str]] = None,
+        restate_all_snapshots: bool = False,
         backfill_models: t.Optional[t.Iterable[str]] = None,
         no_gaps: bool = False,
         skip_backfill: bool = False,
@@ -154,6 +158,7 @@ class PlanBuilder:
         self._auto_categorization_enabled = auto_categorization_enabled
         self._include_unmodified = include_unmodified
         self._restate_models = set(restate_models) if restate_models is not None else None
+        self._restate_all_snapshots = restate_all_snapshots
         self._effective_from = effective_from
 
         # note: this deliberately doesnt default to now() here.
@@ -277,7 +282,6 @@ class PlanBuilder:
         if self._latest_plan:
             return self._latest_plan
 
-        self._ensure_no_new_snapshots_with_restatements()
         self._ensure_new_env_with_changes()
         self._ensure_valid_date_range()
         self._ensure_no_broken_references()
@@ -340,6 +344,7 @@ class PlanBuilder:
             deployability_index=deployability_index,
             selected_models_to_restate=self._restate_models,
             restatements=restatements,
+            restate_all_snapshots=self._restate_all_snapshots,
             start_override_per_model=self._start_override_per_model,
             end_override_per_model=end_override_per_model,
             selected_models_to_backfill=self._backfill_models,
@@ -859,15 +864,6 @@ class PlanBuilder:
                     f"""Removed {broken_references_msg} are referenced in '{snapshot.name}'. Please remove broken references before proceeding."""
                 )
 
-    def _ensure_no_new_snapshots_with_restatements(self) -> None:
-        if self._restate_models is not None and (
-            self._context_diff.new_snapshots or self._context_diff.modified_snapshots
-        ):
-            raise PlanError(
-                "Model changes and restatements can't be a part of the same plan. "
-                "Revert or apply changes before proceeding with restatements."
-            )
-
     def _ensure_new_env_with_changes(self) -> None:
         if (
             self._is_dev

sqlmesh/core/plan/definition.py

@@ -67,6 +67,8 @@ class Plan(PydanticModel, frozen=True):
     Note that dev previews are also considered restatements, so :selected_models_to_restate can be empty
     while :restatements is still populated with dev previews
     """
+    restate_all_snapshots: bool
+    """Whether or not to clear intervals from state for other versions of the models listed in :restatements"""
 
     start_override_per_model: t.Optional[t.Dict[str, datetime]]
     end_override_per_model: t.Optional[t.Dict[str, datetime]]
@@ -268,6 +270,7 @@ class Plan(PydanticModel, frozen=True):
             skip_backfill=self.skip_backfill,
             empty_backfill=self.empty_backfill,
             restatements={s.name: i for s, i in self.restatements.items()},
+            restate_all_snapshots=self.restate_all_snapshots,
             is_dev=self.is_dev,
             allow_destructive_models=self.allow_destructive_models,
             allow_additive_models=self.allow_additive_models,
@@ -312,6 +315,7 @@ class EvaluatablePlan(PydanticModel):
     skip_backfill: bool
     empty_backfill: bool
     restatements: t.Dict[str, Interval]
+    restate_all_snapshots: bool
     is_dev: bool
     allow_destructive_models: t.Set[str]
     allow_additive_models: t.Set[str]

sqlmesh/core/plan/stages.py

@@ -14,6 +14,7 @@ from sqlmesh.core.snapshot.definition import (
     SnapshotId,
     snapshots_to_dag,
 )
+from sqlmesh.utils.errors import PlanError
 
 
 @dataclass
@@ -461,13 +462,18 @@ class PlanStagesBuilder:
     def _get_restatement_stage(
         self, plan: EvaluatablePlan, snapshots_by_name: t.Dict[str, Snapshot]
     ) -> t.Optional[RestatementStage]:
-        if not plan.restatements or plan.is_dev:
-            # The RestatementStage to clear intervals from state across all environments is not needed for plans against dev, only prod
-            return None
+        if plan.restate_all_snapshots:
+            if plan.is_dev:
+                raise PlanError(
+                    "Clearing intervals from state across dev model versions is only valid for prod plans"
+                )
 
-        return RestatementStage(
-            all_snapshots=snapshots_by_name,
-        )
+            if plan.restatements:
+                return RestatementStage(
+                    all_snapshots=snapshots_by_name,
+                )
+
+        return None
 
     def _get_physical_layer_update_stage(
         self,

sqlmesh/core/snapshot/evaluator.py

@@ -746,11 +746,15 @@ class SnapshotEvaluator:
             adapter.execute(model.render_pre_statements(**render_statements_kwargs))
 
             if not target_table_exists or (model.is_seed and not snapshot.intervals):
-                columns_to_types_provided = (
+                # Only create the empty table if the columns were provided explicitly by the user
+                should_create_empty_table = (
                     model.kind.is_materialized
                     and model.columns_to_types_
                     and columns_to_types_all_known(model.columns_to_types_)
                 )
+                if not should_create_empty_table:
+                    # Or if the model is self-referential and its query is fully annotated with types
+                    should_create_empty_table = model.depends_on_self and model.annotated
                 if self._can_clone(snapshot, deployability_index):
                     self._clone_snapshot_in_dev(
                         snapshot=snapshot,
@@ -763,7 +767,7 @@ class SnapshotEvaluator:
                     )
                     runtime_stage = RuntimeStage.EVALUATING
                     target_table_exists = True
-                elif columns_to_types_provided or model.is_seed or model.kind.is_scd_type_2:
+                elif should_create_empty_table or model.is_seed or model.kind.is_scd_type_2:
                     self._execute_create(
                         snapshot=snapshot,
                         table_name=target_table_name,

{sqlmesh-0.219.0.dist-info → sqlmesh-0.219.1.dev2.dist-info}/METADATA

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

{sqlmesh-0.219.0.dist-info → sqlmesh-0.219.1.dev2.dist-info}/RECORD

@@ -1,5 +1,5 @@
 sqlmesh/__init__.py,sha256=QjwaamJIdW7voXoS880yAx7tHm-Im4_mqGA-XJgafos,7631
-sqlmesh/_version.py,sha256=n60rwpz60kADQ732QDDScWY-wCxM24JjP95JV38Zj3U,708
+sqlmesh/_version.py,sha256=gcGONnIcxilCZ4d_C8R95DfiO4eV7bcVx6lyptEjD7Y,721
 sqlmesh/magics.py,sha256=xLh3u4eqpVrKRVN5KF3X84RPRqjygAB9AJP1TXwH8hg,42086
 sqlmesh/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sqlmesh/cicd/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -13,7 +13,7 @@ sqlmesh/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sqlmesh/core/_typing.py,sha256=e1f7xO2aZCy38M_3VoDy-XI3shyd99-IFctgIFSgXWM,497
 sqlmesh/core/console.py,sha256=0LGXUw7wFGeX-PhsKUIscE1d8mMtoqgPe4WzMiiqw1g,172752
 sqlmesh/core/constants.py,sha256=y92qUS6s5upGr1Kvbf9KXJticNmehBxSM1kzbwSXFAE,2664
-sqlmesh/core/context.py,sha256=1B-xz4t81nopIm9hR7-PwYf3QZAFDDCNRrB0vMPShKA,129421
+sqlmesh/core/context.py,sha256=uU9GGzXETS28Sjr-_8gNskshgO-KbTp-Th4Tf4FdQI4,130553
 sqlmesh/core/context_diff.py,sha256=mxkJu0IthFMOlaQ_kcq5C09mlgkq2RQb-pG2rd-x_nA,21648
 sqlmesh/core/dialect.py,sha256=CnKcPj6BnREfu9Zn1OyS7hZ3ktnaX03ygOg91nADlTU,53029
 sqlmesh/core/environment.py,sha256=Kgs_gUEUI072mh0JJFWNRynrCxp1TzRHZhX_NWJRfXc,13142
@@ -94,17 +94,17 @@ sqlmesh/core/model/meta.py,sha256=a68bnvc-qCCRLo-KCqc1JTrI9faDxsgrR4-P9jeZB0w,20
 sqlmesh/core/model/schema.py,sha256=_HMYfzK9wWXh7_CQDIIGnuQUD4aiX3o5D2cRp2sERzc,3387
 sqlmesh/core/model/seed.py,sha256=a0M-1zY1gOkN5ph2GQyataEdBSCtq50YjeFk2LyvInI,5058
 sqlmesh/core/plan/__init__.py,sha256=NKSvM7ZBVjw9ho3J65M1wFvG3KURB8PJ0FHHLmtSF44,443
-sqlmesh/core/plan/builder.py,sha256=1o7T5ErB46kJ1Qn5lUWNiXoopoud5uIoOanxtHwijXA,43615
+sqlmesh/core/plan/builder.py,sha256=enW5o_PaWYZ0YRT7UMPy-mk5lqkwUgy7kndvegbTTA0,43679
 sqlmesh/core/plan/common.py,sha256=V5mBYa_iQEB-fe9eqQQdMO2ow8cDVXRtnowUucQi9Mg,10453
-sqlmesh/core/plan/definition.py,sha256=6ZazmxzWOxdmx4Ckclmp1GBsB1a62pR0qtaXTU-nkTY,14987
+sqlmesh/core/plan/definition.py,sha256=YPpp7ABu77UznIHjhcPiDi7vxLyhj4II9CED_cQ19g4,15225
 sqlmesh/core/plan/evaluator.py,sha256=lJe3cwSICGiJ3KdGxvfpPfkaWzoJg49LAAjawz5QYoU,21062
 sqlmesh/core/plan/explainer.py,sha256=UITln7f4vxf6-nx7mV_IBbtIZ4f8ob4TyooqZMB9Pqg,15442
-sqlmesh/core/plan/stages.py,sha256=nDd8MrRwasLmgkwADPzIovz4h9e295yuiZbUbR5S66o,27338
+sqlmesh/core/plan/stages.py,sha256=ZRwJqf1XM7Yep9qzynYPpX9XzhaL4ZkxxPlLhcuKoIE,27476
 sqlmesh/core/snapshot/__init__.py,sha256=NUhvP-glftOWwxONK79Bud93yNQJv8ApBUjkV35RhMY,1465
 sqlmesh/core/snapshot/cache.py,sha256=bgqCR2hyf6r2A_8QP1EnXFK25gDX37-Zg0YeMuETWxg,3934
 sqlmesh/core/snapshot/categorizer.py,sha256=iNBEqK2KIyTAYURlB9KLfyKCpXN7vjxSqA7QjFa7e5c,2418
 sqlmesh/core/snapshot/definition.py,sha256=2Pob60pngLy70C5HWbb_tE7wkgsUddZdOZ4HNxJq0sk,95140
-sqlmesh/core/snapshot/evaluator.py,sha256=hTN6UqSQvOyuEcWHq1252vy9g7cPAa3Or80-CAVwKKY,111546
+sqlmesh/core/snapshot/evaluator.py,sha256=sSHRnkYoW8jhPiKmmckTl8eo1FiG0jnLDfFVvSpyalI,111886
 sqlmesh/core/snapshot/execution_tracker.py,sha256=Ss1oYgH28Fy1mQ4HriX-luE9MG0eLdecrE1SssUveQI,3651
 sqlmesh/core/state_sync/__init__.py,sha256=B60xj-_Xk-4jas3UphLvwkuf04G-9AyGckcblXE0aRg,869
 sqlmesh/core/state_sync/base.py,sha256=1Q_E8yixUg75PxfaVKOfWQote83ZXwOGN0r9BPiRVpE,19241
@@ -233,12 +233,12 @@ sqlmesh/utils/pydantic.py,sha256=o_NsXbIpDqNpUA1Uc5xF0ZzoXQYYB0DfHwdRxBwXPNk,120
 sqlmesh/utils/rich.py,sha256=cwQ5nJ6sgz64xHtoh6_ec7ReV5YpsOGhMtUJnwoRfEI,3549
 sqlmesh/utils/windows.py,sha256=r7Yin4WEwbvH7sKA3hOJtRsclmscNuBeCklCfVPvtQs,611
 sqlmesh/utils/yaml.py,sha256=KFBd7hsKNRTtRudGR7d410qUYffQv0EWRcDM8hVNNZg,3025
-sqlmesh-0.219.0.dist-info/licenses/LICENSE,sha256=OlMefUjgWJdULtf84BLW0AZZcY8DwdgQqb_1j2862j8,11346
+sqlmesh-0.219.1.dev2.dist-info/licenses/LICENSE,sha256=OlMefUjgWJdULtf84BLW0AZZcY8DwdgQqb_1j2862j8,11346
 sqlmesh_dbt/__init__.py,sha256=awYS5y5mz-1NUmx6i5h5NSTJ7tidRl9NC0FAnFWSF6U,350
-sqlmesh_dbt/cli.py,sha256=28I7NEKIYvLc1bSOnKL-4uYDhc2QVHaZW4RZHjq2Lg0,4483
+sqlmesh_dbt/cli.py,sha256=z07hDwEU46k3mAbSKVBsvPWnwXOOOFnYw2kQSRJahPA,4524
 sqlmesh_dbt/console.py,sha256=80sCEbrKfR5f3SvxIyI7hw_SuiDiiUwuJYxXbQO2014,830
 sqlmesh_dbt/error.py,sha256=1sPNU6Dik30DR9WTCvGp3ED-pzNmAA3LhP95BXb3ndI,1146
-sqlmesh_dbt/operations.py,sha256=BhNtnQRLPmP1uF8h10k_nv6MQj9jnSNymjVEmDFj_ew,10714
+sqlmesh_dbt/operations.py,sha256=PrbS2wiWCliMMgMBxnBl6eDltSwUEXcZ3a4Zy6qOaVA,13089
 sqlmesh_dbt/options.py,sha256=noB_qK4uGGi7Erqk1XkkMaFz5aUc6lp44wwn1Nv_LI4,737
 sqlmesh_dbt/selectors.py,sha256=4w8eE0qAgoYC2K8afk3whfju-u3e5muXGwgkfXxQR3Y,5228
 web/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -358,8 +358,8 @@ web/server/api/endpoints/models.py,sha256=kwj0s7uve3iZSMfmjkoPVMFMeY1sD0peTeyrWf
 web/server/api/endpoints/modules.py,sha256=8hqqgonGay_mJmpCw0IdbjsPhWlQH2VLdKAqha-myac,468
 web/server/api/endpoints/plan.py,sha256=bbbY50W_2MsZSTxOHWMKz0tbIm75nsRSlPy8GI2fg9Q,9306
 web/server/api/endpoints/table_diff.py,sha256=8XTwgOh6QBbNy_hTM1JuHgRjbnie-pGPrphiW-FNLjQ,6058
-sqlmesh-0.219.0.dist-info/METADATA,sha256=del8UbRPS_cvD74EuN6EiqAyO_P0r6R7lZUO2lmWjY0,26686
-sqlmesh-0.219.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-sqlmesh-0.219.0.dist-info/entry_points.txt,sha256=sHAf6tQczIM8xZoduN4qaUjV7QEPVUUW_LCT8EDUMv4,155
-sqlmesh-0.219.0.dist-info/top_level.txt,sha256=RQ-33FPe2IgL0rgossAfJkCRtqslz9b7wFARqiWLC5Q,24
-sqlmesh-0.219.0.dist-info/RECORD,,
+sqlmesh-0.219.1.dev2.dist-info/METADATA,sha256=R34m7XRaIfBEA4SGbU-rkE8uA2QMR59dY2LtbULxm_o,26691
+sqlmesh-0.219.1.dev2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+sqlmesh-0.219.1.dev2.dist-info/entry_points.txt,sha256=sHAf6tQczIM8xZoduN4qaUjV7QEPVUUW_LCT8EDUMv4,155
+sqlmesh-0.219.1.dev2.dist-info/top_level.txt,sha256=RQ-33FPe2IgL0rgossAfJkCRtqslz9b7wFARqiWLC5Q,24
+sqlmesh-0.219.1.dev2.dist-info/RECORD,,

sqlmesh_dbt/cli.py

@@ -90,7 +90,9 @@ def dbt(
 @click.option(
     "-f",
     "--full-refresh",
-    help="If specified, dbt will drop incremental models and fully-recalculate the incremental table from the model definition.",
+    is_flag=True,
+    default=False,
+    help="If specified, sqlmesh will drop incremental models and fully-recalculate the incremental table from the model definition.",
 )
 @click.option(
     "--env",

sqlmesh_dbt/operations.py

@@ -11,7 +11,7 @@ if t.TYPE_CHECKING:
     from sqlmesh.dbt.project import Project
     from sqlmesh_dbt.console import DbtCliConsole
     from sqlmesh.core.model import Model
-    from sqlmesh.core.plan import Plan
+    from sqlmesh.core.plan import Plan, PlanBuilder
 
 logger = logging.getLogger(__name__)
 
@@ -42,8 +42,39 @@ class DbtOperations:
         full_refresh: bool = False,
         empty: bool = False,
     ) -> Plan:
-        return self.context.plan(
-            **self._plan_options(
+        plan_builder = self._plan_builder(
+            environment=environment,
+            select=select,
+            exclude=exclude,
+            full_refresh=full_refresh,
+            empty=empty,
+        )
+
+        plan = plan_builder.build()
+
+        self.console.plan(
+            plan_builder,
+            default_catalog=self.context.default_catalog,
+            # start doing work immediately (since no_diff is set, there isnt really anything for the user to say yes/no to)
+            auto_apply=True,
+            # dont output a diff of model changes
+            no_diff=True,
+            # don't throw up any prompts like "set the effective date" - use defaults
+            no_prompts=True,
+        )
+
+        return plan
+
+    def _plan_builder(
+        self,
+        environment: t.Optional[str] = None,
+        select: t.Optional[t.List[str]] = None,
+        exclude: t.Optional[t.List[str]] = None,
+        full_refresh: bool = False,
+        empty: bool = False,
+    ) -> PlanBuilder:
+        return self.context.plan_builder(
+            **self._plan_builder_options(
                 environment=environment,
                 select=select,
                 exclude=exclude,
@@ -71,13 +102,15 @@ class DbtOperations:
 
         return selected_models
 
-    def _plan_options(
+    def _plan_builder_options(
         self,
-        environment: t.Optional[str] = None,
+        # upstream dbt options
         select: t.Optional[t.List[str]] = None,
         exclude: t.Optional[t.List[str]] = None,
         empty: bool = False,
         full_refresh: bool = False,
+        # sqlmesh extra options
+        environment: t.Optional[str] = None,
     ) -> t.Dict[str, t.Any]:
         import sqlmesh.core.constants as c
 
@@ -130,24 +163,38 @@ class DbtOperations:
             # `dbt --empty` adds LIMIT 0 to the queries, resulting in empty tables. In addition, it happily clobbers existing tables regardless of if they are populated.
             # This *partially* lines up with --skip-backfill in SQLMesh, which indicates to not populate tables if they happened to be created/updated as part of this plan.
             # However, if a table already exists and has data in it, there is no change so SQLMesh will not recreate the table and thus it will not be cleared.
-            # So in order to fully replicate dbt's --empty, we also need --full-refresh semantics in order to replace existing tables
+            # Currently, SQLMesh has no way to say "restate with empty data", because --restate-model coupled with --skip-backfill ends up being a no-op
             options["skip_backfill"] = True
-            full_refresh = True
+
+            self.console.log_warning(
+                "dbt's `--empty` drops the tables for all selected models and replaces them with empty ones.\n"
+                "This can easily result in accidental data loss, so SQLMesh limits this to only new or modified models and leaves the tables for existing unmodified models alone.\n\n"
+                "If you were creating empty tables to preview model changes, please consider using `--environment` to preview these changes in an isolated Virtual Data Environment instead.\n\n"
+                "Otherwise, if you really do want dbt's `--empty` behaviour of clearing every selected table, please file an issue on GitHub so we can better understand the use-case.\n"
+            )
+
+            if full_refresh:
+                # --full-refresh is implemented in terms of "add every model as a restatement"
+                # however, `--empty` sets skip_backfill=True, which causes the BackfillStage of the plan to be skipped.
+                # the re-processing of data intervals happens in the BackfillStage, so if it gets skipped, restatements become a no-op
+                raise ValueError("`--full-refresh` alongside `--empty` is not currently supported.")
 
         if full_refresh:
-            # TODO: handling this requires some updates in the engine to enable restatements+changes in the same plan without affecting prod
-            # if the plan targets dev
-            pass
+            options.update(
+                dict(
+                    # Add every selected model as a restatement to force them to get repopulated from scratch
+                    restate_models=list(self.context.models)
+                    if not select_models
+                    else select_models,
+                    # by default in SQLMesh, restatements only operate on what has been committed to state.
+                    # in order to emulate dbt, we need to use the local filesystem instead, so we override this default
+                    always_include_local_changes=True,
+                )
+            )
 
         return dict(
             environment=environment,
             select_models=select_models,
-            # dont output a diff of model changes
-            no_diff=True,
-            # don't throw up any prompts like "set the effective date" - use defaults
-            no_prompts=True,
-            # start doing work immediately (since no_diff is set, there isnt really anything for the user to say yes/no to)
-            auto_apply=True,
             **options,
         )