Switch impl to always_init_from_prod

Author: VaggelisD

docs/guides/configuration.md

@@ -386,15 +386,15 @@ Example showing default values:
 
 By default, SQLMesh compares the current state of project files to the target `<env>` environment when `sqlmesh plan <env>` is run. However, a common expectation is that local changes should always be compared to the production environment.
 
-The `always_compare_against_prod` boolean plan option can alter this behavior. When enabled, SQLMesh will always attempt to compare against the production environment; If that does not exist, SQLMesh will fall back to comparing against the target environment.
+The `always_init_from_prod` boolean plan option can alter this behavior. When enabled, SQLMesh will always attempt to compare against the production environment; If that does not exist, SQLMesh will fall back to comparing against the target environment.
 
 **NOTE:**: Upon succesfull plan application, changes are still promoted to the target `<env>` environment.
 
 === "YAML"
 
     ```yaml linenums="1"
     plan:
-        always_compare_against_prod: True
+        always_init_from_prod: True
     ```
 
 === "Python"
@@ -416,7 +416,7 @@ The `always_compare_against_prod` boolean plan option can alter this behavior. W
 
 #### Change Categorization Example
 
-Consider this scenario with `always_compare_against_prod` enabled:
+Consider this scenario with `always_init_from_prod` enabled:
 
 1. Initial state in `prod`:
 ```sql
@@ -426,7 +426,7 @@ SELECT 1 AS col
 
 1. First (breaking) change in `dev`:
 ```sql
-MODEL (name test.a, kind FULL);
+MODEL (name sqlmesh_example__dev.test_model, kind FULL);
 SELECT 2 AS col
 ```
 
@@ -454,13 +454,15 @@ SELECT 2 AS col
 
 3. Second (metadata) change in `dev`:
 ```sql
-MODEL (name test.a, kind FULL, owner 'John Doe');
+MODEL (name sqlmesh_example__dev.test_model, kind FULL, owner 'John Doe');
 SELECT 5 AS col
 ```
 
 ??? "Output plan example #2"
 
     ```bash
+    New environment `dev` will be created from `prod`
+
     Differences from the `prod` environment:
 
     Models:

docs/reference/configuration.md

@@ -80,7 +80,7 @@ Configuration for the `sqlmesh plan` command.
 | `enable_preview`          | Indicates whether to enable [data preview](../concepts/plans.md#data-preview) for forward-only models when targeting a development environment (Default: True, except for dbt projects where the target engine does not support cloning)                | Boolean              | N        |
 | `no_diff`                 | Don't show diffs for changed models (Default: False)                                                                                                                                                                                                    | boolean              | N        |
 | `no_prompts`              | Disables interactive prompts in CLI (Default: True)                                                                                                                                                                                                     | boolean              | N        |
-
+| `always_init_from_prod`              | Always recreates the target environment from the environment specified in `create_from` (by default `prod`) (Default: False)                                                                                                                                                                                                     | boolean              | N        |
 ## Run
 
 Configuration for the `sqlmesh run` command. Please note that this is only applicable when configured with the [builtin](#builtin) scheduler.

sqlmesh/core/config/plan.py

@@ -20,7 +20,7 @@ class PlanConfig(BaseConfig):
         auto_apply: Whether to automatically apply the new plan after creation.
         use_finalized_state: Whether to compare against the latest finalized environment state, or to use
             whatever state the target environment is currently in.
-        always_compare_against_prod: Whether to always compare against production when planning, even if the target environment exists.
+        always_init_from_prod: Whether to always recreate the target environment from the prod environment.
     """
 
     forward_only: bool = False
@@ -31,4 +31,4 @@ class PlanConfig(BaseConfig):
     no_prompts: bool = True
     auto_apply: bool = False
     use_finalized_state: bool = False
-    always_compare_against_prod: bool = False
+    always_init_from_prod: bool = False

sqlmesh/core/console.py

@@ -219,7 +219,6 @@ def show_environment_difference_summary(
         self,
         context_diff: ContextDiff,
         no_diff: bool = True,
-        environment: t.Optional[str] = None,
     ) -> None:
         """Displays a summary of differences for the environment."""
 
@@ -646,7 +645,6 @@ def show_environment_difference_summary(
         self,
         context_diff: ContextDiff,
         no_diff: bool = True,
-        environment: t.Optional[str] = None,
     ) -> None:
         pass
 
@@ -1526,7 +1524,6 @@ def show_environment_difference_summary(
         self,
         context_diff: ContextDiff,
         no_diff: bool = True,
-        environment: t.Optional[str] = None,
     ) -> None:
         """Shows a summary of the environment differences.
 
@@ -1536,11 +1533,10 @@ def show_environment_difference_summary(
             environment: The initial target environment
         """
         if context_diff.is_new_environment:
-            new_environment = environment or context_diff.environment
             msg = (
-                f"\n`{new_environment}` environment will be initialized"
+                f"\n`{context_diff.environment}` environment will be initialized"
                 if not context_diff.create_from_env_exists
-                else f"\nNew environment `{new_environment}` will be created from `{context_diff.create_from}`"
+                else f"\nNew environment `{context_diff.environment}` will be created from `{context_diff.create_from}`"
             )
             self._print(Tree(f"[bold]{msg}\n"))
             if not context_diff.has_snapshot_changes:
@@ -1791,7 +1787,6 @@ def _prompt_categorize(
             self.show_environment_difference_summary(
                 plan.context_diff,
                 no_diff=no_diff,
-                environment=plan_builder.environment_naming_info.name,
             )
 
         if plan.context_diff.has_changes:
@@ -2904,7 +2899,6 @@ def show_environment_difference_summary(
         self,
         context_diff: ContextDiff,
         no_diff: bool = True,
-        environment: t.Optional[str] = None,
     ) -> None:
         """Shows a summary of the environment differences.
 
@@ -2914,11 +2908,10 @@ def show_environment_difference_summary(
             environment: The initial target environment
         """
         if context_diff.is_new_environment:
-            new_environment = environment or context_diff.environment
             msg = (
-                f"\n**`{new_environment}` environment will be initialized**"
+                f"\n**`{context_diff.environment}` environment will be initialized**"
                 if not context_diff.create_from_env_exists
-                else f"\n**New environment `{new_environment}` will be created from `{context_diff.create_from}`**"
+                else f"\n**New environment `{context_diff.environment}` will be created from `{context_diff.create_from}`**"
             )
             self._print(msg)
             if not context_diff.has_snapshot_changes:
@@ -3510,7 +3503,6 @@ def show_environment_difference_summary(
         self,
         context_diff: ContextDiff,
         no_diff: bool = True,
-        environment: t.Optional[str] = None,
     ) -> None:
         self._write("Environment Difference Summary:")
 

sqlmesh/core/context.py

@@ -1487,7 +1487,7 @@ def plan_builder(
             or (backfill_models is not None and not backfill_models),
             ensure_finalized_snapshots=self.config.plan.use_finalized_state,
             diff_rendered=diff_rendered,
-            always_compare_against_prod=self.config.plan.always_compare_against_prod,
+            always_init_from_prod=self.config.plan.always_init_from_prod,
         )
         modified_model_names = {
             *context_diff.modified_snapshots,
@@ -1644,7 +1644,6 @@ def diff(self, environment: t.Optional[str] = None, detailed: bool = False) -> b
         self.console.show_environment_difference_summary(
             context_diff,
             no_diff=not detailed,
-            environment=environment,
         )
         if context_diff.has_changes:
             self.console.show_model_difference_summary(
@@ -2631,7 +2630,7 @@ def _context_diff(
         force_no_diff: bool = False,
         ensure_finalized_snapshots: bool = False,
         diff_rendered: bool = False,
-        always_compare_against_prod: bool = False,
+        always_init_from_prod: bool = False,
     ) -> ContextDiff:
         environment = Environment.sanitize_name(environment)
         if force_no_diff:
@@ -2649,7 +2648,7 @@ def _context_diff(
             environment_statements=self._environment_statements,
             gateway_managed_virtual_layer=self.config.gateway_managed_virtual_layer,
             infer_python_dependencies=self.config.infer_python_dependencies,
-            always_compare_against_prod=always_compare_against_prod,
+            always_init_from_prod=always_init_from_prod,
         )
 
     def _destroy(self) -> None:

sqlmesh/core/context_diff.py

@@ -104,7 +104,7 @@ def create(
         environment_statements: t.Optional[t.List[EnvironmentStatements]] = [],
         gateway_managed_virtual_layer: bool = False,
         infer_python_dependencies: bool = True,
-        always_compare_against_prod: bool = False,
+        always_init_from_prod: bool = False,
     ) -> ContextDiff:
         """Create a ContextDiff object.
 
@@ -129,35 +129,25 @@ def create(
         Returns:
             The ContextDiff object.
         """
-        initial_environment_name = environment.lower()
-        initial_env = state_reader.get_environment(initial_environment_name)
-
+        environment = environment.lower()
+        existing_env = state_reader.get_environment(environment)
         create_from_env_exists = False
-        if initial_env is None or initial_env.expired:
-            initial_env = state_reader.get_environment(create_from.lower())
 
-            if not initial_env and create_from != c.PROD:
+        if existing_env is None or existing_env.expired or always_init_from_prod:
+            env = state_reader.get_environment(create_from.lower())
+
+            if not env and create_from != c.PROD:
                 get_console().log_warning(
                     f"The environment name '{create_from}' was passed to the `plan` command's `--create-from` argument, but '{create_from}' does not exist. Initializing new environment '{environment}' from scratch."
                 )
 
             is_new_environment = True
-            create_from_env_exists = initial_env is not None
+            create_from_env_exists = env is not None
             previously_promoted_snapshot_ids = set()
         else:
+            env = existing_env
             is_new_environment = False
-            previously_promoted_snapshot_ids = {
-                s.snapshot_id for s in initial_env.promoted_snapshots
-            }
-
-        # Find the proper environment to diff against, this might be different than the initial (i.e user provided) environment
-        # e.g it will default to prod if the plan option `always_compare_against_prod` is set.
-        environment = _get_diff_environment(environment, state_reader, always_compare_against_prod)
-        env = (
-            initial_env
-            if (initial_environment_name == environment)
-            else state_reader.get_environment(environment)
-        )
+            previously_promoted_snapshot_ids = {s.snapshot_id for s in env.promoted_snapshots}
 
         environment_snapshot_infos = []
         if env:
@@ -233,6 +223,11 @@ def create(
 
         previous_environment_statements = state_reader.get_environment_statements(environment)
 
+        if existing_env and always_init_from_prod:
+            previous_plan_id: t.Optional[str] = existing_env.plan_id
+        else:
+            previous_plan_id = env.plan_id if env and not is_new_environment else None
+
         return ContextDiff(
             environment=environment,
             is_new_environment=is_new_environment,
@@ -245,9 +240,7 @@ def create(
             modified_snapshots=modified_snapshots,
             snapshots=merged_snapshots,
             new_snapshots=new_snapshots,
-            previous_plan_id=initial_env.plan_id
-            if initial_env and not is_new_environment
-            else None,
+            previous_plan_id=previous_plan_id,
             previously_promoted_snapshot_ids=previously_promoted_snapshot_ids,
             previous_finalized_snapshots=env.previous_finalized_snapshots if env else None,
             previous_requirements=env.requirements if env else {},
@@ -494,17 +487,6 @@ def text_diff(self, name: str) -> str:
             return ""
 
 
-def _get_diff_environment(
-    environment: str, state_reader: StateReader, always_compare_against_prod: bool = False
-) -> str:
-    if always_compare_against_prod:
-        prod = state_reader.get_environment(c.PROD)
-        if prod:
-            environment = c.PROD
-
-    return environment.lower()
-
-
 def _build_requirements(
     provided_requirements: t.Dict[str, str],
     excluded_requirements: t.Set[str],

tests/core/test_integration.py

@@ -6256,7 +6256,7 @@ def test_render_path_instead_of_model(tmp_path: Path):
 
 
 @use_terminal_console
-def test_plan_always_compare_against_prod(mocker: MockerFixture, tmp_path: Path):
+def test_plan_always_init_from_prod(tmp_path: Path):
     def plan_with_output(ctx: Context, environment: str):
         with patch.object(logger, "info") as mock_logger:
             with capture_output() as output:
@@ -6268,11 +6268,6 @@ def plan_with_output(ctx: Context, environment: str):
 
         return output
 
-    def assert_environments(ctx: Context, input_env: str, promote_env: str, diff_env: str):
-        plan_builder = ctx.plan_builder(input_env)
-        assert plan_builder.environment_naming_info.name == promote_env
-        assert plan_builder.build().context_diff.environment == diff_env
-
     models_dir = tmp_path / "models"
 
     logger = logging.getLogger("sqlmesh.core.state_sync.db.facade")
@@ -6281,31 +6276,26 @@ def assert_environments(ctx: Context, input_env: str, promote_env: str, diff_env
         tmp_path, models_dir / "a.sql", "MODEL (name test.a, kind FULL); SELECT 1 AS col"
     )
 
-    config = Config(plan=PlanConfig(always_compare_against_prod=True))
+    config = Config(plan=PlanConfig(always_init_from_prod=True))
     ctx = Context(paths=[tmp_path], config=config)
 
     # Case 1: Neither prod nor dev exists, so dev is initialized
     output = plan_with_output(ctx, "dev")
 
     assert """`dev` environment will be initialized""" in output.stdout
-    assert_environments(ctx, input_env="dev", promote_env="dev", diff_env="dev")
 
     # Case 2: Prod does not exist, so dev is updated
     create_temp_file(
         tmp_path, models_dir / "a.sql", "MODEL (name test.a, kind FULL); SELECT 5 AS col"
     )
 
     output = plan_with_output(ctx, "dev")
-
-    assert_environments(ctx, input_env="dev", promote_env="dev", diff_env="dev")
-    assert "Differences from the `dev` environment" in output.stdout
+    assert "`dev` environment will be initialized" in output.stdout
 
     # Case 3: Prod is initialized, so plan comparisons moving forward should be against prod
     output = plan_with_output(ctx, "prod")
     assert "`prod` environment will be initialized" in output.stdout
 
-    assert_environments(ctx, input_env="prod", promote_env="prod", diff_env="prod")
-
     # Case 4: Dev is updated with a breaking change. Prod exists now so plan comparisons moving forward should be against prod
     create_temp_file(
         tmp_path, models_dir / "a.sql", "MODEL (name test.a, kind FULL); SELECT 10 AS col"
@@ -6314,14 +6304,13 @@ def assert_environments(ctx: Context, input_env: str, promote_env: str, diff_env
 
     plan = ctx.plan_builder("dev").build()
 
-    assert_environments(ctx, input_env="dev", promote_env="dev", diff_env="prod")
-
     assert (
         next(iter(plan.context_diff.snapshots.values())).change_category
         == SnapshotChangeCategory.BREAKING
     )
 
     output = plan_with_output(ctx, "dev")
+    assert "New environment `dev` will be created from `prod`" in output.stdout
     assert "Differences from the `prod` environment" in output.stdout
 
     # Case 5: Dev is updated with a metadata change, but comparison against prod shows both the previous and the current changes
@@ -6335,14 +6324,13 @@ def assert_environments(ctx: Context, input_env: str, promote_env: str, diff_env
 
     plan = ctx.plan_builder("dev").build()
 
-    assert_environments(ctx, input_env="dev", promote_env="dev", diff_env="prod")
-
     assert (
         next(iter(plan.context_diff.snapshots.values())).change_category
         == SnapshotChangeCategory.BREAKING
     )
 
     output = plan_with_output(ctx, "dev")
+    assert "New environment `dev` will be created from `prod`" in output.stdout
     assert "Differences from the `prod` environment" in output.stdout
 
     assert (