database - nodejs - sequelize migration:create

Sequelize.js: cómo usar migraciones y sincronización

Question

Estoy cerca de tener mi proyecto listo para lanzar. Tengo grandes planes para después del lanzamiento y la estructura de la base de datos va a cambiar: nuevas columnas en las tablas existentes, así como nuevas tablas y nuevas asociaciones con modelos existentes y nuevos.

No he tocado las migraciones en Sequelize aún, ya que solo tengo datos de prueba que no me importa borrar cada vez que cambia la base de datos.

Para ese fin, actualmente estoy ejecutando la sync force: true cuando se inicia mi aplicación, si he cambiado las definiciones del modelo. Esto borra todas las tablas y las hace desde cero. Podría omitir la opción de force para que solo cree nuevas tablas. Pero si los existentes han cambiado esto no es útil.

Entonces, una vez que agrego las migraciones, ¿cómo funcionan las cosas? Obviamente, no quiero que se eliminen las tablas existentes (con datos en ellas), por lo que la sync force: true queda descartada. En otras aplicaciones que he ayudado a desarrollar (Laravel y otros marcos) como parte del procedimiento de implementación de la aplicación, ejecutamos el comando migrate para ejecutar cualquier migración pendiente. Pero en estas aplicaciones, la primera migración tiene una base de datos esquemática, con la base de datos en el estado en el que hubo algún momento de desarrollo temprano: la primera versión alfa o lo que sea. De modo que incluso una instancia de la aplicación hasta la fiesta puede ponerse al día de una vez, ejecutando todas las migraciones en secuencia.

¿Cómo puedo generar una "primera migración" en Sequelizar? Si no tengo uno, una nueva instancia de la aplicación en algún punto de la línea no tendrá una base de datos de esqueleto para ejecutar las migraciones, o se sincronizará al inicio y hará que la base de datos esté en el nuevo estado con todos las nuevas tablas, etc., pero cuando intente ejecutar las migraciones no tendrán sentido, ya que se escribieron con la base de datos original y cada iteración sucesiva en mente.

Mi proceso de pensamiento: en cada etapa, la base de datos inicial más cada migración en secuencia debe ser igual (más o menos datos) a la base de datos generada cuando se ejecuta sync force: true . Esto se debe a que las descripciones del modelo en el código describen la estructura de la base de datos. Entonces, si no hay una tabla de migración, simplemente ejecutamos la sincronización y marcamos todas las migraciones como finalizadas, aunque no se hayan ejecutado. ¿Es esto lo que debo hacer (¿cómo?), O se supone que Sequelize hará esto por sí mismo, o ¿estoy ladrando en el árbol equivocado? Y si estoy en el área correcta, seguramente debería haber una buena manera de generar automáticamente la mayor parte de una migración, dados los viejos modelos (¿por commit hash? O incluso cada migración podría estar ligada a un commit?) Concedo que estoy pensando en un universo no portátil centrado en git) y los nuevos modelos. Puede diferir la estructura y generar los comandos necesarios para transformar la base de datos de vieja a nueva, y viceversa, y luego el desarrollador puede ingresar y hacer los ajustes necesarios (eliminar / transitar datos particulares, etc.).

Cuando ejecuto el archivo secuencial binario con el comando --init , me da un directorio de migraciones vacío. Cuando ejecuto sequelize --migrate , me convierte en una tabla SequelizeMeta sin nada, sin otras tablas. Obviamente no, porque ese binario no sabe cómo cargar mi aplicación y cargar los modelos.

Debo estar perdiendo algo.

TLDR: ¿cómo configuro mi aplicación y sus migraciones para que se actualicen varias instancias de la aplicación en vivo, así como una nueva aplicación sin base de datos heredada?

Answer 1

Generando la "primera migración"

En su caso, la forma más confiable es hacerlo casi de forma manual. Sugeriría usar la herramienta sequelize-cli . La sintaxis es bastante simple:

sequelize init
...
sequelize model:create --name User --attributes first_name:string,last_name:string,bio:text

Esto creará tanto el modelo Y la migración. Luego, fusione manualmente sus modelos existentes con generados con sequelize-cli, y haga lo mismo con las migraciones. Después de hacer esto, limpie la base de datos (si es posible) y ejecútelo

sequelize db:migrate

Esto creará un esquema de migraciones. Debe hacer esto solo una vez para cambiar al proceso adecuado de desarrollos de esquema (sin sincronización: fuerza, pero con migraciones autorizadas).

Más tarde, cuando necesite cambiar el esquema:

1. Crear una migración: sequelize migration:create
2. Escribir funciones arriba y abajo en su archivo de migración
3. De acuerdo con los cambios en el archivo de migración, cambie su modelo manualmente
4. Ejecutar sequelize db:migrate

Ejecución de migraciones en producción

Obviamente, no puede enviarse ssh al servidor de producción y ejecutar las migraciones manualmente. Utilice umzug , herramienta de migración umzug marco para Node.JS para realizar migraciones pendientes antes de que se inicie la aplicación.

Puede obtener una lista de migraciones pendientes / aún no ejecutadas como esta:

umzug.pending().then(function (migrations) {
  // "migrations" will be an Array with the names of
  // pending migrations.
}); 

Luego ejecuta migraciones ( devolución de llamada interna ). El método de ejecución es una función de propósito general que ejecuta para cada migración especificada la función respectiva:

umzug.execute({
  migrations: [''some-id'', ''some-other-id''],
  method: ''up''
}).then(function (migrations) {
  // "migrations" will be an Array of all executed/reverted migrations.
});

Y mi sugerencia es hacerlo antes de que se inicie la aplicación e intente servir rutas cada vez. Algo como esto:

umzug.pending().then(function(migrations) {
    // "migrations" will be an Array with the names of
    // pending migrations.
    umzug.execute({
        migrations: migrations,
        method: ''up''
    }).then(function(migrations) {
        // "migrations" will be an Array of all executed/reverted migrations.
        // start the server
        app.listen(3000);
        // do your stuff
    });
});

No puedo probar esto ahora, pero a primera vista debería funcionar.

UPD abril de 2016

Después de un año, sigue siendo útil, por lo que compartir mis consejos actuales. Por ahora, estoy instalando el paquete sequelize-cli como dependencia en vivo requerida, y luego modifico los scripts de inicio de NPM en package.json siguiente manera:

...
"scripts": {
  "dev": "grunt && sequelize db:migrate && sequelize db:seed:all && node bin/www",
  "start": "sequelize db:migrate && sequelize db:seed:all && node bin/www"
},
...

Lo único que tengo que hacer en el servidor de producción es npm start . Este comando ejecutará todas las migraciones, aplicará todas las sembradoras e iniciará el servidor de aplicaciones. No es necesario llamar a umzug manualmente.

Answer 2

Ahora con la nueva migración secuencial es muy simple.

Este es un ejemplo de lo que puedes hacer.

    ''use strict'';

    var Promise = require(''bluebird''),
        fs = require(''fs'');

    module.exports = {
        up: function (queryInterface, Sequelize) {

            return Promise
                .resolve()
                .then(function() {
                    return fs.readFileSync(__dirname + ''/../initial-db.sql'', ''utf-8'');
                })
                .then(function (initialSchema) {
                    return queryInterface.sequelize.query(initialSchema);
                })
        },

        down: function (queryInterface, Sequelize) {
            return Promise
                .resolve()
                .then(function() {
                    return fs.readFileSync(__dirname + ''/../drop-initial-db.sql'', ''utf-8'');
                })
                .then(function (dropSql) {
                    return queryInterface.sequelize.query(dropSql);
                });
        }
    };

Recuerde que debe establecer:

"dialectOptions": { "multipleStatements": true }

en la configuración de la base de datos

Answer 3

Amigo, tuve la misma pregunta y logré entender cómo usarlos.

Empecé sin la secuencia de ORM, por lo tanto, ya tenía un modelo de datos.
Tuve que generar los modelos automáticamente con secuela automática y generar sus migraciones con este archivo que usted crea https://gist.github.com/ahelord/a7a7d293695b71aadf04157f0f7dee64 y poner en sincronización ( {Force: false} )
Esto está en desarrollo. Tendría que versionar el modelo y las migraciones y ejecutarlos cada vez que extraiga el código.

En producción, el servidor solo está arriba, por lo que solo debe ejecutar migraciones y en cada administración de compromiso, ya que va a versionar el modelo sin detener el back-end.

Answer 4

Aquí está mi flujo de trabajo actual. Estoy abierto a sugerencias.

1. Establecer la secuencia para crear tablas que no existen
2. Configure secuela para descartar y volver a crear todas las tablas en una base de datos en blanco llamada _blank
3. Use una herramienta mysql para comparar _blank y sincronizar cambios usando esa herramienta. Todavía estoy buscando una herramienta asequible que pueda hacer esto en mac. Parece que MySql workbench puede importar un modelo desde un esquema existente y luego sincronizar el esquema. Tratando de descubrir cómo hacer esto a través de la línea de comando para hacerlo más fácil.

De esta forma, no tiene que actualizar manualmente la tabla de migraciones y debe preocuparse por los dedos gordos, pero aún obtiene un ORM.

Answer 5

Hay una manera más simple (evitar Sequalizar). Que dice así:

1. Escribe un comando dentro de su proyecto: npm run migrate: new

2. Esto crea 3 archivos. Un archivo js y dos archivos sql nombrados arriba y abajo

3. Pones tu declaración SQL en esos archivos, que es puro sql
4. Luego escriba: npm run migrate: up o npm run migrate: down

Para que esto funcione, eche un vistazo al módulo db-migrate .

Una vez que lo configura (lo cual no es difícil), cambiar su DB es realmente fácil y le ahorra mucho tiempo.

Answer 6

Para el desarrollo , ahora hay una opción para sincronizar las tablas actuales mediante la alteración de su estructura. Usando la última versión de la secuencia de repositorio github , ahora puede ejecutar la sincronización con el parámetro alter .

Table.sync({alter: true})

Una advertencia de los documentos:

Altera las tablas para adaptarse a los modelos. No recomendado para uso de producción. Elimina datos en columnas que se eliminaron o se cambió su tipo en el modelo.

Answer 7

Sequelize puede ejecutar arbitrar SQL. Pero ten cuidado porque es asincrónico .

Lo que yo haría es:

• Generar una migración (para usar como primera migración);
• Vuelque su base de datos, algo así como: mysql_dump -uUSER -pPASS DBNAME > FILE.SQL
• Pegue el volcado completo como texto (peligroso) o cargue un archivo con el volcado completo en el nodo:
  • var baseSQL = "LOTS OF SQL and it''s EVIL because you gotta put / backslashes before line breakes and /"quotes/" and/or sum" + " one string for each line, or everything will break";
  • var baseSQL = fs.readFileSync(''../seed/baseDump.sql'');
• Ejecute este volcado en Sequelizar la migración:

module.exports = {
  up: function (migration, DataTypes) {
    var baseSQL = "whatever" // I recommend loading a file
    migration.migrator.sequelize.query(baseSQL);
  }
}

Eso debería encargarse de configurar la base de datos, aunque la cosa asincrónica puede convertirse en un problema. Si eso sucede, buscaría la manera de aplazar la devolución de la función de secuenciación hasta que la función de query asíncrona haya finalizado.

Más sobre mysql_dump: http://dev.mysql.com/doc/refman/5.1/en/mysqldump.html
Más acerca de Migraciones Sequelizadas: http://sequelize.readthedocs.org/en/latest/docs/migrations/
Más sobre Ejecutar SQL desde la Migración Sequelize: https://github.com/sequelize/sequelize/issues/313

Answer 8

Solo estoy aprendiendo esto, pero creo que recomendaría usar migraciones ahora para que te acostumbres. He descubierto que lo mejor para descubrir lo que ocurre en la migración es ver el sql en las tablas creadas por sequelize.sync () y luego crear las migraciones desde allí.

migraciones -c [nombre de la migración]

creará el archivo de migración de la plantilla en un directorio de migraciones. Luego puede poblarlo con los campos que necesita crear. Este archivo deberá incluir createdAt / updatedAt, los campos necesarios para las asociaciones, etc. Para la creación inicial de la tabla, debe tener:

migration.dropTable (''MyTable'');

pero las actualizaciones posteriores a la estructura de la tabla pueden dejar esto fuera y solo usar alter table.

./node_modules/.bin/sequelize --migrate

Un ejemplo de creación se vería así:

module.exports = {
  up: function(migration, DataTypes, done) {
    migration.createTable(
        ''MyTable'',
        {
          id: {
            type: DataTypes.INTEGER,
            primaryKey: true,
            autoIncrement: true
          },
          bigString: {type: DataTypes.TEXT, allowNull: false},
          MyOtherTableId: DataTypes.INTEGER,
          createdAt: {
            type: DataTypes.DATE
          },
          updatedAt: {
            type: DataTypes.DATE
          }
        });
    done();
  },
  down: function(migration, DataTypes, done) {
    migration.dropTable(''MyTable'');
    done();
  }

para rehacer desde el comienzo:

./node_modules/.bin/sequelize --migrate --undo
./node_modules/.bin/sequelize --migrate

Estoy usando café para ejecutar un archivo semilla para rellenar las tablas después de:

coffee server/seed.coffee

Esto solo tiene una función de creación que se parece a esto:

user = db.User.create
  username: ''bob''
  password: ''suruncle''
  email: ''[email protected]''
.success (user) ->
  console.log ''added user''
  user_id = user.id
  myTable = [
    field1: ''womp''
    field2: ''rat''

    subModel: [
      field1: ''womp''
     ,
      field1: ''rat''
    ]
  ]

Recuerde sacar su sincronización () del índice en sus modelos o sobrescribirá lo que hacen las migraciones y las semillas.

Los documentos están en http://sequelize.readthedocs.org/en/latest/docs/migrations/ por supuesto. Pero la respuesta básica es que debe agregar todo en usted para especificar los campos que necesita. No lo hace por ti :-(

Answer 9

Un poco tarde, y después de leer la documentación, no necesita tener esa primera migración de la que está hablando. Todo lo que tienes que hacer es llamar a la sync para crear las tablas.

sequelize.sync()

También puede ejecutar una sincronización de modelo simple haciendo algo como:

Project.sync() pero creo que sequelize.sync() es un caso general más útil para su proyecto (siempre y cuando importe los buenos modelos en el momento del inicio).

(tomado de http://sequelizejs.com/docs/latest/models#database-synchronization )

Esto creará todas las estructuras iniciales . Después, solo tendrá que crear migraciones para desarrollar sus esquemas.

Espero eso ayude.

Answer 10

Usa la versión. La versión de la aplicación depende de la versión de la base de datos. Si la nueva versión requiere una actualización de una base de datos, cree una migración para ella.

actualización: decidí abandonar la migración ( KISS ) y ejecutar el script update_db (sync forse: false) cuando sea necesario.