マイグレーション (Migrations) は、Django でモデルに対して行った変更 (フィールドの追加やモデルの削除など) をデータベーススキーマに反映させる方法です。大抵のマイグレーションは自動で行われるものの、いつマイグレーションが作られ、いつ実行され、どんな問題がよく起こるのかは、知っておいた方がいいでしょう。
\nマイグレーションと Django のデータベーススキーマの操作に関わる時によく使うコマンドを、いくつか挙げておきましょう。
\nmigrate は、マイグレーションを適用したり、適用をキャンセルするのに使います。
makemigrations は、モデルに対して行った変更をもとに、新しいマイグレーションを作成します。
sqlmigrate は、マイグレーションに対応する SQL 文を表示します。
showmigrations は、プロジェクトのマイグレーションとそのステータスをリストします。
マイグレーションというのは、データベーススキーマに対するバージョン管理システムのようなものです。makemigrations はモデルの変更点を1つのマイグレーションファイルにパッケージングし(コミットのようなものです)、migrate はその変更点をデータベースに適用する、というわけです。
各アプリのマイグレーションファイルはそのアプリの "migrations" ディレクトリの中に保管され、コードベースの一部としてコミットされ、配布されるようにデザインされています。いったん開発用マシンでマイグレーションファイルが作成されれば、その後、チームメンバーのマシンやステージング環境のマシン上で同一のマイグレーションが行われ、最終的にプロダクション環境でも同じマイグレーションが行われます。
\n\nマイグレーションが同じデータセットに同じ方法で実行され、一貫した結果を生み出すということは、開発環境やステージング環境下で目にする結果が、プロダクション環境下でも全く同じになるということです。
\nDjango will make migrations for any change to your models or fields - even\noptions that don't affect the database - as the only way it can reconstruct\na field correctly is to have all the changes in the history, and you might\nneed those options in some data migrations later on (for example, if you've\nset custom validators).
\nマイグレーションは Django で標準で利用できるすべてのバックエンドに対応しています。サードパーティ製のバックエンドでも、プログラムからのスキーマの変更の操作(SchemaEditor クラスで実行される)に対応していれば大丈夫です。
\nしかし、スキーマのマイグレーションは、データベースによってが得手・不得手があります。注意点を以下で説明します。
\nPostgreSQL is the most capable of all the databases here in terms of schema\nsupport.
\nThe only caveat is that prior to PostgreSQL 11, adding columns with default\nvalues causes a full rewrite of the table, for a time proportional to its size.\nFor this reason, it's recommended you always create new columns with\nnull=True, as this way they will be added immediately.
MySQL はスキーマの変更操作周りのトランザクションをサポートしていません。つまり、マイグレーションの適用が失敗した場合には、手動で変更点を調べあげ、やり直さなければならないということです (過去の時点にロールバックすることは不可能ということです)。
\nさらに、MySQL はほとんどすべてのスキーマ操作でテーブル全体を書き直すため、カラムを追加・削除するたびに、一般にテーブルの行数に比例した時間がかかってしまいます。遅いハードでは、この操作に100万行あたり1分以上もかかってしまうため、たった数100万行のテーブルに数カラムを追加するだけで、サイトを10分以上ロックすることになります。
\nしたがって、MySQL にはカラムやテーブルやインデックスの長さに比較的短い制限があり、インデックスが作られたカラムの結合後のサイズにも制限があります。つまり、他のバックエンドでは可能なインデックスであっても、MySQL では作成に失敗してしまうことがあるということです。
\nSQLite はビルトインのスキーマ変更操作をほとんどサポートしていません。そのため、Django は以下のようにしてスキーマの変更動作をエミュレートします。
\n新しいスキーマで、新しいテーブルを作成する
テーブル間でデータをコピーする
古いテーブルを削除する
新しいテーブルを元のテーブル名に変更する
この方法で大抵はうまくいきますが、遅かったりたまにテーブルが壊れてしまうことがあります。そのため、SQLite をプロダクション環境で使用するのは、このリスクと制限を十分理解している場合以外には、おすすめしません。Django がデフォルトで SQLite を使用しているのは、開発者が SQLite をローカルマシンでかんたんに実行できるようにすることで、本格的なデータベースがなくても Django のプロジェクトが開発できるようにして、複雑さを除くようにデザインされているからです。
\nDjango can create migrations for you. Make changes to your models - say, add a\nfield and remove a model - and then run makemigrations:
$ python manage.py makemigrations\nMigrations for 'books':\n books/migrations/0003_auto.py:\n - Alter field author on book\nすると、あなたが書いたモデルがスキャンされ、現在のバージョンのマイグレーションファイルに記録されているモデルと比較されます。この時、makemigrations があなたが何を変更したと考えているのかを理解するために、出力をよく読んでください。不完全だったり、意図したよりも複雑な結果が表示されるかもしれません。
問題なく新しいマイグレーションファイルが生成されたら、期待通りに変更が行われるように、データベースに適用します
\n$ python manage.py migrate\nOperations to perform:\n Apply all migrations: books\nRunning migrations:\n Rendering model states... DONE\n Applying books.0003_auto... OK\nマイグレーションを適用したら、マイグレーションとモデルの変更をバージョン管理システムに1つのコミットとしてコミットしましょう。こうすることで、他の開発者 (やプロダクションサーバー) がコードをチェックアウトした時に、モデルの変更とマイグレーションの適用を同時に実行することができます。
\nマイグレーションに、自動生成された名前ではなく、意味のある名前を与えたければ、makemigrations --name オプションが使えます。
$ python manage.py makemigrations --name changed_my_model your_app_label\nマイグレーションはバージョン管理システムに保管されるため、あなたがマイグレーションをコミットしたのと同じアプリに、同じタイミングで、他の開発者もマイグレーションをコミットしてしまい、結果として同じ数字のマイグレーションが2つできてしまう、というシチュエーションに遭遇するかもしれません。
\nでも、大丈夫。マイグレーションの数字は開発者が参考にするために付けられているだけなのです。Django が気にするのは、マイグレーションの名前が異なっているかどうかだけです。マイグレーションはファイルの中で、自分が依存している他のマイグレーション (同じアプリの過去のマイグレーションを含む) を明記しています。そのため、同じアプリへの2つの順序関係がない新しいマイグレーションが存在していれば、それらをちゃんと検出できます。
\nこのような状況が起きた場合、Django はいくつかの選択肢を提示します。それを読んで十分安全だと判断できれば、2つのマイグレーションを自動的に2つの連続するマイグレーションに変更してくれます。そうでなければ、マイグレーションファイルを自分で修正する必要があります。でも、難しくないので心配はいりません。詳しくは、下の マイグレーションファイル で説明しています。
\nOn databases that support DDL transactions (SQLite and PostgreSQL), all\nmigration operations will run inside a single transaction by default. In\ncontrast, if a database doesn't support DDL transactions (e.g. MySQL, Oracle)\nthen all operations will run without a transaction.
\nYou can prevent a migration from running in a transaction by setting the\natomic attribute to False. For example:
from django.db import migrations\n\nclass Migration(migrations.Migration):\n atomic = False\nIt's also possible to execute parts of the migration inside a transaction using\natomic() or by passing atomic=True to\nRunPython. See\n非アトミックのマイグレーション for more details.
While migrations are per-app, the tables and relationships implied by\nyour models are too complex to be created for one app at a time. When you make\na migration that requires something else to run - for example, you add a\nForeignKey in your books app to your authors app - the resulting\nmigration will contain a dependency on a migration in authors.
つまり、マイグレーションを実行すると、最初に authors のマイグレーションが実行されて ForeignKey リファレンスが参照するテーブルが作成され、その後で ForeignKey カラムを作るマイグレーションが実行された後、制約が作られます。もしそうでなかったら、books のマイグレーションが存在しないテーブルを参照する ForeignKey カラムを作ろうとして、結果、データベースはエラーを出してしまうでしょう。
This dependency behavior affects most migration operations where you\nrestrict to a single app. Restricting to a single app (either in\nmakemigrations or migrate) is a best-efforts promise, and not\na guarantee; any other apps that need to be used to get dependencies correct\nwill be.
Apps without migrations must not have relations (ForeignKey,\nManyToManyField, etc.) to apps with migrations. Sometimes it may work, but\nit's not supported.
Migrations are stored as an on-disk format, referred to here as\n"migration files". These files are actually normal Python files with an\nagreed-upon object layout, written in a declarative style.
\n基本的なマイグレーションファイルは、次のような形式です。
\nfrom django.db import migrations, models\n\nclass Migration(migrations.Migration):\n\n dependencies = [('migrations', '0001_initial')]\n\n operations = [\n migrations.DeleteModel('Tribble'),\n migrations.AddField('Author', 'rating', models.IntegerField(default=0)),\n ]\nDjango が (Python モジュールとして) マイグレーションファイルを読み込んだ時に最初に探すのは、Migration という名前の django.db.migrations.Migration のサブクラスです。そして、このサブクラスの4つの属性を調べますが、ほとんど場合に使われるのは、次の2つの属性です。
dependencies は、このマイグレーションが依存する他のマイグレーションのリストです。
operations は、このマイグレーションが行う操作を定義している Operation クラスのリストです。
operations がポイントです。これは、宣言的な命令の集まりで、Django にどんなスキーマの変更が必要かを教えます。Django はそれらをスキャンして、全アプリへのスキーマの変更を完全に表現するデータ構造をメモリ上に作り上げ、これを利用して、Django スキーマを実際に変化させる SQL 文を生成します。
\nこの時に作られるメモリ上のデータ構造は、新しいモデルと現在のマイグレーションの状態の差分を計算するのにも使われます。Django は、メモリ上のモデルの集まりのすべての変更点を順番にたどってゆき、最後に makemigrations した時のモデルの状態を理解します。そして、そのモデルと models.py ファイルにあるモデルとを比較し、行った変更に対して作業を行うのです。
ごく稀にマイグレーションファイルを手で修正しなければならないことがありますが、必要があればすべて手で書くことも特に難しい作業ではありません。複雑なデータベース操作の中には自動的には検出できないものもあり、その場合にはマイグレーションを手で書くことが必須になることがあります。でも必要な場合には、自分の手で書くのを怖がらないでくださいね。
\nすでにマイグレートしたカスタムのフィールドの位置引数の数を変更しようとすると、TypeError が発生してしまします。古いマイグレーションは、修正した __init__ メソッドを古い引数で呼んでしまいます。そこで、新しい引数が必要な場合は、キーワード引数を作り、コンストラクタ内に assert 'argument_name' in kwargs のような一文を追加してください。
オプションとして、マネージャをマイグレーションにシリアライズして、RunPython の中で使えるようにすることができます。それには次のように、マネージャクラスの中で use_in_migrations 属性を定義します。
class MyManager(models.Manager):\n use_in_migrations = True\n\nclass MyModel(models.Model):\n objects = MyManager()\nもし from_queryset() 関数で動的に生成されたマネージャクラスを使うなら、インポートできるように生成されたクラスを継承する必要があります。
class MyManager(MyBaseManager.from_queryset(CustomQuerySet)):\n use_in_migrations = True\n\nclass MyModel(models.Model):\n objects = MyManager()\nそれに伴う影響については、マイグレーションにおける Historical models のメモも参考にしてください。
\nThe "initial migrations" for an app are the migrations that create the first\nversion of that app's tables. Usually an app will have one initial migration,\nbut in some cases of complex model interdependencies it may have two or more.
\nInitial migrations are marked with an initial = True class attribute on the\nmigration class. If an initial class attribute isn't found, a migration\nwill be considered "initial" if it is the first migration in the app (i.e. if\nit has no dependencies on any other migration in the same app).
When the migrate --fake-initial option is used, these initial\nmigrations are treated specially. For an initial migration that creates one or\nmore tables (CreateModel operation), Django checks that all of those tables\nalready exist in the database and fake-applies the migration if so. Similarly,\nfor an initial migration that adds one or more fields (AddField operation),\nDjango checks that all of the respective columns already exist in the database\nand fake-applies the migration if so. Without --fake-initial, initial\nmigrations are treated no differently from any other migration.
As previously discussed, you may need to linearize migrations manually when two\ndevelopment branches are joined. While editing migration dependencies, you can\ninadvertently create an inconsistent history state where a migration has been\napplied but some of its dependencies haven't. This is a strong indication that\nthe dependencies are incorrect, so Django will refuse to run migrations or make\nnew migrations until it's fixed. When using multiple databases, you can use the\nallow_migrate() method of database routers to control which databases\nmakemigrations checks for consistent history.
New apps come preconfigured to accept migrations, and so you can add migrations\nby running makemigrations once you've made some changes.
If your app already has models and database tables, and doesn't have migrations\nyet (for example, you created it against a previous Django version), you'll\nneed to convert it to use migrations by running:
\n$ python manage.py makemigrations your_app_label\nThis will make a new initial migration for your app. Now, run python\nmanage.py migrate --fake-initial, and Django will detect that you have an\ninitial migration and that the tables it wants to create already exist, and\nwill mark the migration as already applied. (Without the migrate\n--fake-initial flag, the command would error out because the tables it wants\nto create already exist.)
Note that this only works given two things:
\nYou have not changed your models since you made their tables. For migrations\nto work, you must make the initial migration first and then make changes,\nas Django compares changes against migration files, not the database.
You have not manually edited your database - Django won't be able to detect\nthat your database doesn't match your models, you'll just get errors when\nmigrations try to modify those tables.
Migrations can be reversed with migrate by passing the number of the\nprevious migration. For example, to reverse migration books.0003:
Linux / macOS
$ python manage.py migrate books 0002\nOperations to perform:\n Target specific migration: 0002_auto, from books\nRunning migrations:\n Rendering model states... DONE\n Unapplying books.0003_auto... OK\nWindows
...\\> py manage.py migrate books 0002\nOperations to perform:\n Target specific migration: 0002_auto, from books\nRunning migrations:\n Rendering model states... DONE\n Unapplying books.0003_auto... OK\nIf you want to reverse all migrations applied for an app, use the name\nzero:
Linux / macOS
$ python manage.py migrate books zero\nOperations to perform:\n Unapply all migrations: books\nRunning migrations:\n Rendering model states... DONE\n Unapplying books.0002_auto... OK\n Unapplying books.0001_initial... OK\nWindows
...\\> py manage.py migrate books zero\nOperations to perform:\n Unapply all migrations: books\nRunning migrations:\n Rendering model states... DONE\n Unapplying books.0002_auto... OK\n Unapplying books.0001_initial... OK\nA migration is irreversible if it contains any irreversible operations.\nAttempting to reverse such migrations will raise IrreversibleError:
Linux / macOS
$ python manage.py migrate books 0002\nOperations to perform:\n Target specific migration: 0002_auto, from books\nRunning migrations:\n Rendering model states... DONE\n Unapplying books.0003_auto...Traceback (most recent call last):\ndjango.db.migrations.exceptions.IrreversibleError: Operation <RunSQL sql='DROP TABLE demo_books'> in books.0003_auto is not reversible\nWindows
...\\> py manage.py migrate books 0002\nOperations to perform:\n Target specific migration: 0002_auto, from books\nRunning migrations:\n Rendering model states... DONE\n Unapplying books.0003_auto...Traceback (most recent call last):\ndjango.db.migrations.exceptions.IrreversibleError: Operation <RunSQL sql='DROP TABLE demo_books'> in books.0003_auto is not reversible\nWhen you run migrations, Django is working from historical versions of your\nmodels stored in the migration files. If you write Python code using the\nRunPython operation, or if you have\nallow_migrate methods on your database routers, you need to use these\nhistorical model versions rather than importing them directly.
Because it's impossible to serialize arbitrary Python code, these historical\nmodels will not have any custom methods that you have defined. They will,\nhowever, have the same fields, relationships, managers (limited to those with\nuse_in_migrations = True) and Meta options (also versioned, so they may\nbe different from your current ones).
References to functions in field options such as upload_to and\nlimit_choices_to and model manager declarations with managers having\nuse_in_migrations = True are serialized in migrations, so the functions and\nclasses will need to be kept around for as long as there is a migration\nreferencing them. Any custom model fields\nwill also need to be kept, since these are imported directly by migrations.
In addition, the concrete base classes of the model are stored as pointers, so\nyou must always keep base classes around for as long as there is a migration\nthat contains a reference to them. On the plus side, methods and managers from\nthese base classes inherit normally, so if you absolutely need access to these\nyou can opt to move them into a superclass.
\nTo remove old references, you can squash migrations\nor, if there aren't many references, copy them into the migration files.
\nSimilar to the "references to historical functions" considerations described in\nthe previous section, removing custom model fields from your project or\nthird-party app will cause a problem if they are referenced in old migrations.
\nTo help with this situation, Django provides some model field attributes to\nassist with model field deprecation using the system checks framework.
\nAdd the system_check_deprecated_details attribute to your model field\nsimilar to the following:
class IPAddressField(Field):\n system_check_deprecated_details = {\n 'msg': (\n 'IPAddressField has been deprecated. Support for it (except '\n 'in historical migrations) will be removed in Django 1.9.'\n ),\n 'hint': 'Use GenericIPAddressField instead.', # optional\n 'id': 'fields.W900', # pick a unique ID for your field.\n }\nAfter a deprecation period of your choosing (two or three feature releases for\nfields in Django itself), change the system_check_deprecated_details\nattribute to system_check_removed_details and update the dictionary similar\nto:
class IPAddressField(Field):\n system_check_removed_details = {\n 'msg': (\n 'IPAddressField has been removed except for support in '\n 'historical migrations.'\n ),\n 'hint': 'Use GenericIPAddressField instead.',\n 'id': 'fields.E900', # pick a unique ID for your field.\n }\nYou should keep the field's methods that are required for it to operate in\ndatabase migrations such as __init__(), deconstruct(), and\nget_internal_type(). Keep this stub field for as long as any migrations\nwhich reference the field exist. For example, after squashing migrations and\nremoving the old ones, you should be able to remove the field completely.
As well as changing the database schema, you can also use migrations to change\nthe data in the database itself, in conjunction with the schema if you want.
\nMigrations that alter data are usually called "data migrations"; they're best\nwritten as separate migrations, sitting alongside your schema migrations.
\nDjango can't automatically generate data migrations for you, as it does with\nschema migrations, but it's not very hard to write them. Migration files in\nDjango are made up of Operations, and\nthe main operation you use for data migrations is\nRunPython.
To start, make an empty migration file you can work from (Django will put\nthe file in the right place, suggest a name, and add dependencies for you):
\npython manage.py makemigrations --empty yourappname\nThen, open up the file; it should look something like this:
\n# Generated by Django A.B on YYYY-MM-DD HH:MM\nfrom django.db import migrations\n\nclass Migration(migrations.Migration):\n\n dependencies = [\n ('yourappname', '0001_initial'),\n ]\n\n operations = [\n ]\nNow, all you need to do is create a new function and have\nRunPython use it.\nRunPython expects a callable as its argument\nwhich takes two arguments - the first is an app registry that has the historical versions of all your models\nloaded into it to match where in your history the migration sits, and the\nsecond is a SchemaEditor, which you can use to\nmanually effect database schema changes (but beware, doing this can confuse\nthe migration autodetector!)
Let's write a migration that populates our new name field with the combined\nvalues of first_name and last_name (we've come to our senses and\nrealized that not everyone has first and last names). All we need to do is use\nthe historical model and iterate over the rows:
from django.db import migrations\n\ndef combine_names(apps, schema_editor):\n # We can't import the Person model directly as it may be a newer\n # version than this migration expects. We use the historical version.\n Person = apps.get_model('yourappname', 'Person')\n for person in Person.objects.all():\n person.name = '%s %s' % (person.first_name, person.last_name)\n person.save()\n\nclass Migration(migrations.Migration):\n\n dependencies = [\n ('yourappname', '0001_initial'),\n ]\n\n operations = [\n migrations.RunPython(combine_names),\n ]\nOnce that's done, we can run python manage.py migrate as normal and the\ndata migration will run in place alongside other migrations.
You can pass a second callable to\nRunPython to run whatever logic you\nwant executed when migrating backwards. If this callable is omitted, migrating\nbackwards will raise an exception.
When writing a RunPython function that uses models from apps other than the\none in which the migration is located, the migration's dependencies\nattribute should include the latest migration of each app that is involved,\notherwise you may get an error similar to: LookupError: No installed app\nwith label 'myappname' when you try to retrieve the model in the RunPython\nfunction using apps.get_model().
In the following example, we have a migration in app1 which needs to use\nmodels in app2. We aren't concerned with the details of move_m1 other\nthan the fact it will need to access models from both apps. Therefore we've\nadded a dependency that specifies the last migration of app2:
class Migration(migrations.Migration):\n\n dependencies = [\n ('app1', '0001_initial'),\n # added dependency to enable using models from app2 in move_m1\n ('app2', '0004_foobar'),\n ]\n\n operations = [\n migrations.RunPython(move_m1),\n ]\nIf you're interested in the more advanced migration operations, or want\nto be able to write your own, see the migration operations reference and the "how-to" on writing migrations.
\nYou are encouraged to make migrations freely and not worry about how many you\nhave; the migration code is optimized to deal with hundreds at a time without\nmuch slowdown. However, eventually you will want to move back from having\nseveral hundred migrations to just a few, and that's where squashing comes in.
\nSquashing is the act of reducing an existing set of many migrations down to\none (or sometimes a few) migrations which still represent the same changes.
\nDjango does this by taking all of your existing migrations, extracting their\nOperations and putting them all in sequence, and then running an optimizer\nover them to try and reduce the length of the list - for example, it knows\nthat CreateModel and\nDeleteModel cancel each other out,\nand it knows that AddField can be\nrolled into CreateModel.
Once the operation sequence has been reduced as much as possible - the amount\npossible depends on how closely intertwined your models are and if you have\nany RunSQL\nor RunPython operations (which can't\nbe optimized through unless they are marked as elidable) - Django will then\nwrite it back out into a new set of migration files.
These files are marked to say they replace the previously-squashed migrations,\nso they can coexist with the old migration files, and Django will intelligently\nswitch between them depending where you are in the history. If you're still\npart-way through the set of migrations that you squashed, it will keep using\nthem until it hits the end and then switch to the squashed history, while new\ninstalls will use the new squashed migration and skip all the old ones.
\nThis enables you to squash and not mess up systems currently in production\nthat aren't fully up-to-date yet. The recommended process is to squash, keeping\nthe old files, commit and release, wait until all systems are upgraded with\nthe new release (or if you're a third-party project, ensure your users upgrade\nreleases in order without skipping any), and then remove the old files, commit\nand do a second release.
\nThe command that backs all this is squashmigrations - pass it the\napp label and migration name you want to squash up to, and it'll get to work:
$ ./manage.py squashmigrations myapp 0004\nWill squash the following migrations:\n - 0001_initial\n - 0002_some_change\n - 0003_another_change\n - 0004_undo_something\nDo you wish to proceed? [yN] y\nOptimizing...\n Optimized from 12 operations to 7 operations.\nCreated new squashed migration /home/andrew/Programs/DjangoTest/test/migrations/0001_squashed_0004_undo_somthing.py\n You should commit this migration but leave the old ones in place;\n the new migration will be used for new installs. Once you are sure\n all instances of the codebase have applied the migrations you squashed,\n you can delete them.\nUse the squashmigrations --squashed-name option if you want to set\nthe name of the squashed migration rather than use an autogenerated one.
Note that model interdependencies in Django can get very complex, and squashing\nmay result in migrations that do not run; either mis-optimized (in which case\nyou can try again with --no-optimize, though you should also report an issue),\nor with a CircularDependencyError, in which case you can manually resolve it.
To manually resolve a CircularDependencyError, break out one of\nthe ForeignKeys in the circular dependency loop into a separate\nmigration, and move the dependency on the other app with it. If you're unsure,\nsee how makemigrations deals with the problem when asked to create\nbrand new migrations from your models. In a future release of Django,\nsquashmigrations will be updated to attempt to resolve these errors\nitself.
Once you've squashed your migration, you should then commit it alongside the\nmigrations it replaces and distribute this change to all running instances\nof your application, making sure that they run migrate to store the change\nin their database.
You must then transition the squashed migration to a normal migration by:
\nDeleting all the migration files it replaces.
Updating all migrations that depend on the deleted migrations to depend on\nthe squashed migration instead.
Removing the replaces attribute in the Migration class of the\nsquashed migration (this is how Django tells that it is a squashed migration).
Migrations are Python files containing the old definitions of your models\n- thus, to write them, Django must take the current state of your models and\nserialize them out into a file.
\nDjango はほとんどのオブジェクトをシリアライズできますが、有効な Python 表現へと単純にはシリアライズできないオブジェクトもあります。しかし、任意の値を Python のコードにデコードするような Python の標準は存在しません(repr() は基本的な値にしか機能しませんし、import path は指定できません)。
Django がシリアル化できるのは、以下のオブジェクトです。
\nint, float, bool, str, bytes, None, NoneType
list, set, tuple, dict, range.
datetime.date, datetime.time, datetime.datetime インスタンス (timezone-aware なものも含む)
decimal.Decimal インスタンス
enum.Enum インスタンス
uuid.UUID インスタンス
functools.partial() and functools.partialmethod instances\nwhich have serializable func, args, and keywords values.
シリアル化できる値をラッピングした LazyObject インスタンス
Enumeration types (e.g. TextChoices or IntegerChoices) instances.
任意の Django フィールド
任意の関数またはメソッドへのリファレンス (例: datetime.datetime.today) (ただし、モジュールのトップレベルのスコープにいなければならない)
クラスの本体から使用されている束縛されていないメソッド
任意のクラスへのリファレンス (ただし、モジュールのトップレベルのスコープにいなければならない)
カスタムの deconstruct() メソッドを持つすべてのオブジェクト (以下を参照)
Django は以下のオブジェクトをシリアル化できません。
\nネストしたクラス
任意のクラスのインスタンス (例: MyClass(4.3, 5.7))
ラムダ式
You can serialize other types by writing a custom serializer. For example, if\nDjango didn't serialize Decimal by default, you could do\nthis:
from decimal import Decimal\n\nfrom django.db.migrations.serializer import BaseSerializer\nfrom django.db.migrations.writer import MigrationWriter\n\nclass DecimalSerializer(BaseSerializer):\n def serialize(self):\n return repr(self.value), {'from decimal import Decimal'}\n\nMigrationWriter.register_serializer(Decimal, DecimalSerializer)\nThe first argument of MigrationWriter.register_serializer() is a type or\niterable of types that should use the serializer.
The serialize() method of your serializer must return a string of how the\nvalue should appear in migrations and a set of any imports that are needed in\nthe migration.
deconstruct() メソッドを追加するLink to this heading#自作のカスタムクラスに deconstruct() メソッドを実装することで、インスタンスを Django にシリアル化させることができます。このメソッドは引数を取らず、 (path, args, kwargs) からなる3タプルを返す必要があります。
path はクラス名を最後に含むクラスへの Python パスでなければなりません (たとえば、myapp.custom_things.MyClass)。自作のクラスがモジュールのトップレベルで使用できない場合は、シリアル化することはできません。
args はクラスの __init__ メソッドに渡される位置引数のリストでなければなりません。このリストに含まれる要素は、それ自体でシリアル化可能である必要があります。
kwargs はクラスの __init__ メソッドに渡されるキーワード引数の dict でなければなりません。すべての値はそれ自体でシリアル化可能である必要があります。
Django will write out the value as an instantiation of your class with the\ngiven arguments, similar to the way it writes out references to Django fields.
\nmakemigrations が実行されるたびに新しいマイグレーションが作成されるのを防ぐために、クラスに追加情報を与える __eq__() メソッドも追加した方がいいでしょう。この関数は、Django のマイグレーションフレームワークが状態の変更を検出するために呼び出します。
クラスのコンストラクタのすべての引数がそれ自体でシリアル化可能である場合には、次のように django.utils.deconstruct の @deconstructible クラスデコレータを使うことで deconstruct() メソッドを追加することができます。
from django.utils.deconstruct import deconstructible\n\n@deconstructible\nclass MyCustomClass:\n\n def __init__(self, foo=1):\n self.foo = foo\n ...\n\n def __eq__(self, other):\n return self.foo == other.foo\nデコレータは、コンストラクタに与えられる引数を独自の方法でキャプチャし保存しておきます。そして、deconstruct() が呼ばれるタイミングで、保存しておいた引数を返すようにしてくれます。
もしあなたが、モデルを持つサードパーティのアプリのメンテナならば、Django の複数のバージョンをサポートするマイグレーションを入れておきたいでしょう。その場合、必ず あなたがサポートしたい Django の下限のバージョンで makemigrations を実行するようにしてください。
マイグレーションのシステムは、Django の他のポリシーと同じく、後方互換性を持ちます。そのため、Django X.Y で生成されたマイグレーションファイルは、変更なしに Django X.Y+1 で動作します。しかし、マイグレーションのシステムは前方互換性は保証しません。新しい機能が追加され、新しいバージョンの Django でマイグレーションファイルが生成されれば、そのマイグレーションは古いバージョンでは動きません。
\n\n