Carregando dados iniciais com Django 1.7 e migrações de dados

Recentemente, mudei do Django 1.6 para o 1.7 e comecei a usar migrações (nunca usei o South).

Antes de 1.7, eu costumava carregar os dados iniciais com um fixture/initial_data.jsonarquivo, que era carregado com o python manage.py syncdbcomando (ao criar o banco de dados).

Agora, comecei a usar migrações e este comportamento está obsoleto:

Se um aplicativo usa migrações, não há carregamento automático de acessórios. Como as migrações serão necessárias para aplicativos no Django 2.0, este comportamento é considerado obsoleto. Se você deseja carregar os dados iniciais de um aplicativo, considere fazer isso em uma migração de dados. ( https://docs.djangoproject.com/en/1.7/howto/initial-data/#automatically-loading-initial-data-fixtures )

A documentação oficial não tem um exemplo claro de como fazer isso, então minha pergunta é:

Qual é a melhor maneira de importar esses dados iniciais usando migrações de dados:

1. Escreva o código Python com várias chamadas para mymodel.create(...),
2. Use ou escreva uma função Django ( como chamarloaddata ) para carregar dados de um arquivo de fixação JSON.

Prefiro a segunda opção.

Eu não quero usar o South, já que Django parece ser capaz de fazer isso nativamente agora.

Atualização : Veja o comentário de @GwynBleidD abaixo para os problemas que esta solução pode causar, e veja a resposta de @ Rockallite abaixo para uma abordagem que é mais durável para futuras mudanças de modelo.

Supondo que você tenha um arquivo de fixação em <yourapp>/fixtures/initial_data.json

1. Crie sua migração vazia:

   No Django 1.7:

   python manage.py makemigrations --empty <yourapp>

   No Django 1.8+, você pode fornecer um nome:

   python manage.py makemigrations --empty <yourapp> --name load_intial_data

2. Edite seu arquivo de migração <yourapp>/migrations/0002_auto_xxx.py

   2.1. Implementação personalizada, inspirada em Django ' loaddata(resposta inicial):

   import os
   from sys import path
   from django.core import serializers
   
   fixture_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), '../fixtures'))
   fixture_filename = 'initial_data.json'
   
   def load_fixture(apps, schema_editor):
       fixture_file = os.path.join(fixture_dir, fixture_filename)
   
       fixture = open(fixture_file, 'rb')
       objects = serializers.deserialize('json', fixture, ignorenonexistent=True)
       for obj in objects:
           obj.save()
       fixture.close()
   
   def unload_fixture(apps, schema_editor):
       "Brutally deleting all entries for this model..."
   
       MyModel = apps.get_model("yourapp", "ModelName")
       MyModel.objects.all().delete()
   
   class Migration(migrations.Migration):  
   
       dependencies = [
           ('yourapp', '0001_initial'),
       ]
   
       operations = [
           migrations.RunPython(load_fixture, reverse_code=unload_fixture),
       ]

   2.2. Uma solução mais simples para load_fixture(por sugestão de @juliocesar):

   from django.core.management import call_command
   
   fixture_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), '../fixtures'))
   fixture_filename = 'initial_data.json'
   
   def load_fixture(apps, schema_editor):
       fixture_file = os.path.join(fixture_dir, fixture_filename)
       call_command('loaddata', fixture_file) 

   Útil se você deseja usar um diretório personalizado.

   2.3. Mais simples: chamar loaddatacom app_labelluminárias de carga vontade do <yourapp>'s fixturesdir automaticamente:

   from django.core.management import call_command
   
   fixture = 'initial_data'
   
   def load_fixture(apps, schema_editor):
       call_command('loaddata', fixture, app_label='yourapp') 

   Se você não especificar app_label, loaddata tentará carregar o fixturenome do arquivo de todos os diretórios de fixtures do aplicativo (o que você provavelmente não deseja).

3. Executá-lo

   python manage.py migrate <yourapp>

Versão curta

Você NÃO deve usar o loaddatacomando de gerenciamento diretamente em uma migração de dados.

# Bad example for a data migration
from django.db import migrations
from django.core.management import call_command


def load_fixture(apps, schema_editor):
    # No, it's wrong. DON'T DO THIS!
    call_command('loaddata', 'your_data.json', app_label='yourapp')


class Migration(migrations.Migration):
    dependencies = [
        # Dependencies to other migrations
    ]

    operations = [
        migrations.RunPython(load_fixture),
    ]

Versão longa

loaddatautiliza o django.core.serializers.python.Deserializerque usa os modelos mais atualizados para desserializar dados históricos em uma migração. Esse é um comportamento incorreto.

Por exemplo, suponha que haja uma migração de dados que utiliza o loaddatacomando de gerenciamento para carregar dados de um aparelho, e já está aplicado em seu ambiente de desenvolvimento.

Posteriormente, você decide adicionar um novo campo obrigatório ao modelo correspondente, então você o faz e faz uma nova migração em relação ao seu modelo atualizado (e possivelmente fornece um valor único para o novo campo quando ./manage.py makemigrationssolicitado).

Você executa a próxima migração e está tudo bem.

Finalmente, você concluiu o desenvolvimento de seu aplicativo Django e o implementou no servidor de produção. Agora é a hora de você executar todas as migrações do zero no ambiente de produção.

No entanto, a migração de dados falha . Isso ocorre porque o modelo desserializado do loaddatacomando, que representa o código atual, não pode ser salvo com dados vazios para o novo campo obrigatório adicionado. O acessório original não possui os dados necessários para isso!

Mas mesmo se você atualizar o aparelho com os dados necessários para o novo campo, a migração de dados ainda falhará . Quando a migração de dados está em execução, a próxima migração que adiciona a coluna correspondente ao banco de dados, ainda não é aplicada. Você não pode salvar dados em uma coluna que não existe!

Conclusão: em uma migração de dados, oloaddatacomando introduz uma possível inconsistência entre o modelo e o banco de dados. Definitivamente, você NÃO deveusá-lo diretamente em uma migração de dados.

A solução

loaddatacomando depende da django.core.serializers.python._get_modelfunção para obter o modelo correspondente de um acessório, que retornará a versão mais atualizada de um modelo. Precisamos fazer um patch de macacos para obter o modelo histórico.

(O código a seguir funciona para Django 1.8.x)

# Good example for a data migration
from django.db import migrations
from django.core.serializers import base, python
from django.core.management import call_command


def load_fixture(apps, schema_editor):
    # Save the old _get_model() function
    old_get_model = python._get_model

    # Define new _get_model() function here, which utilizes the apps argument to
    # get the historical version of a model. This piece of code is directly stolen
    # from django.core.serializers.python._get_model, unchanged. However, here it
    # has a different context, specifically, the apps variable.
    def _get_model(model_identifier):
        try:
            return apps.get_model(model_identifier)
        except (LookupError, TypeError):
            raise base.DeserializationError("Invalid model identifier: '%s'" % model_identifier)

    # Replace the _get_model() function on the module, so loaddata can utilize it.
    python._get_model = _get_model

    try:
        # Call loaddata command
        call_command('loaddata', 'your_data.json', app_label='yourapp')
    finally:
        # Restore old _get_model() function
        python._get_model = old_get_model


class Migration(migrations.Migration):
    dependencies = [
        # Dependencies to other migrations
    ]

    operations = [
        migrations.RunPython(load_fixture),
    ]

Inspirado por alguns dos comentários (nomeadamente n__o's) e pelo fato de ter muitos initial_data.*arquivos espalhados por vários aplicativos, decidi criar um aplicativo Django que facilitaria a criação dessas migrações de dados.

Usando Django-migration-dispositivo elétrico você pode simplesmente executar o seguinte comando de gerenciamento e irá procurar através de todo o seu INSTALLED_APPSpara initial_data.*arquivos e transformá-los em migrações de dados.

./manage.py create_initial_data_fixtures
Migrations for 'eggs':
  0002_auto_20150107_0817.py:
Migrations for 'sausage':
  Ignoring 'initial_data.yaml' - migration already exists.
Migrations for 'foo':
  Ignoring 'initial_data.yaml' - not migrated.

Veja django-migration-fixture para instruções de instalação / uso.

Para dar ao seu banco de dados alguns dados iniciais, escreva uma migração de dados. Na migração de dados, use a função RunPython para carregar seus dados.

Não escreva nenhum comando loaddata, pois essa forma está obsoleta.

Suas migrações de dados serão executadas apenas uma vez. As migrações são uma sequência ordenada de migrações. Quando as migrações 003_xxxx.py são executadas, django migrações grava no banco de dados que este aplicativo é migrado até este (003), e executará apenas as seguintes migrações.

As soluções apresentadas acima não funcionaram para mim, infelizmente. Descobri que toda vez que mudo meus modelos, tenho que atualizar meus acessórios. Idealmente, em vez disso, eu escreveria migrações de dados para modificar os dados criados e os dados carregados pelo aparelho de maneira semelhante.

Para facilitar isso , escrevi uma função rápida que irá procurar no fixturesdiretório do aplicativo atual e carregar um fixture. Coloque esta função em uma migração no ponto do histórico do modelo que corresponde aos campos na migração.

Na minha opinião, os jogos estão um pouco ruins. Se o seu banco de dados muda com frequência, mantê-los atualizados logo será um pesadelo. Na verdade, não é só minha opinião, no livro "Two Scoops of Django" é explicado muito melhor.

Em vez disso, escreverei um arquivo Python para fornecer a configuração inicial. Se você precisar de algo mais, sugiro que dê uma olhada no Factory boy .

Se você precisa migrar alguns dados, você deve usar migrações de dados .

Também há "Queime seus acessórios , use fábricas de modelos" sobre o uso de acessórios.

No Django 2.1, eu queria carregar alguns modelos (como nomes de países, por exemplo) com dados iniciais.

Mas eu queria que isso acontecesse automaticamente logo após a execução das migrações iniciais.

Portanto, pensei que seria ótimo ter uma sql/pasta dentro de cada aplicativo que exigisse o carregamento dos dados iniciais.

Então, dentro dessa sql/pasta, eu teria .sqlarquivos com os DMLs necessários para carregar os dados iniciais nos modelos correspondentes, por exemplo:

INSERT INTO appName_modelName(fieldName)
VALUES
    ("country 1"),
    ("country 2"),
    ("country 3"),
    ("country 4");

Para ser mais descritivo, esta é a aparência de um aplicativo contendo uma sql/pasta:

Também encontrei alguns casos em que precisava que os sqlscripts fossem executados em uma ordem específica. Portanto, decidi prefixar os nomes dos arquivos com um número consecutivo, como pode ser visto na imagem acima.

Então eu precisava de uma maneira de carregar qualquer SQLsdisponível dentro de qualquer pasta de aplicativo automaticamente fazendo python manage.py migrate.

Portanto, criei outro aplicativo chamado initial_data_migrationse o adicionei à lista de INSTALLED_APPSno settings.pyarquivo. Em seguida, criei uma migrationspasta dentro e adicionei um arquivo chamado run_sql_scripts.py( que na verdade é uma migração personalizada ). Como pode ser visto na imagem abaixo:

Criei run_sql_scripts.pypara que ele cuide da execução de todos os sqlscripts disponíveis dentro de cada aplicativo. Este é então disparado quando alguém corre python manage.py migrate. Este costume migrationtambém adiciona os aplicativos envolvidos como dependências, dessa forma, ele tenta executar as sqlinstruções somente depois que os aplicativos necessários executaram suas 0001_initial.pymigrações (não queremos tentar executar uma instrução SQL em uma tabela inexistente).

Aqui está a fonte desse script:

import os
import itertools

from django.db import migrations
from YourDjangoProjectName.settings import BASE_DIR, INSTALLED_APPS

SQL_FOLDER = "/sql/"

APP_SQL_FOLDERS = [
    (os.path.join(BASE_DIR, app + SQL_FOLDER), app) for app in INSTALLED_APPS
    if os.path.isdir(os.path.join(BASE_DIR, app + SQL_FOLDER))
]

SQL_FILES = [
    sorted([path + file for file in os.listdir(path) if file.lower().endswith('.sql')])
    for path, app in APP_SQL_FOLDERS
]


def load_file(path):
    with open(path, 'r') as f:
        return f.read()


class Migration(migrations.Migration):

    dependencies = [
        (app, '__first__') for path, app in APP_SQL_FOLDERS
    ]

    operations = [
        migrations.RunSQL(load_file(f)) for f in list(itertools.chain.from_iterable(SQL_FILES))
    ]

Espero que alguém ache isso útil, funcionou muito bem para mim !. Se você tiver alguma dúvida, por favor me avise.

NOTA: Esta pode não ser a melhor solução, uma vez que estou apenas começando com o django, no entanto, ainda quero compartilhar este "Como fazer" com todos vocês, já que não encontrei muitas informações enquanto pesquisava sobre isso no Google.