Merge pull request #1 from luisggc/add-option-to-continue-on-script-error

luisggc · web-flow · commit ad4a9b30e6f2 · 2025-08-02T17:52:23.000-03:00
feat: add optional continue on error
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -3,6 +3,12 @@ All notable changes to this project will be documented in this file.
 
 *The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).*
 
+## [4.1.0] - 2025-03-18
+### Added
+- Optional flags to continue deploying remaining scripts after an error, recording full error messages in the change history table and listing failed scripts at completion.
+### Fixed
+- Automatically add missing `ERROR_MESSAGE` column to the change history table to capture full script errors
+
 ## [4.0.1] - 2025-02-17
 ### Changed
 - Added back the ability to pass the Snowflake password in the `SNOWFLAKE_PASSWORD` environment variable.
diff --git a/README.md b/README.md
@@ -476,8 +476,14 @@ usage: schemachange deploy [-h] [--config-folder CONFIG_FOLDER] [--config-file-n
 | -ac, --autocommit                                                    | Enable autocommit feature for DML commands. The default is 'False'.                                                                                                                                                                                                 |
 | -v, --verbose                                                        | Display verbose debugging details during execution. The default is 'False'.                                                                                                                                                                                         |
 | --dry-run                                                            | Run schemachange in dry run mode. The default is 'False'.                                                                                                                                                                                                           |
+| --continue-all-on-error                                              | Continue executing remaining scripts even if one fails. The default is 'False'. Use the script-type specific flags for finer control.       |
+| --continue-versioned-on-error                                        | Continue executing remaining versioned scripts after an error. The default is 'False'.                                                      |
+| --continue-repeatable-on-error                                       | Continue executing remaining repeatable scripts after an error. The default is 'False'.                                                     |
+| --continue-always-on-error                                           | Continue executing remaining always scripts after an error. The default is 'False'.                                                         |
 | --query-tag                                                          | A string to include in the QUERY_TAG that is attached to every SQL statement executed.                                                                                                                                                                              |
 
+When any continue-on-error flag is used, schemachange records full error messages for failed scripts in the change history table and reports the list of failed scripts before exiting.
+
 ### render
 
 This subcommand is used to render a single script to the console. It is intended to support the development and
diff --git a/schemachange/cli.py b/schemachange/cli.py
@@ -13,7 +13,7 @@
 
 # region Global Variables
 # metadata
-SCHEMACHANGE_VERSION = "4.0.1"
+SCHEMACHANGE_VERSION = "4.1.0"
 SNOWFLAKE_APPLICATION_NAME = "schemachange"
 module_logger = structlog.getLogger(__name__)
 
diff --git a/schemachange/config/DeployConfig.py b/schemachange/config/DeployConfig.py
@@ -38,6 +38,9 @@ class DeployConfig(BaseConfig):
     create_change_history_table: bool = False
     autocommit: bool = False
     dry_run: bool = False
+    continue_versioned_on_error: bool = False
+    continue_repeatable_on_error: bool = False
+    continue_always_on_error: bool = False
     query_tag: str | None = None
 
     @classmethod
diff --git a/schemachange/config/get_merged_config.py b/schemachange/config/get_merged_config.py
@@ -95,6 +95,12 @@ def get_merged_config(
         **{k: v for k, v in yaml_kwargs.items() if v is not None},
         **{k: v for k, v in cli_kwargs.items() if v is not None},
     }
+    if "continue_all_on_error" in kwargs:
+        if kwargs["continue_all_on_error"]:
+            kwargs["continue_versioned_on_error"] = True
+            kwargs["continue_repeatable_on_error"] = True
+            kwargs["continue_always_on_error"] = True
+        del kwargs["continue_all_on_error"]
     if connections_file_path is not None:
         kwargs["connections_file_path"] = connections_file_path
     if connection_name is not None:
@@ -107,4 +113,4 @@ def get_merged_config(
     elif cli_kwargs["subcommand"] == "render":
         return RenderConfig.factory(**kwargs)
     else:
-        raise Exception(f"unhandled subcommand: {cli_kwargs['subcommand'] }")
+        raise Exception(f"unhandled subcommand: {cli_kwargs['subcommand']}")
diff --git a/schemachange/config/parse_cli_args.py b/schemachange/config/parse_cli_args.py
@@ -221,6 +221,38 @@ def parse_cli_args(args) -> dict:
         help="The string to add to the Snowflake QUERY_TAG session value for each query executed",
         required=False,
     )
+    parser_deploy.add_argument(
+        "--continue-versioned-on-error",
+        action="store_const",
+        const=True,
+        default=None,
+        help="Continue running remaining versioned scripts after an error (the default is False)",
+        required=False,
+    )
+    parser_deploy.add_argument(
+        "--continue-repeatable-on-error",
+        action="store_const",
+        const=True,
+        default=None,
+        help="Continue running remaining repeatable scripts after an error (the default is False)",
+        required=False,
+    )
+    parser_deploy.add_argument(
+        "--continue-always-on-error",
+        action="store_const",
+        const=True,
+        default=None,
+        help="Continue running remaining always scripts after an error (the default is False)",
+        required=False,
+    )
+    parser_deploy.add_argument(
+        "--continue-all-on-error",
+        action="store_const",
+        const=True,
+        default=None,
+        help="Continue running remaining scripts after an error (the default is False)",
+        required=False,
+    )
     parser_render = subcommands.add_parser(
         "render",
         description="Renders a script to the console, used to check and verify jinja output from scripts.",
diff --git a/schemachange/deploy.py b/schemachange/deploy.py
@@ -75,6 +75,8 @@ def deploy(config: DeployConfig, session: SnowflakeSession):
 
     scripts_skipped = 0
     scripts_applied = 0
+    scripts_failed = 0
+    failed_scripts: list[str] = []
 
     # Loop through each script in order and apply any required changes
     for script_name in all_script_names_sorted:
@@ -139,17 +141,40 @@ def deploy(config: DeployConfig, session: SnowflakeSession):
                 scripts_skipped += 1
                 continue
 
-        session.apply_change_script(
-            script=script,
-            script_content=content,
-            dry_run=config.dry_run,
-            logger=script_log,
+        should_continue = (
+            (script.type == "V" and config.continue_versioned_on_error)
+            or (script.type == "R" and config.continue_repeatable_on_error)
+            or (script.type == "A" and config.continue_always_on_error)
+        )
+        try:
+            session.apply_change_script(
+                script=script,
+                script_content=content,
+                dry_run=config.dry_run,
+                logger=script_log,
+            )
+            scripts_applied += 1
+        except Exception as e:
+            scripts_failed += 1
+            failed_scripts.append(script.name)
+            script_log.error("Failed to apply change script", error=str(e))
+            if not should_continue:
+                raise
+
+    if scripts_failed > 0:
+        logger.error(
+            "Completed with errors",
+            scripts_applied=scripts_applied,
+            scripts_skipped=scripts_skipped,
+            scripts_failed=scripts_failed,
+            failed_scripts=failed_scripts,
+        )
+        raise Exception(
+            f"{scripts_failed} change script(s) failed: {', '.join(failed_scripts)}"
+        )
+    else:
+        logger.info(
+            "Completed successfully",
+            scripts_applied=scripts_applied,
+            scripts_skipped=scripts_skipped,
         )
-
-        scripts_applied += 1
-
-    logger.info(
-        "Completed successfully",
-        scripts_applied=scripts_applied,
-        scripts_skipped=scripts_skipped,
-    )
diff --git a/schemachange/session/SnowflakeSession.py b/schemachange/session/SnowflakeSession.py
@@ -168,6 +168,7 @@ def create_change_history_table(self, dry_run: bool) -> None:
                 CHECKSUM VARCHAR,
                 EXECUTION_TIME NUMBER,
                 STATUS VARCHAR,
+                ERROR_MESSAGE VARCHAR,
                 INSTALLED_BY VARCHAR,
                 INSTALLED_ON TIMESTAMP_LTZ
             )
@@ -316,22 +317,26 @@ def apply_change_script(
         checksum = hashlib.sha224(script_content.encode("utf-8")).hexdigest()
         execution_time = 0
         status = "Success"
-
-        # Execute the contents of the script
+        error_message = ""
+        error: Exception | None = None
+        start = time.time()
         if len(script_content) > 0:
-            start = time.time()
             self.reset_session(logger=logger)
             self.reset_query_tag(extra_tag=script.name, logger=logger)
             try:
                 self.execute_snowflake_query(query=script_content, logger=logger)
             except Exception as e:
-                raise Exception(f"Failed to execute {script.name}") from e
-            self.reset_query_tag(logger=logger)
-            self.reset_session(logger=logger)
-            end = time.time()
-            execution_time = round(end - start)
+                status = "Failed"
+                error = e
+                error_message = str(e).replace("'", "''")
+            finally:
+                self.reset_query_tag(logger=logger)
+                self.reset_session(logger=logger)
+                end = time.time()
+                execution_time = round(end - start)
 
         # Compose and execute the insert statement to the log file
+        script_version = getattr(script, "version", "")
         query = f"""\
             INSERT INTO {self.change_history_table.fully_qualified} (
                 VERSION,
@@ -341,18 +346,40 @@ def apply_change_script(
                 CHECKSUM,
                 EXECUTION_TIME,
                 STATUS,
+                ERROR_MESSAGE,
                 INSTALLED_BY,
                 INSTALLED_ON
             ) VALUES (
-                '{getattr(script, "version", "")}',
+                '{script_version}',
                 '{script.description}',
                 '{script.name}',
                 '{script.type}',
                 '{checksum}',
                 {execution_time},
                 '{status}',
+                '{error_message}',
                 '{self.user}',
                 CURRENT_TIMESTAMP
             );
         """
-        self.execute_snowflake_query(dedent(query), logger=logger)
+        dedent_query = dedent(query)
+        try:
+            self.execute_snowflake_query(dedent_query, logger=logger)
+        except snowflake.connector.errors.ProgrammingError as e:
+            if "ERROR_MESSAGE" in str(e):
+                logger.warning(
+                    "Change history table missing ERROR_MESSAGE column, adding column",
+                    error=str(e),
+                )
+                alter_query = (
+                    f"ALTER TABLE {self.change_history_table.fully_qualified} "
+                    "ADD COLUMN IF NOT EXISTS ERROR_MESSAGE VARCHAR"
+                )
+                self.execute_snowflake_query(alter_query, logger=logger)
+                self.execute_snowflake_query(dedent_query, logger=logger)
+            else:
+                raise
+        if status != "Success":
+            raise Exception(
+                f"Failed to execute {script.name}: {error_message}"
+            ) from error
diff --git a/setup.cfg b/setup.cfg
@@ -1,6 +1,6 @@
 [metadata]
 name = schemachange
-version = 4.0.1
+version = 4.1.0
 description = A Database Change Management tool for Snowflake
 long_description = file: README.md
 long_description_content_type = text/markdown
diff --git a/tests/config/schemachange-config-full.yml b/tests/config/schemachange-config-full.yml
@@ -17,4 +17,7 @@ create-change-history-table: false
 autocommit: false
 verbose: false
 dry-run: false
+continue-versioned-on-error: false
+continue-repeatable-on-error: false
+continue-always-on-error: false
 query-tag: 'query-tag-from-yaml'
diff --git a/tests/config/test_get_merged_config.py b/tests/config/test_get_merged_config.py
@@ -454,6 +454,9 @@ def test_invalid_config_folder(mock_parse_cli_args, _):
                 "dry_run",
                 "query_tag",
                 "connection_name",
+                "continue_versioned_on_error",
+                "continue_repeatable_on_error",
+                "continue_always_on_error",
             ]
         },
     },
@@ -519,6 +522,9 @@ def test_invalid_config_folder(mock_parse_cli_args, _):
         "autocommit": True,
         "log_level": logging.INFO,
         "dry_run": True,
+        "continue_versioned_on_error": False,
+        "continue_repeatable_on_error": False,
+        "continue_always_on_error": False,
         "query_tag": "query-tag-from-cli",
         "connection_name": "myaltconnection",
         "connections_file_path": assets_path / "alt-connections.toml",
@@ -585,6 +591,9 @@ def test_invalid_config_folder(mock_parse_cli_args, _):
         "autocommit": True,
         "log_level": logging.INFO,
         "dry_run": True,
+        "continue_versioned_on_error": False,
+        "continue_repeatable_on_error": False,
+        "continue_always_on_error": False,
         "query_tag": "query-tag-from-cli",
         "connection_name": "myaltconnection",
         "connections_file_path": assets_path / "alt-connections.toml",
diff --git a/tests/config/test_get_yaml_config.py b/tests/config/test_get_yaml_config.py
@@ -92,5 +92,8 @@ def test_get_yaml_config(_):
     assert yaml_config["create_change_history_table"] is False
     assert yaml_config["autocommit"] is False
     assert yaml_config["dry_run"] is False
+    assert yaml_config["continue_versioned_on_error"] is False
+    assert yaml_config["continue_repeatable_on_error"] is False
+    assert yaml_config["continue_always_on_error"] is False
 
     assert yaml_config["config_vars"] == {"var1": "from_yaml", "var2": "also_from_yaml"}
diff --git a/tests/config/test_parse_cli_args.py b/tests/config/test_parse_cli_args.py
@@ -65,6 +65,10 @@ def test_parse_args_deploy_names():
         ("--create-change-history-table", True),
         ("--autocommit", True),
         ("--dry-run", True),
+        ("--continue-all-on-error", True),
+        ("--continue-versioned-on-error", True),
+        ("--continue-repeatable-on-error", True),
+        ("--continue-always-on-error", True),
     ]
 
     for arg, expected_value in valueless_test_args:
diff --git a/tests/session/test_SnowflakeSession.py b/tests/session/test_SnowflakeSession.py
@@ -1,12 +1,15 @@
 from __future__ import annotations
 
 from unittest import mock
+from pathlib import Path
 
 import pytest
 import structlog
+from snowflake.connector.errors import ProgrammingError
 
 from schemachange.config.ChangeHistoryTable import ChangeHistoryTable
 from schemachange.session.SnowflakeSession import SnowflakeSession
+from schemachange.session.Script import VersionedScript
 
 
 @pytest.fixture
@@ -47,3 +50,50 @@ def test_fetch_change_history_metadata_does_not_exist(
         assert result == {}
         assert session.con.execute_string.call_count == 1
         assert session.logger.calls[1][1][0] == "Executing query"
+
+    def test_apply_change_script_failure_records_history(
+        self, session: SnowflakeSession
+    ):
+        script = VersionedScript.from_path(Path("V1__test.sql"))
+        session.execute_snowflake_query = mock.Mock(
+            side_effect=[Exception("boom"), None]
+        )
+        with (
+            mock.patch.object(session, "reset_session"),
+            mock.patch.object(session, "reset_query_tag"),
+            pytest.raises(Exception),
+        ):
+            session.apply_change_script(script, "select 1", False, session.logger)
+        assert session.execute_snowflake_query.call_count == 2
+        insert_query = session.execute_snowflake_query.call_args_list[1].args[0]
+        assert "Failed" in insert_query
+        assert "ERROR_MESSAGE" in insert_query
+        assert "boom" in insert_query
+
+    def test_apply_change_script_missing_error_message_column(
+        self, session: SnowflakeSession
+    ):
+        script = VersionedScript.from_path(Path("V1__test.sql"))
+        session.execute_snowflake_query = mock.Mock(
+            side_effect=[
+                Exception("boom"),
+                ProgrammingError("invalid identifier 'ERROR_MESSAGE'", 0, 0),
+                None,
+                None,
+            ]
+        )
+        with (
+            mock.patch.object(session, "reset_session"),
+            mock.patch.object(session, "reset_query_tag"),
+            pytest.raises(Exception),
+        ):
+            session.apply_change_script(script, "select 1", False, session.logger)
+        assert session.execute_snowflake_query.call_count == 4
+        first_insert = session.execute_snowflake_query.call_args_list[1].args[0]
+        alter_stmt = session.execute_snowflake_query.call_args_list[2].args[0]
+        retry_insert = session.execute_snowflake_query.call_args_list[3].args[0]
+        assert "ERROR_MESSAGE" in first_insert
+        assert "ALTER TABLE" in alter_stmt
+        assert "ADD COLUMN" in alter_stmt
+        assert "ERROR_MESSAGE" in alter_stmt
+        assert "ERROR_MESSAGE" in retry_insert
diff --git a/tests/test_cli_misc.py b/tests/test_cli_misc.py
@@ -9,7 +9,7 @@
 
 
 def test_cli_given__schemachange_version_change_updated_in_setup_config_file():
-    assert SCHEMACHANGE_VERSION == "4.0.1"
+    assert SCHEMACHANGE_VERSION == "4.1.0"
 
 
 def test_cli_given__constants_exist():
diff --git a/tests/test_deploy_continue_on_error.py b/tests/test_deploy_continue_on_error.py
diff --git a/tests/test_main.py b/tests/test_main.py
