Categorías
Python

El uso de cuadernos Jupyter

 

Tabla de Contenidos

  • El problema con la creación de un índice en la configuración de Django migraciones
  • falso Migración
  • Ejecutar Raw SQL en Migraciones
  • inversa Migración Operación
  • conozca bien el modelo de Estado y de base de datos StateWhen Django genera un nuevo MigrationHow a Separar base de datos y Estado en Migraciones
  • Cuando Django genera una nueva migración
  • Como base de datos separada y Estado en Migraciones
  • no atómica migraciones
  • Conclusión
  • Cuando Django genera una nueva migración
  • Como base de datos separada y Estado Las migraciones en

Gestión de migraciones de bases de datos es un gran desafío en cualquier proyecto de software. Por suerte, a partir de la versión 1.7, Django viene con un marco migratorio incorporado. El marco es muy potente y útil en la gestión del cambio en las bases de datos. Pero la flexibilidad proporcionada por el marco requiere algunos compromisos. Para entender las limitaciones de las migraciones de Django, que se va a abordar un problema bien conocido: la creación de un índice en Django sin tiempo de inactividad.

En este tutorial, aprenderá:

  • ¿Cómo y cuando Django genera nuevas migraciones
  • cómo inspeccionar los comandos Django genera para ejecutar las migraciones
  • cómo modificar de forma segura las migraciones para satisfacer sus necesidades

Este tutorial de nivel intermedio está diseñado para los lectores que ya están familiarizados con las migraciones de Django. Para una introducción a este tema, echa un vistazo a Django Migraciones: Una cartilla. Bono

gratuito: Haga clic aquí para obtener acceso gratuito a Django tutoriales adicionales y recursos que puede utilizar para profundizar en sus habilidades de desarrollo web de Python.

El problema con la creación de un índice de Django migraciones

Un cambio común que generalmente se hace necesaria cuando los datos almacenados por su aplicación crece es la adición de un índice. Los índices se utilizan para acelerar las consultas y hacer su sensación aplicación rápida y sensible.

En la mayoría de las bases de datos, añadiendo un índice requiere un bloqueo exclusivo en la tabla. Un operaciones exclusivo de modificación de datos evita el bloqueo (DML), tales como UPDATE, INSERT y DELETE, mientras se crea el índice.

Cerraduras se obtienen implícitamente por la base de datos al ejecutar ciertas operaciones. Por ejemplo, cuando un usuario inicia sesión en su aplicación, Django actualizar el campo last_login en la tabla auth_user. Para realizar la actualización, la base de datos primero tendrá que obtener un bloqueo en la fila. Si la fila está siendo bloqueada por otra conexión, entonces es posible que obtenga una excepción de base de datos.

Bloqueo de una mesa podría plantear un problema cuando es necesario para mantener el sistema disponible durante las migraciones. Cuanto más grande sea la tabla, cuanto más tiempo se puede tomar para crear el índice. Cuanto más tiempo se necesita para crear el índice, mayor será el sistema no está disponible o no responde a los usuarios.

Algunos proveedores de bases de datos proporciona una forma de crear un índice sin bloquear la tabla. Por ejemplo, para crear un índice en PostgreSQL sin la fijación de una tabla, puede utilizar la CONCURRENTEMENTE palabra clave:

CREATE INDEX CONCURRENTLY ix ON table (column);

En Oracle, no es una opción en línea para permitir las operaciones de DML en la mesa mientras se crea el índice:

CREATE INDEX ix ON table (column) ONLINE;

Cuando generación migraciones, Django no van a usar estas palabras clave especiales. Ejecución de la migración tal cual hará que la base de datos de adquirir un bloqueo exclusivo sobre la mesa y las operaciones DML Prevenir mientras se crea el índice.

Creación de un índice al mismo tiempo tiene algunas advertencias. Es importante entender los problemas específicos de su base de datos con antelación. Por ejemplo, una advertencia en PostgreSQL es que la creación de un índice simultáneamente lleva más tiempo, ya que requiere un recorrido de tabla adicional.

En este tutorial, vamos a usar las migraciones de Django para crear un índice en una tabla grande, sin causar ningún tiempo de inactividad.

Nota: Para seguir este tutorial, se recomienda que utilice un motor de PostgreSQL, 2.x Django y Python 3.

Es posible seguir junto con otros backends de bases de datos también. En los lugares donde SQL características únicas para PostgreSQL se utilizan, cambiar el SQL para que coincida con su base de datos. Configuración

Vas a utilizar un modelo de la venta hecha en una aplicación aplicación llamada. En una situación de la vida real, los modelos tales como la venta son las principales tablas de la base de datos, y por lo general va a ser muy grande y almacenar una gran cantidad de datos:

# models.py

from django.db import models

class Sale(models.Model):
sold_at = models.DateTimeField(
auto_now_add=True,
)
charged_amount = models.PositiveIntegerField()

Para crear la tabla, generar la migración inicial y aplicarlo:

$ python manage.py makemigrations
Migrations for 'app':
app/migrations/0001_initial.py
- Create model Sale

$ python manage migrate
Operations to perform:
Apply all migrations: app
Running migrations:
Applying app.0001_initial... OK

Después de un tiempo, la mesa se convierte en ventas muy grande, y los usuarios comienzan a quejarse de la lentitud. Durante la supervisión de la base de datos, se ha notado que una gran cantidad de consultas utilizan la columna sold_at. Para acelerar las cosas, decide que necesita un índice en la columna.

Para añadir un índice en sold_at, se hace el siguiente cambio en el modelo:

# models.py

from django.db import models

class Sale(models.Model):
sold_at = models.DateTimeField(
auto_now_add=True,
db_index=True,
)
charged_amount = models.PositiveIntegerField()

Si ejecuta esta migración como es, entonces Django creará el índice de la tabla, y se bloqueará hasta que se complete el índice . Se puede tomar un tiempo para crear un índice en una tabla muy grande, y que desea evitar el tiempo de inactividad.

En un entorno de desarrollo local con un pequeño conjunto de datos y muy pocas conexiones, esta migración puede sentir instantánea. Sin embargo, en los grandes conjuntos de datos con muchas conexiones simultáneas, la obtención de una cerradura y la creación del índice puede tomar un tiempo.

En los siguientes pasos, que van a modificar las migraciones creados por Django para crear el índice, sin causar ningún tiempo de inactividad.

falso Migración

El primer enfoque es crear el índice manualmente. Usted va a generar la migración, pero no se va a dejar que en realidad Django aplicarlo. En su lugar, se corre el SQL de forma manual en la base de datos y luego hacer Django cree que la migración ha finalizado.

En primer lugar, generar la migración:

$ python manage.py makemigrations --name add_index_fake
Migrations for 'app':
app/migrations/0002_add_index_fake.py
- Alter field sold_at on sale

Utilice el comando sqlmigrate para ver el SQL Django utilizará para ejecutar esta migración:

$ python manage.py sqlmigrate app 0002

BEGIN;
--
-- Alter field sold_at on sale
--
CREATE INDEX "app_sale_sold_at_b9438ae4" ON "app_sale" ("sold_at");
COMMIT;

Desea crear el índice sin bloquear la tabla, por lo que resulta necesario modificar el comando. Añadir la palabra clave CONCURRENTEMENTE y ejecutar en la base de datos:

app=# CREATE INDEX CONCURRENTLY "app_sale_sold_at_b9438ae4"
ON "app_sale" ("sold_at");

CREATE INDEX

en cuenta que se ejecutara el comando sin el BEGIN y COMMIT partes. La omisión de estas palabras clave ejecutará los comandos sin una transacción de base de datos. Vamos a discutir las transacciones de bases de datos más adelante en el artículo.

Después de ejecutar el comando, si se intenta aplicar las migraciones, por lo que recibirá el siguiente error:

$ python manage.py migrate

Operations to perform:
Apply all migrations: app
Running migrations:
Applying app.0002_add_index_fake...Traceback (most recent call last):
File "venv/lib/python3.7/site-packages/django/db/backends/utils.py", line 85, in _execute
return self.cursor.execute(sql, params)

psycopg2.ProgrammingError: relation "app_sale_sold_at_b9438ae4" already exists

Django se queja de que el índice ya existe, por lo que no se puede realizar la migración. Que acaba de crear el índice directamente en la base de datos, por lo que ahora es necesario hacer Django cree que la migración ya se aplicó.

cómo fingir una migración de

Django provee un sistema incorporado en forma de marcar las migraciones como ejecutados, sin tener que ejecutarlas. Para utilizar esta opción, establezca el indicador –fake cuando se aplica la migración:

$ python manage.py migrate --fake
Operations to perform:
Apply all migrations: app
Running migrations:
Applying app.0002_add_index_fake... FAKED

Django no levantó un error esta vez. De hecho, Django realmente no aplica ninguna migración. Sólo marcó como ejecutados (o simulada).

Aquí hay algunas cuestiones a considerar al falsificar las migraciones:

  • El comando manual debe ser equivalente al SQL generado por Django: Usted necesita asegurarse de que el comando se ejecuta es equivalente al SQL generado por Django. Utilice sqlmigrate para producir el comando SQL. Si los comandos no coinciden, entonces usted podría terminar con inconsistencias entre la base de datos y el estado de los modelos. También se pueden falsificar
  • Otras migraciones no aplicados: Cuando tenga varias migraciones no aplicados, todos ellos serán falsificado. Antes de aplicar las migraciones, es importante asegurarse de que sólo las migraciones que desea falsos son no aplicado. De lo contrario, podría terminar con inconsistencias. Otra opción es especificar la migración exacto que desea falso. Se requiere acceso a
  • directo a la base de datos: Es necesario ejecutar el comando SQL en la base de datos. Esto no es siempre una opción. Además, la ejecución de comandos directamente en una base de datos de producción es peligroso y debe evitarse siempre que sea posible. procesos de implementación
  • automatizados podrían necesitar ajustes: Si automatizado el proceso de despliegue (utilizando CI, CD, u otras herramientas de automatización), entonces es posible que tenga que modificar el proceso de migración falsos. Esto no siempre es deseable.

El comando manual debe ser equivalente al SQL generado por Django: Usted necesita asegurarse de que el comando se ejecuta es equivalente al SQL generado por Django. Utilice sqlmigrate para producir el comando SQL. Si los comandos no coinciden, entonces usted podría terminar con inconsistencias entre la base de datos y el estado de los modelos.

Otras migraciones no aplicados también serán fingido: Cuando tenga varias migraciones no aplicados, todos ellos se pueden falsificar. Antes de aplicar las migraciones, es importante asegurarse de que sólo las migraciones que desea falsos son no aplicado. De lo contrario, podría terminar con inconsistencias. Otra opción es especificar la migración exacto que desea falso. Se requiere acceso a

directo a la base de datos: Tiene que ejecutar el comando SQL en la base de datos. Esto no es siempre una opción. Además, la ejecución de comandos directamente en una base de datos de producción es peligroso y debe evitarse siempre que sea posible. procesos de implementación

automatizados podrían necesitar ajustes: Si automatizado el proceso de despliegue (utilizando CI, CD, u otras herramientas de automatización), entonces es posible que tenga que modificar el proceso de migración falsos. Esto no siempre es deseable.

Cleanup

Antes de pasar a la siguiente sección, que tiene que traer la parte posterior de base de datos a su estado correcto después de la migración inicial. Para hacer eso, volver migrar a la migración inicial:

$ python manage.py migrate 0001
Operations to perform:
Target specific migration: 0001_initial, from app
Running migrations:
Rendering model states... DONE
Unapplying app.0002_add_index_fake... OK

Django sin aplicar los cambios realizados en la segunda migración, así que ahora es seguro eliminar también el archivo:

$ rm app/migrations/0002_add_index_fake.py

Para asegurarse de que hicimos todo bien, inspeccionar las migraciones:

se aplicó $ python manage.py showmigrations app
app
[X] 0001_initial

la migración inicial, y no hay migraciones no aplicados.

Ejecutar SQL crudo en Migraciones

En la sección anterior, que ejecutó SQL directamente en la base de datos y falsificó la migración. Esto hace el trabajo, pero no es una solución mejor.

Django proporciona una manera de ejecutar SQL prima en migraciones utilizando EjecutarSQL. Vamos a tratar de usarlo en lugar de ejecutar el comando directamente en la base de datos.

En primer lugar, generar una nueva migración vacío:

$ python manage.py makemigrations app --empty --name add_index_runsql
Migrations for 'app':
app/migrations/0002_add_index_runsql.py

A continuación, editar el archivo de migración y añadir una operación EjecutarSQL:

# migrations/0002_add_index_runsql.py

from django.db import migrations, models

class Migration(migrations.Migration):
atomic = False

dependencies = [
('app', '0001_initial'),
]

operations = [
migrations.RunSQL(
'CREATE INDEX "app_sale_sold_at_b9438ae4" '
'ON "app_sale" ("sold_at");',
),
]

Al ejecutar la migración, obtendrá el siguiente resultado:

$ python manage.py migrate
Operations to perform:
Apply all migrations: app
Running migrations:
Applying app.0002_add_index_runsql... OK

Esto se ve bien, pero Hay un problema. Vamos a tratar de generar migraciones de nuevo:

$ python manage.py makemigrations --name leftover_migration
Migrations for 'app':
app/migrations/0003_leftover_migration.py
- Alter field sold_at on sale

Django genera el mismo proceso de nuevo. ¿Porque hizo eso?

Cleanup

Antes de responder a esta pregunta, es necesario limpiar y deshacer los cambios realizados a la base de datos. Para empezar, la supresión de la última migración. No se aplica, por lo que es seguro eliminar:

$ rm app/migrations/0003_leftover_migration.py

A continuación, la lista de las migraciones para la aplicación aplicación:

$ python manage.py showmigrations app
app
[X] 0001_initial
[X] 0002_add_index_runsql

La tercera migración se ha ido, pero se aplica la segunda. Usted desea conseguir de nuevo a la derecha después de la migración del estado inicial. Tratar de migrar de nuevo a la migración inicial como lo hizo en la sección anterior:

$ python manage.py migrate app 0001
Operations to perform:
Target specific migration: 0001_initial, from app
Running migrations:
Rendering model states... DONE
Unapplying app.0002_add_index_runsql...Traceback (most recent call last):

NotImplementedError: You cannot reverse this operation

Django es incapaz de revertir la migración.

Reverse Migración Operación

para revertir una migración, Django ejecuta una acción opuesta para cada operación. En este caso, el reverso de la adición de un índice es a caer. Como ya se ha visto, cuando una migración es reversible, puede cancelar la aplicación de la misma. Al igual que usted puede utilizar la caja de Git, se puede revertir una migración si se ejecuta migrar a una migración anterior.

Muchos incorporado migración operaciones ya definir una acción inversa. Por ejemplo, la acción inversa para añadir un campo es dejar caer la columna correspondiente. La acción inversa para la creación de un modelo es eliminar la tabla correspondiente.

Algunas operaciones de migración no son reversibles. Por ejemplo, no hay ninguna acción inversa para la eliminación de un campo o eliminación de un modelo, porque una vez que se aplicó la migración, los datos se ha ido.

En la sección anterior, se utiliza la operación EjecutarSQL. Cuando se trató de revertir la migración, se ha detectado un error. De acuerdo con el error, una de las operaciones en la migración no se puede revertir. Django es incapaz de revertir SQL prima por defecto. Debido a que Django no tiene conocimiento de lo ejecutado por la operación, no puede generar una acción opuesta automáticamente.

Cómo hacer una migración reversible

Para una migración a ser reversible, todas las operaciones en que deben ser reversibles. No es posible revertir parte de una migración, por lo que una sola operación no reversible hará que toda la migración no reversible.

Para realizar una operación reversible EjecutarSQL, debe proporcionar SQL que se ejecutará cuando se invierte la operación. El SQL inversa se proporciona en el argumento reverse_sql.

la acción opuesta a la adición de un índice es a caer. Para realizar su migración reversible, proporcionar al reverse_sql a quitar el índice:

# migrations/0002_add_index_runsql.py

from django.db import migrations, models

class Migration(migrations.Migration):
atomic = False

dependencies = [
('app', '0001_initial'),
]

operations = [
migrations.RunSQL(
'CREATE INDEX "app_sale_sold_at_b9438ae4" '
'ON "app_sale" ("sold_at");',

reverse_sql='DROP INDEX "app_sale_sold_at_b9438ae4";',
),
]

Ahora trata de revertir la migración:

$ python manage.py showmigrations app
app
[X] 0001_initial
[X] 0002_add_index_runsql

$ python manage.py migrate app 0001
Operations to perform:
Target specific migration: 0001_initial, from app
Running migrations:
Rendering model states... DONE
Unapplying app.0002_add_index_runsql... OK

$ python manage.py showmigrations app
app
[X] 0001_initial
[ ] 0002_add_index_runsql

La segunda migración se invirtió, y el índice se redujo en Django. Ahora es seguro eliminar el archivo de migración:

$ rm app/migrations/0002_add_index_runsql.py

Es siempre una buena idea para proporcionar reverse_sql. En situaciones en las que una operación de marcha atrás SQL prima no requiere ninguna acción, puede marcar la operación reversible mediante el centinela especial migrations.RunSQL.noop:

migrations.RunSQL(
sql='...', # Your forward SQL here
reverse_sql=migrations.RunSQL.noop,
),

Entender Estado del modelo y de la base de datos Estado

en su intento anterior para crear el índice manualmente mediante EjecutarSQL, Django genera la misma migración una y otra vez a pesar de que el índice fue creado en la base de datos. Para entender por qué Django hizo, primero tiene que entender cómo Django decide cuándo generar nuevas migraciones.

Cuando Django genera un nuevo Migración

En el proceso de generación y migraciones Aplicar, sincroniza Django entre el estado de la base de datos y el estado de los modelos. Por ejemplo, cuando se agrega un campo a un modelo, Django agrega una columna a la tabla. Cuando se elimina un campo a partir del modelo, Django quita la columna de la tabla.

sincronizar entre los modelos y la base de datos, Django mantiene un estado que representa los modelos. Para sincronizar la base de datos con los modelos, Django genera migración operaciones. Migración operaciones se traducen en un SQL específica del proveedor que se puede ejecutar en la base de datos. Cuando se ejecutan todas las operaciones de migración, se espera que la base de datos y los modelos para ser consistente.

Para obtener el estado de la base de datos, Django agrega las operaciones de todas las migraciones pasadas. Cuando el estado agregado de las migraciones no es coherente con el estado de los modelos, Django genera una nueva migración.

En el ejemplo anterior, se crea el índice utilizando SQL prima. Django no sabía que creó el índice debido a que no utiliza una operación de migración familiar.

Cuando Django agrega todas las migraciones y los comparó con el estado de los modelos, se encontró que un índice faltaba. Es por esto que, incluso después de que ha creado el índice manualmente, Django todavía pensaba que había desaparecido y generó una nueva migración para ello.

Como base de datos separada y Estado en Migraciones

Dado que Django es incapaz de crear el índice de la manera que quiere, desea proporcionar su propio SQL, pero aún deja Django sabe que lo creó.

En otras palabras, es necesario para ejecutar algo en la base de datos y proporcionar Django con la operación de migración para sincronizar su estado interno. Para hacer eso, Django nos proporciona una operación de migración especial llamado SeparateDatabaseAndState. Esta operación no es bien conocido y se debe reservar para casos especiales como éste.

Es mucho más fácil de editar las migraciones que ellos escribir desde cero, así que empieza generando una migración de la forma habitual:

$ python manage.py makemigrations --name add_index_separate_database_and_state

Migrations for 'app':
app/migrations/0002_add_index_separate_database_and_state.py
- Alter field sold_at on sale

Este es el contenido de la migración generada por Django, igual que antes:

# migrations/0002_add_index_separate_database_and_state.py

from django.db import migrations, models

class Migration(migrations.Migration):

dependencies = [
('app', '0001_initial'),
]

operations = [
migrations.AlterField(
model_name='sale',
name='sold_at',
field=models.DateTimeField(
auto_now_add=True,
db_index=True,
),
),
]

Django genera una operación AlterField en el campo de sold_at. La operación creará un índice y actualizar el estado. Queremos mantener esta operación, pero proporcionamos un comando diferente para ejecutar en la base de datos.

Una vez más, para obtener el comando, utilice el SQL generado por Django:

$ python manage.py sqlmigrate app 0002
BEGIN;
--
-- Alter field sold_at on sale
--
CREATE INDEX "app_sale_sold_at_b9438ae4" ON "app_sale" ("sold_at");
COMMIT;

Añadir la CONCURRENTEMENTE palabra clave en el lugar apropiado:

CREATE INDEX CONCURRENTLY "app_sale_sold_at_b9438ae4"
ON "app_sale" ("sold_at");

A continuación, editar el archivo de migración y utilizar SeparateDatabaseAndState para proporcionar a su comando SQL modificado para su ejecución:

# migrations/0002_add_index_separate_database_and_state.py

from django.db import migrations, models

class Migration(migrations.Migration):

dependencies = [
('app', '0001_initial'),
]

operations = [

migrations.SeparateDatabaseAndState(

state_operations=[
migrations.AlterField(
model_name='sale',
name='sold_at',
field=models.DateTimeField(
auto_now_add=True,
db_index=True,
),
),
],

database_operations=[
migrations.RunSQL(sql="""
CREATE INDEX CONCURRENTLY "app_sale_sold_at_b9438ae4"
ON "app_sale" ("sold_at");
""", reverse_sql="""
DROP INDEX "app_sale_sold_at_b9438ae4";
"""),
],
),

],

la migración operación SeparateDatabaseAndState acepta 2 listas de operaciones:

Usted mantiene la operación original generada por Django en state_operations. Al utilizar SeparateDatabaseAndState, esto es lo que por lo general tendrá que hacer. Tenga en cuenta que el argumento db_index = Verdadero se proporciona al campo. Esta operación permitirá que la migración de Django sabe que hay un índice en el campo.

Utilizó el SQL generado por Django y añadió la palabra clave CONCURRENTEMENTE. Utilizó el EjecutarSQL acción especial para ejecutar SQL prima en la migración.

Si intenta ejecutar la migración, obtendrá el siguiente resultado:

$ python manage.py migrate app
Operations to perform:
Apply all migrations: app
Running migrations:
Applying app.0002_add_index_separate_database_and_state...Traceback (most recent call last):
File "/venv/lib/python3.7/site-packages/django/db/backends/utils.py", line 83, in _execute
return self.cursor.execute(sql)
psycopg2.InternalError: CREATE INDEX CONCURRENTLY cannot run inside a transaction block

no atómica migraciones

En SQL, CREATE, DROP, ALTER y operaciones TRUNCATE se refiere como Definición Data Language (DDL) . En bases de datos que soportan DDL transaccional, como PostgreSQL, Django ejecuta migraciones dentro de una transacción de la base de datos por defecto. Sin embargo, de acuerdo con el error anterior, PostgreSQL no puede crear un índice simultáneamente dentro de un bloque de transacción.

Para poder crear un índice simultáneamente dentro de una migración, debe decirle a Django para no ejecutar la migración en una transacción de base de datos. Para ello, se marca la migración como no atómica mediante el establecimiento atómica en Falso:

# migrations/0002_add_index_separate_database_and_state.py

from django.db import migrations, models

class Migration(migrations.Migration):
atomic = False

dependencies = [
('app', '0001_initial'),
]

operations = [

migrations.SeparateDatabaseAndState(

state_operations=[
migrations.AlterField(
model_name='sale',
name='sold_at',
field=models.DateTimeField(
auto_now_add=True,
db_index=True,
),
),
],

database_operations=[
migrations.RunSQL(sql="""
CREATE INDEX CONCURRENTLY "app_sale_sold_at_b9438ae4"
ON "app_sale" ("sold_at");
""",
reverse_sql="""
DROP INDEX "app_sale_sold_at_b9438ae4";
"""),
],
),

],

Después de que haya marcado la migración como no atómica, puede ejecutar la migración:

$ python manage.py migrate app
Operations to perform:
Apply all migrations: app
Running migrations:
Applying app.0002_add_index_separate_database_and_state... OK

Usted acaba de ejecutar la migración sin causar ningún tiempo de inactividad.

Aquí hay algunas cuestiones a considerar cuando se está utilizando SeparateDatabaseAndState: las operaciones de base de datos

  • deben ser equivalentes a las operaciones del estado: Las incoherencias entre la base de datos y el modelo de estado puede causar muchos problemas. Un buen punto de partida es mantener las operaciones generadas por Django en state_operations y editar la salida de sqlmigrate para su uso en database_operations. migraciones
  • no atómicas No se puede revertir en caso de error: Si se produce un error durante la migración, entonces no será capaz de deshacer. Usted tendría que deshacer o bien la migración o completar manualmente. Es una buena idea para mantener las operaciones que se ejecutan dentro de una migración no atómica al mínimo. Si tiene operaciones adicionales en la migración, ellos pasar a una nueva migración.
  • migración puede ser específico del proveedor: El SQL generado por Django es específico para el backend de base de datos utilizada en el proyecto. Puede que funcione con otros backends de bases de datos, pero que no está garantizada. Si tiene que soportar múltiples backends de bases de datos, es necesario hacer algunos ajustes a este enfoque. las operaciones de base de datos

deben ser equivalentes a las operaciones del estado: Las incoherencias entre la base de datos y el modelo de estado puede causar muchos problemas. Un buen punto de partida es mantener las operaciones generadas por Django en state_operations y editar la salida de sqlmigrate para su uso en database_operations. migraciones

no atómicas pueden no reversión en caso de error: Si hay un error durante la migración, a continuación, usted no será capaz de deshacer. Usted tendría que deshacer o bien la migración o completar manualmente. Es una buena idea para mantener las operaciones que se ejecutan dentro de una migración no atómica al mínimo. Si tiene operaciones adicionales en la migración, ellos pasar a una nueva migración.

migración puede ser específico del vendedor: El SQL generado por Django es específico para el backend de base de datos utilizada en el proyecto. Puede que funcione con otros backends de bases de datos, pero que no está garantizada. Si tiene que soportar múltiples backends de bases de datos, es necesario hacer algunos ajustes a este enfoque.

Conclusión

Empezaste este tutorial con una mesa grande y un problema. Quería hacer su aplicación más rápida para sus usuarios, y que quería hacer eso sin causarles ningún tiempo de inactividad.

Al final del tutorial, se logró generar y segura modificar una migración de Django para lograr este objetivo. Usted abordado diferentes problemas en el camino y logró superarlos utilizando una función de herramientas proporcionadas por el marco de las migraciones.

En este tutorial, aprendió lo siguiente: migraciones

  • Cómo Django trabajar internamente utilizando el modelo y el estado de base de datos, y cuando las nuevas migraciones se generan
  • cómo ejecutar SQL personalizada en migraciones mediante la acción EjecutarSQL
  • Lo migraciones reversibles son , y cómo hacer que una acción EjecutarSQL reversible
  • lo migraciones atómicas son, y cómo cambiar el comportamiento predeterminado de acuerdo a sus necesidades
  • cómo ejecutar con seguridad las migraciones complejas en Django

la separación entre el modelo y el estado de base de datos es un importante concepto. Una vez que entienda, y cómo utilizarla, puede superar muchas limitaciones de la incorporada en la migración operaciones. Algunos casos de uso que vienen a la mente incluyen la adición de un índice que ya se creó en la base de datos y proporcionar argumentos específicos de los proveedores a los comandos DDL.

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *