def find_unsafe_migrations(connection): loader = MigrationLoader(connection) disk_migrations = set(loader.disk_migrations.keys()) new_migrations = disk_migrations.difference(loader.applied_migrations) unsafe_migrations = [] for app_name, migration_name in new_migrations: migration = loader.get_migration(app_name, migration_name) project_state = loader.project_state((app_name, migration_name), at_end=False) result = analyze_migration(connection, migration, project_state) if result: unsafe_migrations.append(result) unsafe_migrations = sorted(unsafe_migrations, key=operator.attrgetter("app_name", "migration_name")) conflicts = loader.detect_conflicts() for app, names in conflicts.items(): unsafe_migrations.append( MigrationConflict(app_name=app, migration_names=names)) return unsafe_migrations
def test_total_deconstruct(self): loader = MigrationLoader(None, load=True, ignore_no_migrations=True) loader.disk_migrations = {t: v for t, v in loader.disk_migrations.items() if t[0] != 'testapp'} app_labels = {"testapp"} questioner = NonInteractiveMigrationQuestioner(specified_apps=app_labels, dry_run=True) autodetector = MigrationAutodetector( loader.project_state(), ProjectState.from_apps(apps), questioner, ) # Detect changes changes = autodetector.changes( graph=loader.graph, trim_to_apps=app_labels or None, convert_apps=app_labels or None, migration_name="my_fake_migration_for_test_deconstruct", ) self.assertGreater(len(changes), 0) for app_label, app_migrations in changes.items(): for migration in app_migrations: # Describe the migration writer = MigrationWriter(migration) migration_string = writer.as_string() self.assertNotEqual(migration_string, "")
def test_load(self): """ Makes sure the loader can load the migrations for the test apps, and then render them out to a new Apps. """ # Load and test the plan migration_loader = MigrationLoader(connection) self.assertEqual( migration_loader.graph.forwards_plan( ("migrations", "0002_second")), [ ("migrations", "0001_initial"), ("migrations", "0002_second"), ], ) # Now render it out! project_state = migration_loader.project_state( ("migrations", "0002_second")) self.assertEqual(len(project_state.models), 2) author_state = project_state.models["migrations", "author"] self.assertEqual([x for x, y in author_state.fields], ["id", "name", "slug", "age", "rating"]) book_state = project_state.models["migrations", "book"] self.assertEqual([x for x, y in book_state.fields], ["id", "author"]) # Ensure we've included unmigrated apps in there too self.assertIn("basic", project_state.real_apps)
def handle(self, app_label, **options): self.verbosity = options.get('verbosity') fixture_name = options.get('fixture_name') self.dry_run = False # Make sure the app they asked for exists try: apps.get_app_config(app_label) except LookupError: self.stderr.write( "App '%s' could not be found. Is it in INSTALLED_APPS?" % app_label) # Load the current graph state. Pass in None for the connection so # the loader doesn't try to resolve replaced migrations from DB. loader = MigrationLoader(None, ignore_no_migrations=True) autodetector = MigrationAutodetector( loader.project_state(), ProjectState.from_apps(apps), InteractiveMigrationQuestioner(specified_apps=[app_label]), ) migration = Migration("custom", app_label) migration.operations.append(LoadFixtureMigration(fixture_name)) migration.dependencies += loader.graph.nodes.keys() changes = {app_label: [migration]} changes = autodetector.arrange_for_graph( changes=changes, graph=loader.graph, ) self.write_migration_files(changes) return
def make_migration(app_label="tests", from_state=None, to_state=None): """Generates migrations based on the specified app's state.""" app_labels = [app_label] loader = MigrationLoader(None, ignore_no_migrations=True) loader.check_consistent_history(connection) questioner = NonInteractiveMigrationQuestioner(specified_apps=app_labels, dry_run=False) autodetector = MigrationAutodetector( from_state or loader.project_state(), to_state or ProjectState.from_apps(apps), questioner, ) changes = autodetector.changes( graph=loader.graph, trim_to_apps=app_labels or None, convert_apps=app_labels or None, migration_name="test", ) changes_for_app = changes.get(app_label) if not changes_for_app or len(changes_for_app) == 0: return None return changes_for_app[0]
def check_missing_migrations(): """Check that user model and migration files are in sync""" from django.db.migrations.autodetector import MigrationAutodetector from django.db.migrations.loader import MigrationLoader from django.db.migrations.questioner import ( NonInteractiveMigrationQuestioner as Questioner, ) from django.db.migrations.state import ProjectState loader = MigrationLoader(None, ignore_no_migrations=True) conflicts = loader.detect_conflicts() if conflicts: raise Exception( "Migration conflicts detected. Please fix your migrations.") questioner = Questioner(dry_run=True, specified_apps=None) autodetector = MigrationAutodetector( loader.project_state(), ProjectState.from_apps(apps), questioner, ) changes = autodetector.changes( graph=loader.graph, trim_to_apps=None, convert_apps=None, migration_name=None, ) if changes: raise Exception( "Migration changes detected. " "Please update or add to the migration file as appropriate") print("Migration-checker detected no problems.")
def test_total_deconstruct(self): loader = MigrationLoader(None, load=True, ignore_no_migrations=True) loader.disk_migrations = { t: v for t, v in loader.disk_migrations.items() if t[0] != 'testapp' } app_labels = {"testapp"} questioner = NonInteractiveMigrationQuestioner( specified_apps=app_labels, dry_run=True) autodetector = MigrationAutodetector( loader.project_state(), ProjectState.from_apps(apps), questioner, ) # Detect changes changes = autodetector.changes( graph=loader.graph, trim_to_apps=app_labels or None, convert_apps=app_labels or None, migration_name="my_fake_migration_for_test_deconstruct", ) self.assertGreater(len(changes), 0) for app_label, app_migrations in changes.items(): for migration in app_migrations: # Describe the migration writer = MigrationWriter(migration) migration_string = writer.as_string() self.assertNotEqual(migration_string, "")
def test_models_match_migrations(self): """Make sure that no model changes exist. This logic is taken from django's makemigrations.py file. Here just detect if model changes exist that require a migration, and if so we fail. """ app_labels = ['django_celery_results'] loader = MigrationLoader(None, ignore_no_migrations=True) questioner = NonInteractiveMigrationQuestioner( specified_apps=app_labels, dry_run=False) autodetector = MigrationAutodetector( loader.project_state(), ProjectState.from_apps(apps), questioner, ) changes = autodetector.changes( graph=loader.graph, trim_to_apps=app_labels, convert_apps=app_labels, migration_name='fake_name', ) self.assertTrue( not changes, msg='Model changes exist that do not have a migration')
def test_load(self): """ Makes sure the loader can load the migrations for the test apps, and then render them out to a new Apps. """ # Load and test the plan migration_loader = MigrationLoader(connection) self.assertEqual( migration_loader.graph.forwards_plan(("migrations", "0002_second")), [ ("migrations", "0001_initial"), ("migrations", "0002_second"), ], ) # Now render it out! project_state = migration_loader.project_state(("migrations", "0002_second")) self.assertEqual(len(project_state.models), 2) author_state = project_state.models["migrations", "author"] self.assertEqual( [x for x, y in author_state.fields], ["id", "name", "slug", "age", "rating"] ) book_state = project_state.models["migrations", "book"] self.assertEqual( [x for x, y in book_state.fields], ["id", "author"] ) # Ensure we've included unmigrated apps in there too self.assertIn("basic", project_state.real_apps)
def write_migration(self, migration): loader = MigrationLoader(None, ignore_no_migrations=True) autodetector = MigrationAutodetector(loader.project_state(), ProjectState.from_apps(apps),) changes = autodetector.arrange_for_graph(changes={'share': [migration]}, graph=loader.graph,) for m in changes['share']: writer = MigrationWriter(m) with open(writer.path, 'wb') as fp: fp.write(writer.as_string())
def run_backward_migration(self): """Run/unapply migrations from `migrate_to` to `migrate_from`.""" if not self._migration_run: raise RuntimeError("Forward migration not run") loader = MigrationLoader(connection) self._migrate(self.migrate_from) self._apps = loader.project_state([(self.app_name, self.migrate_from) ]).apps self._migration_run = False
def run_forward_migration(self): """Run/apply migrations from `migrate_from` to `migrate_to`.""" if self._migration_run: raise RuntimeError("Forward migration already run") loader = MigrationLoader(connection) self._migrate(self.migrate_to) self._apps = loader.project_state([(self.app_name, self.migrate_to) ]).apps self._migration_run = True
def _get_apps_for_migration(self, migration_states): loader = MigrationLoader(connection) full_names = [] for app_name, migration_name in migration_states: if migration_name != 'zero': migration_name = loader.get_migration_by_prefix( app_name, migration_name).name full_names.append((app_name, migration_name)) state = loader.project_state(full_names) return state.apps
def _get_apps_for_migration(self, migration_states): loader = MigrationLoader(connection) full_names = [] for app_name, migration_name in migration_states: migration_name = loader.get_migration_by_prefix(app_name, migration_name).name full_names.append((app_name, migration_name)) state = loader.project_state(full_names) if django.VERSION < (1, 8): state.render() return state.apps
def _get_apps_for_migration(self, migration_states): loader = MigrationLoader(connection) full_names = [] for app_name, migration_name in migration_states: migration_name = loader.get_migration_by_prefix( app_name, migration_name).name full_names.append((app_name, migration_name)) state = loader.project_state(full_names) if django.VERSION < (1, 8): state.render() return state.apps
def handle(self, *app_labels, **options): # get supported options. self.verbosity = options['verbosity'] self.dry_run = options['dry_run'] self.merge = options['merge'] self.migration_name = options['name'] self.include_header = options['include_header'] check_changes = options['check_changes'] # validation application labels app_labels = set(app_labels) self.validate_applications(app_labels) # we don't check conflicts as regular makemigrations command. # we don't check if any migrations are applied before their dependencies as regular makemigrations command. # load migrations using same loader as in regular command loader = MigrationLoader(None, ignore_no_migrations=True) from_state = loader.project_state() to_state = ProjectState.from_apps(apps) # overwritten autodetector. They detect only view changes. autodetector = ViewMigrationAutoDetector( from_state, to_state, ) changes = autodetector.changes( graph=loader.graph, trim_to_apps=app_labels or None, convert_apps=app_labels or None, migration_name=self.migration_name, ) # it's copy paste from make migration command if not changes: # No changes? Tell them. if self.verbosity >= 1: if len(app_labels) == 1: self.stdout.write("No changes detected in app '%s'" % app_labels.pop()) elif len(app_labels) > 1: self.stdout.write("No changes detected in apps '%s'" % ("', '".join(app_labels))) else: self.stdout.write("No changes detected") else: self.write_migration_files(changes)
def write_migration(self, migration): loader = MigrationLoader(None, ignore_no_migrations=True) autodetector = MigrationAutodetector( loader.project_state(), ProjectState.from_apps(apps), ) changes = autodetector.arrange_for_graph( changes={'share': [migration]}, graph=loader.graph, ) for m in changes['share']: writer = MigrationWriter(m) with open(writer.path, 'wb') as fp: fp.write(writer.as_string())
def test_django_17_migrations(self): from django.apps import apps from django.db.migrations.loader import MigrationLoader from django.db.migrations.autodetector import MigrationAutodetector from django.db.migrations.state import ProjectState from django.db.migrations.questioner import MigrationQuestioner app_labels = set(app.label for app in apps.get_app_configs() if app.name.startswith('wagtail.')) for app_label in app_labels: apps.get_app_config(app_label.split('.')[-1]) loader = MigrationLoader(None, ignore_no_migrations=True) conflicts = dict( (app_label, conflict) for app_label, conflict in iteritems(loader.detect_conflicts()) if app_label in app_labels ) if conflicts: name_str = "; ".join("%s in %s" % (", ".join(names), app) for app, names in conflicts.items()) self.fail("Conflicting migrations detected (%s)." % name_str) autodetector = MigrationAutodetector( loader.project_state(), ProjectState.from_apps(apps), MigrationQuestioner(specified_apps=app_labels, dry_run=True), ) changes = autodetector.changes( graph=loader.graph, trim_to_apps=app_labels or None, convert_apps=app_labels or None, ) if changes: apps = ', '.join(apps.get_app_config(label).name for label in changes.keys()) migrations = '\n'.join(( ' {migration}\n{changes}'.format( migration=migration, changes='\n'.join(' {0}'.format(operation.describe()) for operation in migration.operations)) for (_, migrations) in changes.items() for migration in migrations)) self.fail('Model changes with no migrations detected:\n%s' % migrations)
def test_load_unmigrated_dependency(self): """ Makes sure the loader can load migrations with a dependency on an unmigrated app. """ # Load and test the plan migration_loader = MigrationLoader(connection) self.assertEqual( migration_loader.graph.forwards_plan(("migrations", "0001_initial")), [("contenttypes", "0001_initial"), ("auth", "0001_initial"), ("migrations", "0001_initial")], ) # Now render it out! project_state = migration_loader.project_state(("migrations", "0001_initial")) self.assertEqual(len([m for a, m in project_state.models if a == "migrations"]), 1) book_state = project_state.models["migrations", "book"] self.assertEqual([x for x, y in book_state.fields], ["id", "user"])
def test_django_17_migrations(self): from django.apps import apps from django.db.migrations.loader import MigrationLoader from django.db.migrations.autodetector import MigrationAutodetector from django.db.migrations.state import ProjectState from django.db.migrations.questioner import MigrationQuestioner app_labels = set(app.label for app in apps.get_app_configs() if app.name.startswith('wagtail.')) for app_label in app_labels: apps.get_app_config(app_label.split('.')[-1]) loader = MigrationLoader(None, ignore_no_migrations=True) conflicts = dict( (app_label, conflict) for app_label, conflict in iteritems(loader.detect_conflicts()) if app_label in app_labels) if conflicts: name_str = "; ".join("%s in %s" % (", ".join(names), app) for app, names in conflicts.items()) self.fail("Conflicting migrations detected (%s)." % name_str) autodetector = MigrationAutodetector( loader.project_state(), ProjectState.from_apps(apps), MigrationQuestioner(specified_apps=app_labels, dry_run=True), ) changes = autodetector.changes( graph=loader.graph, trim_to_apps=app_labels or None, convert_apps=app_labels or None, ) if changes: apps = ', '.join( apps.get_app_config(label).name for label in changes.keys()) migrations = '\n'.join((' {migration}\n{changes}'.format( migration=migration, changes='\n'.join(' {0}'.format(operation.describe()) for operation in migration.operations)) for (_, migrations) in changes.items() for migration in migrations)) self.fail('Model changes with no migrations detected:\n%s' % migrations)
def __iter__(self): l = MigrationLoader(self.conn) for app, migrations in self.migrations.iteritems(): yield "-- Application: " + app migrations.sort() for name in migrations: yield "-- Migration: " + name state = l.project_state((app, name), at_end=False) mig = l.graph.nodes[(app, name)] self.commented = False if not len(mig.operations): yield "-- Blank migration" yield """INSERT INTO "django_migrations" ("app", "name", "applied") VALUES ('{}', '{}', now());""".format(app, name) yield "" continue for op in mig.operations: # reject mutating changes if op.__class__ in DANGEROUS_OPS: yield "-- DANGEROUS OPERATION FOUND. : {}".format( op.__class__.__name__ ) self.commented = True break try: se = self.conn.schema_editor(collect_sql=True) se.deferred_sql = [] # Hack!!! do not drop default on column creation se.skip_default = lambda x: True mig.apply(state, se, collect_sql=True) lines = se.collected_sql + se.deferred_sql except: yield "-- GOT AN EXCEPTION!" else: if not lines: yield "-- NO SQL MIGRATION HERE" self.commented = True else: yield self.format("BEGIN;") for line in lines: yield self.format(line) #yield "" yield self.format("""INSERT INTO "django_migrations" ("app", "name", "applied") VALUES ('{}', '{}', now());""".format(app, name)) if lines: yield self.format("COMMIT;") yield ""
def test_no_migration_left(self): loader = MigrationLoader(None, ignore_no_migrations=True) conflicts = loader.detect_conflicts() app_labels = ['cities_light'] autodetector = MigrationAutodetector( loader.project_state(), ProjectState.from_apps(apps), InteractiveMigrationQuestioner(specified_apps=app_labels, dry_run=True), ) changes = autodetector.changes( graph=loader.graph, trim_to_apps=app_labels or None, convert_apps=app_labels or None, ) assert 'cities_light' not in changes
def handle(self, app_label, *models, **options): self.verbosity = int(options.get('verbosity')) self.interactive = options.get('interactive') self.dry_run = options.get('dry_run', False) if not models and '.' in app_label: app_label, models = app_label.split('.', 1) models = [models] try: apps.get_app_config(app_label) except LookupError: self.stderr.write("App '%s' could not be found. Is it in INSTALLED_APPS?" % app_label) sys.exit(2) # We want to basically write an empty migration, but with some # extra bits. # Load the current graph state. Pass in None for the connection so # the loader doesn't try to resolve replaced migrations from DB. loader = MigrationLoader(None) # Set up autodetector autodetector = MigrationAutodetector( loader.project_state(), ProjectState.from_apps(apps), InteractiveMigrationQuestioner(specified_apps=[app_label]), ) changes = autodetector.arrange_for_graph({ app_label: [Migration("audit_tables", app_label)] }, loader.graph) migration = changes[app_label][0] migration.dependencies.append( ('audit', '0001_initial') ) migration.name = 'audit_%s' % ('_'.join(models[:3])) for model_name in models: model = apps.get_model(app_label, model_name) migration.operations.append(postgres.audit.operations.AuditModel(model)) self.write_migration_files(changes)
def test__migrations(self): app_labels = { app.label for app in apps.get_app_configs() if app.name.startswith("wagtail.") } for app_label in app_labels: apps.get_app_config(app_label.split(".")[-1]) loader = MigrationLoader(None, ignore_no_migrations=True) conflicts = { (app_label, conflict) for app_label, conflict in loader.detect_conflicts().items() if app_label in app_labels } if conflicts: name_str = "; ".join("%s in %s" % (", ".join(names), app) for app, names in conflicts.items()) self.fail("Conflicting migrations detected (%s)." % name_str) autodetector = MigrationAutodetector( loader.project_state(), ProjectState.from_apps(apps), MigrationQuestioner(specified_apps=app_labels, dry_run=True), ) changes = autodetector.changes( graph=loader.graph, trim_to_apps=app_labels or None, convert_apps=app_labels or None, ) if changes: migrations = "\n".join((" {migration}\n{changes}".format( migration=migration, changes="\n".join(" {0}".format(operation.describe()) for operation in migration.operations), ) for (_, migrations) in changes.items() for migration in migrations)) self.fail("Model changes with no migrations detected:\n%s" % migrations)
def create_runpython_migration(self, app_label, forwards_backwards, extra_functions, extra_dependencies=None): # Copy source code, so that we can uninstall this helper app # and the migrations still work. extra_func_code = "\n\n".join( inspect.getsource(f) for f in extra_functions) loader = MigrationLoader(None, ignore_no_migrations=True) autodetector = MigrationAutodetector( loader.project_state(), ProjectState.from_apps(apps), None, ) changes = {app_label: [Migration("custom", app_label)]} changes = autodetector.arrange_for_graph( changes=changes, graph=loader.graph, ) for app_label, app_migrations in changes.items(): for migration in app_migrations: if extra_dependencies is not None: migration.dependencies.extend(extra_dependencies) writer = MigrationWriter(migration) migration_string = writer.as_string().decode('utf-8') # Add support functions: migration_string = migration_string.replace( "\nclass Migration", forwards_backwards + "\n\n" + extra_func_code + "\n\n" + "\nclass Migration") # Add operations: migration_string = migration_string.replace( "operations = [", "operations = [\n" " migrations.RunPython(forwards, backwards),") with open(writer.path, "wb") as fh: fh.write(migration_string.encode('utf-8'))
def test_load_unmigrated_dependency(self): """ Makes sure the loader can load migrations with a dependency on an unmigrated app. """ # Load and test the plan migration_loader = MigrationLoader(connection) self.assertEqual( migration_loader.graph.forwards_plan(("migrations", "0001_initial")), [ ('contenttypes', '0001_initial'), ('auth', '0001_initial'), ("migrations", "0001_initial"), ], ) # Now render it out! project_state = migration_loader.project_state(("migrations", "0001_initial")) self.assertEqual(len([m for a, m in project_state.models if a == "migrations"]), 1) book_state = project_state.models["migrations", "book"] self.assertEqual(list(book_state.fields), ['id', 'user'])
def __iter__(self): l = MigrationLoader(self.conn) for app, migrations in self.migrations.iteritems(): yield "-- Application: " + app migrations.sort() for name in migrations: yield "-- Migration: " + name state = l.project_state((app, name), at_end=False) mig = l.graph.nodes[(app, name)] self.commented = False if not len(mig.operations): yield "-- Blank migration" yield """INSERT INTO "django_migrations" ("app", "name", "applied") VALUES ('{}', '{}', now());""".format(app, name) yield "" continue for op in mig.operations: # reject mutating changes if op.__class__ in DANGEROUS_OPS: yield "-- DANGEROUS OPERATION FOUND. : {}".format( op.__class__.__name__ ) self.commented = True break try: se = self.conn.schema_editor(collect_sql=True) se.deferred_sql = [] # Hack!!! do not drop default on column creation se.skip_default = lambda x: True mig.apply(state, se, collect_sql=True) lines = se.collected_sql + se.deferred_sql except: yield "-- GOT AN EXCEPTION!" else: if not lines: yield "-- NO SQL MIGRATION HERE" self.commented = True for line in lines: yield self.format(line) yield "" yield self.format("""INSERT INTO "django_migrations" ("app", "name", "applied") VALUES ('{}', '{}', now());""".format(app, name)) yield ""
def test_load_unmigrated_dependency(self): """ Makes sure the loader can load migrations with a dependency on an unmigrated app. """ # Load and test the plan migration_loader = MigrationLoader(connection) self.assertEqual( migration_loader.graph.forwards_plan( ("migrations", "0001_initial")), [ ("migrations", "0001_initial"), ], ) # Now render it out! project_state = migration_loader.project_state( ("migrations", "0001_initial")) self.assertEqual( len([m for a, m in project_state.models if a == "migrations"]), 1) book_state = project_state.models["migrations", "book"] self.assertEqual([x for x, y in book_state.fields], ["id", "user"])
def make_migration(app_label="tests"): """Generates migrations based on the specified app's state.""" app_labels = [app_label] loader = MigrationLoader(None, ignore_no_migrations=True) loader.check_consistent_history(connection) questioner = NonInteractiveMigrationQuestioner(specified_apps=app_labels, dry_run=False) autodetector = MigrationAutodetector(loader.project_state(), ProjectState.from_apps(apps), questioner) changes = autodetector.changes( graph=loader.graph, trim_to_apps=app_labels or None, convert_apps=app_labels or None, migration_name="test", ) return changes[app_label][0]
def handle(self, app_label, **options): self.verbosity = options.get('verbosity') fixture_name = options.get('fixture_name') self.dry_run = False # Make sure the app they asked for exists try: apps.get_app_config(app_label) except LookupError: self.stderr.write( "App '%s' could not be found. Is it in INSTALLED_APPS?" % app_label) # Load the current graph state. Pass in None for the connection so # the loader doesn't try to resolve replaced migrations from DB. loader = MigrationLoader(None, ignore_no_migrations=True) autodetector = MigrationAutodetector( loader.project_state(), ProjectState.from_apps(apps), InteractiveMigrationQuestioner(specified_apps=[app_label]), ) migration = Migration("custom", app_label) migration.operations.append(LoadFixtureMigration(fixture_name)) migration.dependencies += loader.graph.nodes.keys() changes = { app_label: [migration] } changes = autodetector.arrange_for_graph( changes=changes, graph=loader.graph, ) self.write_migration_files(changes) return
def check_model_state(): """Checks if the state of local models is represented by migration files. This code follows the logic of Djangos makemigrations https://github.com/django/django/blob/master/django/core/management/commands/makemigrations.py Raises: MigrationStateError: If the loader detects conflicts or unapplied changes. Future: It might be desirable to allow partial checks by, e.g., providing an app_labels argument. """ try: # Load the current graph state. Pass in None for the connection so # the loader doesn't try to resolve replaced migrations from DB. loader = MigrationLoader(None, ignore_no_migrations=True) # Identify conflicting apps conflicts = loader.detect_conflicts() # Set up autodetector and detect changes changes = MigrationAutodetector( loader.project_state(), ProjectState.from_apps(apps), ).changes(graph=loader.graph) except Exception as error: raise MigrationStateError( f"Error when checking state of migrations conflicts:\n{error}") if conflicts: raise MigrationStateError("Conflicting migrations", conflicts) if changes: raise MigrationStateError(f"Migrations have changed", changes)
def handle(self, *app_labels, **options): self.verbosity = options['verbosity'] self.interactive = options['interactive'] self.dry_run = options['dry_run'] self.merge = options['merge'] self.empty = options['empty'] self.migration_name = options['name'] check_changes = options['check_changes'] # Make sure the app they asked for exists app_labels = set(app_labels) bad_app_labels = set() for app_label in app_labels: try: apps.get_app_config(app_label) except LookupError: bad_app_labels.add(app_label) if bad_app_labels: for app_label in bad_app_labels: self.stderr.write("App '%s' could not be found. Is it in INSTALLED_APPS?" % app_label) sys.exit(2) # Load the current graph state. Pass in None for the connection so # the loader doesn't try to resolve replaced migrations from DB. loader = MigrationLoader(None, ignore_no_migrations=True) # Raise an error if any migrations are applied before their dependencies. consistency_check_labels = {config.label for config in apps.get_app_configs()} # Non-default databases are only checked if database routers used. aliases_to_check = connections if settings.DATABASE_ROUTERS else [DEFAULT_DB_ALIAS] for alias in sorted(aliases_to_check): connection = connections[alias] if (connection.settings_dict['ENGINE'] != 'django.db.backends.dummy' and any( # At least one model must be migrated to the database. router.allow_migrate(connection.alias, app_label, model_name=model._meta.object_name) for app_label in consistency_check_labels for model in apps.get_app_config(app_label).get_models() )): loader.check_consistent_history(connection) # Before anything else, see if there's conflicting apps and drop out # hard if there are any and they don't want to merge conflicts = loader.detect_conflicts() # If app_labels is specified, filter out conflicting migrations for unspecified apps if app_labels: conflicts = { app_label: conflict for app_label, conflict in conflicts.items() if app_label in app_labels } if conflicts and not self.merge: name_str = "; ".join( "%s in %s" % (", ".join(names), app) for app, names in conflicts.items() ) raise CommandError( "Conflicting migrations detected; multiple leaf nodes in the " "migration graph: (%s).\nTo fix them run " "'python manage.py makemigrations --merge'" % name_str ) # If they want to merge and there's nothing to merge, then politely exit if self.merge and not conflicts: self.stdout.write("No conflicts detected to merge.") return # If they want to merge and there is something to merge, then # divert into the merge code if self.merge and conflicts: return self.handle_merge(loader, conflicts) if self.interactive: questioner = InteractiveMigrationQuestioner(specified_apps=app_labels, dry_run=self.dry_run) else: questioner = NonInteractiveMigrationQuestioner(specified_apps=app_labels, dry_run=self.dry_run) # Set up autodetector autodetector = MigrationAutodetector( loader.project_state(), ProjectState.from_apps(apps), questioner, ) # If they want to make an empty migration, make one for each app if self.empty: if not app_labels: raise CommandError("You must supply at least one app label when using --empty.") # Make a fake changes() result we can pass to arrange_for_graph changes = { app: [Migration("custom", app)] for app in app_labels } changes = autodetector.arrange_for_graph( changes=changes, graph=loader.graph, migration_name=self.migration_name, ) self.write_migration_files(changes) return # Detect changes changes = autodetector.changes( graph=loader.graph, trim_to_apps=app_labels or None, convert_apps=app_labels or None, migration_name=self.migration_name, ) if not changes: # No changes? Tell them. if self.verbosity >= 1: if app_labels: if len(app_labels) == 1: self.stdout.write("No changes detected in app '%s'" % app_labels.pop()) else: self.stdout.write("No changes detected in apps '%s'" % ("', '".join(app_labels))) else: self.stdout.write("No changes detected") else: self.write_migration_files(changes) if check_changes: sys.exit(1)
class Django19MigrationExecutor(object): """ End-to-end migration execution - loads migrations, and runs them up or down to a specified set of targets. Backported from Django 1.9.1, containing changes from: https://github.com/django/django/commit/5aa55038ca9ac44b440b56d1fc4e79c876e51393 https://github.com/django/django/commit/a80fb8ae24e77abf20047b9dfe867b4b53a8d648 """ def __init__(self, connection, progress_callback=None): self.connection = connection self.loader = MigrationLoader(self.connection) self.recorder = MigrationRecorder(self.connection) self.progress_callback = progress_callback def migration_plan(self, targets, clean_start=False): """ Given a set of targets, returns a list of (Migration instance, backwards?). """ plan = [] if clean_start: applied = set() else: applied = set(self.loader.applied_migrations) for target in targets: # If the target is (app_label, None), that means unmigrate everything if target[1] is None: for root in self.loader.graph.root_nodes(): if root[0] == target[0]: for migration in self.loader.graph.backwards_plan( root): if migration in applied: plan.append( (self.loader.graph.nodes[migration], True)) applied.remove(migration) # If the migration is already applied, do backwards mode, # otherwise do forwards mode. elif target in applied: # Don't migrate backwards all the way to the target node (that # may roll back dependencies in other apps that don't need to # be rolled back); instead roll back through target's immediate # child(ren) in the same app, and no further. next_in_app = sorted( n for n in self.loader.graph.node_map[target].children if n[0] == target[0]) for node in next_in_app: for migration in self.loader.graph.backwards_plan(node): if migration in applied: plan.append( (self.loader.graph.nodes[migration], True)) applied.remove(migration) else: for migration in self.loader.graph.forwards_plan(target): if migration not in applied: plan.append( (self.loader.graph.nodes[migration], False)) applied.add(migration) return plan def migrate(self, targets, plan=None, fake=False, fake_initial=False): """ Migrates the database up to the given targets. Django first needs to create all project states before a migration is (un)applied and in a second step run all the database operations. """ if plan is None: plan = self.migration_plan(targets) # Create the forwards plan Django would follow on an empty database full_plan = self.migration_plan(self.loader.graph.leaf_nodes(), clean_start=True) all_forwards = all(not backwards for mig, backwards in plan) all_backwards = all(backwards for mig, backwards in plan) if not plan: pass # Nothing to do for an empty plan elif all_forwards == all_backwards: # This should only happen if there's a mixed plan raise InvalidMigrationPlan( "Migration plans with both forwards and backwards migrations " "are not supported. Please split your migration process into " "separate plans of only forwards OR backwards migrations.", plan, ) elif all_forwards: self._migrate_all_forwards(plan, full_plan, fake=fake, fake_initial=fake_initial) else: # No need to check for `elif all_backwards` here, as that condition # would always evaluate to true. self._migrate_all_backwards(plan, full_plan, fake=fake) self.check_replacements() def _migrate_all_forwards(self, plan, full_plan, fake, fake_initial): """ 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 = {m[0] for m in plan} state = ProjectState(real_apps=list(self.loader.unmigrated_apps)) for migration, _ in full_plan: if not migrations_to_run: # We remove every migration that we applied from this set 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 "apps" not in state.__dict__: if self.progress_callback: self.progress_callback("render_start") state.apps # Render all -- performance critical if self.progress_callback: self.progress_callback("render_success") state = self.apply_migration(state, migration, fake=fake, fake_initial=fake_initial) migrations_to_run.remove(migration) else: migration.mutate_state(state, preserve=False) def _migrate_all_backwards(self, plan, full_plan, fake): """ Take a list of 2-tuples of the form (migration instance, True) and unapply them in reverse order they occur in the full_plan. Since unapplying a migration requires the project state prior to that migration, Django will compute the migration states before each of them in a first run over the plan and then unapply them in a second run over the plan. """ migrations_to_run = {m[0] for m in plan} # Holds all migration states prior to the migrations being unapplied states = {} state = ProjectState(real_apps=list(self.loader.unmigrated_apps)) if self.progress_callback: self.progress_callback("render_start") for migration, _ in full_plan: if not migrations_to_run: # We remove every migration that we applied from this set 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 "apps" not in state.__dict__: state.apps # Render all -- performance critical # The state before this migration states[migration] = state # The old state keeps as-is, we continue with the new state state = migration.mutate_state(state, preserve=True) migrations_to_run.remove(migration) else: migration.mutate_state(state, preserve=False) if self.progress_callback: self.progress_callback("render_success") for migration, _ in plan: self.unapply_migration(states[migration], migration, fake=fake) def collect_sql(self, plan): """ Takes a migration plan and returns a list of collected SQL statements that represent the best-efforts version of that plan. """ statements = [] state = None for migration, backwards in plan: with self.connection.schema_editor( collect_sql=True) as schema_editor: if state is None: state = self.loader.project_state( (migration.app_label, migration.name), at_end=False) if not backwards: state = migration.apply(state, schema_editor, collect_sql=True) else: state = migration.unapply(state, schema_editor, collect_sql=True) statements.extend(schema_editor.collected_sql) return statements def apply_migration(self, state, migration, fake=False, fake_initial=False): """ Runs a migration forwards. """ if self.progress_callback: self.progress_callback("apply_start", migration, fake) if not fake: if fake_initial: # Test to see if this is an already-applied initial migration applied, state = self.detect_soft_applied(state, migration) if applied: fake = True if not fake: # Alright, do it normally with self.connection.schema_editor() as schema_editor: state = migration.apply(state, schema_editor) # For replacement migrations, record individual statuses if migration.replaces: for app_label, name in migration.replaces: self.recorder.record_applied(app_label, name) else: self.recorder.record_applied(migration.app_label, migration.name) # Report progress if self.progress_callback: self.progress_callback("apply_success", migration, fake) return state def unapply_migration(self, state, migration, fake=False): """ Runs a migration backwards. """ if self.progress_callback: self.progress_callback("unapply_start", migration, fake) if not fake: with self.connection.schema_editor() as schema_editor: state = migration.unapply(state, schema_editor) # For replacement migrations, record individual statuses if migration.replaces: for app_label, name in migration.replaces: self.recorder.record_unapplied(app_label, name) else: self.recorder.record_unapplied(migration.app_label, migration.name) # Report progress if self.progress_callback: self.progress_callback("unapply_success", migration, fake) return state def check_replacements(self): """ Mark replacement migrations applied if their replaced set all are. We do this unconditionally on every migrate, rather than just when migrations are applied or unapplied, so as to correctly handle the case when a new squash migration is pushed to a deployment that already had all its replaced migrations applied. In this case no new migration will be applied, but we still want to correctly maintain the applied state of the squash migration. """ applied = self.recorder.applied_migrations() for key, migration in self.loader.replacements.items(): all_applied = all(m in applied for m in migration.replaces) if all_applied and key not in applied: self.recorder.record_applied(*key) def detect_soft_applied(self, project_state, migration): """ Tests whether a migration has been implicitly applied - that the tables or columns it would create exist. This is intended only for use on initial migrations (as it only looks for CreateModel and AddField). """ if migration.initial is None: # Bail if the migration isn't the first one in its app if any(app == migration.app_label for app, name in migration.dependencies): return False, project_state elif migration.initial is False: # Bail if it's NOT an initial migration return False, project_state if project_state is None: after_state = self.loader.project_state( (migration.app_label, migration.name), at_end=True) else: after_state = migration.mutate_state(project_state) apps = after_state.apps found_create_model_migration = False found_add_field_migration = False existing_table_names = self.connection.introspection.table_names( self.connection.cursor()) # Make sure all create model and add field operations are done for operation in migration.operations: if isinstance(operation, migrations.CreateModel): model = apps.get_model(migration.app_label, operation.name) if model._meta.swapped: # We have to fetch the model to test with from the # main app cache, as it's not a direct dependency. model = global_apps.get_model(model._meta.swapped) if model._meta.proxy or not model._meta.managed: continue if model._meta.db_table not in existing_table_names: return False, project_state found_create_model_migration = True elif isinstance(operation, migrations.AddField): model = apps.get_model(migration.app_label, operation.model_name) if model._meta.swapped: # We have to fetch the model to test with from the # main app cache, as it's not a direct dependency. model = global_apps.get_model(model._meta.swapped) if model._meta.proxy or not model._meta.managed: continue table = model._meta.db_table field = model._meta.get_field(operation.name) # Handle implicit many-to-many tables created by AddField. if field.many_to_many: if field.remote_field.through._meta.db_table not in existing_table_names: return False, project_state else: found_add_field_migration = True continue column_names = [ column.name for column in self.connection.introspection. get_table_description(self.connection.cursor(), table) ] if field.column not in column_names: return False, project_state found_add_field_migration = True # If we get this far and we found at least one CreateModel or AddField migration, # the migration is considered implicitly applied. return (found_create_model_migration or found_add_field_migration), after_state
def handle(self, *app_labels, **options): self.verbosity = int(options.get('verbosity')) self.interactive = options.get('interactive') self.dry_run = options.get('dry_run', False) self.merge = options.get('merge', False) self.empty = options.get('empty', False) # Make sure the app they asked for exists app_labels = set(app_labels) bad_app_labels = set() for app_label in app_labels: try: apps.get_app_config(app_label) except LookupError: bad_app_labels.add(app_label) if bad_app_labels: for app_label in bad_app_labels: self.stderr.write("App '%s' could not be found. Is it in INSTALLED_APPS?" % app_label) sys.exit(2) # Load the current graph state. Pass in None for the connection so # the loader doesn't try to resolve replaced migrations from DB. loader = MigrationLoader(None) # Before anything else, see if there's conflicting apps and drop out # hard if there are any and they don't want to merge conflicts = loader.detect_conflicts() if conflicts and not self.merge: name_str = "; ".join( "%s in %s" % (", ".join(names), app) for app, names in conflicts.items() ) raise CommandError("Conflicting migrations detected (%s).\nTo fix them run 'python manage.py makemigrations --merge'" % name_str) # If they want to merge and there's nothing to merge, then politely exit if self.merge and not conflicts: self.stdout.write("No conflicts detected to merge.") return # If they want to merge and there is something to merge, then # divert into the merge code if self.merge and conflicts: return self.handle_merge(loader, conflicts) # Set up autodetector autodetector = MigrationAutodetector( loader.project_state(), ProjectState.from_apps(apps), InteractiveMigrationQuestioner(specified_apps=app_labels, dry_run=self.dry_run), ) # If they want to make an empty migration, make one for each app if self.empty: if not app_labels: raise CommandError("You must supply at least one app label when using --empty.") # Make a fake changes() result we can pass to arrange_for_graph changes = dict( (app, [Migration("custom", app)]) for app in app_labels ) changes = autodetector.arrange_for_graph(changes, loader.graph) self.write_migration_files(changes) return # Detect changes changes = autodetector.changes( graph=loader.graph, trim_to_apps=app_labels or None, convert_apps=app_labels or None, ) # No changes? Tell them. if not changes and self.verbosity >= 1: if len(app_labels) == 1: self.stdout.write("No changes detected in app '%s'" % app_labels.pop()) elif len(app_labels) > 1: self.stdout.write("No changes detected in apps '%s'" % ("', '".join(app_labels))) else: self.stdout.write("No changes detected") return self.write_migration_files(changes)
def handle(self, *app_labels, **options): self.verbosity = options["verbosity"] self.interactive = options["interactive"] self.dry_run = options["dry_run"] self.merge = options["merge"] self.empty = options["empty"] self.migration_name = options["name"] if self.migration_name and not self.migration_name.isidentifier(): raise CommandError( "The migration name must be a valid Python identifier.") self.include_header = options["include_header"] check_changes = options["check_changes"] # Make sure the app they asked for exists app_labels = set(app_labels) has_bad_labels = False for app_label in app_labels: try: apps.get_app_config(app_label) except LookupError as err: self.stderr.write(str(err)) has_bad_labels = True if has_bad_labels: sys.exit(2) # Load the current graph state. Pass in None for the connection so # the loader doesn't try to resolve replaced migrations from DB. loader = MigrationLoader(None, ignore_no_migrations=True) # Raise an error if any migrations are applied before their dependencies. consistency_check_labels = { config.label for config in apps.get_app_configs() } # Non-default databases are only checked if database routers used. aliases_to_check = (connections if settings.DATABASE_ROUTERS else [DEFAULT_DB_ALIAS]) for alias in sorted(aliases_to_check): connection = connections[alias] if connection.settings_dict[ "ENGINE"] != "django.db.backends.dummy" and any( # At least one model must be migrated to the database. router.allow_migrate(connection.alias, app_label, model_name=model._meta.object_name ) for app_label in consistency_check_labels for model in apps.get_app_config(app_label).get_models()): loader.check_consistent_history(connection) # Before anything else, see if there's conflicting apps and drop out # hard if there are any and they don't want to merge conflicts = loader.detect_conflicts() # If app_labels is specified, filter out conflicting migrations for unspecified apps if app_labels: conflicts = { app_label: conflict for app_label, conflict in conflicts.items() if app_label in app_labels } if conflicts and not self.merge: name_str = "; ".join("%s in %s" % (", ".join(names), app) for app, names in conflicts.items()) raise CommandError( "Conflicting migrations detected; multiple leaf nodes in the " "migration graph: (%s).\nTo fix them run " "'python manage.py makemigrations --merge'" % name_str) # If they want to merge and there's nothing to merge, then politely exit if self.merge and not conflicts: self.stdout.write("No conflicts detected to merge.") return # If they want to merge and there is something to merge, then # divert into the merge code if self.merge and conflicts: return self.handle_merge(loader, conflicts) if self.interactive: questioner = InteractiveMigrationQuestioner( specified_apps=app_labels, dry_run=self.dry_run) else: questioner = NonInteractiveMigrationQuestioner( specified_apps=app_labels, dry_run=self.dry_run) # Set up autodetector autodetector = MigrationAutodetector( loader.project_state(), ProjectState.from_apps(apps), questioner, ) # If they want to make an empty migration, make one for each app if self.empty: if not app_labels: raise CommandError( "You must supply at least one app label when using --empty." ) # Make a fake changes() result we can pass to arrange_for_graph changes = {app: [Migration("custom", app)] for app in app_labels} changes = autodetector.arrange_for_graph( changes=changes, graph=loader.graph, migration_name=self.migration_name, ) self.write_migration_files(changes) return # Detect changes changes = autodetector.changes( graph=loader.graph, trim_to_apps=app_labels or None, convert_apps=app_labels or None, migration_name=self.migration_name, ) if not changes: # No changes? Tell them. if self.verbosity >= 1: if app_labels: if len(app_labels) == 1: self.stdout.write("No changes detected in app '%s'" % app_labels.pop()) else: self.stdout.write("No changes detected in apps '%s'" % ("', '".join(app_labels))) else: self.stdout.write("No changes detected") else: self.write_migration_files(changes) if check_changes: sys.exit(1)
import os
class Command(makemigrations.Command): help = 'Runs makemigrations with some injected code that causes makemigrations to ignore combined model views, ' \ 'then adds the combined model views separately.' """To avoid the risk of overloading names from the makemigrations.Command class, I've prefixed all attributes I assign to this Command class, or an instance thereof, with '_mcv_' (short for 'Make Combined Views'). This convention makes it unlikely that my names will ever collide with Django's, even if updates are made to the Django makemigrations script.""" def _mcv_step2_init(self, *app_labels, **options): self._mcv_loader = MigrationLoader(None) self._mcv_combined_model_nodes = { tup_id: migration for tup_id, migration in self._mcv_loader.graph.nodes.items() if any([ type(op) == CreateCombinedView for op in migration.operations ]) } self._mcv_current_combined_models = gather_combined_models() self._mcv_current_state = self._mcv_loader.project_state() self._mcv_latest_combined_model_state = self._mcv_loader.project_state( nodes=list(self._mcv_combined_model_nodes.keys())) def handle(self, *app_labels, **options): """A filthy hack. Can't be helped so far as I can tell because Django makes the assumption that, other than /the class Model/, all classes whose metaclasses inherit from ModelBase are user-defined models that need to have normal migration logic applied to them. This usually doesn't matter, since CombinedModelViews are forced to be unmanaged (see combine.base.CombinedModelViewBase). However, the CreateModel operation is applied even to unmanaged models. So we have to monkey patch it.""" with patch('django.db.migrations.operations.CreateModel', new=CombinedViewCheckingCreateModel): super(Command, self).handle(*app_labels, **options) #TODO: Handle wacky makemigrations options such as --dry-run. self._mcv_step2_init(*app_labels, **options) models_to_add, models_to_remove = self._mcv_get_combined_model_additions_and_removals( ) app_labels_to_use = set([ label_and_model[0] for label_and_model in models_to_add ]).union( set([label_and_model[0] for label_and_model in models_to_remove])) operations = {label: [] for label in app_labels_to_use} for app_label, model_name in models_to_add: model = self._mcv_current_combined_models[(app_label, model_name)] donors = model._combiner.donors renames = model._combiner.renames.deconstruct() operations[app_label].append( CreateCombinedView(model._meta.object_name, donors, renames)) changes = {} for label, op_list in operations.items(): subclass = type(str("Migration"), (Migration, ), { "operations": op_list, "dependencies": [] }) instance = subclass("combinedview", app_label) changes[label] = [instance] # TODO: Record model changes among models #I don't actually care about autodetecting anything, I just want the arrange_for_graph() method autodetector = MigrationAutodetector(self._mcv_loader.project_state(), ProjectState.from_apps(apps)) changes = autodetector.arrange_for_graph(changes, self._mcv_loader.graph) if changes: self.write_migration_files(changes) def _mcv_historical_combined_models(self): # TODO: Currently counts all combined models that EVER existed, but should instead check the state history to # prune out overwritten/deleted combined models to_return = {} for app_label, migration_name in self._mcv_combined_model_nodes.keys(): migration = self._mcv_combined_model_nodes[(app_label, migration_name)] model_name = [ o for o in migration.operations if type(o) == CreateCombinedView ][0].name.lower() to_return[( app_label, model_name)] = self._mcv_latest_combined_model_state.models[( app_label, model_name)] return to_return def _mcv_get_combined_model_additions_and_removals(self): #returns a 2-tuple of sets of (app_label, model) 2-tuples historic_combined_model_identifiers = set( self._mcv_historical_combined_models().keys()) current_combined_model_identifiers = set( self._mcv_current_combined_models.keys()) models_to_add = current_combined_model_identifiers - historic_combined_model_identifiers models_to_remove = historic_combined_model_identifiers - current_combined_model_identifiers return (models_to_add, models_to_remove)
class TestAlterSortedManyToManyFieldOperation(TransactionTestCase): def setUp(self): from django.db.migrations.executor import MigrationExecutor from django.db.migrations.loader import MigrationLoader from django.db import connection self.migration_executor = MigrationExecutor(connection) self.migration_loader = MigrationLoader(connection) self.state_0001 = self.migration_loader.project_state( ('altersortedmanytomanyfield_tests', '0001_initial')) self.state_0002 = self.migration_loader.project_state( ('altersortedmanytomanyfield_tests', '0002_alter_m2m_fields')) self.state_0001_apps = self.state_0001.render() self.state_0002_apps = self.state_0002.render() # Make sure we are at the latest migration when starting the test. with capture_stdout(): call_command('migrate', 'altersortedmanytomanyfield_tests') def test_apply_migrations_backwards(self): with capture_stdout(): call_command('migrate', 'altersortedmanytomanyfield_tests', '0001') def test_operation_m2m_to_sorted_m2m(self): # Let's start with state after 0001 with capture_stdout(): call_command('migrate', 'altersortedmanytomanyfield_tests', '0001') Target = self.state_0001_apps.get_model( 'altersortedmanytomanyfield_tests', 'target') M2MToSortedM2M = self.state_0001_apps.get_model( 'altersortedmanytomanyfield_tests', 'm2mtosortedm2m') t1 = Target.objects.create(pk=1) t2 = Target.objects.create(pk=2) t3 = Target.objects.create(pk=3) field = M2MToSortedM2M._meta.get_field_by_name('m2m')[0] through_model = field.rel.through # No ordering is in place. self.assertTrue(not through_model._meta.ordering) instance = M2MToSortedM2M.objects.create(pk=1) instance.m2m.add(t3) instance.m2m.add(t1) instance.m2m.add(t2) # We cannot assume any particular order now. # Migrate to state 0002, then we should be able to apply order. with capture_stdout(): call_command('migrate', 'altersortedmanytomanyfield_tests', '0002') Target = self.state_0002_apps.get_model( 'altersortedmanytomanyfield_tests', 'target') M2MToSortedM2M = self.state_0002_apps.get_model( 'altersortedmanytomanyfield_tests', 'm2mtosortedm2m') t1 = Target.objects.get(pk=1) t2 = Target.objects.get(pk=2) t3 = Target.objects.get(pk=3) field = M2MToSortedM2M._meta.get_field_by_name('m2m')[0] through_model = field.rel.through # Now, ordering is there. self.assertTrue(list(through_model._meta.ordering), ['sort_value']) instance = M2MToSortedM2M.objects.get(pk=1) self.assertEqual(list(instance.m2m.order_by('pk')), [t1, t2, t3]) instance.m2m = [t3, t1, t2] self.assertEqual(list(instance.m2m.all()), [t3, t1, t2]) instance.m2m.remove(t1) instance.m2m.remove(t2) instance.m2m.add(t2) instance.m2m.add(t1) self.assertEqual(list(instance.m2m.all()), [t3, t2, t1])
def handle(self, *app_labels, **options): self.verbosity = int(options.get('verbosity')) self.interactive = options.get('interactive') self.dry_run = options.get('dry_run', False) self.merge = options.get('merge', False) self.empty = options.get('empty', False) # Make sure the app they asked for exists app_labels = set(app_labels) bad_app_labels = set() for app_label in app_labels: try: apps.get_app_config(app_label) except LookupError: bad_app_labels.add(app_label) if bad_app_labels: for app_label in bad_app_labels: self.stderr.write( "App '%s' could not be found. Is it in INSTALLED_APPS?" % app_label) sys.exit(2) # Load the current graph state. Pass in None for the connection so # the loader doesn't try to resolve replaced migrations from DB. loader = MigrationLoader(None) # Before anything else, see if there's conflicting apps and drop out # hard if there are any and they don't want to merge conflicts = loader.detect_conflicts() if conflicts and not self.merge: name_str = "; ".join("%s in %s" % (", ".join(names), app) for app, names in conflicts.items()) raise CommandError( "Conflicting migrations detected (%s).\nTo fix them run 'python manage.py makemigrations --merge'" % name_str) # If they want to merge and there's nothing to merge, then politely exit if self.merge and not conflicts: self.stdout.write("No conflicts detected to merge.") return # If they want to merge and there is something to merge, then # divert into the merge code if self.merge and conflicts: return self.handle_merge(loader, conflicts) # Set up autodetector autodetector = MigrationAutodetector( loader.project_state(), ProjectState.from_apps(apps), InteractiveMigrationQuestioner(specified_apps=app_labels), ) # If they want to make an empty migration, make one for each app if self.empty: if not app_labels: raise CommandError( "You must supply at least one app label when using --empty." ) # Make a fake changes() result we can pass to arrange_for_graph changes = dict( (app, [Migration("custom", app)]) for app in app_labels) changes = autodetector.arrange_for_graph(changes, loader.graph) self.write_migration_files(changes) return # Detect changes changes = autodetector.changes(graph=loader.graph, trim_to_apps=app_labels or None) # No changes? Tell them. if not changes and self.verbosity >= 1: if len(app_labels) == 1: self.stdout.write("No changes detected in app '%s'" % app_labels.pop()) elif len(app_labels) > 1: self.stdout.write("No changes detected in apps '%s'" % ("', '".join(app_labels))) else: self.stdout.write("No changes detected") return self.write_migration_files(changes)
def handle(self, *app_labels, **options): self.verbosity = options['verbosity'] self.interactive = options['interactive'] self.dry_run = options['dry_run'] self.merge = options['merge'] self.empty = options['empty'] self.migration_name = options['name'] self.exit_code = options['exit_code'] check_changes = options['check_changes'] if self.exit_code: warnings.warn( "The --exit option is deprecated in favor of the --check option.", RemovedInDjango20Warning ) # Make sure the app they asked for exists app_labels = set(app_labels) bad_app_labels = set() for app_label in app_labels: try: apps.get_app_config(app_label) except LookupError: bad_app_labels.add(app_label) if bad_app_labels: for app_label in bad_app_labels: self.stderr.write("App '%s' could not be found. Is it in INSTALLED_APPS?" % app_label) sys.exit(2) # Load the current graph state. Pass in None for the connection so # the loader doesn't try to resolve replaced migrations from DB. loader = MigrationLoader(None, ignore_no_migrations=True) # Raise an error if any migrations are applied before their dependencies. for db in connections: loader.check_consistent_history(connections[db]) # Before anything else, see if there's conflicting apps and drop out # hard if there are any and they don't want to merge conflicts = loader.detect_conflicts() # If app_labels is specified, filter out conflicting migrations for unspecified apps if app_labels: conflicts = { app_label: conflict for app_label, conflict in iteritems(conflicts) if app_label in app_labels } if conflicts and not self.merge: name_str = "; ".join( "%s in %s" % (", ".join(names), app) for app, names in conflicts.items() ) raise CommandError( "Conflicting migrations detected; multiple leaf nodes in the " "migration graph: (%s).\nTo fix them run " "'python manage.py makemigrations --merge'" % name_str ) # If they want to merge and there's nothing to merge, then politely exit if self.merge and not conflicts: self.stdout.write("No conflicts detected to merge.") return # If they want to merge and there is something to merge, then # divert into the merge code if self.merge and conflicts: return self.handle_merge(loader, conflicts) if self.interactive: questioner = InteractiveMigrationQuestioner(specified_apps=app_labels, dry_run=self.dry_run) else: questioner = NonInteractiveMigrationQuestioner(specified_apps=app_labels, dry_run=self.dry_run) # Set up autodetector autodetector = MigrationAutodetector( loader.project_state(), ProjectState.from_apps(apps), questioner, ) # If they want to make an empty migration, make one for each app if self.empty: if not app_labels: raise CommandError("You must supply at least one app label when using --empty.") # Make a fake changes() result we can pass to arrange_for_graph changes = { app: [Migration("custom", app)] for app in app_labels } changes = autodetector.arrange_for_graph( changes=changes, graph=loader.graph, migration_name=self.migration_name, ) self.write_migration_files(changes) return # Detect changes changes = autodetector.changes( graph=loader.graph, trim_to_apps=app_labels or None, convert_apps=app_labels or None, migration_name=self.migration_name, ) if not changes: # No changes? Tell them. if self.verbosity >= 1: if len(app_labels) == 1: self.stdout.write("No changes detected in app '%s'" % app_labels.pop()) elif len(app_labels) > 1: self.stdout.write("No changes detected in apps '%s'" % ("', '".join(app_labels))) else: self.stdout.write("No changes detected") if self.exit_code: sys.exit(1) else: self.write_migration_files(changes) if check_changes: sys.exit(1)
class TestAlterSortedManyToManyFieldOperation(TransactionTestCase): def setUp(self): from django.db.migrations.executor import MigrationExecutor from django.db.migrations.loader import MigrationLoader from django.db import connection self.migration_executor = MigrationExecutor(connection) self.migration_loader = MigrationLoader(connection) self.state_0001 = self.migration_loader.project_state( ('altersortedmanytomanyfield_tests', '0001_initial')) self.state_0002 = self.migration_loader.project_state( ('altersortedmanytomanyfield_tests', '0002_alter_m2m_fields')) self.state_0001_apps = get_apps_from_state(self.state_0001) self.state_0002_apps = get_apps_from_state(self.state_0002) # Make sure we are at the latest migration when starting the test. with capture_stdout(): call_command('migrate', 'altersortedmanytomanyfield_tests') def test_apply_migrations_backwards(self): with capture_stdout(): call_command('migrate', 'altersortedmanytomanyfield_tests', '0001') def test_operation_m2m_to_sorted_m2m(self): # Let's start with state after 0001 with capture_stdout(): call_command('migrate', 'altersortedmanytomanyfield_tests', '0001') Target = self.state_0001_apps.get_model( 'altersortedmanytomanyfield_tests', 'target') M2MToSortedM2M = self.state_0001_apps.get_model( 'altersortedmanytomanyfield_tests', 'm2mtosortedm2m') t1 = Target.objects.create(pk=1) t2 = Target.objects.create(pk=2) t3 = Target.objects.create(pk=3) field = get_field(M2MToSortedM2M,'m2m') through_model = get_rel(field).through # No ordering is in place. self.assertTrue(not through_model._meta.ordering) instance = M2MToSortedM2M.objects.create(pk=1) instance.m2m.add(t3) instance.m2m.add(t1) instance.m2m.add(t2) # We cannot assume any particular order now. # Migrate to state 0002, then we should be able to apply order. with capture_stdout(): call_command('migrate', 'altersortedmanytomanyfield_tests', '0002') Target = self.state_0002_apps.get_model( 'altersortedmanytomanyfield_tests', 'target') M2MToSortedM2M = self.state_0002_apps.get_model( 'altersortedmanytomanyfield_tests', 'm2mtosortedm2m') t1 = Target.objects.get(pk=1) t2 = Target.objects.get(pk=2) t3 = Target.objects.get(pk=3) field = get_field(M2MToSortedM2M,'m2m') through_model = get_rel(field).through # Now, ordering is there. self.assertTrue(list(through_model._meta.ordering), ['sort_value']) instance = M2MToSortedM2M.objects.get(pk=1) self.assertEqual(list(instance.m2m.order_by('pk')), [t1, t2, t3]) m2m_set(instance, "m2m", [t3, t1, t2]) self.assertEqual(list(instance.m2m.all()), [t3, t1, t2]) instance.m2m.remove(t1) instance.m2m.remove(t2) instance.m2m.add(t2) instance.m2m.add(t1) self.assertEqual(list(instance.m2m.all()), [t3, t2, t1])
def handle(self, *app_labels, **options): self.verbosity = options['verbosity'] self.interactive = options['interactive'] self.dry_run = options['dry_run'] self.merge = options['merge'] self.empty = options['empty'] self.migration_name = options['name'] self.replace_all = options['replace_all'] check_changes = options['check_changes'] # Make sure the app they asked for exists app_labels = set(app_labels) bad_app_labels = set() for app_label in app_labels: try: apps.get_app_config(app_label) except LookupError: bad_app_labels.add(app_label) if bad_app_labels: for app_label in bad_app_labels: if '.' in app_label: self.stderr.write( "'%s' is not a valid app label. Did you mean '%s'?" % ( app_label, app_label.split('.')[-1], )) else: self.stderr.write( "App '%s' could not be found. Is it in INSTALLED_APPS?" % app_label) sys.exit(2) # Load the current graph state. Pass in None for the connection so # the loader doesn't try to resolve replaced migrations from DB. loader = MigrationLoader(None, ignore_no_migrations=True) # Raise an error if any migrations are applied before their dependencies. consistency_check_labels = { config.label for config in apps.get_app_configs() } # Non-default databases are only checked if database routers used. aliases_to_check = connections if settings.DATABASE_ROUTERS else [ DEFAULT_DB_ALIAS ] for alias in sorted(aliases_to_check): connection = connections[alias] if (connection.settings_dict['ENGINE'] != 'django.db.backends.dummy' and any( # At least one model must be migrated to the database. router.allow_migrate(connection.alias, app_label, model_name=model._meta.object_name ) for app_label in consistency_check_labels for model in apps.get_app_config(app_label).get_models())): loader.check_consistent_history(connection) # Before anything else, see if there's conflicting apps and drop out # hard if there are any and they don't want to merge conflicts = loader.detect_conflicts() # If app_labels is specified, filter out conflicting migrations for unspecified apps if app_labels: conflicts = { app_label: conflict for app_label, conflict in conflicts.items() if app_label in app_labels } if conflicts and not self.merge: name_str = "; ".join("%s in %s" % (", ".join(names), app) for app, names in conflicts.items()) raise CommandError( "Conflicting migrations detected; multiple leaf nodes in the " "migration graph: (%s).\nTo fix them run " "'python manage.py makemigrations --merge'" % name_str) # If they want to merge and there's nothing to merge, then politely exit if self.merge and not conflicts: self.stdout.write("No conflicts detected to merge.") return # If they want to merge and there is something to merge, then # divert into the merge code if self.merge and conflicts: return self.handle_merge(loader, conflicts) if self.interactive: questioner = InteractiveMigrationQuestioner( specified_apps=app_labels, dry_run=self.dry_run) else: questioner = NonInteractiveMigrationQuestioner( specified_apps=app_labels, dry_run=self.dry_run) if self.replace_all: replace_list = [ migration for migration in loader.graph.nodes.values() ] temp_nodes = loader.graph.nodes loader.graph.nodes = { k: v for (k, v) in loader.graph.nodes.items() if k[0] not in app_labels } autodetector = MigrationAutodetector( loader.project_state(), ProjectState.from_apps(apps), questioner, ) loader.graph.nodes = temp_nodes else: autodetector = MigrationAutodetector( loader.project_state(), ProjectState.from_apps(apps), questioner, ) # If they want to make an empty migration, make one for each app if self.empty: if not app_labels: raise CommandError( "You must supply at least one app label when using --empty." ) # Make a fake changes() result we can pass to arrange_for_graph changes = {app: [Migration("custom", app)] for app in app_labels} changes = autodetector.arrange_for_graph( changes=changes, graph=loader.graph, migration_name=self.migration_name, ) self.write_migration_files(changes) return # Detect changes changes = autodetector.changes( graph=loader.graph, trim_to_apps=app_labels or None, convert_apps=app_labels or None, migration_name=self.migration_name, ) if not changes: # No changes? Tell them. if self.verbosity >= 1: if app_labels: if len(app_labels) == 1: self.stdout.write("No changes detected in app '%s'" % app_labels.pop()) else: self.stdout.write("No changes detected in apps '%s'" % ("', '".join(app_labels))) else: self.stdout.write("No changes detected") else: if self.replace_all: for app_label, app_migrations in changes.items(): for app_migration in app_migrations: app_migration.replaces = \ [ (migration.app_label, migration.name) for migration in replace_list if migration.app_label == app_label ] app_migration.dependencies = [ dependency for dependency in app_migration.dependencies if dependency not in app_migration.replaces ] self.write_migration_files(changes) if check_changes: sys.exit(1)
def handle(self, *app_labels, **options): self.verbosity = options['verbosity'] self.interactive = options['interactive'] self.dry_run = options['dry_run'] self.merge = options['merge'] self.empty = options['empty'] self.migration_name = options['name'] self.exit_code = options['exit_code'] check_changes = options['check_changes'] if self.exit_code: warnings.warn( "The --exit option is deprecated in favor of the --check option.", RemovedInDjango20Warning ) # Make sure the app they asked for exists app_labels = set(app_labels) bad_app_labels = set() for app_label in app_labels: try: apps.get_app_config(app_label) except LookupError: bad_app_labels.add(app_label) if bad_app_labels: for app_label in bad_app_labels: self.stderr.write("App '%s' could not be found. Is it in INSTALLED_APPS?" % app_label) sys.exit(2) # Load the current graph state. Pass in None for the connection so # the loader doesn't try to resolve replaced migrations from DB. loader = MigrationLoader(None, ignore_no_migrations=True) # Before anything else, see if there's conflicting apps and drop out # hard if there are any and they don't want to merge conflicts = loader.detect_conflicts() # If app_labels is specified, filter out conflicting migrations for unspecified apps if app_labels: conflicts = { app_label: conflict for app_label, conflict in iteritems(conflicts) if app_label in app_labels } if conflicts and not self.merge: name_str = "; ".join( "%s in %s" % (", ".join(names), app) for app, names in conflicts.items() ) raise CommandError( "Conflicting migrations detected; multiple leaf nodes in the " "migration graph: (%s).\nTo fix them run " "'python manage.py makemigrations --merge'" % name_str ) # If they want to merge and there's nothing to merge, then politely exit if self.merge and not conflicts: self.stdout.write("No conflicts detected to merge.") return # If they want to merge and there is something to merge, then # divert into the merge code if self.merge and conflicts: return self.handle_merge(loader, conflicts) if self.interactive: questioner = InteractiveMigrationQuestioner(specified_apps=app_labels, dry_run=self.dry_run) else: questioner = NonInteractiveMigrationQuestioner(specified_apps=app_labels, dry_run=self.dry_run) # Set up autodetector autodetector = MigrationAutodetector( loader.project_state(), ProjectState.from_apps(apps), questioner, ) # If they want to make an empty migration, make one for each app if self.empty: if not app_labels: raise CommandError("You must supply at least one app label when using --empty.") # Make a fake changes() result we can pass to arrange_for_graph changes = { app: [Migration("custom", app)] for app in app_labels } changes = autodetector.arrange_for_graph( changes=changes, graph=loader.graph, migration_name=self.migration_name, ) self.write_migration_files(changes) return # Detect changes changes = autodetector.changes( graph=loader.graph, trim_to_apps=app_labels or None, convert_apps=app_labels or None, migration_name=self.migration_name, ) if not changes: # No changes? Tell them. if self.verbosity >= 1: if len(app_labels) == 1: self.stdout.write("No changes detected in app '%s'" % app_labels.pop()) elif len(app_labels) > 1: self.stdout.write("No changes detected in apps '%s'" % ("', '".join(app_labels))) else: self.stdout.write("No changes detected") if self.exit_code: sys.exit(1) else: self.write_migration_files(changes) if check_changes: sys.exit(1)