1 follower

Migración de Base de Datos

Durante el curso de desarrollo y mantenimiento de una aplicación con base de datos, la estructura de dicha base de datos evoluciona tanto como el código fuente. Por ejemplo, durante el desarrollo de una aplicación, una nueva tabla podría ser necesaria; una vez que la aplicación se encuentra en producción, podría descrubrirse que debería crearse un índice para mejorar el tiempo de ejecución de una consulta; y así sucesivamente. Debido a los cambios en la estructura de la base de datos a menudo se requieren cambios en el código, Yii soporta la característica llamada migración de base de datos, la cual permite tener un seguimiento de esos cambios en término de migración de base de datos, cuyo versionado es controlado junto al del código fuente.

Los siguientes pasos muestran cómo una migración puede ser utilizada por un equipo durante el desarrollo:

  1. Tim crea una nueva migración (por ej. crea una nueva table, cambia la definición de una columna, etc.).
  2. Tim hace un commit con la nueva migración al sistema de control de versiones (por ej. Git, Mercurial).
  3. Doug actualiza su repositorio desde el sistema de control de versiones y recibe la nueva migración.
  4. Doug aplica dicha migración a su base de datos local de desarrollo, de ese modo sincronizando su base de datos y reflejando los cambios que hizo Tim.

Los siguientes pasos muestran cómo hacer una puesta en producción con una migración de base de datos:

  1. Scott crea un tag de lanzamiento en el repositorio del proyecto que contiene algunas migraciones de base de datos.
  2. Scott actualiza el código fuente en el servidor de producción con el tag de lanzamiento.
  3. Scott aplica cualquier migración de base de datos acumulada a la base de datos de producción.

Yii provee un grupo de herramientas de línea de comandos que te permite:

  • crear nuevas migraciones;
  • aplicar migraciones;
  • revertir migraciones;
  • re-aplicar migraciones;
  • mostrar el historial y estado de migraciones.

Todas esas herramientas son accesibles a través del comando yii migrate. En esta sección describiremos en detalle cómo lograr varias tareas utilizando dichas herramientas. Puedes a su vez ver el uso de cada herramienta a través del comando de ayuda yii help migrate.

Consejo: las migraciones pueden no sólo afectar un esquema de base de datos sino también ajustar datos existentes para que encajen en el nuevo esquema, crear herencia RBAC o también limpiar el cache.

Creando Migraciones

Para crear una nueva migración, ejecuta el siguiente comando:

yii migrate/create <name>

El argumento requerido name da una pequeña descripción de la nueva migración. Por ejemplo, si la migración se trata acerca de crear una nueva tabla llamada news, podrías utilizar el nombre create_news_table y ejecutar el siguiente comando:

yii migrate/create create_news_table

Nota: Debido a que el argumento name será utilizado como parte del nombre de clase de la migración generada, sólo debería contener letras, dígitos, y/o guines bajos.

El comando anterior un nuevo archivo de clase PHP llamado m150101_185401_create_news_table.php en el directorio @app/migrations. El archivo contendrá el siguiente código, que principalmente declara una clase de tipo migración m150101_185401_create_news_table con el siguiente esqueleto de código:

<?php

use yii\db\Migration;

class m150101_185401_create_news_table extends Migration
{
    public function up()
    {

    }

    public function down()
    {
        echo "m101129_185401_create_news_table cannot be reverted.\n";

        return false;
    }

    /*
    // Use safeUp/safeDown to run migration code within a transaction
    public function safeUp()
    {
    }

    public function safeDown()
    {
    }
    */
}

Cada migración de base de datos es definida como una clase PHP que extiende de yii\db\Migration. La nombre de clase de la migración es generado automáticamente en el formato m<YYMMDD_HHMMSS>_<Name>, donde

  • <YYMMDD_HHMMSS> se refiere a la marca de tiempo UTC en la cual el comando de migración fue ejecutado.
  • <Name> es el mismo valor del argumento name provisto al ejecutar el comando.

En la clase de la migración, se espera que tu escribas código en el método up(), que realiza los cambios en la base de datos. Podrías también querer introducir código en el método down(), que debería revertir los cambios realizados por up(). El método up() es llamado cuando actualizas la base de datos con esta migración, mientras que el método down() es llamado cuando reviertes dicha migración. El siguiente código muestra cómo podrías implementar la clase de migración para crear la tabla news:

<?php

use yii\db\Schema;
use yii\db\Migration;

class m150101_185401_create_news_table extends Migration
{
    public function up()
    {
        $this->createTable('news', [
            'id' => Schema::TYPE_PK,
            'title' => Schema::TYPE_STRING . ' NOT NULL',
            'content' => Schema::TYPE_TEXT,
        ]);
    }

    public function down()
    {
        $this->dropTable('news');
    }
}

Información: No todas las migraciones son reversibles. Por ejemplo, si el método up() elimina un registro en una tabla, podrías no ser capáz de recuperarla en el método down(). A veces, podrías ser simplemente demasiado perezoso para implementar el método down(), debido a que no es muy común revertir migraciones de base de datos. En este caso, deberías devolver false en el método down() para indicar que dicha migración no es reversible.

La clase de migración de base de datos yii\db\Migration expone una conexión a la base de datos mediante la propiedad db. Puedes utilizar esto para manipular el esquema de la base de datos utilizando métodos como se describen en Trabajando con Esquemas de Base de Datos.

En vez de utilizar tipos físicos, al crear tablas o columnas deberías utilizar los tipos abstractos así las migraciones son independientes de algún DBMS específico. La clase yii\db\Schema define un grupo de constantes que representan los tipos abstractos soportados. Dichas constantes son llamadas utilizando el formato de TYPE_<Name>. Por ejemplo, TYPE_PK se refiere al tipo clave primaria auto-incremental; TYPE_STRING se refiere al tipo string. Cuando se aplica una migración a una base de datos en particular, los tipos abstractos serán traducidos a los tipos físicos correspondientes. En el caso de MySQL, TYPE_PK será transformado en int(11) NOT NULL AUTO_INCREMENT PRIMARY KEY, mientras TYPE_STRING se vuelve varchar(255).

Puedes agregar restricciones adicionales al utilizar tipos abstractos. En el ejemplo anterior, NOT NULL es agregado a Schema::TYPE_STRING para especificar que la columna no puede ser null.

Información: El mapeo entre tipos abstractos y tipos físicos es especificado en la propiedad $typeMap en cada clase concreta QueryBuilder.

Desde la versión 2.0.6, puedes hacer uso del recientemente introducido generador de esquemas, el cual provee una forma más conveniente de definir las columnas. De esta manera, la migración anterior podría ser escrita así:

<?php

use yii\db\Migration;

class m150101_185401_create_news_table extends Migration
{
    public function up()
    {
        $this->createTable('news', [
            'id' => $this->primaryKey(),
            'title' => $this->string()->notNull(),
            'content' => $this->text(),
        ]);
    }

    public function down()
    {
        $this->dropTable('news');
    }
}

Existe una lista de todos los métodos disponibles para la definición de tipos de columna en la API de la documentación de yii\db\SchemaBuilderTrait.

Generar Migraciones

Desde la versión 2.0.7 la consola provee una manera muy conveniente de generar migraciones.

Si el nombre de la migración tiene una forma especial, por ejemplo create_xxx_table o drop_xxx_table entonces el archivo de la migración generada contendrá código extra, en este caso para crear/eliminar tablas. A continuación se describen todas estas variantes.

Crear Tabla

yii migrate/create create_post_table

esto genera

/**
 * Handles the creation for table `post`.
 */
class m150811_220037_create_post_table extends Migration
{
    /**
     * {@inheritdoc}
     */
    public function up()
    {
        $this->createTable('post', [
            'id' => $this->primaryKey()
        ]);
    }

    /**
     * {@inheritdoc}
     */
    public function down()
    {
        $this->dropTable('post');
    }
}

Para crear las columnas en ese momento, las puedes especificar vía la opción --fields.

yii migrate/create create_post_table --fields="title:string,body:text"

genera

/**
 * Handles the creation for table `post`.
 */
class m150811_220037_create_post_table extends Migration
{
    /**
     * {@inheritdoc}
     */
    public function up()
    {
        $this->createTable('post', [
            'id' => $this->primaryKey(),
            'title' => $this->string(),
            'body' => $this->text(),
        ]);
    }

    /**
     * {@inheritdoc}
     */
    public function down()
    {
        $this->dropTable('post');
    }
}

Puedes especificar más parámetros para las columnas.

yii migrate/create create_post_table --fields="title:string(12):notNull:unique,body:text"

genera

/**
 * Handles the creation for table `post`.
 */
class m150811_220037_create_post_table extends Migration
{
    /**
     * {@inheritdoc}
     */
    public function up()
    {
        $this->createTable('post', [
            'id' => $this->primaryKey(),
            'title' => $this->string(12)->notNull()->unique(),
            'body' => $this->text()
        ]);
    }

    /**
     * {@inheritdoc}
     */
    public function down()
    {
        $this->dropTable('post');
    }
}

Nota: la clave primaria es automáticamente agragada y llamada id por defecto. Si quieres utilizar otro nombre puedes especificarlo así --fields="name:primaryKey".

Claves Foráneas

Desde 2.0.8 el generador soporta claves foráneas utilizando la palabra clave foreignKey.

yii migrate/create create_post_table --fields="author_id:integer:notNull:foreignKey(user),category_id:integer:defaultValue(1):foreignKey,title:string,body:text"

genera

/**
 * Handles the creation for table `post`.
 * Has foreign keys to the tables:
 *
 * - `user`
 * - `category`
 */
class m160328_040430_create_post_table extends Migration
{
    /**
     * {@inheritdoc}
     */
    public function up()
    {
        $this->createTable('post', [
            'id' => $this->primaryKey(),
            'author_id' => $this->integer()->notNull(),
            'category_id' => $this->integer()->defaultValue(1),
            'title' => $this->string(),
            'body' => $this->text(),
        ]);

        // creates index for column `author_id`
        $this->createIndex(
            'idx-post-author_id',
            'post',
            'author_id'
        );

        // add foreign key for table `user`
        $this->addForeignKey(
            'fk-post-author_id',
            'post',
            'author_id',
            'user',
            'id',
            'CASCADE'
        );

        // creates index for column `category_id`
        $this->createIndex(
            'idx-post-category_id',
            'post',
            'category_id'
        );

        // add foreign key for table `category`
        $this->addForeignKey(
            'fk-post-category_id',
            'post',
            'category_id',
            'category',
            'id',
            'CASCADE'
        );
    }

    /**
     * {@inheritdoc}
     */
    public function down()
    {
        // drops foreign key for table `user`
        $this->dropForeignKey(
            'fk-post-author_id',
            'post'
        );

        // drops index for column `author_id`
        $this->dropIndex(
            'idx-post-author_id',
            'post'
        );

        // drops foreign key for table `category`
        $this->dropForeignKey(
            'fk-post-category_id',
            'post'
        );

        // drops index for column `category_id`
        $this->dropIndex(
            'idx-post-category_id',
            'post'
        );

        $this->dropTable('post');
    }
}

La posición de la palabra clave foreignKey en la descripción de la columna no cambia el código generado. Esto significa:

  • author_id:integer:notNull:foreignKey(user)
  • author_id:integer:foreignKey(user):notNull
  • author_id:foreignKey(user):integer:notNull

Todas generan el mismo código.

La palabra clave foreignKey puede tomar un parámetro entre paréntesis el cual será el nombre de la tabla relacionada por la clave foránea generada. Si no se pasa ningún parámetro el nombre de la tabla será deducido en base al nombre de la columna.

En el ejemplo anterior author_id:integer:notNull:foreignKey(user) generará una columna llamada author_id con una clave foránea a la tabla user mientras category_id:integer:defaultValue(1):foreignKey generará category_id con una clave foránea a la tabla category.

Eliminar Tabla

yii migrate/create drop_post_table --fields="title:string(12):notNull:unique,body:text"

genera

class m150811_220037_drop_post_table extends Migration
{
    public function up()
    {
        $this->dropTable('post');
    }

    public function down()
    {
        $this->createTable('post', [
            'id' => $this->primaryKey(),
            'title' => $this->string(12)->notNull()->unique(),
            'body' => $this->text()
        ]);
    }
}

Agregar Columna

Si el nombre de la migración está en la forma add_xxx_column_to_yyy_table entonces el archivo generado contendrá las declaraciones addColumn y dropColumn necesarias.

Para agregar una columna:

yii migrate/create add_position_column_to_post_table --fields="position:integer"

genera

class m150811_220037_add_position_column_to_post_table extends Migration
{
    public function up()
    {
        $this->addColumn('post', 'position', $this->integer());
    }

    public function down()
    {
        $this->dropColumn('post', 'position');
    }
}

Eliminar Columna

Si el nombre de la migración está en la forma drop_xxx_column_from_yyy_table entonces el archivo generado contendrá las declaraciones addColumn y dropColumn necesarias.

yii migrate/create drop_position_column_from_post_table --fields="position:integer"

genera

class m150811_220037_drop_position_column_from_post_table extends Migration
{
    public function up()
    {
        $this->dropColumn('post', 'position');
    }

    public function down()
    {
        $this->addColumn('post', 'position', $this->integer());
    }
}

Agregar Tabla de Unión

Si el nombre de la migración está en la forma create_junction_table_for_xxx_and_yyy_tables entonces se generará el código necesario para una tabla de unión.

yii migrate/create create_junction_table_for_post_and_tag_tables --fields="created_at:dateTime"

genera

/**
 * Handles the creation for table `post_tag`.
 * Has foreign keys to the tables:
 *
 * - `post`
 * - `tag`
 */
class m160328_041642_create_junction_table_for_post_and_tag_tables extends Migration
{
    /**
     * {@inheritdoc}
     */
    public function up()
    {
        $this->createTable('post_tag', [
            'post_id' => $this->integer(),
            'tag_id' => $this->integer(),
            'created_at' => $this->dateTime(),
            'PRIMARY KEY(post_id, tag_id)',
        ]);

        // creates index for column `post_id`
        $this->createIndex(
            'idx-post_tag-post_id',
            'post_tag',
            'post_id'
        );

        // add foreign key for table `post`
        $this->addForeignKey(
            'fk-post_tag-post_id',
            'post_tag',
            'post_id',
            'post',
            'id',
            'CASCADE'
        );

        // creates index for column `tag_id`
        $this->createIndex(
            'idx-post_tag-tag_id',
            'post_tag',
            'tag_id'
        );

        // add foreign key for table `tag`
        $this->addForeignKey(
            'fk-post_tag-tag_id',
            'post_tag',
            'tag_id',
            'tag',
            'id',
            'CASCADE'
        );
    }

    /**
     * {@inheritdoc}
     */
    public function down()
    {
        // drops foreign key for table `post`
        $this->dropForeignKey(
            'fk-post_tag-post_id',
            'post_tag'
        );

        // drops index for column `post_id`
        $this->dropIndex(
            'idx-post_tag-post_id',
            'post_tag'
        );

        // drops foreign key for table `tag`
        $this->dropForeignKey(
            'fk-post_tag-tag_id',
            'post_tag'
        );

        // drops index for column `tag_id`
        $this->dropIndex(
            'idx-post_tag-tag_id',
            'post_tag'
        );

        $this->dropTable('post_tag');
    }
}

Migraciones Transaccionales

Al ejecutar migraciones complejas de BD, es importante asegurarse que todas las migraciones funcionen o fallen como una unidad así la base de datos puede mantener integridad y consistencia. Para alcanzar este objetivo, se recomienda que encierres las operación de la BD de cada migración en una transacción.

Una manera simple de implementar migraciones transaccionales es poniendo el código de las migraciones en los métodos safeUp() y safeDown(). Estos métodos se diferencias con up() y down() en que son encerrados implícitamente en una transacción. Como resultado, si alguna de las operaciones dentro de estos métodos falla, todas las operaciones previas son automáticamente revertidas.

En el siguiente ejemplo, además de crear la tabla news también insertamos un registro inicial dentro de la dicha tabla.

<?php

use yii\db\Migration;

class m150101_185401_create_news_table extends Migration
{
    public function safeUp()
    {
        $this->createTable('news', [
            'id' => $this->primaryKey(),
            'title' => $this->string()->notNull(),
            'content' => $this->text(),
        ]);

        $this->insert('news', [
            'title' => 'test 1',
            'content' => 'content 1',
        ]);
    }

    public function safeDown()
    {
        $this->delete('news', ['id' => 1]);
        $this->dropTable('news');
    }
}

Ten en cuenta que usualmente cuando ejecutas múltiples operaciones en la BD en safeUp(), deberías revertir su orden de ejecución en safeDown(). En el ejemplo anterior primero creamos la tabla y luego insertamos la finla en safeUp(); mientras que en safeDown() primero eliminamos el registro y posteriormente eliminamos la tabla.

Nota: No todos los DBMS soportan transacciones. Y algunas consultas a la BD no pueden ser puestas en transacciones. Para algunos ejemplos, por favor lee acerca de commits implícitos. En estos casos, deberías igualmente implementar up() y down().

Métodos de Acceso a la Base de Datos

La clase base yii\db\Migration provee un grupo de métodos que te permiten acceder y manipular bases de datos. Podrías encontrar que estos métodos son nombrados de forma similar a los métodos DAO provistos por la clase yii\db\Command. Por ejemplo, el método yii\db\Migration::createTable() te permite crear una nueva tabla, tal como lo hace yii\db\Command::createTable().

El beneficio de utilizar lo métodos provistos por yii\db\Migration es que no necesitas explícitamente crear instancias de yii\db\Command, y la ejecución de cada método mostrará automáticamente mensajes útiles diciéndote qué operaciones de la base de datos se realizaron y cuánto tiempo tomaron.

Debajo hay una lista de todos los métodos de acceso a la base de datos:

Información: yii\db\Migration no provee un método de consulta a la base de datos. Esto es porque normalmente no necesitas mostrar mensajes detallados al traer datos de una base de datos. También se debe a que puedes utilizar el poderoso Query Builder para generar y ejecutar consultas complejas.

Nota: Al manipular datos utilizando una migración podrías encontrar que utilizando tus clases Active Record para esto podría ser útil ya que algo de la lógica ya está implementada ahí. Ten en cuenta de todos modos, que en contraste con el código escrito en las migraciones, cuya naturaleza es permanecer constante por siempre, la lógica de la aplicación está sujeta a cambios. Entonces al utilizar Active Record en migraciones, los cambios en la lógica en la capa Active Record podrían accidentalmente romper migraciones existentes. Por esta razón, el código de las migraciones debería permanecer independiente de determinada lógica de la aplicación tal como clases Active Record.

Aplicar Migraciones

To upgrade a database to its latest structure, you should apply all available new migrations using the following command: Para actualizar una base de datos a su última estructura, deberías aplicar todas las nuevas migraciones utilizando el siguiente comando:

yii migrate

Este comando listará todas las migraciones que no han sido aplicadas hasta el momento. Si confirmas que quieres aplicar dichas migraciones, se correrá el método up() o safeUp() en cada clase de migración nueva, una tras otra, en el orden de su valor de marca temporal. Si alguna de las migraciones falla, el comando terminará su ejecución sin aplicar el resto de las migraciones.

Consejo: En caso de no disponer de la línea de comandos en el servidor, podrías intentar utilizar la extensión web shell.

Por cada migración aplicada correctamente, el comando insertará un registro en la base de datos, en la tabla llamada migration para registrar la correcta aplicación de la migración. Esto permitirá a la herramienta de migración identificar cuáles migraciones han sido aplicadas y cuáles no.

Información: La herramienta de migración creará automáticamente la tabla migration en la base de datos especificada en la opción db del comando. Por defecto, la base de datos es especificada en el componente de aplicación db.

A veces, podrías sólo querer aplicar una o algunas pocas migraciones, en vez de todas las migraciones disponibles. Puedes hacer esto el número de migraciones que quieres aplicar al ejecutar el comando. Por ejemplo, el siguiente comando intentará aplicar las tres siguientes migraciones disponibles:

yii migrate 3

Puedes además explícitamente especificar una migración en particular a la cual la base de datos debería migrar utilizando el comando migrate/to de acuerdo a uno de los siguientes formatos:

yii migrate/to 150101_185401                      # utiliza la marca temporal para especificar la migración
yii migrate/to "2015-01-01 18:54:01"              # utiliza un string que puede ser analizado por strtotime()
yii migrate/to m150101_185401_create_news_table   # utiliza el nombre completo
yii migrate/to 1392853618                         # utiliza el tiempo UNIX

Si hubiera migraciones previas a la especificada sin aplicar, estas serán aplicadas antes de que la migración especificada sea aplicada.

Si la migración especificada ha sido aplicada previamente, cualquier migración aplicada posteriormente será revertida.

Revertir Migraciones

Para revertir (deshacer) una o varias migraciones ya aplicadas, puedes ejecutar el siguiente comando:

yii migrate/down     # revierte la más reciente migración aplicada
yii migrate/down 3   # revierte las 3 últimas migraciones aplicadas

Nota: No todas las migraciones son reversibles. Intentar revertir tales migraciones producirá un error y detendrá completamente el proceso de reversión.

Rehacer Migraciones

Rehacer (re-ejecutar) migraciones significa primero revertir las migraciones especificadas y luego aplicarlas nuevamente. Esto puede hacerse de esta manera:

yii migrate/redo        # rehace la más reciente migración aplicada
yii migrate/redo 3      # rehace las 3 últimas migraciones aplicadas

Nota: Si una migración no es reversible, no tendrás posibilidades de rehacerla.

Listar Migraciones

Para listar cuáles migraciones han sido aplicadas y cuáles no, puedes utilizar los siguientes comandos:

yii migrate/history     # muestra las últimas 10 migraciones aplicadas
yii migrate/history 5   # muestra las últimas 5 migraciones aplicadas
yii migrate/history all # muestra todas las migraciones aplicadas

yii migrate/new         # muestra las primeras 10 nuevas migraciones
yii migrate/new 5       # muestra las primeras 5 nuevas migraciones
yii migrate/new all     # muestra todas las nuevas migraciones

Modificar el Historial de Migraciones

En vez de aplicar o revertir migraciones, a veces simplemente quieres marcar que tu base de datos ha sido actualizada a una migración en particular. Esto sucede normalmente cuando cambias manualmente la base de datos a un estado particular y no quieres que la/s migración/es de ese cambio sean re-aplicadas posteriormente. Puedes alcanzar este objetivo con el siguiente comando:

yii migrate/mark 150101_185401                      # utiliza la marca temporal para especificar la migración
yii migrate/mark "2015-01-01 18:54:01"              # utiliza un string que puede ser analizado por strtotime()
yii migrate/mark m150101_185401_create_news_table   # utiliza el nombre completo
yii migrate/mark 1392853618                         # utiliza el tiempo UNIX

El comando modificará la tabla migration agregando o eliminado ciertos registros para indicar que en la base de datos han sido aplicadas las migraciones hasta la especificada. Ninguna migración será aplicada ni revertida por este comando.

Personalizar Migraciones

Hay varias maneras de personalizar el comando de migración.

Utilizar Opciones de la Línea de Comandos

El comando de migración trae algunas opciones de línea de comandos que pueden ser utilizadas para personalizar su comportamiento:

  • interactive: boolean (por defecto true), especificar si se debe ejecutar la migración en modo interactivo. Cuando se indica true, se le pedirá confirmación al usuario antes de ejecutar ciertas acciones. Puedes querer definirlo como false si el comando está siendo utilizado como un proceso de fondo.

  • migrationPath: string (por defecto @app/migrations), especifica el directorio que contiene todos los archivos de clase de las migraciones. Este puede ser especificado tanto como una ruta a un directorio un alias de ruta. Ten en cuenta que el directorio debe existir, o el comando disparará un error.

  • migrationTable: string (por defecto migration), especifica el nombre de la tabla de la base de datos que almacena información del historial de migraciones. Dicha tabla será creada por el comando en caso de que no exista. Puedes también crearla manualmente utilizando la estructura version varchar(255) primary key, apply_time integer.

  • db: string (por defecto db), especifica el ID del componente de aplicación de la base de datos. Esto representa la base de datos que será migrada en este comando.

  • templateFile: string (por defecto @yii/views/migration.php), especifica la ruta al template utilizado para generar el esqueleto de los archivos de clases de migración. Puede ser especificado tanto como una ruta a un archivo como una alias de una ruta. El template es un archivo PHP en el cual puedes utilizar una variable predefinida llamada $className para obtener el nombre de clase de la migración.

  • generatorTemplateFiles: array (por defecto `[

      'create_table' => '@yii/views/createTableMigration.php',
      'drop_table' => '@yii/views/dropTableMigration.php',
      'add_column' => '@yii/views/addColumnMigration.php',
      'drop_column' => '@yii/views/dropColumnMigration.php',
      'create_junction' => '@yii/views/createTableMigration.php'
    

    ]`), especifica los templates utilizados para generar las migraciones. Ver "Generar Migraciones" para más detalles.

  • fields: array de strings de definiciones de columna utilizado por el código de migración. Por defecto []. El formato de cada definición es COLUMN_NAME:COLUMN_TYPE:COLUMN_DECORATOR. Por ejemplo, --fields=name:string(12):notNull produce una columna string de tamaño 12 que es not null.

El siguiente ejemplo muestra cómo se pueden utilizar estas opciones.

Por ejemplo, si queremos migrar un módulo forum cuyos arhivos de migración están ubicados dentro del directorio migrations del módulo, podemos utilizar el siguientedocs/guide-es/db-migrations.md comando:

# realiza las migraciones de un módulo forum sin interacción del usuario
yii migrate --migrationPath=@app/modules/forum/migrations --interactive=0

Configurar el Comando Globalmente

En vez de introducir los valores de las opciones cada vez que ejecutas un comandod e migración, podrías configurarlos de una vez por todas en la configuración de la aplicación como se muestra a continuación:

return [
    'controllerMap' => [
        'migrate' => [
            'class' => 'yii\console\controllers\MigrateController',
            'migrationTable' => 'backend_migration',
        ],
    ],
];

Con esta configuración, cada vez que ejecutes un comando de migración, la tabla backend_migration será utilizada para registrar el historial de migraciones. No necesitarás volver a especificarla con la opción migrationTable de la línea de comandos.

Migrar Múltiples Bases de Datos

Por defecto, las migraciones son aplicadas en la misma base de datos especificada en el componente de aplicación db. Si quieres que sean aplicadas en una base de datos diferente, puedes especificar la opción db como se muestra a continuación,

yii migrate --db=db2

El comando anterior aplicará las migraciones en la base de datos db2.

A veces puede suceder que quieras aplicar algunas de las migraciones a una base de datos, mientras algunas otras a una base de datos distinta. Para lograr esto, al implementar una clase de migración debes especificar explícitamente el ID del componente DB que la migración debe utilizar, como a continuación:

<?php

use yii\db\Migration;

class m150101_185401_create_news_table extends Migration
{
    public function init()
    {
        $this->db = 'db2';
        parent::init();
    }
}

La migración anterior se aplicará a db2, incluso si especificas una base de datos diferente en la opción db de la línea de comandos. Ten en cuenta que el historial aún será registrado in la base de datos especificada en la opción db de la línea de comandos.

Si tienes múltiples migraciones que utilizan la misma base de datos, es recomandable que crees una clase base de migración con el código init() mostrado. Entonces cada clase de migración puede extender de esa clase base.

Consejo: Aparte de definir la propiedad db, puedes también operar en diferentes bases de datos creando nuevas conexiones de base de datos en tus clases de migración. También puedes utilizar métodos DAO con esas conexiones para manipular diferentes bases de datos.

Another strategy that you can take to migrate multiple databases is to keep migrations for different databases in different migration paths. Then you can migrate these databases in separate commands like the following: Otra estrategia que puedes seguir para migrar múltiples bases de datos es mantener las migraciones para diferentes bases de datos en distintas rutas de migración. Entonces podrías migrar esas bases de datos en comandos separados como a continuación:

yii migrate --migrationPath=@app/migrations/db1 --db=db1
yii migrate --migrationPath=@app/migrations/db2 --db=db2
...

El primer comando aplicará las migraciones que se encuentran en @app/migrations/db1 en la base de datos db1, el segundo comando aplicará las migraciones que se encuentran en @app/migrations/db2 en db2, y así sucesivamente.

Found a typo or you think this page needs improvement?
Edit it on github !