Migrations

CommandError: Conflicting migrations detected; multiple leaf nodes in the migration graph: (0007_book_isbn, 0007_book_page_count in catalog).
To fix them run 'python manage.py makemigrations --merge'

python manage.py makemigrations --merge --noinput
python manage.py showmigrations --plan catalog

Merging catalog
  Branch 0007_book_isbn
    + Add field isbn to book
  Branch 0007_book_page_count
    + Add field page_count to book

Created new merge migration .../catalog/migrations/0008_merge_0007_book_isbn_0007_book_page_count.py
[X]  catalog.0006_book_title_index
[ ]  catalog.0007_book_page_count
[ ]  catalog.0007_book_isbn
[ ]  catalog.0008_merge_0007_book_isbn_0007_book_page_count

# catalog/migrations/0008_merge_0007_book_isbn_0007_book_page_count.py
from django.db import migrations


class Migration(migrations.Migration):

    dependencies = [
        ("catalog", "0007_book_isbn"),
        ("catalog", "0007_book_page_count"),
    ]

    operations = []

python manage.py migrate catalog 0002
python manage.py showmigrations catalog
python manage.py migrate catalog

Operations to perform:
  Target specific migration: 0002_book_slug, from catalog
Running migrations:
  Rendering model states... DONE
  Unapplying catalog.0004_book_slug_unique... OK
  Unapplying catalog.0003_populate_book_slugs... OK
catalog
 [X] 0001_initial
 [X] 0002_book_slug
 [ ] 0003_populate_book_slugs
 [ ] 0004_book_slug_unique
Operations to perform:
  Apply all migrations: catalog
Running migrations:
  Applying catalog.0003_populate_book_slugs... OK
  Applying catalog.0004_book_slug_unique... OK

# catalog/migrations/0005_irreversible_demo.py (demonstration only; removed afterwards)
from django.db import migrations


class Migration(migrations.Migration):
    dependencies = [("catalog", "0004_book_slug_unique")]
    operations = [
        migrations.RunSQL("CREATE TABLE demo_books (id integer PRIMARY KEY)"),
    ]

django.db.migrations.exceptions.IrreversibleError: Operation <RunSQL 'CREATE TABLE demo_books (id integer PRIMARY KEY)'> in catalog.0005_irreversible_demo is not reversible

class Book(models.Model):
    # ...
    class Meta:
        indexes = [models.Index(fields=["title"], name="book_title_idx")]

# catalog/migrations/0006_book_title_index.py
from django.db import migrations, models


class Migration(migrations.Migration):

    dependencies = [
        ("catalog", "0005_rename_author_name"),
    ]

    operations = [
        migrations.RunSQL(
            sql='CREATE INDEX "book_title_idx" ON "catalog_book" ("title")',
            reverse_sql='DROP INDEX "book_title_idx"',
            state_operations=[
                migrations.AddIndex(
                    model_name="book",
                    index=models.Index(fields=["title"], name="book_title_idx"),
                ),
            ],
        ),
    ]

python manage.py makemigrations --check --dry-run
python manage.py sqlmigrate catalog 0006 --backwards

No changes detected
BEGIN;
--
-- Raw SQL operation
--
DROP INDEX "book_title_idx";
COMMIT;

# models.py (after the change)
class Book(models.Model):
    # ...
    tags = models.ManyToManyField("Tag", through="BookTag", blank=True)


class Tag(models.Model):
    name = models.CharField(max_length=50, unique=True)


class BookTag(models.Model):
    book = models.ForeignKey(Book, on_delete=models.CASCADE)
    tag = models.ForeignKey(Tag, on_delete=models.CASCADE)
    is_primary = models.BooleanField(default=False)

    class Meta:
        constraints = [
            models.UniqueConstraint(fields=["book", "tag"], name="unique_book_tag"),
        ]

# catalog/migrations/0010_book_tags_through.py
import django.db.models.deletion
from django.db import migrations, models


class Migration(migrations.Migration):

    dependencies = [
        ("catalog", "0009_tag_and_book_tags"),
    ]

    operations = [
        migrations.SeparateDatabaseAndState(
            database_operations=[
                # Old name: from sqlmigrate/dbshell. New name: BookTag._meta.db_table.
                migrations.RunSQL(
                    sql="ALTER TABLE catalog_book_tags RENAME TO catalog_booktag",
                    reverse_sql="ALTER TABLE catalog_booktag RENAME TO catalog_book_tags",
                ),
            ],
            state_operations=[
                migrations.CreateModel(
                    name="BookTag",
                    fields=[
                        ("id", models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name="ID")),
                        ("book", models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to="catalog.book")),
                        ("tag", models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to="catalog.tag")),
                    ],
                    options={
                        "constraints": [
                            models.UniqueConstraint(fields=["book", "tag"], name="unique_book_tag")
                        ],
                    },
                ),
                migrations.AlterField(
                    model_name="book",
                    name="tags",
                    field=models.ManyToManyField(blank=True, through="catalog.BookTag", to="catalog.tag"),
                ),
            ],
        ),
        migrations.AddField(
            model_name="booktag",
            name="is_primary",
            field=models.BooleanField(default=False),
        ),
    ]

python manage.py makemigrations --check --dry-run -v3
python manage.py migrate catalog
python manage.py shell -c "
from catalog.models import BookTag
print([(bt.book.title, bt.tag.name, bt.is_primary) for bt in BookTag.objects.all()])"
python manage.py migrate catalog 0009

No changes detected
Running migrations:
  Applying catalog.0010_book_tags_through... OK
[('Kindred', 'time travel', False), ('The Dispossessed', 'utopia', False)]
Running migrations:
  Rendering model states... DONE
  Unapplying catalog.0010_book_tags_through... OK

python manage.py squashmigrations catalog 0001 0004 --noinput

Will squash the following migrations:
 - 0001_initial
 - 0002_book_slug
 - 0003_populate_book_slugs
 - 0004_book_slug_unique
Optimizing...
  Optimized from 5 operations to 4 operations.
Created new squashed migration .../catalog/migrations/0001_initial_squashed_0004_book_slug_unique.py
  You should commit this migration but leave the old ones in place;
  the new migration will be used for new installs. Once you are sure
  all instances of the codebase have applied the migrations you squashed,
  you can delete them.
Manual porting required
  Your migrations contained functions that must be manually copied over,
  as we could not safely copy their implementation.
  See the comment at the top of the squashed migration for details.

# Functions from the following migrations need manual copying.
# Move them and any dependencies into this file, then update the
# RunPython operations to refer to the local versions:
# catalog.migrations.0003_populate_book_slugs

class Migration(migrations.Migration):

    replaces = [('catalog', '0001_initial'), ('catalog', '0002_book_slug'), ('catalog', '0003_populate_book_slugs'), ('catalog', '0004_book_slug_unique')]
    # ...
        migrations.RunPython(
            code=catalog.migrations.0003_populate_book_slugs.populate_slugs,
            reverse_code=catalog.migrations.0003_populate_book_slugs.clear_slugs,
        ),

python manage.py showmigrations catalog
python manage.py makemigrations --check

catalog
 [-] 0001_initial_squashed_0004_book_slug_unique (4 squashed migrations) Run 'manage.py migrate' to finish recording.
 [X] 0005_rename_author_name
 ...
No changes detected

Running migrations:
  Applying catalog.0001_initial_squashed_0004_book_slug_unique... OK
  Applying catalog.0005_rename_author_name... OK
  ...

# catalog/migrations/0012_backfill_title_words.py
from django.db import migrations, transaction

BATCH_SIZE = 2  # use a few thousand on a real table


def backfill(apps, schema_editor):
    Book = apps.get_model("catalog", "Book")
    db_alias = schema_editor.connection.alias
    last_pk = 0
    while True:
        batch = list(
            Book.objects.using(db_alias)
            .filter(pk__gt=last_pk, title_words__isnull=True)
            .order_by("pk")[:BATCH_SIZE]
        )
        if not batch:
            break
        # One short transaction per batch instead of one for the whole table.
        with transaction.atomic(using=db_alias):
            for book in batch:
                book.title_words = len(book.title.split())
            Book.objects.using(db_alias).bulk_update(batch, ["title_words"])
        last_pk = batch[-1].pk


class Migration(migrations.Migration):
    atomic = False

    dependencies = [
        ("catalog", "0011_book_title_words"),
    ]

    operations = [
        migrations.RunPython(backfill, reverse_code=migrations.RunPython.noop),
    ]

# catalog/migrations/0013_title_words_not_null.py
from django.db import migrations, models


class Migration(migrations.Migration):

    dependencies = [
        ("catalog", "0012_backfill_title_words"),
    ]

    operations = [
        migrations.AlterField(
            model_name="book",
            name="title_words",
            field=models.PositiveSmallIntegerField(),
        ),
    ]

python manage.py makemigrations --check
python manage.py migrate catalog

No changes detected
Running migrations:
  Applying catalog.0013_title_words_not_null... OK

# PostgreSQL only: not run here (no PostgreSQL server was available)
from django.contrib.postgres.operations import AddIndexConcurrently
from django.db import migrations, models


class Migration(migrations.Migration):
    atomic = False  # CREATE INDEX CONCURRENTLY cannot run in a transaction

    dependencies = [("catalog", "0013_title_words_not_null")]

    operations = [
        AddIndexConcurrently(
            "book",
            models.Index(fields=["isbn"], name="book_isbn_idx"),
        ),
    ]

# catalog/operations.py
from django.db.migrations.operations.base import Operation, OperationCategory


class CreateView(Operation):
    """Create a database view; reverse drops it. Does not change the model state."""

    reversible = True
    reduces_to_sql = True  # show the SQL in sqlmigrate
    category = OperationCategory.SQL

    def __init__(self, name, select_sql):
        self.name = name
        self.select_sql = select_sql

    def state_forwards(self, app_label, state):
        pass  # views are not models, so the project state does not change

    def database_forwards(self, app_label, schema_editor, from_state, to_state):
        schema_editor.execute(
            "CREATE VIEW %s AS %s"
            % (schema_editor.quote_name(self.name), self.select_sql)
        )

    def database_backwards(self, app_label, schema_editor, from_state, to_state):
        schema_editor.execute("DROP VIEW %s" % schema_editor.quote_name(self.name))

    def describe(self):
        return "Creates view %s" % self.name

    @property
    def migration_name_fragment(self):
        return "create_view_%s" % self.name

    def deconstruct(self):
        # Needed only if makemigrations/squashmigrations must write the operation out.
        return (self.__class__.__qualname__, [], {"name": self.name, "select_sql": self.select_sql})

# catalog/migrations/0014_book_titles_view.py
from django.db import migrations

from catalog.operations import CreateView


class Migration(migrations.Migration):

    dependencies = [
        ("catalog", "0013_title_words_not_null"),
    ]

    operations = [
        CreateView(
            "catalog_book_titles",
            "SELECT id, title, title_words FROM catalog_book",
        ),
    ]

python manage.py sqlmigrate catalog 0014
python manage.py migrate catalog
python manage.py migrate catalog 0013

BEGIN;
--
-- Creates view catalog_book_titles
--
CREATE VIEW "catalog_book_titles" AS SELECT id, title, title_words FROM catalog_book;
COMMIT;
Running migrations:
  Applying catalog.0014_book_titles_view... OK
  Rendering model states... DONE
  Unapplying catalog.0014_book_titles_view... OK

from django.db import connection

with connection.schema_editor() as schema_editor:
    schema_editor.create_model(MyUnmanagedModel)

# catalog/models.py
from django.core.exceptions import ValidationError
from django.db import models
from django.utils.deconstruct import deconstructible


@deconstructible
class DigitsOnly:
    def __init__(self, length=13):
        self.length = length

    def __call__(self, value):
        if not (value.isdigit() and len(value) == self.length):
            raise ValidationError(f"Expected {self.length} digits.")

    def __eq__(self, other):
        return isinstance(other, DigitsOnly) and self.length == other.length


class Book(models.Model):
    isbn = models.CharField(max_length=13, blank=True, validators=[DigitsOnly(13)])
    # ...

Migrations for 'catalog':
  catalog/migrations/0016_alter_book_isbn.py
    ~ Alter field isbn on book

migrations.AlterField(
    model_name="book",
    name="isbn",
    field=models.CharField(blank=True, max_length=13, validators=[catalog.models.DigitsOnly(13)]),
)

ValueError: Cannot serialize function: lambda

# catalog/dbrouters.py
class HintRouter:
    def allow_migrate(self, db, app_label, model_name=None, **hints):
        if "target_db" in hints:
            return db == hints["target_db"]
        return True

# config/settings.py
DATABASES["archive"] = {"ENGINE": "django.db.backends.sqlite3", "NAME": BASE_DIR / "archive.sqlite3"}
DATABASE_ROUTERS = ["catalog.dbrouters.HintRouter"]

# catalog/migrations/0015_seed_default_db_only.py
from django.db import migrations


def forwards(apps, schema_editor):
    Tag = apps.get_model("catalog", "Tag")
    # Always use the alias of the database being migrated.
    Tag.objects.using(schema_editor.connection.alias).get_or_create(name="seeded")


class Migration(migrations.Migration):

    dependencies = [
        ("catalog", "0014_book_titles_view"),
    ]

    operations = [
        migrations.RunPython(
            forwards,
            reverse_code=migrations.RunPython.noop,
            hints={"target_db": "default"},
        ),
    ]

python manage.py migrate
python manage.py migrate --database archive
python manage.py shell -c "
from catalog.models import Tag
print('default', list(Tag.objects.using('default').values_list('name', flat=True)))
print('archive', list(Tag.objects.using('archive').values_list('name', flat=True)))"

default ['utopia', 'time travel', 'seeded']
archive []

# catalog/tests.py
from django.core.management import call_command
from django.db import connection
from django.db.migrations.executor import MigrationExecutor
from django.test import TransactionTestCase


class MigrationTestCase(TransactionTestCase):
    """Base class: migrate to `migrate_from`, let the test seed data, then to `migrate_to`."""

    app = "catalog"
    migrate_from = None
    migrate_to = None

    def setUp(self):
        super().setUp()
        self.executor = MigrationExecutor(connection)
        self.executor.migrate([(self.app, self.migrate_from)])
        old_apps = self.executor.loader.project_state([(self.app, self.migrate_from)]).apps
        self.setUpBeforeMigration(old_apps)
        self.executor = MigrationExecutor(connection)  # reload the graph
        self.executor.migrate([(self.app, self.migrate_to)])
        self.apps = self.executor.loader.project_state([(self.app, self.migrate_to)]).apps

    def setUpBeforeMigration(self, apps):
        pass

    def tearDown(self):
        # Leave the test database fully migrated for the next test.
        call_command("migrate", verbosity=0)
        super().tearDown()


class PopulateSlugsTests(MigrationTestCase):
    migrate_from = "0002_book_slug"
    migrate_to = "0004_book_slug_unique"

    def setUpBeforeMigration(self, apps):
        Author = apps.get_model("catalog", "Author")
        Book = apps.get_model("catalog", "Book")
        author = Author.objects.create(name="Ursula K. Le Guin")
        Book.objects.create(title="The Dispossessed", author=author)
        Book.objects.create(title="The Dispossessed", author=author)

    def test_slugs_are_filled_and_unique(self):
        Book = self.apps.get_model("catalog", "Book")
        slugs = sorted(Book.objects.values_list("slug", flat=True))
        self.assertEqual(len(slugs), len(set(slugs)))
        self.assertTrue(all(s.startswith("the-dispossessed-") for s in slugs))

    def test_historical_models_have_no_custom_methods(self):
        Author = self.apps.get_model("catalog", "Author")
        # The real Author.__str__ returns the name; the historical one is Django's default.
        self.assertTrue(str(Author(pk=1)).startswith("Author object"))


class ReversibilityTests(MigrationTestCase):
    migrate_from = "0004_book_slug_unique"
    migrate_to = "0004_book_slug_unique"

    def test_every_migration_can_be_reversed_and_reapplied(self):
        call_command("migrate", "catalog", "zero", verbosity=0)
        call_command("migrate", "catalog", verbosity=0)


class NoMissingMigrationsTests(TransactionTestCase):
    def test_models_and_migrations_are_in_sync(self):
        # --check exits with status 1 (SystemExit) when model changes lack a migration.
        call_command("makemigrations", "--check", "--dry-run", verbosity=0)

python manage.py test catalog

Creating test database for alias 'default'...
....
----------------------------------------------------------------------
Ran 4 tests in 0.140s

OK
Destroying test database for alias 'default'...

# tables exist, but django_migrations has no catalog rows
python manage.py migrate catalog 0001
python manage.py migrate catalog 0001 --fake-initial

django.db.utils.OperationalError: table "catalog_author" already exists
  Target specific migration: 0001_initial, from catalog
Running migrations:
  Applying catalog.0001_initial... FAKED