upscheme
1.0.0
Pacote PHP fácil de usar para atualizar o esquema do banco de dados do seu aplicativo e migrar dados entre versões.
composer req aimeos/upschemeÍndice
As migrações são como o controle de versão do seu banco de dados. Eles permitem que você obtenha exatamente o mesmo estado em todas as instalações. Usando o Upscheme, você obtém:
Aqui está um exemplo de definição de tabela que você pode adaptar sempre que o layout da tabela precisar mudar. Em seguida, o Upscheme adicionará e modificará automaticamente as colunas e propriedades da tabela existentes (mas não excluirá nada por motivos de segurança):
$ 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 atualizar esquemas de banco de dados relacionais, dois pacotes são usados atualmente com mais frequência: Doctrine DBAL e Doctrine Migrations. Embora o Doctrine DBAL faça um bom trabalho ao abstrair as diferenças de diversas implementações de banco de dados, sua API requer a escrita de muito código. As migrações doutrinárias em outro site têm algumas desvantagens que dificultam o uso em todos os aplicativos que suportam extensões de terceiros.
A API do DBAL é muito detalhada e você precisa escrever muito código, mesmo para coisas simples. Upscheme usa Doctrine DBAL para oferecer uma API fácil de usar para atualizar o esquema de banco de dados de seu aplicativo com código mínimo. Para o exemplo Upscheme acima, estas linhas de código são equivalentes para DBAL em uma migração:
$ 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 );
}O Doctrine Migration depende de classes de migração que são nomeadas no momento em que foram criadas para garantir uma determinada ordem. Além disso, armazena quais migrações foram executadas em uma tabela do seu banco de dados. Existem três problemas principais que surgem disso:
down() Se o seu aplicativo oferecer suporte a extensões de terceiros, essas extensões provavelmente adicionarão colunas às tabelas existentes e migrarão os dados por conta própria. Como não há como definir dependências entre migrações, pode ser quase impossível executar migrações em um aplicativo com diversas extensões de terceiros sem conflitos. Para evitar isso, Upscheme oferece métodos before() e after() fáceis de usar em cada tarefa de migração onde as tarefas podem definir suas dependências com outras tarefas.
Como o Doctrine Migrations usa uma tabela de banco de dados para registrar qual migração já foi executada, esses registros podem ficar facilmente fora de sincronia em caso de problemas. Ao contrário, o Upscheme depende apenas do esquema real, portanto é possível atualizar a partir de qualquer estado, independentemente do que tenha acontecido antes.
Doctrine Migrations também suporta operações reversas em métodos down() para que você possa reverter migrações que o Upscheme não faz. A experiência tem mostrado que muitas vezes é impossível reverter migrações, por exemplo, após adicionar uma nova coluna, migrar os dados de uma coluna existente e descartar a coluna antiga posteriormente. Se a migração dos dados apresentar perdas, você não poderá recriar o mesmo estado em um método down() . O mesmo acontece se você derrubar uma mesa. Assim, o Upscheme oferece apenas atualização de esquema, mas nenhum downgrade para evitar perda implícita de dados.
Upscheme usa Doctrine DBAL para abstrair diferentes implementações de servidores de banco de dados. DBAL suporta todos os principais sistemas de gerenciamento de banco de dados relacional (RDBMS), mas com um nível diferente de suporte para os recursos disponíveis:
Bom suporte:
Suporte limitado:
Depois de instalar o pacote aimeos/upscheme usando o compositor, você pode usar a classe Up para executar suas tarefas de migração:
$ config = [
' driver ' => ' pdo_mysql ' ,
' host ' => ' 127.0.0.1 ' ,
' dbname ' => ' <database> ' ,
' user ' => ' <dbuser> ' ,
' password ' => ' <secret> '
];
Aimeos Upscheme Up:: use ( $ config , ' src/migrations ' )-> up (); O método Up::use() requer dois parâmetros: a configuração do banco de dados e o(s) caminho(s) para as tarefas de migração. Para a configuração, as chaves do array e os valores do driver devem ser suportados pelo Doctrine DBAL. Os drivers disponíveis são:
Alguns bancos de dados requerem parâmetros diferentes, sendo os mais notáveis SQLite e 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> '
];Se você não usou o Doctrine DBAL antes, a configuração do seu banco de dados pode ter uma estrutura diferente e/ou usar valores diferentes para o tipo de banco de dados. Upscheme permite registrar um método personalizado que transforma sua configuração em configurações DBAL válidas, por exemplo:
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 também oferece suporte a várias conexões de banco de dados que você pode distinguir pelo nome da chave:
$ 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 (); Claro, você também pode passar por vários caminhos de migração para a classe Up :
Aimeos Upscheme Up:: use ( $ config , [ ' src/migrations ' , ' ext/migrations ' ] )-> up ();Para ativar a saída (depuração), use o método verbose():
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 Uma tarefa de migração requer apenas a implementação do método up() e deve ser armazenada em um dos diretórios passados para a classe 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 ' );
} );
}
}; No seu arquivo PHP, sempre inclua primeiro a instrução namespace . A instrução use é opcional e necessária apenas como atalho para a dica de tipo para o argumento da função de fechamento. Sua classe também precisa se estender da classe de tarefa "Base" ou implementar a interface de tarefa "Iface".
Alternativamente às classes anônimas, você pode usar classes nomeadas para tarefas de migração:
<?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 ' );
} );
}
} O arquivo em que sua classe está armazenada deve ter o mesmo nome (diferencia maiúsculas de minúsculas) da própria classe e o sufixo .php , por exemplo:
class TestTable -> TestTable.php
Não há uma convenção estrita sobre como nomear os arquivos de tarefas de migração. Você pode nomeá-los pelo que fazem (por exemplo, "CreateTestTable.php"), pelo que operam (por exemplo, "TestTable.php") ou até mesmo usar um carimbo de data/hora (por exemplo, "20201231_Test.php").
Caso as tarefas não contenham dependências, elas serão ordenadas e executadas em ordem alfabética de acordo com o nome do arquivo e a ordenação seria:
20201231_Test.php
CreateTestTable.php
TestTable.php
Para especificar dependências para outras tarefas de migração, use os métodos after() e before() . Sua tarefa é executada após as tarefas retornadas por after() e antes das tarefas retornadas por before() :
return new class ( $ this ) extends Base {
public function after () : array
{
return [ ' CreateRefTable ' ];
}
public function before () : array
{
return [ ' InsertTestData ' ];
}
} Os nomes das tarefas são os nomes dos arquivos das tarefas sem o sufixo .php . Se o exemplo de migração estiver armazenado no arquivo TestTable.php , a ordem de execução seria:
CreateRefTable.php -> TestTable.php -> InsertTestData.php
Para gerar mensagens em sua tarefa de migração, use o método info() :
$ this -> info ( ' some message ' );
$ this -> info ( ' more verbose message ' , ' vv ' );
$ this -> info ( ' very verbose debug message ' , ' vvv ' ); O segundo parâmetro é o nível de verbosidade e nenhum ou v são mensagens padrão, vv são mensagens que só são exibidas se for desejada mais verbosidade, enquanto vvv é para mensagens de depuração. Há também um terceiro parâmetro para recuar as mensagens:
$ this -> info ( ' some message ' );
$ this -> info ( ' second level message ' , ' v ' , 1 );
$ this -> info ( ' third level message ' , ' v ' , 2 );Isso exibirá:
some message
second level message
third level message
O pré-requisito é que o método verbose() da classe Up tenha sido chamado antes:
Aimeos Upscheme Up:: use ( $ config , ' ... ' )-> verbose ()-> up (); No método up() , você tem acesso ao esquema do banco de dados usando o método db() . Caso você tenha passado mais de uma configuração de banco de dados para Up::use() , você pode acessar os diferentes esquemas por sua chave de configuração:
// $config = [ 'db' => [ ... ] , 'temp' => [ ... ] ] ;
// Aimeos UpschemeUp::use( $config , '...' )->up() ;
$ this -> db ();
$ this -> db ( ' db ' );
$ this -> db ( ' temp ' ); Se você não passar nenhuma chave de configuração ou uma que não exista, a primeira configuração será retornada ("db" neste caso). Usando os métodos disponíveis do objeto de esquema de banco de dados, você pode adicionar, atualizar ou eliminar tabelas, colunas, índices e outros objetos de banco de dados. Além disso, você pode usar insert() , select() , update() , delete() e stmt() para manipular os registros das tabelas.
Após cada tarefa de migração, as atualizações de esquema feitas na tarefa são aplicadas automaticamente ao banco de dados. Se você precisar persistir uma alteração imediatamente porque deseja inserir dados, chame $this->db()->up() você mesmo. O método up() também está disponível em qualquer objeto de tabela, sequência e coluna para que você possa chamar up() em qualquer lugar.
Caso você precise de duas conexões de banco de dados diferentes porque deseja executar instruções SELECT e INSERT/UPDATE/DELETE ao mesmo tempo, passe TRUE como segundo parâmetro para db() para obter o esquema do banco de dados incluindo uma nova conexão:
$ 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 ] ); Todas as alterações de esquema feitas são aplicadas ao banco de dados antes que o esquema com a nova conexão seja retornado. Para evitar que as conexões de banco de dados se acumulem até que o servidor de banco de dados rejeite novas conexões, sempre chame close() para novas conexões criadas por db( '<name>', true ) :
$ db2 -> close ();Em vez de escrever migrações para seus objetos de banco de dados manualmente, você pode gerar os arquivos de migração automaticamente usando:
$ config = [
' db ' => [
' driver ' => ' pdo_mysql ' ,
' host ' => ' 127.0.0.1 ' ,
' dbname ' => ' <database> ' ,
' user ' => ' <dbuser> ' ,
' password ' => ' <secret> '
]
];
Aimeos Upscheme Up:: use ( $ config , ' migrations ' )-> create (); Isso irá gerar um arquivo para cada sequência, tabela e visualização no diretório passado ( ./migrations/ neste exemplo). Se você possui vários bancos de dados e deseja criar migrações para todos eles de uma vez, passe as chaves de conexão da configuração para create() :
$ config = [
' db ' => [
' driver ' => ' pdo_mysql ' ,
// ...
],
' order ' => [
' driver ' => ' pdo_oci ' ,
// ...
]
];
Aimeos Upscheme Up:: use ( $ config , ' migrations ' )-> create ( [ ' db ' , ' order ' ] ); Você obtém o objeto do esquema do banco de dados em sua tarefa chamando $this->db() conforme descrito na seção esquema. Dá acesso total ao esquema do banco de dados, incluindo todas as tabelas, sequências e outros objetos do esquema:
$ table = $ this -> db ()-> table ( ' users ' );
$ seq = $ this -> db ()-> sequence ( ' seq_users ' );Caso a tabela ou sequência não exista, ela será criada. Caso contrário, a tabela ou objeto de sequência existente será retornado. Em ambos os casos, você pode modificar os objetos posteriormente e adicionar, por exemplo, novas colunas à tabela.
Você pode testar tabelas, colunas, índices, chaves estrangeiras e sequências usando o esquema do banco de dados retornado 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
} O objeto de banco de dados retornado por $this->db() oferece a possibilidade de renomear tabelas, colunas e índices usando renameTable() , renameColumn() e 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 ' ); O objeto de banco de dados retornado por $this->db() também possui métodos para eliminar tabelas, colunas, índices, chaves estrangeiras e sequências:
$ 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 ' ); Se a tabela, coluna, índice, chave estrangeira ou sequência não existir, ela será ignorada silenciosamente. Para casos em que você precisa saber se eles existem, use os métodos hasTable() , hasColumn() , hasIndex() , hasForeign() e hasSeqence() descritos anteriormente na seção "Verificando existência".
Os métodos insert() , select() , update() e delete() são uma maneira fácil de adicionar, recuperar, modificar e remover linhas em qualquer tabela:
$ 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 ();
} ); Se você usar select() simultaneamente com insert() , update() ou delete() , deverá criar uma segunda conexão com o banco de dados porque a instrução select() retornará linhas enquanto você envia novos comandos ao servidor de banco de dados. Isso funciona apenas em conexões separadas, não na mesma.
Para agrupar todas as operações de exclusão/inserção/atualização em uma transação, você deve usar o método transaction() do objeto de banco de dados:
$ this -> db ()-> transaction ( function ( $ db ) {
// $db- > insert ( ... )
// $db- > update ( ... )
// $db- > delete ( ... )
} ); Isso garante que todas as operações de gravação sejam executadas atomicamente ou nenhuma delas em caso de erro. O método transaction() garante que a transação seja confirmada ou revertida automaticamente depois que sua função anônima retornar o controle ao método.
Se precisar de parâmetros adicionais em sua função anônima, você pode entregá-los na lista use de sua função:
$ userid = 123 ;
$ this -> db ()-> transaction ( function ( $ db ) use ( $ userid ) {
$ db -> insert ( ' newusers ' , [ ' userid ' => userid, ' status ' => true ] );
} ); Você só pode passar pares simples de chave/valor para condições para os métodos que são combinados por AND. Se você precisar de consultas mais complexas, use stmt() :
$ 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 (); O método stmt() retorna um objeto DoctrineDBALQueryQueryBuilder que permite construir instruções mais avançadas. Por favor, dê uma olhada na documentação do Doctrine Query Builder para mais detalhes.
Se você quiser usar valores diretamente em uma instrução SQL (use instruções preparadas por motivos de segurança sempre que possível!), você deverá citar os valores usando o método q() :
$ db = $ this -> db ();
$ result = $ db -> stmt ()-> select ( ' * ' )-> from ( ' products ' )
-> where ( ' status = ' . $ db -> q ( $ _GET [ ' status ' ] ) )-> executeQuery (); Da mesma forma, se o seu esquema contém palavras-chave reservadas, por exemplo, como nomes de colunas, você também deve citá-las usando o método qi() :
$ db = $ this -> db ();
$ result = $ db -> stmt ()-> select ( $ db -> qi ( ' key ' ) )-> from ( ' products ' )-> executeQuery (); O Doctrine suporta apenas um subconjunto comum de instruções SQL e nem todas as possibilidades que os fornecedores de banco de dados implementaram. Para remover esse limite, Upscheme oferece os métodos exec() , for() e query() para executar instruções SQL personalizadas não suportadas pelo Doctrine DBAL.
Para executar consultas SQL personalizadas, use o método query() que retorna um conjunto de resultados que você pode iterar:
$ sql = ' SELECT id, label, status FROM product WHERE label LIKE ? ' ;
$ result = $ this -> db ()-> query ( $ sql , [ ' test% ' ] );
foreach ( $ result -> iterateAssociative () as $ row ) {
// ...
} Para todas as outras instruções SQL use o método exec() que retorna o número de linhas afetadas:
$ sql = ' UPDATE product SET status=? WHERE status=? ' ;
$ num = $ this -> db ()-> exec ( $ sql , [ 1 , 0 ] ); Usando o método for() , você também pode executar instruções dependendo da plataforma do banco de dados:
$ this -> db ()-> for ( ' mysql ' , ' CREATE FULLTEXT INDEX idx_text ON product (text) ' );Especificar a plataforma do banco de dados é muito útil para criar tipos especiais de índices onde a sintaxe difere entre as implementações do banco de dados.
Chama métodos personalizados ou passa chamadas de métodos desconhecidos para o objeto do esquema Doctrine
public function __call( string $ method , array $ args )$method Nome do método$args Parâmetros do métodoExemplos:
Você pode registrar métodos personalizados que tenham acesso às propriedades de classe do objeto Upscheme DB:
Aimeos Upscheme Schema DB :: macro ( ' hasFkIndexes ' , function ( $ val ) {
return $ this -> to -> hasExplicitForeignKeyIndexes ();
} );
$ db -> hasFkIndexes ();
// returns true / falseAs propriedades de classe disponíveis são:
$this->from : Esquema de banco de dados original do Doctrine representando o banco de dados atual
$this->to : Esquema do banco de dados do Doctrine contendo as alterações feitas até agora
$this->conn : Conexão com o banco de dados do Doctrine
$this->up : objeto Upscheme
Além disso, você pode chamar qualquer método de esquema do Doctrine diretamente, por exemplo:
$ db -> hasExplicitForeignKeyIndexes ();Fecha a conexão com o banco de dados
public function close() : void Chame close() apenas para objetos de esquema de banco de dados criados com $this->db( '...', true ) . Caso contrário, você fechará a conexão principal e o DBAL terá que se reconectar ao servidor, o que prejudicará o desempenho!
Exemplos:
$ db = $ this -> db ( ' temp ' , true );
$ db -> dropTable ( ' test ' );
$ db -> close ();Exclui os registros da tabela fornecida
public function delete( string $ table , array $ conditions = [] ) : self$table Nome da tabela$conditions Pares chave/valor de nomes de colunas e valores para compararAviso: Os valores de condição têm escape, mas o nome da tabela e os nomes das colunas de condição não! Use apenas strings fixas para nomes de tabelas e nomes de colunas de condições, mas nenhuma entrada externa!
Exemplos:
$ db -> delete ( ' test ' , [ ' status ' => false , ' type ' => ' old ' ] );
$ db -> delete ( ' test ' ); Diversas condições passadas no segundo parâmetro são combinadas por “AND”. Se você precisar de instruções mais complexas, use o método stmt() .
Descarta a coluna dada pelo seu nome, se existir
public function dropColumn( string $ table , $ name ) : self$table Nome da tabela à qual a coluna pertence$name Nome da coluna ou colunasExemplos:
$ db -> dropColumn ( ' test ' , ' oldcol ' );
$ db -> dropColumn ( ' test ' , [ ' oldcol ' , ' oldcol2 ' ] );Se a coluna ou uma das colunas não existir, ela será ignorada silenciosamente.
Descarta a restrição de chave estrangeira dada pelo seu nome, se existir
public function dropForeign( string $ table , $ name ) : self$table Nome da tabela à qual pertence a restrição de chave estrangeira$name Nome da restrição ou restrições de chave estrangeiraExemplos:
$ db -> dropForeign ( ' test ' , ' fk_old ' );
$ db -> dropForeign ( ' test ' , [ ' fk_old ' , ' fk_old2 ' ] );Se a restrição de chave estrangeira ou uma das restrições não existir, ela será ignorada silenciosamente.
Descarta o índice dado pelo seu nome, se existir
public function dropIndex( string $ table , $ name ) : self$table Nome da tabela à qual o índice pertence$name Nome do índice ou índicesExemplos:
$ db -> dropIndex ( ' test ' , ' idx_old ' );
$ db -> dropIndex ( ' test ' , [ ' idx_old ' , ' idx_old2 ' ] );Se o índice ou um dos índices não existir, ele será ignorado silenciosamente.
Elimina a sequência dada pelo seu nome, se existir
public function dropSequence( $ name ) : self$name Nome da sequência ou sequênciasExemplos:
$ db -> dropSequence ( ' seq_old ' );
$ db -> dropSequence ( [ ' seq_old ' , ' seq_old2 ' ] );Se a sequência ou uma das sequências não existir, ela será ignorada silenciosamente.
Descarta a tabela dada pelo seu nome, se existir
public function dropTable( $ name ) : self$name Nome da tabela ou tabelasExemplos:
$ db -> dropTable ( ' test ' );
$ db -> dropTable ( [ ' test ' , ' test2 ' ] );Se a tabela ou uma das tabelas não existir, ela será ignorada silenciosamente.
Descarta a visão dada pelo seu nome, se existir
public function dropView( $ name ) : self$name Nome da visualização ou visualizaçõesExemplos:
$ db -> dropView ( ' test ' );
$ db -> dropView ( [ ' test ' , ' test2 ' ] );Se a visualização ou uma das visualizações não existir, ela será ignorada silenciosamente.
Executa uma instrução SQL personalizada
public function exec( string $ sql , array $ params = [], array $ types = [] ) : int$sql Instrução SQL personalizada$params Lista de parâmetros posicionais ou lista associativa de espaços reservados e parâmetros$types Lista de tipos de dados DBAL para os parâmetros de espaço reservado posicional ou associativoAs alterações no banco de dados não são aplicadas imediatamente, então sempre chame up() antes de executar instruções personalizadas para ter certeza de que as tabelas que você deseja usar foram criadas antes!
Exemplos:
$ sql = ' UPDATE product SET status=? WHERE status=? ' ;
$ num = $ this -> db ()-> exec ( $ sql , [ 1 , 0 ] );Executa uma instrução SQL personalizada se o banco de dados for do tipo especificado
public function for( $ type , $ sql ) : self$type Tipo de banco de dados para o qual a instrução deve ser executada$sql Instrução ou instruções SQL personalizadasOs tipos de plataforma de banco de dados disponíveis são:
As alterações no banco de dados não são aplicadas imediatamente, então sempre chame up() antes de executar instruções personalizadas para ter certeza de que as tabelas que você deseja usar foram criadas antes!
Exemplos:
$ 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 ' ,
] );Verifica se a coluna ou colunas existem
public function hasColumn( string $ table , $ name ) : bool$table Nome da tabela à qual a coluna pertence$name Nome da coluna ou colunasExemplos:
$ db -> hasColumn ( ' test ' , ' testcol ' );
$ db -> hasColumn ( ' test ' , [ ' testcol ' , ' testcol2 ' ] );Verifica se existem restrições de chave estrangeira
public function hasForeign( string $ table , $ name ) : bool$table Nome da tabela à qual pertence a restrição de chave estrangeira$name Nome da restrição ou restrições de chave estrangeiraExemplos:
$ db -> hasForeign ( ' test ' , ' fk_testcol ' );
$ db -> hasForeign ( ' test ' , [ ' fk_testcol ' , ' fk_testcol2 ' ] );Verifica se os índices existem
public function hasIndex( string $ table , $ name ) : bool$table Nome da tabela à qual o índice pertence$name Nome do índice ou índicesExemplos:
$ db -> hasIndex ( ' test ' , ' idx_test_col ' );
$ db -> hasIndex ( ' test ' , [ ' idx_test_col ' , ' idx_test_col2 ' ] );Verifica se as sequências existem
public function hasSequence( $ name ) : bool$name Nome da sequência ou sequênciasExemplos:
$ db -> hasSequence ( ' seq_test ' );
$ db -> hasSequence ( [ ' seq_test ' , ' seq_test2 ' ] );Verifica se as tabelas existem
public function hasTable( $ name ) : bool$name Nome da tabela ou tabelasExemplos:
$ db -> hasTable ( ' test ' );
$ db -> hasTable ( [ ' test ' , ' test2 ' ] );Verifica se as visualizações existem
public function hasView( $ name ) : bool$name Nome da visualização ou visualizaçõesExemplos:
$ db -> hasView ( ' test ' );
$ db -> hasView ( [ ' test ' , ' test2 ' ] );Insere um registro na tabela fornecida
public function insert( string $ table , array $ data ) : self$table Nome da tabela$data Pares chave/valor de nome/valor da coluna a serem inseridosExemplos:
$ db -> insert ( ' test ' , [ ' label ' => ' myvalue ' , ' status ' => true ] );Retorna o ID da última linha inserida em qualquer tabela do banco de dados
public function lastId() : stringCuidado: Isso não funciona para a plataforma Oracle porque o Doctrine DBAL não suporta colunas Oracle IDENTITY no momento.
Exemplos:
$ db -> lastId ();Retorna o nome do banco de dados
public function name() : stringExemplos:
$ db -> name ();Cita um valor
public function q( $ value , $ type = Doctrine DBAL ParameterType:: STRING ) : string$value Valor a ser usado em uma consulta SQL não preparada$typeExemplos:
$ result = $ db -> stmt ()-> select ( ' * ' )-> from ( ' products ' )
-> where ( ' status = ' . $ db -> q ( $ _GET [ ' status ' ] ) )-> executeQuery ();Cita um identificador de banco de dados
public function qi( string $ identifier ) : string$identifier Identificador como nome de tabela ou colunaExemplos:
$ result = $ db -> stmt ()-> select ( $ db -> qi ( ' key ' ) )-> from ( ' products ' )-> executeQuery ();Executa uma consulta SQL personalizada
public function query( string $ sql , array $ params = [], array $ types = [] ) : Doctrine DBAL Result$sql Instrução SQL personalizada$params Lista de parâmetros posicionais ou lista associativa de espaços reservados e parâmetros$types Lista de tipos de dados DBAL para os parâmetros de espaço reservado posicional ou associativoExemplos:
$ result = $ db -> query ( ' SELECT id, label, status FROM product WHERE label LIKE ? ' , [ ' test% ' ] );
foreach ( $ result -> iterateAssociative () as $ row ) {
// ...
}Dica: Verifique os métodos DBAL para recuperação de dados para obter mais informações.
Renomeia uma coluna ou uma lista de colunas
public function renameColumn( string $ table , $ from , string $ to = null ) : self$table Nome da tabela$from Nome da coluna ou matriz de nomes de colunas antigas/novas$to Novo nome de coluna ignorado se o primeiro parâmetro for um array Se a coluna ainda não existir, o método terá sucesso, mas nada acontecerá. Nenhuma chamada para up() é necessária.
Limitações
Exemplos:
// single column
$ db -> renameColumn ( ' testtable ' , ' test_col ' , ' test_column ' );
// rename several columns at once
$ db -> renameColumn ( ' testtable ' , [ ' tcol ' => ' testcol ' , ' tcol2 ' => ' testcol2 ' ] );Renomeia uma coluna ou uma lista de colunas
public function renameIndex( string $ table , $ from , string $ to = null ) : self$table Nome da tabela$from Nome do índice ou array de nomes de índices antigos/novos$to Novo nome de índice ignorado se o primeiro parâmetro for um array Se o índice ainda não existir, o método terá sucesso, mas nada acontecerá. Nenhuma chamada para up() é necessária.
Exemplos:
// single index
$ db -> renameIndex ( ' testtable ' , ' idxcol ' , ' idx_column ' );
// rename several indexes at once
$ db -> renameIndex ( ' testtable ' , [ ' idxcol ' => ' idx_column ' , ' idxcol2 ' => ' idx_column2 ' ] );Renomeia uma tabela ou uma lista de tabelas
public function renameTable( $ from , string $ to = null ) : self$from Nome da tabela ou array de nomes de tabelas antigas/novas$to Novo nome da tabela ignorado se o primeiro parâmetro for um array Se a tabela ainda não existir, o método terá sucesso, mas nada acontecerá. Nenhuma chamada para up() é necessária.
Exemplos:
// single table
$ db -> renameTable ( ' testtable ' , ' newtable ' );
// rename several tables at once
$ db -> renameTable ( [ ' testtable ' => ' newtable ' , ' oldtable ' => ' testtable2 ' ] );Recarrega o esquema real do Doctrine para o banco de dados atual
public function reset() : selfExemplos:
$ db -> reset ();Retorna os registros da tabela fornecida
public function select( string $ table , array $ conditions = null ) : array$table Nome da tabela$conditions Pares de chave/valor de nomes de colunas e valores para compararExemplos:
$ db -> select ( ' test ' , [ ' status ' => false , ' type ' => ' old ' ] );
$ db -> select ( ' test ' ); Diversas condições passadas no segundo parâmetro são combinadas por “AND”. Se você precisar de instruções mais complexas, use o método stmt() .
Retorna o objeto de sequência para o nome fornecido
public function sequence( string $ name , Closure $ fcn = null ) : Sequence$name Nome da sequência$fcn Função anônima com parâmetro ($sequence) criando ou atualizando a definição da sequência Se a sequência ainda não existir, ela será criada. Para persistir as alterações no banco de dados, você deve chamar up() .
Exemplos:
$ sequence = $ db -> sequence ( ' seq_test ' );
$ sequence = $ db -> sequence ( ' seq_test ' , function ( $ seq ) {
$ seq -> start ( 1000 )-> step ( 2 )-> cache ( 100 );
} )-> up ();Retorna o construtor de consultas para uma nova instrução SQL
public function stmt() : Doctrine DBAL Query QueryBuilderExemplos:
$ 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 ' ];
} **Cuidado: ** Você mesmo deve citar todos os nomes de tabelas e colunas usando o método $db->qi() !
Para obter mais detalhes sobre os métodos disponíveis do Doctrine QueryBuilder, dê uma olhada na documentação do Doctrine.
Retorna o objeto de tabela para o nome fornecido
public function table( string $ name , Closure $ fcn = null ) : Table$name Nome da tabela$fcn Função anônima com parâmetro ($table) criando ou atualizando a definição da tabela Se a tabela ainda não existir, ela será criada. Para persistir as alterações no banco de dados, você deve chamar up() .
Exemplos:
$ table = $ db -> table ( ' test ' );
$ table = $ db -> table ( ' test ' , function ( $ t ) {
$ t -> id ();
$ t -> string ( ' label ' );
$ t -> bool ( ' status ' );
} )-> up ();Executa o fechamento fornecido dentro de uma transação
public function transaction( Closure $ fcn ) : selfExemplos:
$ this -> db ()-> transaction ( function ( $ db ) {
// $db- > insert ( ... )
// $db- > update ( ... )
// $db- > delete ( ... )
} );Retorna os objetos como array do banco de dados
public function toArray() : arrayExemplos:
$ this -> db ()-> toArray ();A estrutura do array retornado é:
[
' 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` '
]
]
]Retorna o tipo do banco de dados
public function type() : stringOs valores possíveis são:
Exemplos:
$ type = $ db -> type ();Aplica as alterações ao esquema do banco de dados
public function up() : selfExemplos:
$ db -> up ();Atualiza os registros da tabela fornecida
public function update( string $ table , array $ data , array $ conditions = [] ) : self$table Nome da tabela$data Pares chave/valor de nome/valor da coluna a serem atualizados$conditions Pares chave/valor de nomes de colunas e valores para compararExemplos:
$ db -> update ( ' test ' , [ ' status ' => true ] );
$ db -> update ( ' test ' , [ ' status ' => true ], [ ' status ' => false , ' type ' => ' new ' ] ); Diversas condições passadas no segundo parâmetro são combinadas por “AND”. Se você precisar de instruções mais complexas, use o método stmt() .
Cria uma visualização com o nome fornecido se ela ainda não existir
public function view( string $ name , string $ sql , $ for = null ) : self$name Nome da visualização$sql Instrução SELECT para preencher a visualização$for o tipo de banco de dados para o qual este SQL deve ser usado ("mysql", "mariadb", "postgresql", "sqlite", "sqlserver", "oracle", "db2")Se a visualização ainda não existir, ela será criada. Caso contrário, nada acontecerá.
Exemplos:
$ 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 ' ); O objeto do esquema de tabela que você obtém chamando table() em sua tarefa de migração oferece acesso total à tabela e você pode adicionar, alterar ou remover colunas, índices e chaves estrangeiras, por exemplo:
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
$ table -> id ();
$ table -> string ( ' label ' );
$ table -> col ( ' status ' , ' tinyint ' )-> default ( 0 );
} ); Além do método col() que pode adicionar colunas de tipos arbitrários, existem alguns métodos de atalho para tipos disponíveis em todas as implementações de servidores de banco de dados:
| Tipo de coluna | Descrição |
|---|---|
| bigid | Coluna BIGINT com uma sequência/incremento automático e uma chave primária atribuída |
| grande | Coluna BIGINT com um intervalo de −9223372036854775808 a 9223372036854775807 |
| binário | Coluna VARBINARY com até 255 bytes |
| bolha | Coluna BLOB com até 2 GB |
| bool | Coluna BOOLEAN/BIT/NUMBER, alias para "booleano" |
| booleano | Coluna BOOLEAN/BIT/NUMBER para TRUE/FALSE resp. Valores 0/1 |
| personagem | Coluna CHAR com um número fixo de caracteres |
| data | Coluna DATA no formato de data ISO ("AAAA-MM-DD) sem hora e fuso horário |
| datahora | Coluna DATETIME no formato ISO de data/hora ("YYYY-MM-DD HH:mm:ss" ) |
| tabelasdatetimetz | Coluna DATETIMETZ no formato ISO de data/hora, mas com formato de fuso horário variável |
| decimal | Coluna DECIMAL para dados numéricos com precisão de ponto fixo (string em PHP) |
| flutuador | Coluna FLOAT para dados numéricos com precisão de ponto flutuante de 8 bytes |
| guia | Identificador globalmente exclusivo com 36 bytes |
| eu ia | Coluna INTEGER com uma sequência/incremento automático e uma chave primária atribuída |
| interno | Coluna INTEGER, alias para "inteiro" |
| inteiro | Coluna INTEGER com intervalo de −2147483648 a 2147483647 |
| json | Coluna JSON para dados JSON codificados em UTF-8 |
| pequeno inteiro | Coluna INTEGER com intervalo de −32768 a 32767 |
| corda | Coluna VARCHAR com até 255 caracteres |
| texto | Coluna TEXT/CLOB com até 2 GB de caracteres |
| tempo | Coluna TIME em 24 horas "HH:MM" fromat, por exemplo, "05:30" ou "22:15" |
| uuid | Identificador globalmente exclusivo com 36 bytes, alias para "guid" |
MySQL (ou MariaDB, etc.) suporta algumas opções para definir aspectos da tabela. A opção engine especificará o mecanismo de armazenamento usado para a tabela:
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
$ table -> opt ( ' engine ' , ' InnoDB ' );
} );Como atalho, também é possível definir a opção como propriedade:
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
$ table -> engine = ' InnoDB ' ;
} );Para criar uma tabela temporária , use:
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
$ table -> temporary = true ;
} );Também é possível definir o conjunto de caracteres e o agrupamento padrão para colunas de string e texto:
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
$ table -> charset = ' utf8mb4 ' ;
$ table -> collation = ' utf8mb4_unicode_ci ' ;
} ); Nota: Os agrupamentos também são suportados pelo PostgreSQL e pelo SQL Server, mas seus valores são diferentes. Assim, não é possível utilizar o mesmo valor para todos os tipos de servidores. Para contornar esse problema, use o método da coluna opt() e passe o tipo de servidor de banco de dados como terceiro parâmetro:
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
$ table -> opt ( ' charset ' , ' utf8mb4 ' , ' mysql ' );
$ table -> opt ( ' collation ' , ' utf8mb4_unicode_ci ' , ' mysql ' );
} );Agora, o conjunto de caracteres e agrupamento padrão serão definidos apenas para servidores de banco de dados MySQL (ou MariaDB e bifurcações semelhantes).
Caso você precise saber os valores atuais das opções da tabela:
$ 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 verificar se uma tabela já existe, use o método hasTable() :
if ( $ this -> db ()-> hasTable ( ' users ' ) ) {
// The "users" table exists
}Você também pode verificar várias tabelas ao mesmo tempo:
if ( $ this -> db ()-> hasTable ( [ ' users ' , ' addresses ' ] ) ) {
// The "users" and "addresses" tables exist
} O método hasTable() só retornará TRUE se todas as tabelas existirem.
Além de criar e acessar tabelas, o método table() do objeto esquema também pode ser usado para atualizar um esquema de tabela. Aceita o nome da tabela e um encerramento que receberá o objeto do esquema da tabela.
Vamos criar primeiro uma tabela chamada test incluindo três colunas:
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
$ table -> id ();
$ table -> string ( ' label ' );
$ table -> col ( ' status ' , ' tinyint ' )-> default ( 0 );
} );Agora, queremos atualizar a tabela em outra migração adicionando uma coluna de código e alterando o valor padrão da coluna de status existente:
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
$ table -> string ( ' code ' );
$ table -> col ( ' status ' , ' tinyint ' )-> default ( 1 );
} ); As alterações serão mantidas no banco de dados assim que o método table() retornar, portanto não há necessidade de chamar up() posteriormente. Para os tipos e opções de colunas disponíveis, consulte a seção de colunas.
O objeto de banco de dados retornado por $this->db() pode renomear tabelas ao usar o método renameTable() :
// Renames the table "users" to "accounts"
$ this -> db ()-> renameTable ( ' users ' , ' account ' );Também é possível renomear várias tabelas de uma vez se você passar um array associativo com nomes antigos e novos como pares chave/valor:
// Renames the table "users" to "accounts" and "blog" to "posts"
$ this -> db ()-> renameTable ( [ ' users ' => ' account ' , ' blog ' => ' posts ' ] );As tabelas só são renomeadas se existirem. Se uma tabela não existir mais, nenhum erro será relatado:
$ this -> db ()-> renameTable ( ' notexist ' , ' newtable ' );Nesse caso, a chamada do método será bem-sucedida, mas nada acontecerá.
Para remover uma tabela, você deve usar o método dropTable() do esquema do banco de dados:
$ this -> db ()-> dropTable ( ' users ' );Você também pode eliminar várias tabelas de uma vez, passando a lista como array:
$ this -> db ()-> dropTable ( [ ' users ' , ' addresses ' ] );As tabelas só são removidas se existirem. Se uma tabela não existir mais, nenhum erro será relatado:
$ this -> db ()-> dropTable ( ' notexist ' );Nesse caso, a chamada do método será bem-sucedida, mas nada acontecerá.
Chama métodos personalizados ou passa chamadas de métodos desconhecidos para o objeto da tabela Doctrine
public function __call( string $ method , array $ args )$method Nome do método$args Parâmetros do métodoExemplos:
Você pode registrar métodos customizados que tenham acesso às propriedades de classe do objeto Upscheme Table:
Aimeos Upscheme Schema Table:: macro ( ' addConstraint ' , function ( array $ columns ) {
return $ this -> to -> addUniqueConstraint ( $ columns );
} );
$ table -> addConstraint ( [ ' col1 ' , ' col2 ' ] );As propriedades de classe disponíveis são:
$this->table : Esquema da tabela Doctrine
$this->up : objeto Upscheme
Além disso, você pode chamar qualquer método de tabela do Doctrine diretamente, por exemplo:
$ table -> addUniqueConstraint ( [ ' col1 ' , ' col2 ' ] );Retorna o valor da opção de tabela fornecida
public function __get( string $ name )$name Nome da opção da tabelaA lista de opções de tabela disponíveis é:
Exemplos:
$ engine = $ table -> engine ;
// same as
$ engine = $ table -> opt ( ' engine ' );Define o novo valor para a opção de tabela fornecida
public function __set( string $ name , $ value )$name Nome da opção da tabelaA lista de opções de tabela disponíveis é:
Exemplos:
$ table -> engine = ' InnoDB ' ;
// same as
$ table -> opt ( ' engine ' , ' InnoDB ' );Cria uma nova coluna de ID do tipo "bigint" ou retorna a existente
public function bigid( string $ name = null ) : Column$name Nome da coluna IDA coluna recebe uma sequência (incremento automático) e uma chave primária atribuída automaticamente. Se a coluna ainda não existir, ela será criada.
Exemplos:
$ table -> bigid ();
$ table -> bigid ( ' uid ' );Cria uma nova coluna do tipo "bigint" ou retorna a existente
public function bigint( string $ name ) : Column$name Nome da colunaSe a coluna ainda não existir, ela será criada.
Exemplos:
$ table -> bigint ( ' testcol ' );Cria uma nova coluna do tipo "binário" ou retorna a existente
public function binary( string $ name , int $ length = 255 ) : Column$name Nome da coluna$length Comprimento da coluna em bytesSe a coluna ainda não existir, ela será criada.
Exemplos:
$ table -> binary ( ' testcol ' );
$ table -> binary ( ' testcol ' , 32 );Cria uma nova coluna do tipo "blob" ou retorna a existente
public function blob( string $ name , int $ length = 0x7fff ) : Column$name Nome da coluna$length Comprimento da coluna em bytesO comprimento máximo de uma coluna "blob" é 2GB. Se a coluna ainda não existir, ela será criada.
Exemplos:
$ table -> blob ( ' testcol ' );
$ table -> blob ( ' testcol ' , 0x7fffffff );Cria uma nova coluna do tipo "boolean" ou retorna a existente
public function bool( string $ name ) : Column$name Nome da colunaEste método é um alias para boolean(). Se a coluna ainda não existir, ela será criada.
Exemplos:
$ table -> bool ( ' testcol ' );Cria uma nova coluna do tipo "boolean" ou retorna a existente
public function boolean( string $ name ) : Column$name Nome da colunaSe a coluna ainda não existir, ela será criada.
Exemplos:
$ table -> boolean ( ' testcol ' );Cria uma nova coluna do tipo "char" com tipo fixo ou retorna a existente
public function char( string $ name , int $ length ) : Column$name Nome da coluna$length Comprimento da coluna em caracteresSe a coluna ainda não existir, ela será criada.
Exemplos:
$ table -> char ( ' testcol ' , 3 );Cria uma nova coluna ou retorna a existente
public function col( string $ name , string $ type = null ) : Column$name da coluna$type tipo da colunaSe a coluna ainda não existir, ela será criada.
Exemplos:
$ table -> col ( ' testcol ' );
$ table -> col ( ' testcol ' , ' tinyint ' );Cria uma nova coluna do tipo "data" ou retorna a existente
public function date( string $ name ) : Column$name da colunaSe a coluna ainda não existir, ela será criada.
Exemplos:
$ table -> date ( ' testcol ' );Cria uma nova coluna do tipo "DateTime" ou retorna a existente
public function datetime( string $ name ) : Column$name da colunaSe a coluna ainda não existir, ela será criada.
Exemplos:
$ table -> datetime ( ' testcol ' );Cria uma nova coluna do tipo "DateTimetz" ou retorna a existente
public function datetimetz( string $ name ) : Column$name da colunaSe a coluna ainda não existir, ela será criada.
Exemplos:
$ table -> datetimetz ( ' testcol ' );Cria uma nova coluna do tipo "decimal" ou retorna a existente
public function decimal( string $ name , int $ digits , int $ decimals = 2 ) : Column$name da coluna$digits Número total de dígitos decimais, incluindo decimais$decimals Número de dígitos após o ponto decimalSe a coluna ainda não existir, ela será criada.
Exemplos:
$ table -> decimal ( ' testcol ' , 10 ); // 10 digits incl . 2 decimals
$ table -> decimal ( ' testcol ' , 10 , 4 ); // 10 digits incl . 4 decimals Solta a coluna dada pelo seu nome se existir
public function dropColumn( $ name ) : self$name da coluna ou colunas Se a coluna ou uma das colunas não existir, ela será silenciosamente ignorada. A alteração não será aplicada até que a tarefa de migração termine ou up() seja chamada.
Exemplos:
$ table -> dropColumn ( ' testcol ' );
$ table -> dropColumn ( [ ' testcol ' , ' testcol2 ' ] );Solta o índice dado pelo seu nome se houver
public function dropIndex( $ name ) : self$name Nome do índice ou índices Se o índice ou um dos índices não existir, ele será silenciosamente ignorado. A alteração não será aplicada até que a tarefa de migração termine ou up() seja chamada.
Exemplos:
$ table -> dropIndex ( ' idx_test_col ' );
$ table -> dropIndex ( [ ' idx_test_col ' , ' idx_test_col2 ' ] );Solta a restrição de chave estrangeira dada pelo seu nome se existir
public function dropForeign( $ name ) : self$name Nome da restrição ou restrições de chave estrangeira Se a restrição de chave estrangeira ou uma das restrições não existir, ela será silenciosamente ignorada. A alteração não será aplicada até que a tarefa de migração termine ou up() seja chamada.
Exemplos:
$ table -> dropForeign ( ' fk_test_col ' );
$ table -> dropForeign ( [ ' fk_test_col ' , ' fk_test_col2 ' ] );Solta a chave primária se existir
public function dropPrimary() : self Se a chave primária não existir, ela será silenciosamente ignorada. A alteração não será aplicada até que a tarefa de migração termine ou up() seja chamada.
Exemplos:
$ table -> dropPrimary ();Cria uma nova coluna do tipo "Float" ou retorna a existente
public function float( string $ name ) : Column$name da colunaSe a coluna ainda não existir, ela será criada.
Exemplos:
$ table -> float ( ' testcol ' );Cria uma nova chave estrangeira ou retorna a existente
public function foreign( $ localcolumn , string $ foreigntable , $ foreigncolumn = ' id ' , string $ name = null ) : Foreign$localcolumn da coluna ou colunas locais$foreigntable da tabela referenciada$foreigncolumn da coluna ou colunas referenciadas$name nome da restrição de chave estrangeira e índice de chave estrangeira ou nulo para nome autogeneradoO comprimento do nome da chave estrangeira não deve ter mais de 30 caracteres para máxima compatibilidade.
Exemplos:
$ table -> foreign ( ' parentid ' , ' test ' );
$ table -> foreign ( ' parentid ' , ' test ' , ' uid ' );
$ table -> foreign ( ' parentid ' , ' test ' , ' id ' , ' fk_test_pid ' );
$ table -> foreign ( [ ' parentid ' , ' siteid ' ], ' test ' , [ ' uid ' , ' siteid ' ] );Cria uma nova coluna do tipo "Guid" ou retorna a existente
public function guid( string $ name ) : Column$name da colunaSe a coluna ainda não existir, ela será criada.
Exemplos:
$ table -> guid ( ' testcol ' );Verifica se a coluna existe
public function hasColumn( $ name ) : bool$name da coluna ou colunasExemplos:
$ table -> hasColumn ( ' testcol ' );
$ table -> hasColumn ( [ ' testcol ' , ' testcol2 ' ] );Verifica se o índice existe
public function hasIndex( $ name ) : bool$name Nome do índice ou índicesExemplos:
$ table -> hasIndex ( ' idx_test_col ' );
$ table -> hasIndex ( [ ' idx_test_col ' , ' idx_test_col2 ' ] );Verifica se a restrição de chave estrangeira existe
public function hasForeign( $ name ) : bool$name Nome da restrição ou restrições de chave estrangeiraExemplos:
$ table -> hasForeign ( ' fk_test_col ' );
$ table -> hasForeign ( [ ' fk_test_col ' , ' fk_test_col2 ' ] );Cria uma nova coluna de identificação do tipo "inteiro" ou retorna o existente
public function id( string $ name = null ) : Column$name nome da coluna IDA coluna obtém uma sequência (autoinncrement) e uma chave primária atribuída automaticamente. Se a coluna ainda não existir, ela será criada.
Exemplos:
$ table -> id ();
$ table -> id ( ' uid ' );Cria um novo índice ou substitui um existente
public function index( $ columns , string $ name = null ) : self$columns das colunas ou colunas desova pelo índice$name Nome Índice Nome ou nulo para nome autogeneradoO comprimento do nome do índice não deve ter mais de 30 caracteres para máxima compatibilidade.
Exemplos:
$ table -> index ( ' testcol ' );
$ table -> index ( [ ' testcol ' , ' testcol2 ' ] );
$ table ->index( ' testcol ' , 'idx_test_testcol );Cria uma nova coluna do tipo "inteiro" ou retorna o existente
public function int( string $ name ) : Column$name da colunaEste método é um alias para inteiro (). Se a coluna ainda não existir, ela será criada.
Exemplos:
$ table -> int ( ' testcol ' );Cria uma nova coluna do tipo "inteiro" ou retorna o existente
public function integer( string $ name ) : Column$name da colunaSe a coluna ainda não existir, ela será criada.
Exemplos:
$ table -> integer ( ' testcol ' );Cria uma nova coluna do tipo "json" ou retorna a existente
public function json( string $ name ) : Column$name da colunaSe a coluna ainda não existir, ela será criada.
Exemplos:
$ table -> json ( ' testcol ' );Retorna o nome da tabela
public function name() : stringExemplos:
$ tablename = $ table -> name ();Define uma opção de esquema personalizada ou retorna o valor atual
public function opt( string $ name , $ value = null )$name Nome da opção de esquema personalizado relacionado à tabela$value valor da opção de esquema personalizadoAs opções de esquema personalizado disponíveis são:
Exemplos:
$ charset = $ table -> opt ( ' charset ' );
$ table -> opt ( ' charset ' , ' utf8 ' )-> opt ( ' collation ' , ' utf8_bin ' );
// Magic methods :
$ charset = $ table -> charset ;
$ table -> charset = ' binary ' ;Cria um novo índice primário ou substitui um existente
public function primary( $ columns , string $ name = null ) : self$columns das colunas ou colunas desova pelo índice$name Nome Índice Nome ou nulo para nome autogeneradoO comprimento do nome do índice não deve ter mais de 30 caracteres para máxima compatibilidade.
Exemplos:
$ table -> primary ( ' testcol ' );
$ table -> primary ( [ ' testcol ' , ' testcol2 ' ] );
$ table -> primary ( ' testcol ' , ' pk_test_testcol ' );Renomeia uma coluna ou uma lista de colunas
public function renameColumn( $ from , string $ to = null ) : self$from nome da coluna ou matriz de nomes antigos/novos de colunas$to o novo nome da coluna ignorada se o primeiro parâmetro for uma matrizExemplos:
// single column
$ table -> renameColumn ( ' test_col ' , ' test_column ' );
// rename several columns at once
$ table -> renameColumn ( [ ' tcol ' => ' testcol ' , ' tcol2 ' => ' testcol2 ' ] );Renomeia um índice ou uma lista de índices
public function renameIndex( $ from , string $ to = null ) : self$from nome do índice ou matriz de nomes antigos/novos de índice (se o novo nome do índice for nulo, será gerado)$to novo nome de índice ou nulo para nome autogenerado (ignorado se o primeiro parâmetro for uma matriz)O comprimento do nome dos índices não deve ter mais de 30 caracteres para obter a máxima compatibilidade.
Exemplos:
// 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 ' ] );Cria uma nova coluna do tipo "smallint" ou retorna a existente
public function smallint( string $ name ) : Column$name da colunaSe a coluna ainda não existir, ela será criada.
Exemplos:
$ table -> smallint ( ' testcol ' );Cria um novo índice espacial ou substitui um existente
public function spatial( $ columns , string $ name = null ) : self$columns das colunas ou colunas que desovam o índice$name Nome Índice Nome ou nulo para nome autogeneradoO comprimento do nome do índice não deve ter mais de 30 caracteres para máxima compatibilidade.
Exemplos:
$ table -> spatial ( ' testcol ' );
$ table -> spatial ( [ ' testcol ' , ' testcol2 ' ] );
$ table -> spatial ( ' testcol ' , ' idx_test_testcol ' );Cria uma nova coluna do tipo "string" ou retorna a existente
public function string( string $ name , int $ length = 255 ) : Column$name da coluna$length da coluna em caracteresEste tipo deve ser usado para até 255 caracteres. Para mais caracteres, use o tipo "texto". Se a coluna ainda não existir, ela será criada.
Exemplos:
$ table -> string ( ' testcol ' );
$ table -> string ( ' testcol ' , 32 );Cria uma nova coluna do tipo "texto" ou retorna o existente
public function text( string $ name , int $ length = 0xffff ) : Column$name da coluna$length da coluna em caracteresO comprimento máximo de uma coluna "texto" é de 2 GB. Se a coluna ainda não existir, ela será criada.
Exemplos:
$ table -> text ( ' testcol ' );
$ table -> text ( ' testcol ' , 0x7fffffff );Cria uma nova coluna do tipo "tempo" ou retorna o existente
public function time( string $ name ) : Column$name da colunaSe a coluna ainda não existir, ela será criada. Esse tipo de dados não está disponível ao usar bancos de dados Oracle.
Exemplos:
$ table -> time ( ' testcol ' );Cria um novo índice exclusivo ou substitui um existente
public function unique( $ columns , string $ name = null ) : self$columns das colunas ou colunas que desovam o índice$name Nome Índice Nome ou nulo para nome autogeneradoO comprimento do nome do índice não deve ter mais de 30 caracteres para máxima compatibilidade.
Exemplos:
$ table -> unique ( ' testcol ' );
$ table -> unique ( [ ' testcol ' , ' testcol2 ' ] );
$ table -> unique ( ' testcol ' , ' unq_test_testcol ' );Cria uma nova coluna do tipo "Guid" ou retorna a existente
public function uuid( string $ name ) : Column$name da colunaEste método é um alias para Guid (). Se a coluna ainda não existir, ela será criada.
Exemplos:
$ table -> uuid ( ' testcol ' );Aplica as alterações no esquema do banco de dados
public function up() : selfExemplos:
$ table -> up (); O objeto de esquema da coluna que você recebe chamando col() em sua tarefa de migração fornece acesso a todas as propriedades da coluna. Também existem atalhos disponíveis para tipos de coluna suportados por todos os bancos de dados. Cada coluna pode ser alterada por um ou mais métodos modificadores e você também pode adicionar índices a colunas únicas, por exemplo:
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
$ table -> id ()-> unsigned ( true );
$ table -> string ( ' label ' )-> index ();
$ table -> col ( ' status ' , ' tinyint ' )-> default ( 0 );
} );O exemplo adicionará as seguintes colunas:
Existem alguns métodos de atalho para tipos de coluna disponíveis em todas as implementações do servidor de banco de dados:
| Tipo de coluna | Descrição |
|---|---|
| bigid | Coluna de bigint com uma sequência/autoinncrement e uma chave primária atribuída |
| bigint | Coluna Bigint com um intervalo de -9223372036854775808 a 92233720368547775807 |
| binário | Coluna varbinária com até 255 bytes |
| bolha | Coluna BLOB com até 2 GB |
| bool | Booleano/bit/número colum, alias para "booleano" |
| booleano | Booleano/bit/número colum para verdadeiro/falso resp. Valores 0/1 |
| personagem | Char coluna com um número fixo de caracteres |
| data | Data da coluna no formato de data da ISO ("AAAA-MM-DD) sem tempo e fuso horário |
| DateTime | Coluna DateTime no formato ISO DATE/HORA ("AAAA-MM-DD HH: MM: SS") |
| TablesdateTimetz | Coluna DATETIMETZ no formato ISO DATE/HIME, mas com formato variável de fuso horário |
| decimal | Coluna decimal para dados numéricos com precisão de ponto fixo (string em php) |
| flutuador | Coluna Float para dados numéricos com uma precisão de ponto flutuante de 8 bytes |
| guia | Identificador globalmente único com 36 bytes |
| eu ia | Coluna inteira com uma sequência/autoinncrement e uma chave primária atribuída |
| interno | Colum inteiro, pseudônimo para "inteiro" |
| Inteiro | Colum inteiro com um intervalo de -2147483648 a 2147483647 |
| json | Coluna JSON para UTF-8 codificados dados JSON |
| pequeno inteiro | Colum inteiro com um intervalo de -32768 a 32767 |
| corda | Coluna Varchar com até 255 caracteres |
| texto | Coluna de texto/clob com caracteres de até 2 GB |
| tempo | Coluna de tempo em 24 horas "hh: mm" deat, por exemplo, "05:30" ou "22:15" |
| uuid | Identificador globalmente único com 36 bytes, alias para "GUID" |
Para adicionar tipos de colunas específicos do banco de dados, use o método col() , por exemplo:
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
$ table -> col ( ' status ' , ' tinyint ' );
} );Também é possível alterar as definições de coluna chamando um ou mais métodos modificadores de coluna:
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
$ table -> int ( ' number ' )-> null ( true )-> unsigned ( true );
} );Os métodos de modificador de coluna disponíveis são:
| Modificador da coluna | Descrição |
|---|---|
| AutoinCrement (verdadeiro) | Defina colunas inteiras como incrementação automática (alias para seq() ) |
| charset ('utf8') | O conjunto de personagens usado pela coluna (MySQL) |
| Agrupamento ('Binário') | A coluna Agrupamento (MySQL/PostgreSQL/SQLITE/SQLSERVER, mas não é compatível) |
| Comentário ('Comentário') | Adicione um comentário a uma coluna (mysql/postgresql/oracle/sqlserver) |
| padrão (1) | Valor padrão da coluna Se nenhum valor foi especificado (padrão: NULL ) |
| fixo (verdadeiro) | Se a corda ou colunas binárias deveriam ter um comprimento fixo |
| índice ('idx_col') | Adicione um índice à coluna, o nome do índice é opcional |
| comprimento (32) | O máx. Comprimento das cordas e colunas binárias |
| nulo (verdadeiro) | Permitir que valores nulos sejam inseridos na coluna |
| Precisão (12) | O máx. Número de dígitos armazenados em colunas decimais e flutuantes incl. dígitos decimais |
| primário ('pk_col') | Adicione uma chave primária à coluna, o nome principal é opcional |
| Escala (2) | O número exato de dígitos decimais usados em colunas decimais e flutuantes |
| SEQ (verdadeiro) | Defina colunas inteiras como incrementação automática se nenhum valor foi especificado |
| espacial ('idx_col') | Adicione um índice espacial (GEO) à coluna, o nome do índice é opcional |
| exclusivo ('unq_col') | Adicione um índice exclusivo à coluna, o nome do índice é opcional |
| Não assinado (verdadeiro) | Permitir apenas valores inteiros não assinados (MySQL) |
Para definir opções de esquema personalizado para colunas, use o método opt() , por exemplo:
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
$ table -> string ( ' code ' )-> opt ( ' collation ' , ' utf8mb4 ' );
} );É até possível definir modificadores de coluna para uma implementação específica de banco de dados, passando o tipo de banco de dados como terceiro parâmetro:
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
$ table -> string ( ' code ' )-> opt ( ' collation ' , ' utf8mb4 ' , ' mysql ' );
} ); Para verificar se já existe uma coluna, use o método hasColumn() :
if ( $ this -> db ()-> hasColumn ( ' users ' , ' name ' ) ) {
// The "name" column in the "users" table exists
} Você também pode verificar várias colunas de uma só vez. Nesse caso, o método hasColumn() retornará apenas se todas as colunas existirem:
if ( $ this -> db ()-> hasColumn ( ' users ' , [ ' name ' , ' status ' ] ) ) {
// The "name" and "status" columns in the "users" table exists
} Se você já possui um objeto de tabela, também pode 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
}Além das colunas, você também pode verificar se os modificadores da coluna estão definidos e qual valor eles têm:
if ( $ table -> string ( ' code ' )-> null () ) {
// The "code" columns is nullable
}A recuperação dos valores atuais do modificador da coluna é possível usando estes métodos:
| Modificador da coluna | Descrição |
|---|---|
| AutoinCrement () | Verdadeiro se a coluna estiver incrementando automaticamente (alias para seq() ) |
| charset () | Conjunto de caracteres usado (MySQL) |
| agrupamento () | Utilizou agrupamento (mysql/postgreSql/sqlite/sqlserver, mas não compatível) |
| comentário() | Comentário associado à coluna (mysql/postgresql/oracle/sqlserver) |
| padrão() | Valor padrão da coluna |
| fixo() | Verdadeiro se a string ou coluna binária tiver um comprimento fixo |
| comprimento() | O comprimento máximo da corda ou coluna binária |
| nulo() | Verdadeiro se os valores nulos forem permitidos |
| precisão() | O número máximo de dígitos armazenados em colunas decimais e flutuantes incl. dígitos decimais |
| escala() | O número exato de dígitos decimais usados em colunas decimais e flutuantes |
| SEQ () | Verdadeiro se a coluna estiver incrementando automaticamente |
| não assinado () | Verdadeiro se apenas valores inteiros não assinados forem permitidos (MySQL) |
Para verificar modificadores de coluna fora do padrão, use o método opt() sem o segundo parâmetro. Em seguida, ele retornará o valor atual do modificador da coluna:
if ( $ table -> string ( ' code ' )-> opt ( ' charset ' ) === ' utf8 ' ) {
// The "code" columns uses UTF - 8 charset ( MySQL only)
}É possível alterar a maioria dos modificadores de coluna, como o comprimento de uma coluna de string:
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
$ table -> string ( ' code ' )-> length ( 64 );
} );Alguns métodos também oferecem parâmetros adicionais para definir modificadores mais frequentemente usados diretamente:
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
$ table -> string ( ' code ' , 64 );
} ); Se você precisar alterar os modificadores da coluna imediatamente porque deseja migrar as linhas depois, use o método up() para persistir as alterações:
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
$ table -> string ( ' code ' , 64 )-> null ( true )-> up ();
// modify rows from "test" table
} ); Alterar o tipo de coluna é possível usando o novo método para o tipo apropriado ou o método col() :
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
$ table -> text ( ' code ' );
// or
$ table -> col ( ' code ' , ' text ' );
} );Esteja ciente de que nem todos os tipos de colunas podem ser alterados para outro tipo ou pelo menos não sem perda de dados. Você pode alterar uma coluna inteira para uma coluna Bigint sem problemas, mas o contrário será falhado. O mesmo acontece se você deseja alterar uma coluna VARCHAR (String) em uma coluna inteira.
Para renomear colunas, use o método renameColumn() do esquema de banco de dados:
// single column
$ this -> db ()-> renameColumn ( ' testtable ' , ' label ' , ' name ' );
// multiple columns
$ this -> db ()-> renameColumn ( ' testtable ' , [ ' label ' => ' name ' , ' stat ' => ' status ' ] ); Se um objeto de tabela já estiver disponível, você poderá usar o método renameColumn() para renomear uma ou mais colunas:
$ this -> db ()-> table ( ' testtable ' , function ( $ table ) {
// single column
$ table -> renameColumn ( ' label ' , ' name ' );
// multiple columns
$ table -> renameColumn ( [ ' label ' => ' name ' , ' stat ' => ' status ' ] );
} );Em todos os casos, as colunas são removidas apenas se existirem. Nenhum erro é relatado se uma ou mais colunas não existirem na tabela.
Para soltar as colunas, use o método dropColumn() do objeto de esquema DB:
$ this -> db ()-> dropColumn ( ' users ' , ' name ' );Você pode soltar várias colunas de uma só vez se passar o nome de todas as colunas que deseja cair como matriz:
$ this -> db ()-> dropColumn ( ' users ' , [ ' name ' , ' status ' ] ); Se você já possui um objeto de tabela, também pode usar dropColumn() :
// single column
$ table -> dropColumn ( ' name ' );
// multiple columns
$ table -> dropColumn ( [ ' name ' , ' status ' ] );Em todos os casos, as colunas são removidas apenas se existirem. Nenhum erro é relatado se uma ou mais colunas não existirem na tabela.
Chama métodos personalizados ou passa chamadas de método desconhecido para o objeto de coluna da doutrina
public function __call( string $ method , array $ args )$method do método$args Método parâmetrosExemplos:
Você pode registrar métodos personalizados que têm acesso às propriedades da classe do objeto Upscheme Column:
Aimeos Upscheme Schema Column:: macro ( ' platform ' , function ( array $ options ) {
return $ this -> to -> setPlatformOptions ( $ options );
} );
$ column -> platform ( [ ' option ' => ' value ' ] );As propriedades de classe disponíveis são:
$this->db : upscheme db objeto
$this->table : esquema de tabela de doutrina
$this->column : esquema de coluna da doutrina
Além disso, você pode chamar qualquer método de coluna de doutrina diretamente, por exemplo:
$ column -> setPlatformOptions ( [ ' option ' => ' value ' ] );Retorna o valor da opção de coluna especificada
public function __get( string $ name )$name da coluna Nome da opçãoA lista de opções de coluna disponíveis são:
Exemplos:
$ charset = $ column -> charset ;
// same as
$ charset = $ column -> opt ( ' charset ' );Define o novo valor para a opção de coluna fornecida
public function __set( string $ name , $ value )$name da coluna Nome da opção$value da coluna Valor da colunaA lista de opções de coluna disponíveis são:
Exemplos:
$ column -> charset = ' utf8 ' ;
// same as
$ column -> opt ( ' charset ' , ' utf8 ' );Define a coluna como autoinncrement ou retorna o valor atual
public function autoincrement( bool $ value = null )$value novo sinalizador de auto -increment ou nulo para retornar o valor atual Este método é um alias para o método seq() .
Exemplos:
$ value = $ column -> autoincrement ();
$ column -> autoincrement ( true );Define o charset da coluna ou retorna o valor atual
public function charset( string $ value = null )$value New Column Charset ou NULL para retornar o valor atualExemplos:
$ comment = $ column -> charset ();
$ column -> charset ( ' utf8 ' );Define o agrupamento da coluna ou retorna o valor atual
public function collation( string $ value = null )$value Novo agrupamento ou nulo para retornar o valor atualExemplos:
$ comment = $ column -> collation ();
$ column -> collation ( ' binary ' );Define o comentário da coluna ou retorna o valor atual
public function comment( string $ value = null )$value novo comentário ou nulo para retornar o valor atualExemplos:
$ comment = $ column -> comment ();
$ column -> comment ( ' column comment ' );Define o valor padrão da coluna ou retorna o valor atual
public function default( $ value = null )$value novo valor padrão da coluna ou nulo para retornar o valor atualExemplos:
$ value = $ column -> default ();
$ column -> default ( 0 );Define a coluna bandeira fixa ou retorna o valor atual
public function fixed( bool $ value = null )$value nova coluna sinalizador fixo ou nulo para retornar o valor atualExemplos:
$ value = $ column -> fixed ();
$ column -> fixed ( true );Cria um índice regular para a coluna
public function index( string $ name = null ) : self$name nome do índice ou nulo para gerar automaticamenteExemplos:
$ column -> index ();
$ column -> index ( ' idx_col ' );Define o comprimento da coluna ou retorna o valor atual
public function length( int $ value = null )$value novo comprimento da coluna ou nulo para retornar o valor atualExemplos:
$ value = $ column -> length ();
$ column -> length ( 32 );Retorna o nome da coluna
public function name() : stringExemplos:
$ name = $ column -> name ();Define a bandeira nula da coluna ou retorna o valor atual
public function null( bool $ value = null )$value novo coluna sinalizador nulo ou nulo para retornar o valor atualExemplos:
$ value = $ column -> null ();
$ column -> null ( true );Define o valor da opção da coluna ou retorna o valor atual
public function opt( string $ option , $ value = null , $ for = null )$option coluna Nome da opção$value novo valor de opção ou nulo para retornar o valor atual$for tipo de banco de dados Esta opção deve ser usada para ("mysql", "mariadb", "postgresql", "sqlite", "sqlserver", "oracle", "db2")Exemplos:
$ value = $ column -> opt ( ' length ' );
$ column -> opt ( ' length ' , 64 );Define a precisão da coluna ou retorna o valor atual
public function precision( int $ value = null )$value novo valor de precisão da coluna ou nulo para retornar o valor atualExemplos:
$ value = $ column -> precision ();
$ column -> precision ( 10 );Cria um índice primário para a coluna
public function primary( string $ name = null ) : self$name nome do índice ou nulo para gerar automaticamenteExemplos:
$ column -> primary ();
$ column -> primary ( ' pk_col ' );Define a escala da coluna ou retorna o valor atual
public function scale( int $ value = null )$value novo valor escala de coluna ou nulo para retornar o valor atualExemplos:
$ value = $ column -> scale ();
$ column -> scale ( 3 );Define a coluna como autoinncrement ou retorna o valor atual
public function seq( bool $ value = null )$value novo sinalizador de auto -increment ou nulo para retornar o valor atualExemplos:
$ value = $ column -> seq ();
$ column -> seq ( true );Cria um índice espacial para a coluna
public function spatial( string $ name = null ) : self$name nome do índice ou nulo para gerar automaticamenteExemplos:
$ column -> spatial ();
$ column -> spatial ( ' idx_col ' );Define o tipo de coluna ou retorna o valor atual
public function type( string $ value = null )$valueExemplos:
$ value = $ column -> type ();
$ column -> type ( ' tinyint ' );Cria um índice único para a coluna
public function unique( string $ name = null ) : self$name nome do índice ou nulo para gerar automaticamenteExemplos:
$ column -> unique ();
$ column -> unique ( ' unq_col ' );Define a bandeira não assinada da coluna ou retorna o valor atual
public function unsigned( bool $ value = null )$value nova coluna bandeira ou nulo para retornar o valor atualExemplos:
$ value = $ column -> unsigned ();
$ column -> unsigned ( true );Aplica as alterações no esquema do banco de dados
public function up() : selfExemplos:
$ column -> up (); O Upscheme oferece suporte para restrições de chave estrangeira, que reforçam a integridade dos dados entre duas tabelas. Por exemplo, se a coluna parentid da tabela de users_address faz referência à coluna id da tabela users , não poderá haver linhas na tabela de users_address sem uma linha correspondente na tabela users . Chamar o método foreign() criará essa restrição:
$ this -> db ()-> table ( ' users ' , function ( $ table ) {
$ table -> id ();
} );
$ this -> db ()-> table ( ' users_address ' , function ( $ table ) {
$ table -> foreign ( ' parentid ' , ' users ' );
} ); NOTA: A coluna ( parentid ) terá e deve ter o mesmo tipo de dados e modificadores de coluna que a coluna ( id ) referenciada. O método foreign() garante que e criará um novo índice com o mesmo nome que a restrição de chave estrangeira automaticamente.
Se a coluna ID na tabela users for nomeada de maneira diferente, passe seu nome como terceiro parâmetro para o método foreign() :
$ this -> db ()-> table ( ' users_address ' , function ( $ table ) {
$ table -> foreign ( ' parentid ' , ' users ' , ' uid ' );
} );Recomenda -se passar o nome da restrição de chave estrangeira como parâmetro, para que seja mais fácil alterar ou soltar restrições mais tarde:
$ this -> db ()-> table ( ' users_address ' , function ( $ table ) {
$ table -> foreign ( ' parentid ' , ' users ' , ' id ' , ' fk_test_pid ' );
} );Caso haja mais de uma coluna necessária para obter os valores exclusivos exigidos pelas chaves estrangeiras, passe os nomes das colunas como matriz:
$ this -> db ()-> table ( ' users_address ' , function ( $ table ) {
$ table -> foreign ( [ ' parentid ' , ' siteid ' ], ' users_address ' , [ ' id ' , ' siteid ' ] );
} ); As restrições de chave estrangeira podem executar ações diferentes se a coluna referenciada na tabela estrangeira for excluída do Atualizado. A ação padrão é restringir a exclusão da linha ou a atualização do valor de ID referenciado. Para alterar o comportamento, use os métodos onDelete() e onUpdate() :
$ this -> db ()-> table ( ' users_address ' , function ( $ table ) {
$ table -> foreign ( ' parentid ' , ' users ' )-> onDelete ( ' SET NULL ' )-> onUpdate ( ' RESTRICT ' );
} );Há um atalho se você deseja definir os dois valores para o mesmo valor:
$ this -> db ()-> table ( ' users_address ' , function ( $ table ) {
$ table -> foreign ( ' parentid ' , ' users ' )-> do ( ' SET NULL ' );
} );Valores possíveis para ambos os métodos são:
A ação padrão ao excluir ou atualizar linhas é em cascata, de modo que os valores da coluna de chave estrangeira são atualizados para os mesmos valores da tabela estranha.
Para verificar se já existe uma chave estrangeira, use o método hasForeign() :
if ( $ this -> db ()-> hasForeign ( ' users_address ' , ' fk_usrad_parentid ' ) ) {
// The "fk_usrad_parentid" foreign key in the " users_address " table exists
} Também é possível verificar várias restrições de chave estrangeira de uma só vez. Então, o método hasForeign() retornará apenas se todas as restrições existirem nas tabelas aprovadas como primeiro 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
} Se um objeto de tabela disponível, o método hasForeign() da tabela poderá ser usado:
$ 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
}
} );Caso você precise dos valores atuais de uma restrição 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 remover uma restrição de chave estrangeira de uma tabela, use o método dropForeign() e passe o nome da tabela e o nome da chave estrangeira como argumentos:
$ this -> db ()-> dropForeign ( ' users_address ' , ' fk_usrad_parentid ' );Você também pode passar vários nomes de chave estrangeiros para soltá -los de uma só vez:
$ this -> db ()-> dropForeign ( ' users_address ' , [ ' fk_usrad_parentid ' , ' fk_usrad_siteid ' ] ); Dentro da função anônima passada para o método table() , você também pode usar o 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 ' ] );
} );Chama métodos personalizados
public function __call( string $ method , array $ args )$method do método$args Método parâmetrosExemplos:
Você pode registrar métodos personalizados que têm acesso às propriedades da classe do objeto estranho upscheme:
Aimeos Upscheme Schema Foreign:: macro ( ' default ' , function () {
$ this -> opts = [ ' onDelete ' => ' SET NULL ' , ' onUpdate ' => ' SET NULL ' ];
} );
$ foreign -> default ();As propriedades de classe disponíveis são:
$this->dbaltable : esquema de tabela de doutrina
$this->table : upscheme tabela objeto
$this->localcol : Nome ou nomes da coluna local
$this->fktable : nome da tabela estranha
$this->fkcol : nome ou nomes da coluna estrangeira
$this->name : Nome da chave estrangeira
$this->opts : Lista associativa de opções de chave estrangeira (principalmente "ondelete" e "OnUpdate")
Retorna o valor da opção de chave estrangeira dada
public function __get( string $ name )$name Nome da opção de chave estrangeiraA lista de opções de chave estrangeira disponíveis são:
Valores possíveis para ambas as opções são:
Exemplos:
$ value = $ foreign -> onDelete ;
// same as
$ value = $ foreign -> opt ( ' onDelete ' );Define o novo valor para a opção de chave estrangeira fornecida
public function __set( string $ name , $ value )$name Nome da opção de chave estrangeiraA lista de opções de chave estrangeira disponíveis são:
Valores possíveis para ambas as opções são:
Exemplos:
$ foreign -> onDelete = ' SET NULL ' ;
// same as
$ foreign -> onDelete ( ' SET NULL ' );
$ foreign -> opt ( ' onDelete ' , ' SET NULL ' );Define o novo valor para a opção de chave estrangeira fornecida
public function do( string $ action ) : self$action executada açãoAs ações possíveis são:
Exemplos:
$ foreign -> do ( ' RESTRICT ' ); public function name()Exemplos:
$ fkname = $ foreign -> name (); public function onDelete( string $ value = null ) @param string | $value Ação executada ou nulo para retornar o valor atual
@return self | string o mesmo objeto para definir o valor, valor atual sem parâmetro
As ações disponíveis são:
Exemplos:
$ 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 | $value Ação executada ou nulo para retornar o valor atual
@return self | string o mesmo objeto para definir o valor, valor atual sem parâmetro
As ações disponíveis são:
Exemplos:
$ 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() : selfExemplos:
$ foreign -> up (); Algumas implementações de banco de dados oferecem seqüências em vez de colunas de incrementação/identidade automáticas, nomeadamente Oracle e PostgreSQL. As seqüências são funções que criam números sequencialmente crescentes que são aplicados a uma coluna de tabela ao inserir novas linhas. Para criar uma nova sequência chamada seq_test, use o método sequence() :
$ this -> db ()-> sequence ( ' seq_test ' ); Para usar um valor de inicialização diferente e a largura da etapa de 1 , ligue para os métodos start() e step() :
$ this -> db ()-> sequence ( ' seq_test ' , function ( $ seq ) {
$ seq -> start ( 1000 )-> step ( 2 );
} ); Para verificar se já existe uma sequência, use o método hasSequence() :
if ( $ this -> db ()-> hasSequence ( ' seq_test ' ) ) {
// The "seq_test" sequence exists
} Também é possível verificar várias sequências de uma só vez. Então, o método hasSequence() retornará apenas se todas as seqüências existirem:
if ( $ this -> db ()-> hasSequence ( [ ' seq_id ' , ' seq_test ' ] ) ) {
// The "seq_id" and "seq_test" sequences exist
}Caso você precise conhecer os valores atuais das opções da tabela:
$ 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 remover uma sequência, use o método dropSequence() e passe o nome da sequência como argumento:
$ this -> db ()-> dropSequence ( ' seq_id ' );Você também pode passar vários nomes de sequência para soltá -los de uma só vez:
$ this -> db ()-> dropSequence ( [ ' seq_id ' , ' seq_test ' ] );Chama métodos personalizados ou passa as chamadas de método desconhecido para o objeto da tabela de doutrina
public function __call( string $ method , array $ args )$method do método$args Método parâmetrosExemplos:
Você pode registrar métodos personalizados que têm acesso às propriedades da classe do objeto Upscheme Sequence:
Aimeos Upscheme Schema Sequence:: macro ( ' default ' , function () {
$ this -> start ( 1 )-> step ( 2 );
} );
$ sequence -> default ();As propriedades de classe disponíveis são:
$this->db : upscheme db objeto
$this->sequence : esquema de sequência de doutrina
Retorna o valor da opção de sequência fornecida
public function __get( string $ name )$name Sequência Nome da opçãoExemplos:
$ value = $ sequence -> getInitialValue ();
// same as
$ value = $ sequence -> start ();Define o novo valor para a opção de sequência fornecida
public function __set( string $ name , $ value )$name Sequência Nome da opçãoExemplos:
$ value = $ sequence -> setInitialValue ( 1000 );
// same as
$ value = $ sequence -> start ( 1000 );Define o tamanho em cache da sequência ou retorna o valor atual
public function cache( int $ value = null )$value novo número de IDs de sequência em cache pelo cliente ou nulo para retornar o valor atualExemplos:
$ value = $ sequence -> cache ();
$ sequence -> cache ( 100 );Retorna o nome da sequência
public function name() $ name = $ sequence -> name ();Define o novo valor inicial da sequência ou retorna o valor atual
public function start( int $ value = null )$value novo valor inicial da sequência ou nulo para retornar o valor atual $ value = $ sequence -> start ();
$ sequence -> start ( 1000 );Define o tamanho da etapa dos novos valores de sequência ou retorna o valor atual
public function step( int $ value = null )$value novo tamanho de etapa A sequência é incrementada ou decrementada por ou nulo para retornar o valor atual $ value = $ sequence -> step ();
$ sequence -> step ( 2 );Aplica as alterações no esquema do banco de dados
public function up() : self $ sequence -> up ();Os índices aceleram consultas de banco de dados e o tempo que uma consulta precisa cair de vários minutos para milissegundos, se usada corretamente. Existem vários tipos de índice disponíveis:
Todos os índices podem consistir em uma ou mais colunas, mas a ordem das colunas tem um grande impacto se os índices forem usados para uma consulta ou não.
Todos os índices estão ligados à tabela que contém as colunas que o índice cobre. A maneira mais simples de criar um índice em uma única coluna é usar o método index() do objeto de coluna:
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
$ table -> string ( ' label ' )-> index ();
} ); O segundo parâmetro do método index() permite definir um nome personalizado para o índice:
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
$ table -> string ( ' label ' )-> index ( ' idx_test_label ' );
} );Nota: Para uma compatibilidade máxima entre diferentes tipos de banco de dados, o comprimento dos nomes dos índices deve ser de 30 caracteres ou menos.
O mesmo é possível para índices primários, únicos e espaciais:
$ 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 índices de várias colunas, os métodos primary() , unique() e index() estão disponíveis no objeto da tabela:
$ 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 ' ] );
} ); Os índices espaciais não podem abranger várias colunas, mas criar -as também é possível usando o método spatial() do objeto de tabela:
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
$ table -> spatial ( ' location ' );
} ); Para verificar se já existe um índice, use o método hasIndex() :
if ( $ this -> db ()-> hasIndex ( ' users ' , ' idx_users_name ' ) ) {
// The "idx_users_name" index in the "users" table exists
} You can check for several indexes at once too. In that case, the hasIndex() method will only return TRUE if all indexes exist:
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
} If you already have a table object, you can use hasIndex() as well:
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
