plain.models 0.47.0__tar.gz → 0.48.0__tar.gz

{plain_models-0.47.0 → plain_models-0.48.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plain.models
-Version: 0.47.0
+Version: 0.48.0
 Summary: Model your data and store it in a database.
 Author-email: Dave Gaeddert <dave.gaeddert@dropseed.dev>
 License-File: LICENSE

{plain_models-0.47.0 → plain_models-0.48.0}/plain/models/CHANGELOG.md

@@ -1,5 +1,16 @@
 # plain-models changelog
 
+## [0.48.0](https://github.com/dropseed/plain/releases/plain-models@0.48.0) (2025-09-26)
+
+### What's changed
+
+- Migrations now run in a single transaction by default for databases that support transactional DDL, providing all-or-nothing migration batches for better safety and consistency ([6d0c105](https://github.com/dropseed/plain/commit/6d0c105fa9))
+- Added `--atomic-batch/--no-atomic-batch` options to `plain migrate` to explicitly control whether migrations are run in a single transaction ([6d0c105](https://github.com/dropseed/plain/commit/6d0c105fa9))
+
+### Upgrade instructions
+
+- No changes required
+
 ## [0.47.0](https://github.com/dropseed/plain/releases/plain-models@0.47.0) (2025-09-25)
 
 ### What's changed

{plain_models-0.47.0 → plain_models-0.48.0}/plain/models/backends/base/creation.py

@@ -59,6 +59,7 @@ class BaseDatabaseCreation:
             prune=False,
             no_input=True,
             verbosity=max(verbosity - 1, 0),
+            atomic_batch=False,  # No need for atomic batch when creating test database
         )
 
         # Ensure a connection for the side effect of initializing the test database.

{plain_models-0.47.0 → plain_models-0.48.0}/plain/models/cli.py

@@ -362,6 +362,11 @@ def makemigrations(package_labels, dry_run, empty, no_input, name, check, verbos
     default=1,
     help="Verbosity level; 0=minimal output, 1=normal output, 2=verbose output, 3=very verbose output",
 )
+@click.option(
+    "--atomic-batch/--no-atomic-batch",
+    default=None,
+    help="Run migrations in a single transaction (auto-detected by default)",
+)
 def migrate(
     package_label,
     migration_name,
@@ -372,6 +377,7 @@ def migrate(
     prune,
     no_input,
     verbosity,
+    atomic_batch,
 ):
     """Updates database schema. Manages both packages with migrations and those without."""
 
@@ -575,6 +581,65 @@ def migrate(
     # pprint(sql)
 
     if migration_plan:
+        # Determine whether to use atomic batch
+        use_atomic_batch = False
+        if len(migration_plan) > 1:
+            # Check database capabilities
+            can_rollback_ddl = db_connection.features.can_rollback_ddl
+
+            # Check if all migrations support atomic
+            non_atomic_migrations = [m for m in migration_plan if not m.atomic]
+
+            if atomic_batch is True:
+                # User explicitly requested atomic batch
+                if not can_rollback_ddl:
+                    raise click.UsageError(
+                        f"--atomic-batch not supported on {db_connection.vendor}. "
+                        "Remove the flag or use a database that supports transactional DDL."
+                    )
+                if non_atomic_migrations:
+                    names = ", ".join(
+                        f"{m.package_label}.{m.name}" for m in non_atomic_migrations[:3]
+                    )
+                    if len(non_atomic_migrations) > 3:
+                        names += f", and {len(non_atomic_migrations) - 3} more"
+                    raise click.UsageError(
+                        f"--atomic-batch requested but these migrations have atomic=False: {names}"
+                    )
+                use_atomic_batch = True
+                if verbosity >= 1:
+                    click.echo(
+                        f"  Running {len(migration_plan)} migrations in atomic batch (all-or-nothing)"
+                    )
+            elif atomic_batch is False:
+                # User explicitly disabled atomic batch
+                use_atomic_batch = False
+                if verbosity >= 1:
+                    click.echo(f"  Running {len(migration_plan)} migrations separately")
+            else:
+                # Auto-detect (atomic_batch is None)
+                if can_rollback_ddl and not non_atomic_migrations:
+                    use_atomic_batch = True
+                    if verbosity >= 1:
+                        click.echo(
+                            f"  Running {len(migration_plan)} migrations in atomic batch (all-or-nothing)"
+                        )
+                else:
+                    use_atomic_batch = False
+                    if verbosity >= 1:
+                        if not can_rollback_ddl:
+                            click.echo(
+                                f"  Running {len(migration_plan)} migrations separately ({db_connection.vendor} doesn't support batch transactions)"
+                            )
+                        elif non_atomic_migrations:
+                            click.echo(
+                                f"  Running {len(migration_plan)} migrations separately (some migrations have atomic=False)"
+                            )
+                        else:
+                            click.echo(
+                                f"  Running {len(migration_plan)} migrations separately"
+                            )
+
         if backup or (backup is None and settings.DEBUG):
             backup_name = f"migrate_{time.strftime('%Y%m%d_%H%M%S')}"
             click.secho(
@@ -599,6 +664,7 @@ def migrate(
             plan=migration_plan,
             state=pre_migrate_state.clone(),
             fake=fake,
+            atomic_batch=use_atomic_batch,
         )
         # post_migrate signals have access to all models. Ensure that all models
         # are reloaded in case any are delayed.

{plain_models-0.47.0 → plain_models-0.48.0}/plain/models/migrations/executor.py

@@ -1,3 +1,6 @@
+from contextlib import nullcontext
+
+from ..transaction import atomic
 from .loader import MigrationLoader
 from .recorder import MigrationRecorder
 from .state import ProjectState
@@ -52,12 +55,14 @@ class MigrationExecutor:
                     migration.mutate_state(state, preserve=False)
         return state
 
-    def migrate(self, targets, plan=None, state=None, fake=False):
+    def migrate(self, targets, plan=None, state=None, fake=False, atomic_batch=False):
         """
         Migrate the database up to the given targets.
 
         Plain first needs to create all project states before a migration is
         (un)applied and in a second step run all the database operations.
+
+        atomic_batch: Whether to run all migrations in a single transaction.
         """
         # The plain_migrations table must be present to record applied
         # migrations, but don't create it if there are no migrations to apply.
@@ -82,34 +87,31 @@ class MigrationExecutor:
             if state is None:
                 # The resulting state should still include applied migrations.
                 state = self._create_project_state(with_applied_migrations=True)
-            state = self._migrate_all_forwards(state, plan, full_plan, fake=fake)
-
-        self.check_replacements()
 
-        return state
+            migrations_to_run = set(plan)
+
+            # Choose context manager based on atomic_batch
+            batch_context = atomic if (atomic_batch and len(plan) > 1) else nullcontext
+
+            with batch_context():
+                for migration in full_plan:
+                    if not migrations_to_run:
+                        # We remove every migration that we applied from these sets so
+                        # that we can bail out once the last migration has been applied
+                        # and don't always run until the very end of the migration
+                        # process.
+                        break
+                    if migration in migrations_to_run:
+                        if "models_registry" not in state.__dict__:
+                            if self.progress_callback:
+                                self.progress_callback("render_start")
+                            state.models_registry  # Render all -- performance critical
+                            if self.progress_callback:
+                                self.progress_callback("render_success")
+                        state = self.apply_migration(state, migration, fake=fake)
+                        migrations_to_run.remove(migration)
 
-    def _migrate_all_forwards(self, state, plan, full_plan, fake):
-        """
-        Take a list of 2-tuples of the form (migration instance, False) and
-        apply them in the order they occur in the full_plan.
-        """
-        migrations_to_run = set(plan)
-        for migration in full_plan:
-            if not migrations_to_run:
-                # We remove every migration that we applied from these sets so
-                # that we can bail out once the last migration has been applied
-                # and don't always run until the very end of the migration
-                # process.
-                break
-            if migration in migrations_to_run:
-                if "models_registry" not in state.__dict__:
-                    if self.progress_callback:
-                        self.progress_callback("render_start")
-                    state.models_registry  # Render all -- performance critical
-                    if self.progress_callback:
-                        self.progress_callback("render_success")
-                state = self.apply_migration(state, migration, fake=fake)
-                migrations_to_run.remove(migration)
+        self.check_replacements()
 
         return state
 

{plain_models-0.47.0 → plain_models-0.48.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "plain.models"
-version = "0.47.0"
+version = "0.48.0"
 description = "Model your data and store it in a database."
 authors = [{name = "Dave Gaeddert", email = "dave.gaeddert@dropseed.dev"}]
 readme = "README.md"