upscheme
1.0.0
Paquete PHP fácil de usar para actualizar el esquema de la base de datos de su aplicación y migrar datos entre versiones.
composer req aimeos/upschemeTabla de contenido
Las migraciones son como control de versiones de su base de datos. Permiten obtener exactamente el mismo estado en cada instalación. Usando Upscheme, obtienes:
A continuación se muestra un ejemplo de una definición de tabla que puede adaptar siempre que el diseño de su tabla deba cambiar. Luego, Upscheme agregará y modificará automáticamente las columnas y propiedades de la tabla existentes (pero no eliminará nada por razones de seguridad):
$ this -> db ()-> table ( ' test ' , function ( $ t ) {
$ t -> engine = ' InnoDB ' ;
$ t -> id ();
$ t -> string ( ' domain ' , 32 );
$ t -> string ( ' code ' , 64 )-> opt ( ' charset ' , ' binary ' , [ ' mariadb ' , ' mysql ' ] );
$ t -> string ( ' label ' , 255 );
$ t -> int ( ' pos ' )-> default ( 0 );
$ t -> smallint ( ' status ' );
$ t -> default ();
$ t -> unique ( [ ' domain ' , ' code ' ] );
$ t -> index ( [ ' status ' , ' pos ' ] );
} );Para actualizar esquemas de bases de datos relacionales, actualmente se utilizan con mayor frecuencia dos paquetes: Doctrine DBAL y Doctrine Migraciones. Si bien Doctrine DBAL hace un buen trabajo al abstraer las diferencias de varias implementaciones de bases de datos, su API requiere escribir mucho código. Las migraciones de Doctrine en el otro sitio tienen algunos inconvenientes que dificultan su uso en todas las aplicaciones que admiten extensiones de terceros.
La API de DBAL es muy detallada y es necesario escribir mucho código incluso para cosas simples. Upscheme utiliza Doctrine DBAL para ofrecer una API fácil de usar para actualizar el esquema de la base de datos de su aplicación con un código mínimo. Para el ejemplo de Upscheme anterior, estas líneas de código son equivalentes a DBAL en una migración:
$ dbalManager = $ conn -> createSchemaManager ();
$ from = $ manager -> createSchema ();
$ to = $ manager -> createSchema ();
if ( $ to -> hasTable ( ' test ' ) ) {
$ table = $ to -> getTable ( ' test ' );
} else {
$ table = $ to -> createTable ( ' test ' );
}
$ table -> addOption ( ' engine ' , ' InnoDB ' );
$ table -> addColumn ( ' id ' , ' integer ' , [ ' autoincrement ' => true ] );
$ table -> addColumn ( ' domain ' , ' string ' , [ ' length ' => 32 ] );
$ platform = $ conn -> getDatabasePlatform ();
if ( $ platform instanceof Doctrine DBAL Platform MySQLPlatform
|| $ platform instanceof Doctrine DBAL Platform MariaDBPlatform
) {
$ table -> addColumn ( ' code ' , ' string ' , [ ' length ' => 64 , ' customSchemaOptions ' => [ ' charset ' => ' binary ' ]] );
} else {
$ table -> addColumn ( ' code ' , ' string ' , [ ' length ' => 64 ]] );
}
$ table -> addColumn ( ' label ' , ' string ' , [ ' length ' => 255 ] );
$ table -> addColumn ( ' pos ' , ' integer ' , [ ' default ' => 0 ] );
$ table -> addColumn ( ' status ' , ' smallint ' , [] );
$ table -> addColumn ( ' mtime ' , ' datetime ' , [] );
$ table -> addColumn ( ' ctime ' , ' datetime ' , [] );
$ table -> addColumn ( ' editor ' , ' string ' , [ ' length ' => 255 ] );
$ table -> setPrimaryKey ( [ ' id ' ] );
$ table -> addUniqueIndex ( [ ' domain ' , ' code ' ] );
$ table -> addIndex ( [ ' status ' , ' pos ' ] );
foreach ( $ from -> getMigrateToSql ( $ to , $ conn -> getDatabasePlatform () ) as $ sql ) {
$ conn -> executeStatement ( $ sql );
}Doctrine Migration se basa en clases de migración que reciben un nombre según el momento en que se crearon para garantizar un orden determinado. Además, almacena qué migraciones se han ejecutado en una tabla de su base de datos. Hay tres problemas principales que surgen de esto:
down() Si su aplicación admite extensiones de terceros, es probable que estas extensiones agreguen columnas a las tablas existentes y migren datos por sí mismas. Como no hay forma de definir dependencias entre migraciones, puede resultar casi imposible ejecutar migraciones en una aplicación con varias extensiones de terceros sin conflictos. Para evitar eso, Upscheme ofrece métodos before() y after() fáciles de usar en cada tarea de migración donde las tareas pueden definir sus dependencias con otras tareas.
Debido a que Doctrine Migrations utiliza una tabla de base de datos para registrar qué migración ya se ha ejecutado, estos registros pueden desincronizarse fácilmente en caso de problemas. Por el contrario, Upscheme solo se basa en el esquema real, por lo que es posible actualizar desde cualquier estado, independientemente de lo que haya sucedido antes.
Doctrine Migrations también admite operaciones inversas en los métodos down() para que puedas revertir migraciones que Upscheme no admite. La experiencia ha demostrado que a menudo es imposible revertir las migraciones, por ejemplo, después de agregar una nueva columna, migrar los datos de una columna existente y eliminar la columna anterior posteriormente. Si la migración de los datos tuvo pérdidas, no puede recrear el mismo estado en un método down() . Lo mismo ocurre si se te cae una mesa. Por lo tanto, Upscheme solo ofrece actualización del esquema pero no degradación para evitar la pérdida de datos implícita.
Upscheme utiliza Doctrine DBAL para abstraerse de diferentes implementaciones de servidores de bases de datos. DBAL es compatible con todos los principales sistemas de gestión de bases de datos relacionales (RDBMS), pero con un nivel diferente de soporte para las funciones disponibles:
Buen soporte:
Soporte limitado:
Después de haber instalado el paquete aimeos/upscheme usando Composer, puede usar la clase Up para ejecutar sus tareas de migración:
$ config = [
' driver ' => ' pdo_mysql ' ,
' host ' => ' 127.0.0.1 ' ,
' dbname ' => ' <database> ' ,
' user ' => ' <dbuser> ' ,
' password ' => ' <secret> '
];
Aimeos Upscheme Up:: use ( $ config , ' src/migrations ' )-> up (); El método Up::use() requiere dos parámetros: la configuración de la base de datos y la(s) ruta(s) a las tareas de migración. Para la configuración, las claves de la matriz y los valores del controlador deben ser compatibles con Doctrine DBAL. Los controladores disponibles son:
Algunas bases de datos requieren diferentes parámetros, los más notables SQLite y Oracle:
SQLite:
$ config = [
' driver ' => ' pdo_sqlite ' ,
' path ' => ' path/to/file.sq3 '
];Oráculo:
$ config = [
' driver ' => ' pdo_oci ' ,
' host ' => ' <host or IP> ' ,
' dbname ' => ' <SID or service name (Oracle 18+)> ' ,
' service ' => true , // for Oracle 18 + only
' user ' => ' <dbuser> ' ,
' password ' => ' <secret> '
];Si no usó Doctrine DBAL antes, la configuración de su base de datos puede tener una estructura diferente y/o usar valores diferentes para el tipo de base de datos. Upscheme le permite registrar un método personalizado que transforma su configuración en configuraciones DBAL válidas, por ejemplo:
Aimeos Upscheme Up:: macro ( ' connect ' , function ( array $ cfg ) {
return Doctrine DBAL DriverManager:: getConnection ( [
' driver ' => $ cfg [ ' adapter ' ],
' host ' => $ cfg [ ' host ' ],
' dbname ' => $ cfg [ ' database ' ],
' user ' => $ cfg [ ' username ' ],
' password ' => $ cfg [ ' password ' ]
] );
} );Upscheme también admite varias conexiones de bases de datos que puede distinguir por su nombre de clave:
$ config = [
' db ' => [
' driver ' => ' pdo_mysql ' ,
' host ' => ' 127.0.0.1 ' ,
' dbname ' => ' <database> ' ,
' user ' => ' <dbuser> ' ,
' password ' => ' <secret> '
],
' temp ' => [
' driver ' => ' pdo_sqlite ' ,
' path ' => ' /tmp/mydb.sqlite '
]
];
Aimeos Upscheme Up:: use ( $ config , ' src/migrations ' )-> up (); Por supuesto, también puedes pasar varias rutas de migración a la clase Up :
Aimeos Upscheme Up:: use ( $ config , [ ' src/migrations ' , ' ext/migrations ' ] )-> up ();Para habilitar la salida (depuración), utilice el método detallado():
Aimeos Upscheme Up:: use ( $ config , ' src/migrations ' )-> verbose ()-> up (); // most important only
Aimeos Upscheme Up:: use ( $ config , ' src/migrations ' )-> verbose ( ' vv ' )-> up (); // more verbose
Aimeos Upscheme Up:: use ( $ config , ' src/migrations ' )-> verbose ( ' vvv ' )-> up (); // debugging Una tarea de migración solo requiere implementar el método up() y debe almacenarse en uno de los directorios pasados a la clase Up :
<?php
namespace Aimeos Upscheme Task ;
use Aimeos Upscheme Schema Table ;
return new class ( $ this ) extends Base {
public function up ()
{
$ this -> db ()-> table ( ' test ' , function ( Table $ t ) {
$ t -> id ();
$ t -> string ( ' label ' );
$ t -> bool ( ' status ' );
} );
}
}; En su archivo PHP, incluya siempre primero la declaración namespace . La declaración use es opcional y solo es necesaria como atajo para la sugerencia de tipo para el argumento de la función de cierre. Su clase también debe extenderse desde la clase de tarea "Base" o implementar la interfaz de tarea "Iface".
Como alternativa a las clases anónimas, puede utilizar clases con nombre para tareas de migración:
<?php
namespace Aimeos Upscheme Task ;
use Aimeos Upscheme Schema Table ;
class TestTable extends Base
{
public function up ()
{
$ this -> db ()-> table ( ' test ' , function ( Table $ t ) {
$ t -> id ();
$ t -> string ( ' label ' );
$ t -> bool ( ' status ' );
} );
}
} El archivo en el que está almacenada su clase debe tener el mismo nombre (distingue entre mayúsculas y minúsculas) que la clase misma y el sufijo .php , por ejemplo:
class TestTable -> TestTable.php
No existe una convención estricta sobre cómo nombrar los archivos de tareas de migración. Puedes nombrarlos por lo que hacen (por ejemplo, "CreateTestTable.php"), en qué operan (por ejemplo, "TestTable.php") o incluso usar una marca de tiempo (por ejemplo, "20201231_Test.php").
Si las tareas no contienen dependencias, se ordenan y ejecutan en orden alfabético según el nombre del archivo y la clasificación sería:
20201231_Test.php
CreateTestTable.php
TestTable.php
Para especificar dependencias con otras tareas de migración, utilice los métodos after() y before() . Su tarea se ejecuta después de las tareas devueltas por after() y antes de las tareas devueltas por before() :
return new class ( $ this ) extends Base {
public function after () : array
{
return [ ' CreateRefTable ' ];
}
public function before () : array
{
return [ ' InsertTestData ' ];
}
} Los nombres de las tareas son los nombres de los archivos de las tareas sin el sufijo .php . Si la migración de ejemplo se almacena en el archivo TestTable.php , el orden de ejecución sería:
CreateRefTable.php -> TestTable.php -> InsertTestData.php
Para generar mensajes en su tarea de migración, utilice el método info() :
$ this -> info ( ' some message ' );
$ this -> info ( ' more verbose message ' , ' vv ' );
$ this -> info ( ' very verbose debug message ' , ' vvv ' ); El segundo parámetro es el nivel de detalle y ninguno o v son mensajes estándar, vv son mensajes que solo se muestran si se desea más detalle, mientras que vvv es para mensajes de depuración. También hay un tercer parámetro para sangrar los mensajes:
$ this -> info ( ' some message ' );
$ this -> info ( ' second level message ' , ' v ' , 1 );
$ this -> info ( ' third level message ' , ' v ' , 2 );Esto mostrará:
some message
second level message
third level message
El requisito previo es que el método verbose() de la clase Up haya sido llamado antes:
Aimeos Upscheme Up:: use ( $ config , ' ... ' )-> verbose ()-> up (); En el método up() , tiene acceso al esquema de la base de datos utilizando el método db() . En caso de que haya pasado más de una configuración de base de datos a Up::use() , puede acceder a los diferentes esquemas mediante su clave de configuración:
// $config = [ 'db' => [ ... ] , 'temp' => [ ... ] ] ;
// Aimeos UpschemeUp::use( $config , '...' )->up() ;
$ this -> db ();
$ this -> db ( ' db ' );
$ this -> db ( ' temp ' ); Si no pasa ninguna clave de configuración o una que no existe, se devuelve la primera configuración ("db" en este caso). Al utilizar los métodos disponibles del objeto de esquema de base de datos, puede agregar, actualizar o eliminar tablas, columnas, índices y otros objetos de base de datos. Además, puede utilizar insert() , select() , update() , delete() y stmt() para manipular los registros de las tablas.
Después de cada tarea de migración, las actualizaciones de esquema realizadas en la tarea se aplican automáticamente a la base de datos. Si necesita persistir un cambio inmediatamente porque desea insertar datos, llame $this->db()->up() usted mismo. El método up() también está disponible en cualquier objeto de tabla, secuencia y columna para que pueda llamar up() en cualquier lugar.
En los casos en que necesite dos conexiones de bases de datos diferentes porque desea ejecutar instrucciones SELECT e INSERT/UPDATE/DELETE al mismo tiempo, pase VERDADERO como segundo parámetro a db() para obtener el esquema de la base de datos que incluye una nueva conexión:
$ db1 = $ this -> db ();
$ db2 = $ this -> db ( ' db ' , true );
foreach ( $ db1 -> select ( ' users ' , [ ' status ' => false ] ) as $ row ) {
$ db2 -> insert ( ' oldusers ' , $ row );
}
$ db2 -> delete ( ' users ' , [ ' status ' => false ] ); Todos los cambios de esquema realizados se aplican a la base de datos antes de que se devuelva el esquema con la nueva conexión. Para evitar que las conexiones de la base de datos se acumulen hasta que el servidor de la base de datos rechace nuevas conexiones, llame siempre close() para las nuevas conexiones creadas por db( '<name>', true ) :
$ db2 -> close ();En lugar de escribir las migraciones para los objetos de su base de datos a mano, puede generar los archivos de migración automáticamente usando:
$ config = [
' db ' => [
' driver ' => ' pdo_mysql ' ,
' host ' => ' 127.0.0.1 ' ,
' dbname ' => ' <database> ' ,
' user ' => ' <dbuser> ' ,
' password ' => ' <secret> '
]
];
Aimeos Upscheme Up:: use ( $ config , ' migrations ' )-> create (); Esto generará un archivo para cada secuencia, tabla y vista en el directorio pasado ( ./migrations/ en este ejemplo). Si tienes varias bases de datos y quieres crear migraciones para todas a la vez, pasa las claves de conexión desde la configuración a create() :
$ config = [
' db ' => [
' driver ' => ' pdo_mysql ' ,
// ...
],
' order ' => [
' driver ' => ' pdo_oci ' ,
// ...
]
];
Aimeos Upscheme Up:: use ( $ config , ' migrations ' )-> create ( [ ' db ' , ' order ' ] ); Obtienes el objeto de esquema de base de datos en tu tarea llamando $this->db() como se describe en la sección de esquema. Le brinda acceso completo al esquema de la base de datos, incluidas todas las tablas, secuencias y otros objetos del esquema:
$ table = $ this -> db ()-> table ( ' users ' );
$ seq = $ this -> db ()-> sequence ( ' seq_users ' );Si la tabla o secuencia no existe, se creará. De lo contrario, se devuelve la tabla o el objeto de secuencia existente. En ambos casos, puede modificar los objetos posteriormente y agregar, por ejemplo, nuevas columnas a la tabla.
Puede probar tablas, columnas, índices, claves externas y secuencias utilizando el esquema de base de datos devuelto por $this->db() :
$ db = $ this -> db ();
if ( $ db -> hasTable ( ' users ' ) ) {
// The "users" table exists
}
if ( $ db -> hasColumn ( ' users ' , ' name ' ) ) {
// The "name" column in the "users" table exists
}
if ( $ db -> hasIndex ( ' users ' , ' idx_name ' ) ) {
// The "idx_name" index in the "users" table exists
}
if ( $ db -> hasForeign ( ' users_address ' , ' fk_users_id ' ) ) {
// The foreign key "fk_users_id" in the " users_address " table exists
}
if ( $ db -> hasSequence ( ' seq_users ' ) ) {
// The "seq_users" sequence exists
}
if ( $ db -> hasView ( ' testview ' ) ) {
// The "testview" view exists
} El objeto de base de datos devuelto por $this->db() ofrece la posibilidad de cambiar el nombre de tablas, columnas e índices usando renameTable() , renameColumn() y renameIndex() :
$ db = $ this -> db ();
// Renames the table "users" to "accounts"
$ db -> renameTable ( ' users ' , ' account ' );
// Renames the column "label" to "name" in the "users" table
$ db -> renameColumn ( ' users ' , ' label ' , ' name ' );
// Renames the column "idx_label" to "idx_name" in the "users" table
$ db -> renameIndex ( ' users ' , ' idx_label ' , ' idx_name ' ); El objeto de base de datos devuelto por $this->db() también tiene métodos para eliminar tablas, columnas, índices, claves externas y secuencias:
$ db = $ this -> db ();
// Drops the foreign key " fk_users_id " from the " users_address " table
$ db -> dropForeign ( ' users_address ' , ' fk_users_id ' );
// Drops the " idx_name " index from the " users " table
$ db -> dropIndex ( ' users ' , ' idx_name ' );
// Drops the " name " column from the " users " table
$ db -> dropColumn ( ' users ' , ' name ' );
// Drops the "seq_users" sequence
$ db -> dropSequence ( ' seq_users ' );
// Drops the "users" table
$ db -> dropTable ( ' users ' );
// Drops the "testview" view
$ db -> dropView ( ' testview ' ); Si la tabla, columna, índice, clave externa o secuencia no existe, se ignora silenciosamente. Para los casos en los que necesite saber si existen, utilice los métodos hasTable() , hasColumn() , hasIndex() , hasForeign() y hasSeqence() antes, como se describe en la sección "Comprobación de existencia".
Los métodos insert() , select() , update() y delete() son una manera fácil de agregar, recuperar, modificar y eliminar filas en cualquier tabla:
$ this -> db ()-> transaction ( function ( $ db ) {
$ db2 = $ this -> db ( ' db ' , true );
foreach ( $ db2 -> select ( ' users ' , [ ' status ' => false ] ) as $ row )
{
$ db -> insert ( ' newusers ' , [ ' userid ' => $ row [ ' id ' ], ' status ' => true ] );
$ db -> update ( ' users ' , [ ' refid ' => $ db -> lastId ()], [ ' id ' => $ row [ ' id ' ]] );
}
$ db -> delete ( ' newusers ' , [ ' status ' => false ] );
$ db2 -> close ();
} ); Si usa select() simultáneamente con insert() , update() o delete() , debe crear una segunda conexión a la base de datos porque la instrucción select() devolverá filas mientras envía nuevos comandos al servidor de la base de datos. Esto sólo funciona en conexiones separadas, no en la misma.
Para incluir todas las operaciones de eliminación/inserción/actualización en una transacción, debe utilizar el método transaction() del objeto de base de datos:
$ this -> db ()-> transaction ( function ( $ db ) {
// $db- > insert ( ... )
// $db- > update ( ... )
// $db- > delete ( ... )
} ); Esto garantiza que todas las operaciones de escritura se realicen de forma atómica o ninguna de ellas en caso de error. El método transaction() garantiza que la transacción se confirme o revierta automáticamente después de que su función anónima devuelva el control al método.
Si necesita parámetros adicionales dentro de su función anónima, puede entregarlos en la lista use de su función:
$ userid = 123 ;
$ this -> db ()-> transaction ( function ( $ db ) use ( $ userid ) {
$ db -> insert ( ' newusers ' , [ ' userid ' => userid, ' status ' => true ] );
} ); Solo puede pasar pares clave/valor simples para condiciones a los métodos que se combinan mediante AND. Si necesita consultas más complejas, utilice stmt() en su lugar:
$ db = $ this -> db ();
$ result = $ db -> stmt ()-> select ( ' id ' , ' name ' )
-> from ( ' users ' )
-> where ( ' status != ? ' )
-> setParameter ( 0 , false )
-> executeQuery ();
$ db -> stmt ()-> delete ( ' users ' )
-> where ( ' status != ? ' )
-> setParameter ( 0 , false )
-> executeStatement ();
$ db -> stmt ()-> update ( ' users ' )
-> set ( ' status ' , ' ? ' )
-> where ( ' status != ? ' )
-> setParameters ( [ true , false ] )
-> executeStatement (); El método stmt() devuelve un objeto DoctrineDBALQueryQueryBuilder que le permite crear declaraciones más avanzadas. Eche un vistazo a la documentación de Doctrine Query Builder para obtener más detalles.
Si desea utilizar valores directamente en una declaración SQL (¡use declaraciones preparadas por razones de seguridad siempre que sea posible!), debe citar los valores usando el método q() :
$ db = $ this -> db ();
$ result = $ db -> stmt ()-> select ( ' * ' )-> from ( ' products ' )
-> where ( ' status = ' . $ db -> q ( $ _GET [ ' status ' ] ) )-> executeQuery (); De manera similar, si su esquema contiene palabras clave reservadas, por ejemplo, como nombres de columnas, también debe citarlas usando el método qi() :
$ db = $ this -> db ();
$ result = $ db -> stmt ()-> select ( $ db -> qi ( ' key ' ) )-> from ( ' products ' )-> executeQuery (); Doctrine solo admite un subconjunto común de declaraciones SQL y no todas las posibilidades que los proveedores de bases de datos han implementado. Para eliminar ese límite, Upscheme ofrece los métodos exec() , for() y query() para ejecutar declaraciones SQL personalizadas que no son compatibles con Doctrine DBAL.
Para ejecutar consultas SQL personalizadas, utilice el método query() que devuelve un conjunto de resultados que puede iterar:
$ sql = ' SELECT id, label, status FROM product WHERE label LIKE ? ' ;
$ result = $ this -> db ()-> query ( $ sql , [ ' test% ' ] );
foreach ( $ result -> iterateAssociative () as $ row ) {
// ...
} Para todas las demás declaraciones SQL, utilice el método exec() que devuelve el número de filas afectadas:
$ sql = ' UPDATE product SET status=? WHERE status=? ' ;
$ num = $ this -> db ()-> exec ( $ sql , [ 1 , 0 ] ); Usando el método for() , también puede ejecutar declaraciones dependiendo de la plataforma de la base de datos:
$ this -> db ()-> for ( ' mysql ' , ' CREATE FULLTEXT INDEX idx_text ON product (text) ' );Especificar la plataforma de la base de datos es muy útil para crear tipos especiales de índices donde la sintaxis difiere entre las implementaciones de la base de datos.
Llama a métodos personalizados o pasa llamadas a métodos desconocidos al objeto de esquema de Doctrine
public function __call( string $ method , array $ args )$method Nombre del método$args Parámetros del métodoEjemplos:
Puede registrar métodos personalizados que tengan acceso a las propiedades de clase del objeto Upscheme DB:
Aimeos Upscheme Schema DB :: macro ( ' hasFkIndexes ' , function ( $ val ) {
return $ this -> to -> hasExplicitForeignKeyIndexes ();
} );
$ db -> hasFkIndexes ();
// returns true / falseLas propiedades de clase disponibles son:
$this->from : Esquema de base de datos original de Doctrine que representa la base de datos actual
$this->to : Esquema de la base de datos de Doctrine que contiene los cambios realizados hasta ahora
$this->conn : Conexión a la base de datos de Doctrine
$this->up : objeto de esquema mejorado
Además, puedes llamar directamente a cualquier método de esquema de Doctrine, por ejemplo:
$ db -> hasExplicitForeignKeyIndexes ();Cierra la conexión de la base de datos.
public function close() : void Llame close() solo para objetos de esquema de base de datos creados con $this->db( '...', true ) . De lo contrario, cerrará la conexión principal y DBAL tendrá que volver a conectarse al servidor, lo que degradará el rendimiento.
Ejemplos:
$ db = $ this -> db ( ' temp ' , true );
$ db -> dropTable ( ' test ' );
$ db -> close ();Elimina los registros de la tabla dada.
public function delete( string $ table , array $ conditions = [] ) : self$table Nombre de la tabla$conditions Pares clave/valor de nombres de columnas y valor para compararAdvertencia: Los valores de condición tienen escape, pero el nombre de la tabla y los nombres de las columnas de condición no. Utilice únicamente cadenas fijas para el nombre de la tabla y los nombres de las columnas de condición, ¡pero ninguna entrada externa!
Ejemplos:
$ db -> delete ( ' test ' , [ ' status ' => false , ' type ' => ' old ' ] );
$ db -> delete ( ' test ' ); Varias condiciones pasadas en el segundo parámetro se combinan con "Y". Si necesita declaraciones más complejas, utilice el método stmt() en su lugar.
Elimina la columna dada por su nombre si existe
public function dropColumn( string $ table , $ name ) : self$table Nombre de la tabla a la que pertenece la columna$name Nombre de la columna o columnasEjemplos:
$ db -> dropColumn ( ' test ' , ' oldcol ' );
$ db -> dropColumn ( ' test ' , [ ' oldcol ' , ' oldcol2 ' ] );Si la columna o una de las columnas no existe, se ignorará silenciosamente.
Elimina la restricción de clave externa dada por su nombre si existe
public function dropForeign( string $ table , $ name ) : self$table Nombre de la tabla a la que pertenece la restricción de clave externa$name Nombre de la restricción o restricciones de clave externaEjemplos:
$ db -> dropForeign ( ' test ' , ' fk_old ' );
$ db -> dropForeign ( ' test ' , [ ' fk_old ' , ' fk_old2 ' ] );Si la restricción de clave externa o una de las restricciones no existe, se ignorará silenciosamente.
Elimina el índice dado por su nombre si existe.
public function dropIndex( string $ table , $ name ) : self$table Nombre de la tabla a la que pertenece el índice$name Nombre del índice o índicesEjemplos:
$ db -> dropIndex ( ' test ' , ' idx_old ' );
$ db -> dropIndex ( ' test ' , [ ' idx_old ' , ' idx_old2 ' ] );Si el índice o uno de los índices no existe, se ignorará silenciosamente.
Elimina la secuencia dada por su nombre si existe.
public function dropSequence( $ name ) : self$name Nombre de la secuencia o secuenciasEjemplos:
$ db -> dropSequence ( ' seq_old ' );
$ db -> dropSequence ( [ ' seq_old ' , ' seq_old2 ' ] );Si la secuencia o una de las secuencias no existe, se ignorará silenciosamente.
Elimina la tabla dada por su nombre si existe.
public function dropTable( $ name ) : self$name Nombre de la tabla o tablasEjemplos:
$ db -> dropTable ( ' test ' );
$ db -> dropTable ( [ ' test ' , ' test2 ' ] );Si la tabla o una de las tablas no existe, se ignorará silenciosamente.
Elimina la vista dada por su nombre si existe.
public function dropView( $ name ) : self$name Nombre de la vista o vistasEjemplos:
$ db -> dropView ( ' test ' );
$ db -> dropView ( [ ' test ' , ' test2 ' ] );Si la vista o una de las vistas no existe, se ignorará silenciosamente.
Ejecuta una declaración SQL personalizada
public function exec( string $ sql , array $ params = [], array $ types = [] ) : int$sql Declaración SQL personalizada$params Lista de parámetros posicionales o lista asociativa de marcadores de posición y parámetros$types Lista de tipos de datos DBAL para los parámetros de marcador de posición posicionales o asociativosLos cambios en la base de datos no se aplican inmediatamente, así que siempre llame a up() antes de ejecutar declaraciones personalizadas para asegurarse de que las tablas que desea usar se hayan creado antes.
Ejemplos:
$ sql = ' UPDATE product SET status=? WHERE status=? ' ;
$ num = $ this -> db ()-> exec ( $ sql , [ 1 , 0 ] );Ejecuta una declaración SQL personalizada si la base de datos es del tipo dado
public function for( $ type , $ sql ) : self$type Tipo de base de datos para la que se debe ejecutar la declaración$sql Declaración o declaraciones SQL personalizadasLos tipos de plataformas de bases de datos disponibles son:
Los cambios en la base de datos no se aplican inmediatamente, así que siempre llame up() antes de ejecutar declaraciones personalizadas para asegurarse de que las tablas que desea usar se hayan creado antes.
Ejemplos:
$ db -> for ( ' mysql ' , ' CREATE INDEX idx_test_label ON test (label(16)) ' );
$ db -> for ( [ ' mysql ' , ' sqlite ' ], [
' DROP INDEX unq_test_status ' ,
' UPDATE test SET status = 0 WHERE status IS NULL ' ,
] );Comprueba si la columna o columnas existen.
public function hasColumn( string $ table , $ name ) : bool$table Nombre de la tabla a la que pertenece la columna$name Nombre de la columna o columnasEjemplos:
$ db -> hasColumn ( ' test ' , ' testcol ' );
$ db -> hasColumn ( ' test ' , [ ' testcol ' , ' testcol2 ' ] );Comprueba si existen restricciones de clave externa.
public function hasForeign( string $ table , $ name ) : bool$table Nombre de la tabla a la que pertenece la restricción de clave externa$name Nombre de la restricción o restricciones de clave externaEjemplos:
$ db -> hasForeign ( ' test ' , ' fk_testcol ' );
$ db -> hasForeign ( ' test ' , [ ' fk_testcol ' , ' fk_testcol2 ' ] );Comprueba si los índices existen.
public function hasIndex( string $ table , $ name ) : bool$table Nombre de la tabla a la que pertenece el índice$name Nombre del índice o índicesEjemplos:
$ db -> hasIndex ( ' test ' , ' idx_test_col ' );
$ db -> hasIndex ( ' test ' , [ ' idx_test_col ' , ' idx_test_col2 ' ] );Comprueba si las secuencias existen.
public function hasSequence( $ name ) : bool$name Nombre de la secuencia o secuenciasEjemplos:
$ db -> hasSequence ( ' seq_test ' );
$ db -> hasSequence ( [ ' seq_test ' , ' seq_test2 ' ] );Comprueba si las tablas existen.
public function hasTable( $ name ) : bool$name Nombre de la tabla o tablasEjemplos:
$ db -> hasTable ( ' test ' );
$ db -> hasTable ( [ ' test ' , ' test2 ' ] );Comprueba si las vistas existen.
public function hasView( $ name ) : bool$name Nombre de la vista o vistasEjemplos:
$ db -> hasView ( ' test ' );
$ db -> hasView ( [ ' test ' , ' test2 ' ] );Inserta un registro en la tabla dada.
public function insert( string $ table , array $ data ) : self$table Nombre de la tabla$data Pares clave/valor de nombre/valor de columna para insertarEjemplos:
$ db -> insert ( ' test ' , [ ' label ' => ' myvalue ' , ' status ' => true ] );Devuelve el ID de la última fila insertada en cualquier tabla de base de datos.
public function lastId() : stringPrecaución: Esto no funciona para la plataforma Oracle porque Doctrine DBAL no admite columnas IDENTITY de Oracle en este momento.
Ejemplos:
$ db -> lastId ();Devuelve el nombre de la base de datos.
public function name() : stringEjemplos:
$ db -> name ();Cita un valor
public function q( $ value , $ type = Doctrine DBAL ParameterType:: STRING ) : string$value Valor a utilizar en una consulta SQL no preparada$typeEjemplos:
$ result = $ db -> stmt ()-> select ( ' * ' )-> from ( ' products ' )
-> where ( ' status = ' . $ db -> q ( $ _GET [ ' status ' ] ) )-> executeQuery ();Cita un identificador de base de datos
public function qi( string $ identifier ) : string$identifier Identificador como nombre de tabla o columnaEjemplos:
$ result = $ db -> stmt ()-> select ( $ db -> qi ( ' key ' ) )-> from ( ' products ' )-> executeQuery ();Ejecuta una consulta SQL personalizada
public function query( string $ sql , array $ params = [], array $ types = [] ) : Doctrine DBAL Result$sql Declaración SQL personalizada$params Lista de parámetros posicionales o lista asociativa de marcadores de posición y parámetros$types Lista de tipos de datos DBAL para los parámetros de marcador de posición posicionales o asociativosEjemplos:
$ result = $ db -> query ( ' SELECT id, label, status FROM product WHERE label LIKE ? ' , [ ' test% ' ] );
foreach ( $ result -> iterateAssociative () as $ row ) {
// ...
}Consejo: consulte los métodos DBAL para recuperar datos para obtener más información.
Cambia el nombre de una columna o una lista de columnas
public function renameColumn( string $ table , $ from , string $ to = null ) : self$table Nombre de la tabla$from Nombre de columna o matriz de nombres de columnas antiguos/nuevos$to El nuevo nombre de la columna se ignora si el primer parámetro es una matriz Si la columna aún no existe, el método tendrá éxito pero no sucederá nada. No se requiere ninguna llamada a up() .
Limitaciones
Ejemplos:
// single column
$ db -> renameColumn ( ' testtable ' , ' test_col ' , ' test_column ' );
// rename several columns at once
$ db -> renameColumn ( ' testtable ' , [ ' tcol ' => ' testcol ' , ' tcol2 ' => ' testcol2 ' ] );Cambia el nombre de una columna o una lista de columnas
public function renameIndex( string $ table , $ from , string $ to = null ) : self$table Nombre de la tabla$from Nombre del índice o matriz de nombres de índice antiguos/nuevos$to Nuevo nombre de índice ignorado si el primer parámetro es una matriz Si el índice aún no existe, el método tendrá éxito pero no pasará nada. No se requiere ninguna llamada a up() .
Ejemplos:
// single index
$ db -> renameIndex ( ' testtable ' , ' idxcol ' , ' idx_column ' );
// rename several indexes at once
$ db -> renameIndex ( ' testtable ' , [ ' idxcol ' => ' idx_column ' , ' idxcol2 ' => ' idx_column2 ' ] );Cambia el nombre de una tabla o una lista de tablas
public function renameTable( $ from , string $ to = null ) : self$from Nombre de tabla o conjunto de nombres de tablas antiguos/nuevos$to Se ignora el nuevo nombre de la tabla si el primer parámetro es una matriz Si la tabla aún no existe, el método tendrá éxito pero no sucederá nada. No se requiere ninguna llamada a up() .
Ejemplos:
// single table
$ db -> renameTable ( ' testtable ' , ' newtable ' );
// rename several tables at once
$ db -> renameTable ( [ ' testtable ' => ' newtable ' , ' oldtable ' => ' testtable2 ' ] );Recarga el esquema actual de Doctrine para la base de datos actual.
public function reset() : selfEjemplos:
$ db -> reset ();Devuelve los registros de la tabla dada.
public function select( string $ table , array $ conditions = null ) : array$table Nombre de la tabla$conditions Pares clave/valor de nombres de columna y valor para compararEjemplos:
$ db -> select ( ' test ' , [ ' status ' => false , ' type ' => ' old ' ] );
$ db -> select ( ' test ' ); Varias condiciones pasadas en el segundo parámetro se combinan con "Y". Si necesita declaraciones más complejas, utilice el método stmt() en su lugar.
Devuelve el objeto de secuencia para el nombre dado.
public function sequence( string $ name , Closure $ fcn = null ) : Sequence$name Nombre de la secuencia$fcn Función anónima con parámetro ($sequence) que crea o actualiza la definición de secuencia Si la secuencia aún no existe, se creará. Para conservar los cambios en la base de datos, debe llamar up() .
Ejemplos:
$ sequence = $ db -> sequence ( ' seq_test ' );
$ sequence = $ db -> sequence ( ' seq_test ' , function ( $ seq ) {
$ seq -> start ( 1000 )-> step ( 2 )-> cache ( 100 );
} )-> up ();Devuelve el generador de consultas para una nueva declaración SQL.
public function stmt() : Doctrine DBAL Query QueryBuilderEjemplos:
$ db -> stmt ()-> delete ( $ db -> qi ( ' test ' ) )
-> where ( $ db -> qi ( ' stat ' ) . ' = ? ' )-> setParameter ( 0 , false )
-> executeStatement ();
$ db -> stmt ()-> update ( $ db -> qi ( ' test ' ) )
-> where ( $ db -> qi ( ' stat ' ) . '' , ' ? ' )-> setParameter ( 0 , true )
-> executeStatement ();
$ result = $ db -> stmt ()-> select ( $ db -> qi ( ' id ' ), $ db -> qi ( ' code ' ) )
-> from ( $ db -> qi ( ' test ' ) )
-> where ( $ db -> qi ( ' stat ' ) . ' = 1 ' )
-> executeQuery ();
while ( $ row = $ result -> fetchAssociative () ) {
$ id = $ row [ ' id ' ];
} **Precaución: ** ¡Debe citar todos los nombres de tablas y columnas usted mismo usando el método $db->qi() !
Para obtener más detalles sobre los métodos disponibles de Doctrine QueryBuilder, consulte la documentación de Doctrine.
Devuelve el objeto de tabla para el nombre dado
public function table( string $ name , Closure $ fcn = null ) : Table$name Nombre de la tabla$fcn Función anónima con parámetro ($table) que crea o actualiza la definición de la tabla Si la tabla aún no existe, se creará. Para conservar los cambios en la base de datos, debe llamar up() .
Ejemplos:
$ table = $ db -> table ( ' test ' );
$ table = $ db -> table ( ' test ' , function ( $ t ) {
$ t -> id ();
$ t -> string ( ' label ' );
$ t -> bool ( ' status ' );
} )-> up ();Ejecuta el cierre dado dentro de una transacción.
public function transaction( Closure $ fcn ) : selfEjemplos:
$ this -> db ()-> transaction ( function ( $ db ) {
// $db- > insert ( ... )
// $db- > update ( ... )
// $db- > delete ( ... )
} );Devuelve los objetos como una matriz de la base de datos.
public function toArray() : arrayEjemplos:
$ this -> db ()-> toArray ();La estructura de la matriz devuelta es:
[
' sequence ' => [
' testseq ' => [
' name ' => ' testseq ' ,
' cache ' => null ,
' start ' => 1000 ,
' step ' => 1
]
],
' table ' => [
' testtable ' => [
' name ' => ' testtable ' ,
' opt ' => [
' engine ' => ' InnoDB ' ,
' collation ' => ' utf8mb4_unicode_ci ' ,
' charset ' => ' utf8mb4 ' ,
' autoincrement ' => 1 ,
' comment ' => ''
],
' col ' => [
' id ' => [
' name ' => ' id ' ,
' type ' => ' integer ' ,
' length ' => null ,
' precision ' => null ,
' scale ' => 0 ,
' null ' => false ,
' seq ' => 1
' default ' => null,
' fixed ' => false ,
' unsigned ' => false ,
' comment ' => '' ,
' opt ' => []
],
' parentid ' => [
' name ' => ' parentid ' ,
' type ' => ' bigint ' ,
' length ' => null ,
' precision ' => null ,
' scale ' => 0 ,
' null ' => false ,
' seq ' => false ,
' default ' => null ,
' fixed ' => false ,
' unsigned ' => false ,
' comment ' => '' ,
' opt ' => []
],
' label ' => [
' name ' => ' label ' ,
' type ' => ' string ' ,
' length ' => 255 ,
' precision ' => null ,
' scale ' => 0 ,
' null ' => false ,
' seq ' => false ,
' default ' => null ,
' fixed ' => false ,
' unsigned ' => false ,
' comment ' => '' ,
' opt ' => [
' charset ' => ' utf8mb4 ' ,
' collation ' => ' utf8mb4_unicode_ci '
]
]
],
' index ' => [
' PRIMARY ' => [
' columns ' => [
0 => ' id '
],
' name ' => ' PRIMARY ' ,
' flags ' => [],
' options ' => [
' lengths ' => [
0 => null
]
],
' unique ' => 1 ,
' primary ' => 1
],
],
' foreign ' => [
' FK_6C73FFCA343B91AE ' => [
' localcol ' => [
0 => ' parentid '
],
' fktable ' => ' test ' ,
' fkcol ' => [
0 => ' id '
],
' name ' => ' FK_6C73FFCA343B91AE ' ,
' onDelete ' => ' CASCADE ' ,
' onUpdate ' => ' CASCADE '
]
]
]
],
' view ' => [
' testview ' => [
' name ' => ' testview ' ,
' sql ' => ' select `testtable`.`id` AS `id`,`testtable`.`label` AS `label` from `testtable` '
]
]
]Devuelve el tipo de base de datos.
public function type() : stringLos valores posibles son:
Ejemplos:
$ type = $ db -> type ();Aplica los cambios al esquema de la base de datos.
public function up() : selfEjemplos:
$ db -> up ();Actualiza los registros de la tabla dada.
public function update( string $ table , array $ data , array $ conditions = [] ) : self$table Nombre de la tabla$data Pares clave/valor de nombre/valor de columna para actualizar$conditions Pares clave/valor de nombres de columnas y valor para compararEjemplos:
$ db -> update ( ' test ' , [ ' status ' => true ] );
$ db -> update ( ' test ' , [ ' status ' => true ], [ ' status ' => false , ' type ' => ' new ' ] ); Varias condiciones pasadas en el segundo parámetro se combinan con "Y". Si necesita declaraciones más complejas, utilice el método stmt() en su lugar.
Crea una vista con el nombre de pila si aún no existe
public function view( string $ name , string $ sql , $ for = null ) : self$name Nombre de la vista$sql instrucción SELECT para completar la vista$for el tipo de base de datos para la que se debe usar este SQL ("mysql", "mariadb", "postgresql", "sqlite", "sqlserver", "oracle", "db2")Si la vista aún no existe, se creará. De lo contrario, no pasará nada.
Ejemplos:
$ db -> view ( ' testview ' , ' SELECT * FROM testtable ' );
$ db -> view ( ' testview ' , ' SELECT id, label, status FROM testtable WHERE status = 1 ' );
$ db -> view ( ' testview ' , ' SELECT * FROM `testtable` WHERE `status` = 1 ' , ' mysql ' ); El objeto de esquema de tabla que obtienes al llamar table() en tu tarea de migración te brinda acceso completo a la tabla y puedes agregar, cambiar o eliminar columnas, índices y claves externas, por ejemplo:
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
$ table -> id ();
$ table -> string ( ' label ' );
$ table -> col ( ' status ' , ' tinyint ' )-> default ( 0 );
} ); Además del método col() que puede agregar columnas de tipos arbitrarios, existen algunos métodos abreviados para tipos disponibles en todas las implementaciones de servidores de bases de datos:
| Tipo de columna | Descripción |
|---|---|
| grande | Columna BIGINT con una secuencia/incremento automático y una clave principal asignada |
| bigint | Columna BIGINT con un rango de −9223372036854775808 a 9223372036854775807 |
| binario | Columna VARBINARY con hasta 255 bytes |
| gota | Columna BLOB con hasta 2GB |
| booleano | Columna BOOLEAN/BIT/NUMBER, alias de "booleano" |
| booleano | Columna BOOLEAN/BIT/NÚMERO para VERDADERO/FALSO resp. valores 0/1 |
| carbonizarse | Columna CHAR con un número fijo de caracteres |
| fecha | Columna FECHA en formato de fecha ISO ("AAAA-MM-DD) sin hora ni zona horaria |
| fecha y hora | Columna DATETIME en formato de fecha/hora ISO ("AAAA-MM-DD HH:mm:ss") |
| tablasfechahoratz | Columna DATETIMETZ en formato de fecha/hora ISO pero con formato de zona horaria variable |
| decimal | Columna DECIMAL para datos numéricos con precisión de punto fijo (cadena en PHP) |
| flotar | Columna FLOAT para datos numéricos con una precisión de punto flotante de 8 bytes |
| guía | Identificador único global con 36 bytes |
| identificación | Columna INTEGER con una secuencia/incremento automático y una clave principal asignada |
| entero | Columna INTEGER, alias de "entero" |
| entero | Columna INTEGER con un rango de −2147483648 a 2147483647 |
| json | Columna JSON para datos JSON codificados en UTF-8 |
| pequeño | Columna INTEGER con un rango de −32768 a 32767 |
| cadena | Columna VARCHAR con hasta 255 caracteres |
| texto | Columna TEXT/CLOB con hasta 2 GB de caracteres |
| tiempo | Columna HORA en formato "HH:MM" de 24 horas, por ejemplo, "05:30" o "22:15" |
| UUID | Identificador único global con 36 bytes, alias de "guid" |
MySQL (o MariaDB, etc.) admite algunas opciones para definir aspectos de la tabla. La opción del motor especificará el motor de almacenamiento utilizado para la tabla:
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
$ table -> opt ( ' engine ' , ' InnoDB ' );
} );Como atajo, también es posible configurar la opción como propiedad:
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
$ table -> engine = ' InnoDB ' ;
} );Para crear una tabla temporal , use:
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
$ table -> temporary = true ;
} );También es posible configurar el juego de caracteres y la intercalación predeterminados para columnas de cadena y texto:
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
$ table -> charset = ' utf8mb4 ' ;
$ table -> collation = ' utf8mb4_unicode_ci ' ;
} ); Nota: PostgreSQL y SQL Server también admiten las intercalaciones, pero sus valores son diferentes. Por tanto, no es posible utilizar el mismo valor para todos los tipos de servidores. Para evitar ese problema, utilice el método de columna opt() y pase el tipo de servidor de base de datos como tercer parámetro:
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
$ table -> opt ( ' charset ' , ' utf8mb4 ' , ' mysql ' );
$ table -> opt ( ' collation ' , ' utf8mb4_unicode_ci ' , ' mysql ' );
} );Ahora, el juego de caracteres y la intercalación predeterminados solo se configurarán para servidores de bases de datos MySQL (o MariaDB y bifurcaciones similares).
En caso de que necesite conocer los valores actuales de las opciones de la tabla:
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
// return the used table engine ( only MySQL , MariaDB , etc . )
$ engine = $ table -> engine ;
// returns TRUE if it ' s a temporary table
$ isTemp = $ table -> temporary ;
// return the current charset
$ charset = $ table -> charset ;
// return the current collation
$ collation = $ table -> collation ;
} ); Para comprobar si ya existe una tabla, utilice el método hasTable() :
if ( $ this -> db ()-> hasTable ( ' users ' ) ) {
// The "users" table exists
}También puedes consultar varias tablas a la vez:
if ( $ this -> db ()-> hasTable ( [ ' users ' , ' addresses ' ] ) ) {
// The "users" and "addresses" tables exist
} El método hasTable() solo devolverá VERDADERO si existen todas las tablas.
Además de crear tablas y acceder a ellas, el método table() del objeto de esquema también se puede utilizar para actualizar un esquema de tabla. Acepta el nombre de la tabla y un cierre que recibirá el objeto del esquema de la tabla.
Primero creemos una tabla llamada prueba que incluya tres columnas:
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
$ table -> id ();
$ table -> string ( ' label ' );
$ table -> col ( ' status ' , ' tinyint ' )-> default ( 0 );
} );Ahora queremos actualizar la tabla en otra migración agregando una columna de código y cambiando el valor predeterminado de la columna de estado existente:
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
$ table -> string ( ' code ' );
$ table -> col ( ' status ' , ' tinyint ' )-> default ( 1 );
} ); Los cambios persistirán en la base de datos tan pronto como regrese el método table() por lo que no es necesario llamar up() usted mismo después. Para conocer los tipos y opciones de columnas disponibles, consulte la sección de columnas.
El objeto de base de datos devuelto por $this->db() puede cambiar el nombre de las tablas cuando se utiliza el método renameTable() :
// Renames the table "users" to "accounts"
$ this -> db ()-> renameTable ( ' users ' , ' account ' );También es posible cambiar el nombre de varias tablas a la vez si pasa una matriz asociativa con nombres antiguos y nuevos como pares clave/valor:
// Renames the table "users" to "accounts" and "blog" to "posts"
$ this -> db ()-> renameTable ( [ ' users ' => ' account ' , ' blog ' => ' posts ' ] );Las tablas solo cambian de nombre si existen. Si una tabla ya no existe, no se informa ningún error:
$ this -> db ()-> renameTable ( ' notexist ' , ' newtable ' );En ese caso, la llamada al método tendrá éxito pero no sucederá nada.
Para eliminar una tabla, debes usar el método dropTable() del esquema de la base de datos:
$ this -> db ()-> dropTable ( ' users ' );También puedes eliminar varias tablas a la vez pasando la lista como matriz:
$ this -> db ()-> dropTable ( [ ' users ' , ' addresses ' ] );Las tablas sólo se eliminan si existen. Si una tabla ya no existe, no se informa ningún error:
$ this -> db ()-> dropTable ( ' notexist ' );En ese caso, la llamada al método tendrá éxito pero no sucederá nada.
Llama a métodos personalizados o pasa llamadas a métodos desconocidos al objeto de tabla Doctrine
public function __call( string $ method , array $ args )$method Nombre del método$args Parámetros del métodoEjemplos:
Puede registrar métodos personalizados que tengan acceso a las propiedades de clase del objeto Upscheme Table:
Aimeos Upscheme Schema Table:: macro ( ' addConstraint ' , function ( array $ columns ) {
return $ this -> to -> addUniqueConstraint ( $ columns );
} );
$ table -> addConstraint ( [ ' col1 ' , ' col2 ' ] );Las propiedades de clase disponibles son:
$this->table : esquema de la tabla de doctrina
$this->up : objeto de esquema mejorado
Además, puedes llamar directamente a cualquier método de tabla de Doctrine, por ejemplo:
$ table -> addUniqueConstraint ( [ ' col1 ' , ' col2 ' ] );Devuelve el valor de la opción de tabla dada.
public function __get( string $ name )$name Nombre de opción de tablaLa lista de opciones de mesa disponibles son:
Ejemplos:
$ engine = $ table -> engine ;
// same as
$ engine = $ table -> opt ( ' engine ' );Establece el nuevo valor para la opción de tabla dada
public function __set( string $ name , $ value )$name Nombre de opción de tablaLa lista de opciones de mesa disponibles son:
Ejemplos:
$ table -> engine = ' InnoDB ' ;
// same as
$ table -> opt ( ' engine ' , ' InnoDB ' );Crea una nueva columna de ID de tipo "bigint" o devuelve la existente
public function bigid( string $ name = null ) : Column$name Nombre de la columna IDLa columna obtiene una secuencia (incremento automático) y una clave principal asignada automáticamente. Si la columna aún no existe, se creará.
Ejemplos:
$ table -> bigid ();
$ table -> bigid ( ' uid ' );Crea una nueva columna de tipo "bigint" o devuelve la existente
public function bigint( string $ name ) : Column$name Nombre de la columnaSi la columna aún no existe, se creará.
Ejemplos:
$ table -> bigint ( ' testcol ' );Crea una nueva columna de tipo "binario" o devuelve la existente
public function binary( string $ name , int $ length = 255 ) : Column$name Nombre de la columna$length Longitud de la columna en bytesSi la columna aún no existe, se creará.
Ejemplos:
$ table -> binary ( ' testcol ' );
$ table -> binary ( ' testcol ' , 32 );Crea una nueva columna de tipo "blob" o devuelve la existente
public function blob( string $ name , int $ length = 0x7fff ) : Column$name Nombre de la columna$length Longitud de la columna en bytesLa longitud máxima de una columna "blob" es de 2 GB. Si la columna aún no existe, se creará.
Ejemplos:
$ table -> blob ( ' testcol ' );
$ table -> blob ( ' testcol ' , 0x7fffffff );Crea una nueva columna de tipo "booleano" o devuelve la existente
public function bool( string $ name ) : Column$name Nombre de la columnaEste método es un alias de booleano(). Si la columna aún no existe, se creará.
Ejemplos:
$ table -> bool ( ' testcol ' );Crea una nueva columna de tipo "booleano" o devuelve la existente
public function boolean( string $ name ) : Column$name Nombre de la columnaSi la columna aún no existe, se creará.
Ejemplos:
$ table -> boolean ( ' testcol ' );Crea una nueva columna de tipo "char" con un tipo fijo o devuelve la existente
public function char( string $ name , int $ length ) : Column$name Nombre de la columna$length Longitud de la columna en caracteresSi la columna aún no existe, se creará.
Ejemplos:
$ table -> char ( ' testcol ' , 3 );Crea una nueva columna o devuelve la existente
public function col( string $ name , string $ type = null ) : Column$name de la columna$type de la columnaSi la columna aún no existe, se creará.
Ejemplos:
$ table -> col ( ' testcol ' );
$ table -> col ( ' testcol ' , ' tinyint ' );Crea una nueva columna de tipo "fecha" o devuelve la existente
public function date( string $ name ) : Column$name de la columnaSi la columna aún no existe, se creará.
Ejemplos:
$ table -> date ( ' testcol ' );Crea una nueva columna de tipo "DateTime" o devuelve la existente
public function datetime( string $ name ) : Column$name de la columnaSi la columna aún no existe, se creará.
Ejemplos:
$ table -> datetime ( ' testcol ' );Crea una nueva columna de tipo "DataTimetz" o devuelve la existente
public function datetimetz( string $ name ) : Column$name de la columnaSi la columna aún no existe, se creará.
Ejemplos:
$ table -> datetimetz ( ' testcol ' );Crea una nueva columna de tipo "decimal" o devuelve la existente
public function decimal( string $ name , int $ digits , int $ decimals = 2 ) : Column$name de la columna$digits Número total de dígitos decimales, incluidos decimales$decimals número de dígitos después del punto decimalSi la columna aún no existe, se creará.
Ejemplos:
$ table -> decimal ( ' testcol ' , 10 ); // 10 digits incl . 2 decimals
$ table -> decimal ( ' testcol ' , 10 , 4 ); // 10 digits incl . 4 decimals Deja caer la columna dada por su nombre si existe
public function dropColumn( $ name ) : self$name de la columna o columnas Si la columna o una de las columnas no existe, se ignorará en silencio. El cambio no se aplicará hasta que finalice la tarea de migración o se llame up() .
Ejemplos:
$ table -> dropColumn ( ' testcol ' );
$ table -> dropColumn ( [ ' testcol ' , ' testcol2 ' ] );Deja caer el índice dado por su nombre si existe
public function dropIndex( $ name ) : self$name del índice o índice Si el índice o uno de los índices no existe, se ignorará en silencio. El cambio no se aplicará hasta que finalice la tarea de migración o se llame up() .
Ejemplos:
$ table -> dropIndex ( ' idx_test_col ' );
$ table -> dropIndex ( [ ' idx_test_col ' , ' idx_test_col2 ' ] );Deja caer la restricción de la clave extranjera dada por su nombre si existe
public function dropForeign( $ name ) : self$name Nombre de la restricción o restricciones de clave externa Si la restricción de clave extranjera o una de las restricciones no existe, se ignorará en silencio. El cambio no se aplicará hasta que finalice la tarea de migración o se llame up() .
Ejemplos:
$ table -> dropForeign ( ' fk_test_col ' );
$ table -> dropForeign ( [ ' fk_test_col ' , ' fk_test_col2 ' ] );Deja caer la clave principal si existe
public function dropPrimary() : self Si la clave principal no existe, se ignorará en silencio. El cambio no se aplicará hasta que finalice la tarea de migración o se llame up() .
Ejemplos:
$ table -> dropPrimary ();Crea una nueva columna de tipo "flotante" o devuelve la existente
public function float( string $ name ) : Column$name de la columnaSi la columna aún no existe, se creará.
Ejemplos:
$ table -> float ( ' testcol ' );Crea una nueva clave extranjera o devuelve la existente
public function foreign( $ localcolumn , string $ foreigntable , $ foreigncolumn = ' id ' , string $ name = null ) : Foreign$localcolumn de la columna o columnas locales$foreigntable Nombre de la tabla referenciada$foreigncolumn Nombre de la columna o columnas referenciadas$name Nombre de la restricción de clave extranjera y el índice de claves exteriores o NULL para el nombre autogeneradoLa longitud del nombre de la clave extranjera no debe tener más de 30 caracteres para la máxima compatibilidad.
Ejemplos:
$ table -> foreign ( ' parentid ' , ' test ' );
$ table -> foreign ( ' parentid ' , ' test ' , ' uid ' );
$ table -> foreign ( ' parentid ' , ' test ' , ' id ' , ' fk_test_pid ' );
$ table -> foreign ( [ ' parentid ' , ' siteid ' ], ' test ' , [ ' uid ' , ' siteid ' ] );Crea una nueva columna de tipo "GUID" o devuelve la existente
public function guid( string $ name ) : Column$name de la columnaSi la columna aún no existe, se creará.
Ejemplos:
$ table -> guid ( ' testcol ' );Verifica si existe la columna
public function hasColumn( $ name ) : bool$name de la columna o columnasEjemplos:
$ table -> hasColumn ( ' testcol ' );
$ table -> hasColumn ( [ ' testcol ' , ' testcol2 ' ] );Comprobaciones si existe el índice
public function hasIndex( $ name ) : bool$name del índice o índiceEjemplos:
$ table -> hasIndex ( ' idx_test_col ' );
$ table -> hasIndex ( [ ' idx_test_col ' , ' idx_test_col2 ' ] );Comprobaciones si existe la restricción de clave extranjera
public function hasForeign( $ name ) : bool$name Nombre de la restricción o restricciones de clave externaEjemplos:
$ table -> hasForeign ( ' fk_test_col ' );
$ table -> hasForeign ( [ ' fk_test_col ' , ' fk_test_col2 ' ] );Crea una nueva columna de identificación de tipo "entero" o devuelve la existente
public function id( string $ name = null ) : Column$name Nombre de la columna de identificaciónLa columna obtiene una secuencia (autoincrement) y una clave primaria asignada automáticamente. Si la columna aún no existe, se creará.
Ejemplos:
$ table -> id ();
$ table -> id ( ' uid ' );Crea un nuevo índice o reemplaza uno existente
public function index( $ columns , string $ name = null ) : self$columns de las columnas o columnas que desencadenan el índice$name Nombre Nombre del índice o NULL para el nombre autogeneradoLa longitud del nombre del índice no debe tener más de 30 caracteres para la máxima compatibilidad.
Ejemplos:
$ table -> index ( ' testcol ' );
$ table -> index ( [ ' testcol ' , ' testcol2 ' ] );
$ table ->index( ' testcol ' , 'idx_test_testcol );Crea una nueva columna de tipo "entero" o devuelve la existente
public function int( string $ name ) : Column$name de la columnaEste método es un alias para Integer (). Si la columna aún no existe, se creará.
Ejemplos:
$ table -> int ( ' testcol ' );Crea una nueva columna de tipo "entero" o devuelve la existente
public function integer( string $ name ) : Column$name de la columnaSi la columna aún no existe, se creará.
Ejemplos:
$ table -> integer ( ' testcol ' );Crea una nueva columna de tipo "JSON" o devuelve la existente
public function json( string $ name ) : Column$name de la columnaSi la columna aún no existe, se creará.
Ejemplos:
$ table -> json ( ' testcol ' );Devuelve el nombre de la tabla
public function name() : stringEjemplos:
$ tablename = $ table -> name ();Establece una opción de esquema personalizado o devuelve el valor actual
public function opt( string $ name , $ value = null )$name de la opción de esquema personalizado relacionado con la tabla$value mixto de la opción de esquema personalizadoLas opciones de esquema personalizadas disponibles son:
Ejemplos:
$ charset = $ table -> opt ( ' charset ' );
$ table -> opt ( ' charset ' , ' utf8 ' )-> opt ( ' collation ' , ' utf8_bin ' );
// Magic methods :
$ charset = $ table -> charset ;
$ table -> charset = ' binary ' ;Crea un nuevo índice primario o reemplaza uno existente
public function primary( $ columns , string $ name = null ) : self$columns de las columnas o columnas que desencadenan el índice$name Nombre Nombre del índice o NULL para el nombre autogeneradoLa longitud del nombre del índice no debe tener más de 30 caracteres para la máxima compatibilidad.
Ejemplos:
$ table -> primary ( ' testcol ' );
$ table -> primary ( [ ' testcol ' , ' testcol2 ' ] );
$ table -> primary ( ' testcol ' , ' pk_test_testcol ' );Renombra una columna o una lista de columnas
public function renameColumn( $ from , string $ to = null ) : self$from el nombre de la columna o la matriz de nombres de columna antiguos/nuevos$to nuevo nombre de columna ignorado si el primer parámetro es una matrizEjemplos:
// single column
$ table -> renameColumn ( ' test_col ' , ' test_column ' );
// rename several columns at once
$ table -> renameColumn ( [ ' tcol ' => ' testcol ' , ' tcol2 ' => ' testcol2 ' ] );Renombra un índice o una lista de índices
public function renameIndex( $ from , string $ to = null ) : self$from el nombre del índice o la matriz de nombres de índice antiguos/nuevos (si el nuevo nombre del índice es nulo, se generará)$to nuevo nombre de índice o NULL para el nombre autogenerado (ignorado si el primer parámetro es una matriz)La longitud del nombre de los índices no debe tener más de 30 caracteres para la máxima compatibilidad.
Ejemplos:
// generate a new name automatically
$ table -> renameIndex ( ' test_col_index ' );
// custom name
$ table -> renameIndex ( ' test_col_index ' , ' idx_test_col ' );
// rename several indexes at once
$ table -> renameIndex ( [ ' test_col_index ' => null , ' test_index ' => ' idx_test_col ' ] );Crea una nueva columna de tipo "smallint" o devuelve la existente
public function smallint( string $ name ) : Column$name de la columnaSi la columna aún no existe, se creará.
Ejemplos:
$ table -> smallint ( ' testcol ' );Crea un nuevo índice espacial o reemplaza uno existente
public function spatial( $ columns , string $ name = null ) : self$columns nombre de las columnas o columnas que generan el índice$name Nombre Nombre del índice o NULL para el nombre autogeneradoLa longitud del nombre del índice no debe tener más de 30 caracteres para la máxima compatibilidad.
Ejemplos:
$ table -> spatial ( ' testcol ' );
$ table -> spatial ( [ ' testcol ' , ' testcol2 ' ] );
$ table -> spatial ( ' testcol ' , ' idx_test_testcol ' );Crea una nueva columna de tipo "cadena" o devuelve la existente
public function string( string $ name , int $ length = 255 ) : Column$name de la columna$length de la columna en caracteresEste tipo debe usarse para hasta 255 caracteres. Para más caracteres, use el tipo de "texto". Si la columna aún no existe, se creará.
Ejemplos:
$ table -> string ( ' testcol ' );
$ table -> string ( ' testcol ' , 32 );Crea una nueva columna de tipo "texto" o devuelve la existente
public function text( string $ name , int $ length = 0xffff ) : Column$name de la columna$length de la columna en caracteresLa longitud máxima de una columna de "texto" es 2 GB. Si la columna aún no existe, se creará.
Ejemplos:
$ table -> text ( ' testcol ' );
$ table -> text ( ' testcol ' , 0x7fffffff );Crea una nueva columna de tipo "tiempo" o devuelve la existente
public function time( string $ name ) : Column$name de la columnaSi la columna aún no existe, se creará. Este tipo de datos no está disponible cuando se usa bases de datos Oracle.
Ejemplos:
$ table -> time ( ' testcol ' );Crea un nuevo índice único o reemplaza uno existente
public function unique( $ columns , string $ name = null ) : self$columns nombre de las columnas o columnas que generan el índice$name Nombre Nombre del índice o NULL para el nombre autogeneradoLa longitud del nombre del índice no debe tener más de 30 caracteres para la máxima compatibilidad.
Ejemplos:
$ table -> unique ( ' testcol ' );
$ table -> unique ( [ ' testcol ' , ' testcol2 ' ] );
$ table -> unique ( ' testcol ' , ' unq_test_testcol ' );Crea una nueva columna de tipo "GUID" o devuelve la existente
public function uuid( string $ name ) : Column$name de la columnaEste método es un alias para Guid (). Si la columna aún no existe, se creará.
Ejemplos:
$ table -> uuid ( ' testcol ' );Aplica los cambios al esquema de la base de datos
public function up() : selfEjemplos:
$ table -> up (); El objeto de esquema de columna que recibe llamando col() en su tarea de migración le brinda acceso a todas las propiedades de la columna. También hay accesos directos disponibles para tipos de columnas admitidos por todas las bases de datos. Cada columna se puede cambiar mediante uno o más métodos modificadores y también puede agregar índices a columnas individuales, por ejemplo:
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
$ table -> id ()-> unsigned ( true );
$ table -> string ( ' label ' )-> index ();
$ table -> col ( ' status ' , ' tinyint ' )-> default ( 0 );
} );El ejemplo agregará las siguientes columnas:
Hay algunos métodos de acceso directo para tipos de columnas disponibles en todas las implementaciones del servidor de bases de datos:
| Tipo de columna | Descripción |
|---|---|
| bigid | Columna bigint con una secuencia/autoincrement y una clave principal asignada |
| bigint | Columna Bigint con un rango de −9223372036854775808 a 9223372036854775807 |
| binario | Columna varbinaria con hasta 255 bytes |
| gota | Columna de blob con hasta 2 GB |
| booleano | Booleano/bit/número colum, alias para "booleano" |
| booleano | Boolean/bit/number colum para verdadero/falso resp. Valores 0/1 |
| carbonizarse | Columna de char con un número fijo de caracteres |
| fecha | Columna de fecha en formato de fecha ISO ("yyyy-mm-dd) sin tiempo y zona horaria |
| fecha y hora | Columna de fecha y hora en formato de fecha/hora ISO ("aaa yyy-mm-dd hh: mm: ss") |
| tablesdateTimetz | Columna Detetimetz en formato de fecha/hora ISO pero con formato de zona horaria variable |
| decimal | Columna decimal para datos numéricos con precisión de punto fijo (cadena en PHP) |
| flotar | Columna flotante para datos numéricos con una precisión de punto flotante de 8 bytes |
| guía | Identificador único globalmente con 36 bytes |
| identificación | Columna entera con una secuencia/autoincremento y una clave principal asignada |
| entero | Integer colum, alias para "entero" |
| entero | Columia entera con un rango de −2147483648 a 2147483647 |
| json | Columna JSON para datos JSON codificados por UTF-8 |
| pequeño | Columia entera con un rango de −32768 a 32767 |
| cadena | Columna Varchar con hasta 255 caracteres |
| texto | Columna de texto/CLOB con caracteres de hasta 2 GB |
| tiempo | Columna de tiempo en 24 horas "HH: MM" deat, por ejemplo, "05:30" o "22:15" |
| UUID | Identificador único globalmente con 36 bytes, alias para "GUID" |
Para agregar tipos de columnas específicos de la base de datos, use el método col() , por ejemplo:
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
$ table -> col ( ' status ' , ' tinyint ' );
} );También es posible cambiar las definiciones de columnas llamando a uno o más métodos de modificador de columna:
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
$ table -> int ( ' number ' )-> null ( true )-> unsigned ( true );
} );Los métodos de modificador de columna disponibles son:
| Modificador de columna | Descripción |
|---|---|
| Autoincrement (verdadero) | Establezca columnas enteras como incremento automático (alias para seq() ) |
| Charset ('UTF8') | El conjunto de caracteres utilizado por la columna (mysql) |
| Collation ('binary') | La cola de columna (mysql/postgresql/sqlite/sqlserver pero no compatible) |
| Comentario ('comentario') | Agregue un comentario a una columna (mysql/postgresql/oracle/sqlserver) |
| predeterminado (1) | Valor predeterminado de la columna Si no se especificó ningún valor (predeterminado: NULL ) |
| fijo (verdadero) | Si las columnas de cadena o binaria deben tener una longitud fija |
| índice ('IDX_COL') | Agregue un índice a la columna, el nombre del índice es opcional |
| longitud (32) | El máximo. Longitud de columnas de cadena y binaria |
| nulo (verdadero) | Permitir que los valores nulos se inserten en la columna |
| precisión (12) | El máximo. Número de dígitos almacenados en columnas decimales y flotantes incl. dígitos decimales |
| Primario ('PK_COL') | Agregue una clave principal a la columna, el nombre de la clave principal es opcional |
| escala (2) | El número exacto de dígitos decimales utilizados en columnas decimales y flotantes |
| SEQ (verdadero) | Establezca columnas enteras como incremento automático si no se especificó ningún valor |
| espacial ('IDX_COL') | Agregue un índice espacial (GEO) a la columna, el nombre del índice es opcional |
| único ('unq_col') | Agregue un índice único a la columna, el nombre del índice es opcional |
| sin firmar (verdadero) | Permitir solo valores enteros sin firmar (mysql) |
Para establecer opciones de esquema personalizadas para columnas, use el método opt() , por ejemplo:
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
$ table -> string ( ' code ' )-> opt ( ' collation ' , ' utf8mb4 ' );
} );Incluso es posible establecer modificadores de columna para una implementación de base de datos específica al aprobar el tipo de base de datos como tercer parámetro:
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
$ table -> string ( ' code ' )-> opt ( ' collation ' , ' utf8mb4 ' , ' mysql ' );
} ); Para verificar si ya existe una columna, use el método hasColumn() :
if ( $ this -> db ()-> hasColumn ( ' users ' , ' name ' ) ) {
// The "name" column in the "users" table exists
} También puede verificar varias columnas a la vez. En ese caso, el método hasColumn() solo devolverá verdadero si existen todas las columnas:
if ( $ this -> db ()-> hasColumn ( ' users ' , [ ' name ' , ' status ' ] ) ) {
// The "name" and "status" columns in the "users" table exists
} Si ya tiene un objeto de tabla, también puede usar hasColumn() :
if ( $ table -> hasColumn ( ' name ' ) ) {
// The "name" column in the table exists
}
if ( $ table -> hasColumn ( [ ' name ' , ' status ' ] ) ) {
// The "name" and "status" columns in the table exists
}Además de las columnas, también puede verificar si se establecen modificadores de columna y qué valor tienen:
if ( $ table -> string ( ' code ' )-> null () ) {
// The "code" columns is nullable
}La recuperación de los valores del modificador de columna actual es posible utilizando estos métodos:
| Modificador de columna | Descripción |
|---|---|
| autoincrement () | Verdadero si la columna es automática (alias para seq() ) |
| charset () | Conjunto de personajes usado (mysql) |
| colación() | Usada Collation (MySQL/Postgresql/SQLite/SQLServer pero no compatible) |
| comentario() | Comentario asociado a la columna (MySQL/Postgresql/Oracle/SQLServer) |
| por defecto() | Valor predeterminado de la columna |
| fijado() | Verdadero si la cadena o la columna binaria tienen una longitud fija |
| longitud() | La longitud máxima de la cadena o la columna binaria |
| nulo() | Verdadero si se permiten valores nulos |
| precisión() | El número máximo de dígitos almacenados en columnas decimales y flotantes incl. dígitos decimales |
| escala() | El número exacto de dígitos decimales utilizados en columnas decimales y flotantes |
| Seq () | Verdadero si la columna se incrementa automáticamente |
| no firmado() | Verdadero si solo se permiten valores enteros sin firmar (mysql) |
Para verificar los modificadores de columna no estándar, use el método opt() sin el segundo parámetro. Luego, devolverá el valor actual del modificador de columna:
if ( $ table -> string ( ' code ' )-> opt ( ' charset ' ) === ' utf8 ' ) {
// The "code" columns uses UTF - 8 charset ( MySQL only)
}Es posible cambiar la mayoría de los modificadores de columna como la longitud de una columna de cadena:
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
$ table -> string ( ' code ' )-> length ( 64 );
} );Algunos métodos también ofrecen parámetros adicionales para establecer modificadores más utilizados directamente:
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
$ table -> string ( ' code ' , 64 );
} ); Si necesita cambiar los modificadores de columna inmediatamente porque desea migrar las filas después, use el método up() para persistir los cambios:
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
$ table -> string ( ' code ' , 64 )-> null ( true )-> up ();
// modify rows from "test" table
} ); Cambiar el tipo de columna es posible utilizando el nuevo método para el tipo apropiado o el método col() :
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
$ table -> text ( ' code ' );
// or
$ table -> col ( ' code ' , ' text ' );
} );Tenga en cuenta que no todos los tipos de columnas se pueden cambiar a otro tipo o al menos no sin pérdida de datos. Puede cambiar una columna entera a una columna Bigint sin problema, pero la ronda del otro lado fallará. Lo mismo sucede si desea cambiar una columna Varchar (String) en una columna entera.
Para cambiar el nombre de las columnas, use el método renameColumn() del esquema DB:
// single column
$ this -> db ()-> renameColumn ( ' testtable ' , ' label ' , ' name ' );
// multiple columns
$ this -> db ()-> renameColumn ( ' testtable ' , [ ' label ' => ' name ' , ' stat ' => ' status ' ] ); Si ya está disponible un objeto de tabla, puede usar su método renameColumn() para cambiar el nombre de una o más columnas:
$ this -> db ()-> table ( ' testtable ' , function ( $ table ) {
// single column
$ table -> renameColumn ( ' label ' , ' name ' );
// multiple columns
$ table -> renameColumn ( [ ' label ' => ' name ' , ' stat ' => ' status ' ] );
} );En todos los casos, las columnas solo se eliminan si existen. No se informa ningún error si no existen una o más columnas en la tabla.
Para soltar columnas, use el método dropColumn() desde el objeto de esquema DB:
$ this -> db ()-> dropColumn ( ' users ' , ' name ' );Puede soltar varias columnas a la vez si pasa el nombre de todas las columnas que desea soltar como matriz:
$ this -> db ()-> dropColumn ( ' users ' , [ ' name ' , ' status ' ] ); Si ya tiene un objeto de tabla, también puede usar dropColumn() :
// single column
$ table -> dropColumn ( ' name ' );
// multiple columns
$ table -> dropColumn ( [ ' name ' , ' status ' ] );En todos los casos, las columnas solo se eliminan si existen. No se informa ningún error si no existen una o más columnas en la tabla.
Llama a los métodos personalizados o pasa llamadas de método desconocido al objeto de columna de doctrina
public function __call( string $ method , array $ args )$method Nombre del método$args Method ParametersEjemplos:
Puede registrar métodos personalizados que tengan acceso a las propiedades de clase del objeto UpScheme Column:
Aimeos Upscheme Schema Column:: macro ( ' platform ' , function ( array $ options ) {
return $ this -> to -> setPlatformOptions ( $ options );
} );
$ column -> platform ( [ ' option ' => ' value ' ] );Las propiedades de clase disponibles son:
$this->db : upscheme db objeto
$this->table : esquema de tabla de doctrina
$this->column : esquema de columna de doctrina
Además, puede llamar a cualquier método de columna de doctrina directamente, por ejemplo:
$ column -> setPlatformOptions ( [ ' option ' => ' value ' ] );Devuelve el valor para la opción de columna dada
public function __get( string $ name )$name columna de opción NombreLa lista de opciones de columna disponibles es:
Ejemplos:
$ charset = $ column -> charset ;
// same as
$ charset = $ column -> opt ( ' charset ' );Establece el nuevo valor para la opción de columna dada
public function __set( string $ name , $ value )$name columna de opción Nombre$value de la columna de la columna valorLa lista de opciones de columna disponibles es:
Ejemplos:
$ column -> charset = ' utf8 ' ;
// same as
$ column -> opt ( ' charset ' , ' utf8 ' );Establece la columna como autoincrement o devuelve el valor actual
public function autoincrement( bool $ value = null )$value nuevo indicador de autoincremento o nulo para devolver el valor actual Este método es un alias para el método seq() .
Ejemplos:
$ value = $ column -> autoincrement ();
$ column -> autoincrement ( true );Establece el charset de columna o devuelve el valor actual
public function charset( string $ value = null )$value NUEVA columna Charset o NULL para devolver el valor actualEjemplos:
$ comment = $ column -> charset ();
$ column -> charset ( ' utf8 ' );Establece la recopilación de columna o devuelve el valor actual
public function collation( string $ value = null )$value NUEVA COLOMACIÓN DE LA COLUMNA o NULL para devolver el valor actualEjemplos:
$ comment = $ column -> collation ();
$ column -> collation ( ' binary ' );Establece el comentario de la columna o devuelve el valor actual
public function comment( string $ value = null )$value NUEVO COMENTARIO DE LA COLUMNA o NULL para devolver el valor actualEjemplos:
$ comment = $ column -> comment ();
$ column -> comment ( ' column comment ' );Establece el valor predeterminado de la columna o devuelve el valor actual
public function default( $ value = null )$value nuevo valor predeterminado de columna o nulo para devolver el valor actualEjemplos:
$ value = $ column -> default ();
$ column -> default ( 0 );Establece el indicador de columna fijado o devuelve el valor actual
public function fixed( bool $ value = null )$value nuevo columna fijada o nulo para devolver el valor actualEjemplos:
$ value = $ column -> fixed ();
$ column -> fixed ( true );Crea un índice regular para la columna
public function index( string $ name = null ) : self$name nombre del índice o nulo para generar automáticamenteEjemplos:
$ column -> index ();
$ column -> index ( ' idx_col ' );Establece la longitud de la columna o devuelve el valor actual
public function length( int $ value = null )$value nueva longitud de columna o nulo para devolver el valor actualEjemplos:
$ value = $ column -> length ();
$ column -> length ( 32 );Devuelve el nombre de la columna
public function name() : stringEjemplos:
$ name = $ column -> name ();Establece el indicador nulo de la columna o devuelve el valor actual
public function null( bool $ value = null )$value nuevo nulo bandera o nulo para devolver el valor actualEjemplos:
$ value = $ column -> null ();
$ column -> null ( true );Establece el valor de la opción de columna o devuelve el valor actual
public function opt( string $ option , $ value = null , $ for = null )$option columna opción nombre$value nuevo valor de opción de columna o nulo para devolver el valor actual$for la base de datos Tipo Esta opción debe usarse para ("mySQL", "mariadb", "postgreSQL", "sqlite", "sqlserver", "oracle", "db2")Ejemplos:
$ value = $ column -> opt ( ' length ' );
$ column -> opt ( ' length ' , 64 );Establece la precisión de la columna o devuelve el valor actual
public function precision( int $ value = null )$value nuevo valor de precisión de columna o nulo para devolver el valor actualEjemplos:
$ value = $ column -> precision ();
$ column -> precision ( 10 );Crea un índice primario para la columna
public function primary( string $ name = null ) : self$name nombre del índice o nulo para generar automáticamenteEjemplos:
$ column -> primary ();
$ column -> primary ( ' pk_col ' );Establece la escala de columna o devuelve el valor actual
public function scale( int $ value = null )$value NUEVO VALOR DE LA ESCALA DE LA COLUMNA o NULL para devolver el valor actualEjemplos:
$ value = $ column -> scale ();
$ column -> scale ( 3 );Establece la columna como autoincrement o devuelve el valor actual
public function seq( bool $ value = null )$value nuevo indicador de autoincremento o nulo para devolver el valor actualEjemplos:
$ value = $ column -> seq ();
$ column -> seq ( true );Crea un índice espacial para la columna
public function spatial( string $ name = null ) : self$name nombre del índice o nulo para generar automáticamenteEjemplos:
$ column -> spatial ();
$ column -> spatial ( ' idx_col ' );Establece el tipo de columna o devuelve el valor actual
public function type( string $ value = null )$value nuevo tipo de columna o nulo para devolver el valor actualEjemplos:
$ value = $ column -> type ();
$ column -> type ( ' tinyint ' );Crea un índice único para la columna
public function unique( string $ name = null ) : self$name nombre del índice o nulo para generar automáticamenteEjemplos:
$ column -> unique ();
$ column -> unique ( ' unq_col ' );Establece el indicador sin firmar de columna o devuelve el valor actual
public function unsigned( bool $ value = null )$value nuevo columna sin firmar un indicador o nulo para devolver el valor actualEjemplos:
$ value = $ column -> unsigned ();
$ column -> unsigned ( true );Aplica los cambios al esquema de la base de datos
public function up() : selfEjemplos:
$ column -> up (); UPSCHEME ofrece soporte para restricciones de clave extranjera, que imponen la integridad de los datos entre dos tablas. Por ejemplo, si la columna parentid de la tabla users_address hace referencia a la columna id de la tabla users , no puede haber filas en la tabla users_address sin una fila coincidente en la tabla users . Llamar al método foreign() creará tal restricción:
$ this -> db ()-> table ( ' users ' , function ( $ table ) {
$ table -> id ();
} );
$ this -> db ()-> table ( ' users_address ' , function ( $ table ) {
$ table -> foreign ( ' parentid ' , ' users ' );
} ); Nota: La columna ( parentid ) debe tener el mismo tipo de datos y modificadores de columna que la columna referenciada ( id ). El método foreign() asegura que cree un nuevo índice con el mismo nombre que la restricción de clave extranjera automáticamente.
Si la columna ID en la tabla users se nombra de manera diferente, pase su nombre como tercer parámetro al método foreign() :
$ this -> db ()-> table ( ' users_address ' , function ( $ table ) {
$ table -> foreign ( ' parentid ' , ' users ' , ' uid ' );
} );Se recomienda pasar el nombre de la restricción de clave extranjera como el parámetro para que sea más fácil cambiar o eliminar las restricciones más adelante:
$ this -> db ()-> table ( ' users_address ' , function ( $ table ) {
$ table -> foreign ( ' parentid ' , ' users ' , ' id ' , ' fk_test_pid ' );
} );En caso de que se requiera más de una columna para obtener los valores únicos requeridos por las claves extranjeras, pase los nombres de la columna como matriz:
$ this -> db ()-> table ( ' users_address ' , function ( $ table ) {
$ table -> foreign ( [ ' parentid ' , ' siteid ' ], ' users_address ' , [ ' id ' , ' siteid ' ] );
} ); Las restricciones de clave extranjera pueden realizar diferentes acciones si la columna referenciada en la tabla extranjera se elimina de actualizada. La acción estándar es restringir la eliminación de la fila o actualizar el valor de ID referenciado. Para cambiar el comportamiento, use los métodos onDelete() y onUpdate() :
$ this -> db ()-> table ( ' users_address ' , function ( $ table ) {
$ table -> foreign ( ' parentid ' , ' users ' )-> onDelete ( ' SET NULL ' )-> onUpdate ( ' RESTRICT ' );
} );Hay un atajo si desea establecer ambos valores en el mismo valor:
$ this -> db ()-> table ( ' users_address ' , function ( $ table ) {
$ table -> foreign ( ' parentid ' , ' users ' )-> do ( ' SET NULL ' );
} );Los valores posibles para ambos métodos son:
La acción predeterminada al eliminar o actualizar filas es en cascada, por lo que los valores de la columna de clave extranjera se actualizan a los mismos valores que en la tabla extranjera.
Para verificar si ya existe una clave extranjera, use el método hasForeign() :
if ( $ this -> db ()-> hasForeign ( ' users_address ' , ' fk_usrad_parentid ' ) ) {
// The "fk_usrad_parentid" foreign key in the " users_address " table exists
} También es posible verificar varias limitaciones de clave extranjera a la vez. Luego, el método hasForeign() solo devolverá verdadero si existen todas las restricciones en las tablas aprobadas como primer argumento:
if ( $ this -> db ()-> hasForeign ( ' users_address ' , [ ' fk_usrad_parentid ' , ' fk_usrad_siteid ' ] ) ) {
// The "fk_usrad_parentid" and "fk_usrad_siteid" foreign keys exist in the "users_address" table
} Si se puede usar un objeto de tabla disponible, el método hasForeign() de la tabla se puede usar en su lugar:
$ this -> db ()-> table ( ' users_address ' , function ( $ table ) {
$ table -> hasForeign ( ' fk_usrad_parentid ' ) ) {
// The "fk_usrad_parentid" foreign key in the " users_address " table exists
}
} );
$ this -> db ()-> table ( ' users_address ' , function ( $ table ) {
$ table -> hasForeign ( [ ' fk_usrad_parentid ' , ' fk_usrad_siteid ' ] ) ) {
// The "fk_usrad_parentid" and "fk_usrad_siteid" foreign keys exist in the "users_address" table
}
} );En caso de que necesite los valores actuales de una restricción existente:
$ this -> db ()-> table ( ' users_address ' , function ( $ table ) {
$ fk = $ table -> foreign ( ' parentid ' , ' users ' );
// returns the name of the constraint
$ name = $ fk -> name ()
// returns the action when deleting rows
$ action = $ fk -> onDelete ;
// returns the action when updating the foreign ID
$ action = $ fk -> onUpdate ;
} ); Para eliminar una restricción de clave extranjera de una tabla, use el método dropForeign() y pase el nombre de la tabla y el nombre de la clave extranjera como argumentos:
$ this -> db ()-> dropForeign ( ' users_address ' , ' fk_usrad_parentid ' );También puede pasar varios nombres de claves exteriores para soltarlos de inmediato:
$ this -> db ()-> dropForeign ( ' users_address ' , [ ' fk_usrad_parentid ' , ' fk_usrad_siteid ' ] ); Dentro de la función anónima pasada al método table() , también puede usar el método dropForeign() :
$ this -> db ()-> table ( ' users_address ' , function ( $ table ) {
$ table -> dropForeign ( ' fk_usrad_parentid ' );
} );
$ this -> db ()-> table ( ' users_address ' , function ( $ table ) {
$ table -> dropForeign ( [ ' fk_usrad_parentid ' , ' fk_usrad_siteid ' ] );
} );Llama a los métodos personalizados
public function __call( string $ method , array $ args )$method del método$args Method ParametersEjemplos:
Puede registrar métodos personalizados que tienen acceso a las propiedades de clase del objeto extranjero UpScheme:
Aimeos Upscheme Schema Foreign:: macro ( ' default ' , function () {
$ this -> opts = [ ' onDelete ' => ' SET NULL ' , ' onUpdate ' => ' SET NULL ' ];
} );
$ foreign -> default ();Las propiedades de clase disponibles son:
$this->dbaltable : esquema de tabla de doctrina
$this->table : upscheme table object
$this->localcol : nombre o nombres de columna local
$this->fktable : nombre de la tabla extranjera
$this->fkcol : nombre o nombres de columna extranjera
$this->name : nombre de la clave extranjera
$this->opts : Lista asociativa de opciones de claves exteriores (principalmente "onDelete" y "onupdate")
Devuelve el valor para la opción de clave extranjera dada
public function __get( string $ name )$name la opción de clave extranjeraLa lista de opciones de claves exteriores disponibles es:
Los valores posibles para ambas opciones son:
Ejemplos:
$ value = $ foreign -> onDelete ;
// same as
$ value = $ foreign -> opt ( ' onDelete ' );Establece el nuevo valor para la opción de clave extranjera dada
public function __set( string $ name , $ value )$name la opción de clave extranjeraLa lista de opciones de claves exteriores disponibles es:
Los valores posibles para ambas opciones son:
Ejemplos:
$ foreign -> onDelete = ' SET NULL ' ;
// same as
$ foreign -> onDelete ( ' SET NULL ' );
$ foreign -> opt ( ' onDelete ' , ' SET NULL ' );Establece el nuevo valor para la opción de clave extranjera dada
public function do( string $ action ) : self$action realizada acciónLas posibles acciones son:
Ejemplos:
$ foreign -> do ( ' RESTRICT ' ); public function name()Ejemplos:
$ fkname = $ foreign -> name (); public function onDelete( string $ value = null ) @param String | NULL $value realizada Acción o NULL para devolver el valor actual
@return self | cadena mismo objeto para configurar el valor, el valor actual sin parámetro
Las acciones disponibles son:
Ejemplos:
$ value = $ foreign -> onDelete ();
$ foreign -> onDelete ( ' SET NULL ' );
// same as
$ foreign -> onDelete = ' SET NULL ' ;
// same as
$ foreign -> opt ( ' onDelete ' , ' SET NULL ' );
$ foreign -> onDelete ( ' SET NULL ' )-> onUpdate ( ' SET NULL ' ); public function onUpdate( string $ value = null ) @param String | NULL $value realizada Acción o NULL para devolver el valor actual
@return self | cadena mismo objeto para configurar el valor, el valor actual sin parámetro
Las acciones disponibles son:
Ejemplos:
$ value = $ foreign -> onUpdate ();
$ foreign -> onUpdate ( ' SET NULL ' );
// same as
$ foreign -> onUpdate = ' SET NULL ' ;
// same as
$ foreign -> opt ( ' onUpdate ' , ' SET NULL ' );
$ foreign -> onUpdate ( ' SET NULL ' )-> onDelete ( ' SET NULL ' ); public function up() : selfEjemplos:
$ foreign -> up (); Algunas implementaciones de bases de datos ofrecen secuencias en lugar de columnas de auto-incremento/identidad, a saber, Oracle y PostgreSQL. Las secuencias son funciones que crean números que aumentan secuencialmente que se aplican a una columna de tabla al insertar nuevas filas. Para crear una nueva secuencia llamada SEQ_TEST, use el método sequence() :
$ this -> db ()-> sequence ( ' seq_test ' ); Para usar un valor de inicio diferente y un ancho de paso que 1 , llame a los métodos start() y step() :
$ this -> db ()-> sequence ( ' seq_test ' , function ( $ seq ) {
$ seq -> start ( 1000 )-> step ( 2 );
} ); Para verificar si ya existe una secuencia, use el método hasSequence() :
if ( $ this -> db ()-> hasSequence ( ' seq_test ' ) ) {
// The "seq_test" sequence exists
} También es posible verificar varias secuencias a la vez. Entonces, el método hasSequence() solo devolverá verdadero si existen todas las secuencias:
if ( $ this -> db ()-> hasSequence ( [ ' seq_id ' , ' seq_test ' ] ) ) {
// The "seq_id" and "seq_test" sequences exist
}En caso de que necesite conocer los valores actuales de las opciones de tabla:
$ this -> db ()-> sequence ( ' seq_test ' , function ( $ seq ) {
// returns how many generated numbers are cached
$ cache = $ seq -> cache ;
// returns the number the sequence has started from
$ start = $ seq -> start ;
// returns the step width for newly generated numbers
$ step = $ seq -> step ;
} ); Para eliminar una secuencia, use el método dropSequence() y pase el nombre de la secuencia como argumento:
$ this -> db ()-> dropSequence ( ' seq_id ' );También puede pasar varios nombres de secuencia para soltarlos a la vez:
$ this -> db ()-> dropSequence ( [ ' seq_id ' , ' seq_test ' ] );Llama a los métodos personalizados o pasa llamadas de método desconocido al objeto de tabla de doctrina
public function __call( string $ method , array $ args )$method Nombre del método$args Method ParametersEjemplos:
Puede registrar métodos personalizados que tienen acceso a las propiedades de clase del objeto de secuencia UPSCHEME:
Aimeos Upscheme Schema Sequence:: macro ( ' default ' , function () {
$ this -> start ( 1 )-> step ( 2 );
} );
$ sequence -> default ();Las propiedades de clase disponibles son:
$this->db : upscheme db objeto
$this->sequence : esquema de secuencia de doctrina
Devuelve el valor para la opción de secuencia dada
public function __get( string $ name )$name la opción de secuencia de nombreEjemplos:
$ value = $ sequence -> getInitialValue ();
// same as
$ value = $ sequence -> start ();Establece el nuevo valor para la opción de secuencia dada
public function __set( string $ name , $ value )$name la opción de secuencia de nombreEjemplos:
$ value = $ sequence -> setInitialValue ( 1000 );
// same as
$ value = $ sequence -> start ( 1000 );Establece el tamaño caché de la secuencia o devuelve el valor actual
public function cache( int $ value = null )$value nuevo número de identificaciones de secuencia almacenados en caché por el cliente o nulo para devolver el valor actualEjemplos:
$ value = $ sequence -> cache ();
$ sequence -> cache ( 100 );Devuelve el nombre de la secuencia
public function name() $ name = $ sequence -> name ();Establece el nuevo valor de inicio de la secuencia o devuelve el valor actual
public function start( int $ value = null )$value nuevo valor de inicio de la secuencia o nulo para devolver el valor actual $ value = $ sequence -> start ();
$ sequence -> start ( 1000 );Establece el tamaño de paso de los nuevos valores de secuencia o devuelve el valor actual
public function step( int $ value = null )$value tamaño nuevo paso La secuencia se incrementa o disminuye o disminuye para devolver el valor actual $ value = $ sequence -> step ();
$ sequence -> step ( 2 );Aplica los cambios al esquema de la base de datos
public function up() : self $ sequence -> up ();Los índices aceleran las consultas de la base de datos y el tiempo que necesita una consulta de varios minutos a milisegundos si se usa correctamente. Hay varios tipos de índice disponibles:
Todos los índices pueden consistir en una o más columnas, pero el orden de las columnas tiene un gran impacto si los índices se usan para una consulta o no.
Todos los índices están unidos a la tabla que contiene las columnas que cubre el índice. La forma más simple de crear un índice en una sola columna es usar el método index() del objeto de columna:
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
$ table -> string ( ' label ' )-> index ();
} ); El segundo parámetro del método index() le permite establecer un nombre personalizado para el índice:
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
$ table -> string ( ' label ' )-> index ( ' idx_test_label ' );
} );Nota: Para una compatibilidad máxima entre diferentes tipos de bases de datos, la longitud de los nombres de índice debe ser de 30 caracteres o menos.
Lo mismo es posible para los índices primarios, únicos y espaciales:
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
// primary key
$ table -> int ( ' id ' )-> primary ();
$ table -> int ( ' id ' )-> primary ( ' pk_test_id ' ); // ignored by MySQL , MariaDB , etc .
// unique key
$ table -> string ( ' code ' )-> unique ();
$ table -> string ( ' code ' )-> unique ( ' unq_test_code ' );
// spatial index
$ table -> col ( ' location ' , ' point ' )-> spatial ();
$ table -> col ( ' location ' , ' point ' )-> spatial ( ' idx_test_location ' );
} ); Para los índices multi-columna, los métodos primary() , unique() e index() están disponibles en el objeto de tabla:
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
// primary composite index
$ table -> primary ( [ ' siteid ' , ' code ' ] );
// unique composite index
$ table -> unique ( [ ' parentid ' , ' type ' ] );
// regular composite index
$ table -> index ( [ ' label ' , ' status ' ] );
} ); Los índices espaciales no pueden abarcar múltiples columnas, pero también es posible crear el método spatial() del objeto de tabla:
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
$ table -> spatial ( ' location ' );
} ); Para verificar si ya existe un índice, use el método hasIndex() :
if ( $ this -> db ()-> hasIndex ( ' users ' , ' idx_users_name ' ) ) {
// The "idx_users_name" index in the "users" table exists
} También puede verificar varios índices a la vez. En ese caso, el método hasIndex() solo devolverá verdadero si existen todos los índices:
if ( $ this -> db ()-> hasIndex ( ' users ' , [ ' idx_users_name ' , ' idx_users_status ' ] ) ) {
// The "idx_users_name" and "idx_users_status" indexes in the "users" table exists
} Si ya tiene un objeto de tabla, también puede usar hasIndex() :
if ( $ table -> hasIndex ( ' idx_users_name ' ) ) {
// The "idx_users_name" index in the table exists
}
if ( $ table -> hasIndex ( [ ' idx_users_name ' , ' idx_users_status ' ] ) ) {
// The "idx_users_name" and "idx_users_status" indexes in the table exists
} To rename indexes directly, using the renameIndex() method of the DB schema:
// single index
$ this -> db ()-> renameIndex ( ' testtable ' , ' idx_test_label ' , ' idx_test_name ' );
// multiple indexes
$ this -> db ()-> renameIndex ( ' testtable ' , [ ' idx_test_label ' => ' idx_test_name ' , ' idx_text_stat ' => ' idx_test_status ' ] ); If a table object is already available, you can use its renameIndex() method to rename one or more indexes:
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
// single index
$ table -> renameIndex ( ' idx_test_label ' , ' idx_test_name ' );
// multiple indexes
$ table -> renameIndex ( [ ' idx_test_label ' => ' idx_test_name ' , ' idx_text_stat ' => ' idx_test_status ' ] );
} );In all cases, indexes are only renamed if they exist. No error is reported if one or more indexes doesn't exist in the table.
To drop indexes, use the dropIndex() method from the DB schema object:
$ this -> db ()-> dropIndex ( ' users ' , ' idx_test_name ' );You can drop several indexes at once if you pass the name of all indexes you want to drop as array:
$ this -> db ()-> dropIndex ( ' users ' , [ ' idx_test_name ' , ' idx_test_status ' ] ); If you already have a table object, you can use dropIndex() too:
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
// single index
$ table -> dropIndex ( ' idx_test_name ' );
// multiple indexes
$ table -> dropIndex ( [ ' idx_test_name ' , ' idx_test_status ' ] );
} );In all cases, indexes are only removed if they exist. No error is reported if one or more indexes doesn't exist in the table.
It's not necessary to pass a custom index name when creating new indexes. Then, the index name is generated automatically but their name will consist of a hash that is hard to read. Also, you don't know which columns the indexes span from the index name.
Upscheme allows you to add your own naming function for indexes which is used if not index name is passed to the methods for creating indexes. Before running the migrations, register your nameing function using the macro() method in the table objects:
use Aimeos Upscheme Schema Table ;
Table:: marco ( ' nameIndex ' , function ( string $ table , array $ columns , string $ type ) {
return $ type . ' _ ' . $ table . ' _ ' . join ( ' _ ' , $ columns );
} );
Aimeos Upscheme Up:: use ( $ config , ' ./migrations/ ' )-> up ()For a table "testtable", a column "label" and the type "idx", this will return idx_testtable_label instead of a hash.
Available index types are:
Note: For compatibility to all supported database types, the maximum length of the index names must be not longer than 30 characters!
You can add new methods to all Upscheme objects using the macro() method. Each custom method has access to the class properties and methods of the class it's registered for including the Doctrine DBAL objects.
To register a method named test() in the DB schema object with two parameters $arg1 and $arg2 which has access to the same class properties as the DB __call() method use:
Aimeos Upscheme Schema DB :: marco ( ' test ' , function ( $ arg1 , $ arg2 ) {
// $ this - >conn : Doctrine connection
// $this - >from : Doctrine start schema
// $this - >to : Doctrine current schema
// $ this - >up : Upscheme object
// return $this or a value
} );
$ db -> test ( ' key ' , ' value ' ); Registering a method test() in the Table schema object with one parameter $arg1 which has access to the same class properties as the Table __call() method use:
Aimeos Upscheme Schema Table:: marco ( ' test ' , function ( $ arg1 ) {
// $this - >db : Upscheme DB object
// $this - >table : Doctrine Table object
// return $this or a value
} );
$ table -> test ( ' something ' ); Same for a method test() in the Column schema object with an optional parameter $value which has access to the same class properties as the Column __call() method use:
Aimeos Upscheme Schema Column:: marco ( ' test ' , function ( $ value = null ) {
// $this - >db : Upscheme DB object
// $this - >table : Upscheme Table object
// $this - >column : Doctrine Column object
// return $this or a value
} );
$ column -> test (); To extend the Foreign object for foreign key constraints with a test() method with no parameter having access to the same class properties as the Foreign __call() method use:
Aimeos Upscheme Schema Foreign:: marco ( ' test ' , function () {
// $this - >table : Upscheme Table object
// $this - >dbaltable : Doctrine Table object
// $this - >localcol : Array of local column names
// $this - >fktable : Foreign table name
// $ this - >fkcol : Foreign table column names
// $this - >name : Foreign key name
// $ this - >opts : Array of foreign key options ( "onDelete" and "onUpdate")
// return $this or a value
} );
$ foreign -> test (); Finally, extending the Sequence object with a test() method having no parameters and access to the same class properties as the Sequence __call() method use:
Aimeos Upscheme Schema Sequence:: marco ( ' test ' , function () {
// $this - >db : Upscheme DB object
// $this - >sequence : Doctrine Sequence object
// return $this or a value
} );
$ sequence -> test (); Instead of calling the col() method of the Table object with all parameters and modifiers each time, you can create your own shortcut methods, eg:
Aimeos Upscheme Schema Table:: marco ( ' utinyint ' , function ( string $ name ) {
return $ this -> col ( $ name , ' tinyint ' )-> unsigned ( true );
} );It's also possible to create several columns at once if you want to add them to several tables:
Aimeos Upscheme Schema Table:: marco ( ' defaults ' , function () {
$ this -> id ();
$ this -> datetime ( ' ctime ' );
$ this -> datetime ( ' mtime ' );
$ this -> string ( ' editor ' );
return $ this ;
} );Then, use your custom methods when creating or updating tables:
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
$ table -> defaults ();
$ table -> utinyint ( ' status ' );
} );Version 0.9+ supports Doctrine DBAL 3.x/4.x and dropped support for Doctrine DBAL 2.x.
DB::type() returns mariadb instead of mysql for MariaDDB databaseDB::type() returns sqlserver instead of mssql for Microsoft SQLServer databaseDB::for() , DB::view() and Column::opt require ['mariadb', 'mysql'] to get the same resultsDB::lastId() doesn't require/support passing a sequence name because Doctrine DBAL removed it but doesn't support Oracle IDENTITY columns at the moment
