upscheme
1.0.0
Einfach zu verwendendes PHP-Paket zum Aktualisieren des Datenbankschemas Ihrer Anwendung und zum Migrieren von Daten zwischen Versionen.
composer req aimeos/upschemeInhaltsverzeichnis
Migrationen sind wie eine Versionskontrolle für Ihre Datenbank. Sie ermöglichen es Ihnen, bei jeder Installation den exakt gleichen Zustand zu erreichen. Mit Upscheme erhalten Sie:
Hier ist ein Beispiel für eine Tabellendefinition, die Sie anpassen können, wenn sich Ihr Tabellenlayout ändern muss. Anschließend fügt Upscheme automatisch vorhandene Spalten und Tabelleneigenschaften hinzu und ändert diese (löscht jedoch aus Sicherheitsgründen nichts):
$ 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 ' ] );
} );Zur Aktualisierung relationaler Datenbankschemata werden derzeit am häufigsten zwei Pakete verwendet: Doctrine DBAL und Doctrine migrations. Während Doctrine DBAL die Unterschiede verschiedener Datenbankimplementierungen gut abstrahiert, erfordert seine API das Schreiben einer Menge Code. Doctrine-Migrationen auf der anderen Website weisen einige Nachteile auf, die die Verwendung in allen Anwendungen erschweren, die Erweiterungen von Drittanbietern unterstützen.
Die API von DBAL ist sehr ausführlich und Sie müssen selbst für einfache Dinge viel Code schreiben. Upscheme verwendet Doctrine DBAL, um eine benutzerfreundliche API zum Aktualisieren des Datenbankschemas Ihrer Anwendung mit minimalem Code bereitzustellen. Für das Upscheme-Beispiel oben sind diese Codezeilen das Äquivalent für DBAL in einer Migration:
$ dbalManager = $ conn -> createSchemaManager ();
$ from = $ manager -> createSchema ();
$ to = $ manager -> createSchema ();
if ( $ to -> hasTable ( ' test ' ) ) {
$ table = $ to -> getTable ( ' test ' );
} else {
$ table = $ to -> createTable ( ' test ' );
}
$ table -> addOption ( ' engine ' , ' InnoDB ' );
$ table -> addColumn ( ' id ' , ' integer ' , [ ' autoincrement ' => true ] );
$ table -> addColumn ( ' domain ' , ' string ' , [ ' length ' => 32 ] );
$ platform = $ conn -> getDatabasePlatform ();
if ( $ platform instanceof Doctrine DBAL Platform MySQLPlatform
|| $ platform instanceof Doctrine DBAL Platform MariaDBPlatform
) {
$ table -> addColumn ( ' code ' , ' string ' , [ ' length ' => 64 , ' customSchemaOptions ' => [ ' charset ' => ' binary ' ]] );
} else {
$ table -> addColumn ( ' code ' , ' string ' , [ ' length ' => 64 ]] );
}
$ table -> addColumn ( ' label ' , ' string ' , [ ' length ' => 255 ] );
$ table -> addColumn ( ' pos ' , ' integer ' , [ ' default ' => 0 ] );
$ table -> addColumn ( ' status ' , ' smallint ' , [] );
$ table -> addColumn ( ' mtime ' , ' datetime ' , [] );
$ table -> addColumn ( ' ctime ' , ' datetime ' , [] );
$ table -> addColumn ( ' editor ' , ' string ' , [ ' length ' => 255 ] );
$ table -> setPrimaryKey ( [ ' id ' ] );
$ table -> addUniqueIndex ( [ ' domain ' , ' code ' ] );
$ table -> addIndex ( [ ' status ' , ' pos ' ] );
foreach ( $ from -> getMigrateToSql ( $ to , $ conn -> getDatabasePlatform () ) as $ sql ) {
$ conn -> executeStatement ( $ sql );
}Doctrine Migration basiert auf Migrationsklassen, die nach dem Zeitpunkt ihrer Erstellung benannt werden, um eine bestimmte Reihenfolge sicherzustellen. Darüber hinaus speichert es in einer Tabelle Ihrer Datenbank, welche Migrationen durchgeführt wurden. Daraus ergeben sich drei große Probleme:
down() Wenn Ihre Anwendung Erweiterungen von Drittanbietern unterstützt, fügen diese Erweiterungen wahrscheinlich Spalten zu vorhandenen Tabellen hinzu und migrieren Daten selbst. Da es keine Möglichkeit gibt, Abhängigkeiten zwischen Migrationen zu definieren, kann es nahezu unmöglich werden, Migrationen in einer Anwendung mit mehreren Erweiterungen von Drittanbietern ohne Konflikte auszuführen. Um dies zu vermeiden, bietet Upscheme in jeder Migrationsaufgabe einfach zu verwendende before() und after() Methoden an, mit denen die Aufgaben ihre Abhängigkeiten zu anderen Aufgaben definieren können.
Da Doctrine Migrations eine Datenbanktabelle verwendet, um aufzuzeichnen, welche Migration bereits ausgeführt wurde, können diese Datensätze bei Problemen leicht aus der Synchronisierung geraten. Im Gegensatz dazu verlässt sich Upscheme nur auf das tatsächliche Schema, sodass ein Upgrade von jedem Status aus möglich ist, unabhängig davon, was zuvor passiert ist.
Doctrine Migrations unterstützt auch die umgekehrten Operationen in down() -Methoden, sodass Sie Migrationen rückgängig machen können, was bei Upscheme nicht der Fall ist. Die Erfahrung hat gezeigt, dass es oft unmöglich ist, Migrationen rückgängig zu machen, z. B. nach dem Hinzufügen einer neuen Spalte, der Migration der Daten einer vorhandenen Spalte und dem anschließenden Löschen der alten Spalte. Wenn die Migration der Daten verlustbehaftet war, können Sie denselben Status nicht in einer down() -Methode wiederherstellen. Das Gleiche gilt, wenn Sie einen Tisch fallen gelassen haben. Daher bietet Upscheme nur ein Schema-Upgrade, aber kein Downgrade an, um impliziten Datenverlust zu vermeiden.
Upscheme verwendet Doctrine DBAL zum Abstrahieren von verschiedenen Datenbankserverimplementierungen. DBAL unterstützt alle wichtigen relationalen Datenbankverwaltungssysteme (RDBMS), jedoch mit unterschiedlichem Unterstützungsgrad für die verfügbaren Funktionen:
Gute Unterstützung:
Eingeschränkter Support:
Nachdem Sie das Paket aimeos/upscheme mit Composer installiert haben, können Sie die Up -Klasse verwenden, um Ihre Migrationsaufgaben auszuführen:
$ config = [
' driver ' => ' pdo_mysql ' ,
' host ' => ' 127.0.0.1 ' ,
' dbname ' => ' <database> ' ,
' user ' => ' <dbuser> ' ,
' password ' => ' <secret> '
];
Aimeos Upscheme Up:: use ( $ config , ' src/migrations ' )-> up (); Die Up::use() Methode erfordert zwei Parameter: Die Datenbankkonfiguration und den/die Pfad(e) zu den Migrationsaufgaben. Für die Konfiguration müssen die Array-Schlüssel und die Werte für Treiber von Doctrine DBAL unterstützt werden. Verfügbare Treiber sind:
Einige Datenbanken erfordern unterschiedliche Parameter, insbesondere SQLite und Oracle:
SQLite:
$ config = [
' driver ' => ' pdo_sqlite ' ,
' path ' => ' path/to/file.sq3 '
];Orakel:
$ 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> '
];Wenn Sie Doctrine DBAL noch nicht verwendet haben, hat Ihre Datenbankkonfiguration möglicherweise eine andere Struktur und/oder verwendet andere Werte für den Datenbanktyp. Mit Upscheme können Sie eine benutzerdefinierte Methode registrieren, die Ihre Konfiguration in gültige DBAL-Einstellungen umwandelt, z. B.:
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 unterstützt auch mehrere Datenbankverbindungen, die Sie anhand ihres Schlüsselnamens unterscheiden können:
$ 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 (); Natürlich können Sie auch mehrere Migrationspfade an die Up -Klasse übergeben:
Aimeos Upscheme Up:: use ( $ config , [ ' src/migrations ' , ' ext/migrations ' ] )-> up ();Um die Ausgabe (Debugging) zu aktivieren, verwenden Sie die Methode 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 Eine Migrationsaufgabe erfordert lediglich die Implementierung der up() Methode und muss in einem der an die Up -Klasse übergebenen Verzeichnisse gespeichert werden:
<?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 ' );
} );
}
}; Fügen Sie in Ihre PHP-Datei immer zuerst die namespace Anweisung ein. Die use -Anweisung ist optional und wird nur als Abkürzung für den Typhinweis für das Argument der Abschlussfunktion benötigt. Ihre Klasse muss außerdem die Task-Klasse „Base“ erweitern oder die Task-Schnittstelle „Iface“ implementieren.
Alternativ zu anonymen Klassen können Sie benannte Klassen für Migrationsaufgaben verwenden:
<?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 ' );
} );
}
} Die Datei, in der Ihre Klasse gespeichert ist, muss denselben Namen (Groß-/Kleinschreibung beachten) wie die Klasse selbst und das Suffix .php haben, z. B.:
class TestTable -> TestTable.php
Es gibt keine strenge Konvention für die Benennung von Migrationsaufgabendateien. Sie können sie entweder nach dem benennen, was sie tun (z. B. „CreateTestTable.php“), was sie bearbeiten (z. B. „TestTable.php“) oder sogar einen Zeitstempel verwenden (z. B. „20201231_Test.php“).
Wenn die Aufgaben keine Abhängigkeiten enthalten, werden sie in alphabetischer Reihenfolge nach dem Dateinamen sortiert und ausgeführt. Die Sortierung wäre:
20201231_Test.php
CreateTestTable.php
TestTable.php
Um Abhängigkeiten zu anderen Migrationsaufgaben anzugeben, verwenden Sie die Methoden after() und before() . Ihre Aufgabe wird nach den von after() zurückgegebenen Aufgaben und vor den von before() zurückgegebenen Aufgaben ausgeführt:
return new class ( $ this ) extends Base {
public function after () : array
{
return [ ' CreateRefTable ' ];
}
public function before () : array
{
return [ ' InsertTestData ' ];
}
} Die Aufgabennamen sind die Dateinamen der Aufgaben ohne das Suffix .php . Wenn die Beispielmigration in der Datei TestTable.php gespeichert ist, wäre die Reihenfolge der Ausführung:
CreateRefTable.php -> TestTable.php -> InsertTestData.php
Um Nachrichten in Ihrer Migrationsaufgabe auszugeben, verwenden Sie die Methode info() :
$ this -> info ( ' some message ' );
$ this -> info ( ' more verbose message ' , ' vv ' );
$ this -> info ( ' very verbose debug message ' , ' vvv ' ); Der zweite Parameter ist die Ausführlichkeitsstufe und „keine“ oder v sind Standardmeldungen, vv sind Meldungen, die nur angezeigt werden, wenn mehr Ausführlichkeit gewünscht ist, während vvv für Debug-Meldungen gedacht ist. Es gibt auch einen dritten Parameter zum Einrücken der Nachrichten:
$ this -> info ( ' some message ' );
$ this -> info ( ' second level message ' , ' v ' , 1 );
$ this -> info ( ' third level message ' , ' v ' , 2 );Folgendes wird angezeigt:
some message
second level message
third level message
Voraussetzung ist, dass die verbose() -Methode der Up -Klasse zuvor aufgerufen wurde:
Aimeos Upscheme Up:: use ( $ config , ' ... ' )-> verbose ()-> up (); In der Methode up() haben Sie über die Methode db() Zugriff auf das Datenbankschema. Falls Sie mehr als eine Datenbankkonfiguration an Up::use() übergeben haben, können Sie über ihren Konfigurationsschlüssel auf die verschiedenen Schemas zugreifen:
// $config = [ 'db' => [ ... ] , 'temp' => [ ... ] ] ;
// Aimeos UpschemeUp::use( $config , '...' )->up() ;
$ this -> db ();
$ this -> db ( ' db ' );
$ this -> db ( ' temp ' ); Wenn Sie keinen oder einen nicht vorhandenen Konfigurationsschlüssel übergeben, wird die erste Konfiguration zurückgegeben (in diesem Fall „db“). Mithilfe der verfügbaren Methoden des Datenbankschemaobjekts können Sie Tabellen, Spalten, Indizes und andere Datenbankobjekte hinzufügen, aktualisieren oder löschen. Außerdem können Sie insert() , select() , update() , delete() und stmt() verwenden, um die Datensätze der Tabellen zu manipulieren.
Nach jeder Migrationsaufgabe werden die in der Aufgabe vorgenommenen Schemaaktualisierungen automatisch auf die Datenbank angewendet. Wenn Sie eine Änderung sofort beibehalten müssen, weil Sie Daten einfügen möchten, rufen Sie $this->db()->up() selbst auf. Die Methode up() ist auch in allen Tabellen-, Sequenz- und Spaltenobjekten verfügbar, sodass Sie up() überall aufrufen können.
In Fällen, in denen Sie zwei verschiedene Datenbankverbindungen benötigen, weil Sie SELECT- und INSERT/UPDATE/DELETE-Anweisungen gleichzeitig ausführen möchten, übergeben Sie TRUE als zweiten Parameter an db() um das Datenbankschema einschließlich einer neuen Verbindung zu erhalten:
$ 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 ] ); Alle vorgenommenen Schemaänderungen werden auf die Datenbank angewendet, bevor das Schema mit der neuen Verbindung zurückgegeben wird. Um zu vermeiden, dass sich Datenbankverbindungen anhäufen, bis der Datenbankserver neue Verbindungen ablehnt, rufen Sie immer close() für neue Verbindungen auf, die von db( '<name>', true ) erstellt wurden:
$ db2 -> close ();Anstatt Migrationen für Ihre Datenbankobjekte manuell zu schreiben, können Sie die Migrationsdateien automatisch generieren, indem Sie Folgendes verwenden:
$ config = [
' db ' => [
' driver ' => ' pdo_mysql ' ,
' host ' => ' 127.0.0.1 ' ,
' dbname ' => ' <database> ' ,
' user ' => ' <dbuser> ' ,
' password ' => ' <secret> '
]
];
Aimeos Upscheme Up:: use ( $ config , ' migrations ' )-> create (); Dadurch wird für jede Sequenz, Tabelle und Ansicht eine Datei im übergebenen Verzeichnis generiert (in diesem Beispiel ./migrations/ ). Wenn Sie über mehrere Datenbanken verfügen und für alle gleichzeitig Migrationen erstellen möchten, übergeben Sie die Verbindungsschlüssel aus der Konfiguration an create() :
$ config = [
' db ' => [
' driver ' => ' pdo_mysql ' ,
// ...
],
' order ' => [
' driver ' => ' pdo_oci ' ,
// ...
]
];
Aimeos Upscheme Up:: use ( $ config , ' migrations ' )-> create ( [ ' db ' , ' order ' ] ); Sie erhalten das Datenbankschemaobjekt in Ihrer Aufgabe, indem Sie $this->db() aufrufen, wie im Abschnitt „Schema“ beschrieben. Sie erhalten vollen Zugriff auf das Datenbankschema einschließlich aller Tabellen, Sequenzen und anderer Schemaobjekte:
$ table = $ this -> db ()-> table ( ' users ' );
$ seq = $ this -> db ()-> sequence ( ' seq_users ' );Wenn die Tabelle oder Sequenz nicht existiert, wird sie erstellt. Andernfalls wird das vorhandene Tabellen- oder Sequenzobjekt zurückgegeben. In beiden Fällen können Sie die Objekte nachträglich modifizieren und z. B. neue Spalten zur Tabelle hinzufügen.
Sie können Tabellen, Spalten, Indizes, Fremdschlüssel und Sequenzen mithilfe des von $this->db() zurückgegebenen Datenbankschemas testen:
$ 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
} Das von $this->db() zurückgegebene Datenbankobjekt bietet die Möglichkeit, Tabellen, Spalten und Indizes mithilfe von renameTable() , renameColumn() und renameIndex() umzubenennen:
$ 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 ' ); Das von $this->db() zurückgegebene Datenbankobjekt verfügt auch über Methoden zum Löschen von Tabellen, Spalten, Indizes, Fremdschlüsseln und Sequenzen:
$ 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 ' ); Wenn die Tabelle, Spalte, der Index, der Fremdschlüssel oder die Sequenz nicht vorhanden ist, wird sie stillschweigend ignoriert. In Fällen, in denen Sie wissen müssen, ob sie vorhanden sind, verwenden Sie zuvor die Methoden hasTable() , hasColumn() , hasIndex() , hasForeign() und hasSeqence() wie im Abschnitt „Prüfung auf Existenz“ beschrieben.
Die Methoden insert() , select() , update() und delete() sind eine einfache Möglichkeit, Zeilen in jeder Tabelle hinzuzufügen, abzurufen, zu ändern und zu entfernen:
$ 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 ();
} ); Wenn Sie select() gleichzeitig mit insert() , update() oder delete() verwenden, müssen Sie eine zweite Datenbankverbindung erstellen, da die select() -Anweisung Zeilen zurückgibt, während Sie neue Befehle an den Datenbankserver senden. Dies funktioniert nur bei separaten Verbindungen, nicht bei denselben.
Um alle Lösch-/Einfüge-/Aktualisierungsvorgänge in eine Transaktion einzubinden, müssen Sie die Methode transaction() des Datenbankobjekts verwenden:
$ this -> db ()-> transaction ( function ( $ db ) {
// $db- > insert ( ... )
// $db- > update ( ... )
// $db- > delete ( ... )
} ); Dadurch wird sichergestellt, dass alle Schreibvorgänge atomar ausgeführt werden oder im Fehlerfall keine davon. Die Methode transaction() stellt sicher, dass die Transaktion automatisch festgeschrieben oder zurückgesetzt wird, nachdem Ihre anonyme Funktion die Kontrolle an die Methode zurückgegeben hat.
Wenn Sie innerhalb Ihrer anonymen Funktion zusätzliche Parameter benötigen, können Sie diese in der use Ihrer Funktion übergeben:
$ userid = 123 ;
$ this -> db ()-> transaction ( function ( $ db ) use ( $ userid ) {
$ db -> insert ( ' newusers ' , [ ' userid ' => userid, ' status ' => true ] );
} ); Sie können den Methoden nur einfache Schlüssel/Wert-Paare für Bedingungen übergeben, die durch UND verknüpft werden. Wenn Sie komplexere Abfragen benötigen, verwenden Sie stattdessen 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 (); Die stmt() Methode gibt ein DoctrineDBALQueryQueryBuilder Objekt zurück, mit dem Sie eine erweiterte Anweisung erstellen können. Weitere Informationen finden Sie in der Dokumentation zum Doctrine Query Builder.
Wenn Sie Werte direkt in einer SQL-Anweisung verwenden möchten (verwenden Sie aus Sicherheitsgründen nach Möglichkeit vorbereitete Anweisungen!), müssen Sie die Werte mit der Methode q() in Anführungszeichen setzen:
$ db = $ this -> db ();
$ result = $ db -> stmt ()-> select ( ' * ' )-> from ( ' products ' )
-> where ( ' status = ' . $ db -> q ( $ _GET [ ' status ' ] ) )-> executeQuery (); Wenn Ihr Schema reservierte Schlüsselwörter enthält, z. B. als Spaltennamen, müssen Sie diese ebenfalls mit der qi() -Methode in Anführungszeichen setzen:
$ db = $ this -> db ();
$ result = $ db -> stmt ()-> select ( $ db -> qi ( ' key ' ) )-> from ( ' products ' )-> executeQuery (); Doctrine unterstützt nur eine allgemeine Teilmenge von SQL-Anweisungen und nicht alle Möglichkeiten, die die Datenbankanbieter implementiert haben. Um diese Einschränkung aufzuheben, bietet Upscheme die Methoden exec() , for() und query() an, um benutzerdefinierte SQL-Anweisungen auszuführen, die von Doctrine DBAL nicht unterstützt werden.
Um benutzerdefinierte SQL-Abfragen auszuführen, verwenden Sie die Methode query() , die eine Ergebnismenge zurückgibt, über die Sie iterieren können:
$ sql = ' SELECT id, label, status FROM product WHERE label LIKE ? ' ;
$ result = $ this -> db ()-> query ( $ sql , [ ' test% ' ] );
foreach ( $ result -> iterateAssociative () as $ row ) {
// ...
} Für alle anderen SQL-Anweisungen verwenden Sie die Methode exec() die die Anzahl der betroffenen Zeilen zurückgibt:
$ sql = ' UPDATE product SET status=? WHERE status=? ' ;
$ num = $ this -> db ()-> exec ( $ sql , [ 1 , 0 ] ); Mit der Methode for() können Sie je nach Datenbankplattform auch Anweisungen ausführen:
$ this -> db ()-> for ( ' mysql ' , ' CREATE FULLTEXT INDEX idx_text ON product (text) ' );Die Angabe der Datenbankplattform ist sehr nützlich für die Erstellung spezieller Indextypen, bei denen sich die Syntax zwischen den Datenbankimplementierungen unterscheidet.
Ruft benutzerdefinierte Methoden auf oder übergibt unbekannte Methodenaufrufe an das Doctrine-Schemaobjekt
public function __call( string $ method , array $ args )$method Name der Methode$args MethodenparameterBeispiele:
Sie können benutzerdefinierte Methoden registrieren, die Zugriff auf die Klasseneigenschaften des Upscheme-DB-Objekts haben:
Aimeos Upscheme Schema DB :: macro ( ' hasFkIndexes ' , function ( $ val ) {
return $ this -> to -> hasExplicitForeignKeyIndexes ();
} );
$ db -> hasFkIndexes ();
// returns true / falseVerfügbare Klasseneigenschaften sind:
$this->from : Ursprüngliches Doctrine-Datenbankschema, das die aktuelle Datenbank darstellt
$this->to : Doctrine-Datenbankschema, das die bisher vorgenommenen Änderungen enthält
$this->conn : Doctrine-Datenbankverbindung
$this->up : Upscheme-Objekt
Darüber hinaus können Sie jede Doctrine-Schemamethode direkt aufrufen, z. B.:
$ db -> hasExplicitForeignKeyIndexes ();Schließt die Datenbankverbindung
public function close() : void Rufen Sie close() nur für DB-Schemaobjekte auf, die mit $this->db( '...', true ) erstellt wurden. Andernfalls wird die Hauptverbindung geschlossen und DBAL muss sich erneut mit dem Server verbinden, was zu Leistungseinbußen führt!
Beispiele:
$ db = $ this -> db ( ' temp ' , true );
$ db -> dropTable ( ' test ' );
$ db -> close ();Löscht die Datensätze aus der angegebenen Tabelle
public function delete( string $ table , array $ conditions = [] ) : self$table Name der Tabelle$conditions Schlüssel/Wert-Paare aus Spaltennamen und Wert, mit denen verglichen werden sollWarnung: Die Bedingungswerte werden maskiert, der Tabellenname und die Bedingungsspaltennamen jedoch nicht! Verwenden Sie für Tabellennamen und Bedingungsspaltennamen nur feste Zeichenfolgen, aber keine externen Eingaben!
Beispiele:
$ db -> delete ( ' test ' , [ ' status ' => false , ' type ' => ' old ' ] );
$ db -> delete ( ' test ' ); Mehrere im zweiten Parameter übergebene Bedingungen werden durch „UND“ verknüpft. Wenn Sie komplexere Anweisungen benötigen, verwenden Sie stattdessen die Methode stmt() .
Löscht die durch ihren Namen angegebene Spalte, falls vorhanden
public function dropColumn( string $ table , $ name ) : self$table Name der Tabelle, zu der die Spalte gehört$name Name der Spalte(n).Beispiele:
$ db -> dropColumn ( ' test ' , ' oldcol ' );
$ db -> dropColumn ( ' test ' , [ ' oldcol ' , ' oldcol2 ' ] );Wenn die Spalte oder eine der Spalten nicht vorhanden ist, wird sie stillschweigend ignoriert.
Löscht die durch ihren Namen angegebene Fremdschlüsseleinschränkung, sofern vorhanden
public function dropForeign( string $ table , $ name ) : self$table Name der Tabelle, zu der die Fremdschlüsseleinschränkung gehört$name Name der Fremdschlüsseleinschränkung(en).Beispiele:
$ db -> dropForeign ( ' test ' , ' fk_old ' );
$ db -> dropForeign ( ' test ' , [ ' fk_old ' , ' fk_old2 ' ] );Wenn die Fremdschlüsseleinschränkung oder eine der Einschränkungen nicht vorhanden ist, wird sie stillschweigend ignoriert.
Löscht den durch seinen Namen angegebenen Index, falls vorhanden
public function dropIndex( string $ table , $ name ) : self$table Name der Tabelle, zu der der Index gehört$name Name des Index oder der IndizesBeispiele:
$ db -> dropIndex ( ' test ' , ' idx_old ' );
$ db -> dropIndex ( ' test ' , [ ' idx_old ' , ' idx_old2 ' ] );Wenn der Index oder einer der Indizes nicht vorhanden ist, wird er stillschweigend ignoriert.
Löscht die durch ihren Namen angegebene Sequenz, falls vorhanden
public function dropSequence( $ name ) : self$name Name der Sequenz(en).Beispiele:
$ db -> dropSequence ( ' seq_old ' );
$ db -> dropSequence ( [ ' seq_old ' , ' seq_old2 ' ] );Wenn die Sequenz oder eine der Sequenzen nicht existiert, wird sie stillschweigend ignoriert.
Löscht die mit ihrem Namen angegebene Tabelle, falls vorhanden
public function dropTable( $ name ) : self$name Name der Tabelle(n).Beispiele:
$ db -> dropTable ( ' test ' );
$ db -> dropTable ( [ ' test ' , ' test2 ' ] );Wenn die Tabelle oder eine der Tabellen nicht existiert, wird sie stillschweigend ignoriert.
Löscht die durch ihren Namen angegebene Ansicht, falls vorhanden
public function dropView( $ name ) : self$name Name der Ansicht oder AnsichtenBeispiele:
$ db -> dropView ( ' test ' );
$ db -> dropView ( [ ' test ' , ' test2 ' ] );Wenn die Ansicht oder eine der Ansichten nicht vorhanden ist, wird sie stillschweigend ignoriert.
Führt eine benutzerdefinierte SQL-Anweisung aus
public function exec( string $ sql , array $ params = [], array $ types = [] ) : int$sql Benutzerdefinierte SQL-Anweisung$params Liste von Positionsparametern oder assoziative Liste von Platzhaltern und Parametern$types Liste der DBAL-Datentypen für die Positions- oder assoziativen PlatzhalterparameterDie Datenbankänderungen werden nicht sofort angewendet. Rufen Sie daher immer up() auf, bevor Sie benutzerdefinierte Anweisungen ausführen, um sicherzustellen, dass die Tabellen, die Sie verwenden möchten, zuvor erstellt wurden!
Beispiele:
$ sql = ' UPDATE product SET status=? WHERE status=? ' ;
$ num = $ this -> db ()-> exec ( $ sql , [ 1 , 0 ] );Führt eine benutzerdefinierte SQL-Anweisung aus, wenn die Datenbank vom angegebenen Typ ist
public function for( $ type , $ sql ) : self$type Datenbanktyp, für den die Anweisung ausgeführt werden soll$sql Benutzerdefinierte SQL-Anweisung oder -AnweisungenVerfügbare Datenbankplattformtypen sind:
Die Datenbankänderungen werden nicht sofort angewendet. Rufen Sie daher immer up() auf, bevor Sie benutzerdefinierte Anweisungen ausführen, um sicherzustellen, dass die Tabellen, die Sie verwenden möchten, zuvor erstellt wurden!
Beispiele:
$ 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 ' ,
] );Überprüft, ob die Spalte oder Spalten vorhanden sind
public function hasColumn( string $ table , $ name ) : bool$table Name der Tabelle, zu der die Spalte gehört$name Name der Spalte(n).Beispiele:
$ db -> hasColumn ( ' test ' , ' testcol ' );
$ db -> hasColumn ( ' test ' , [ ' testcol ' , ' testcol2 ' ] );Überprüft, ob die Fremdschlüsseleinschränkungen vorhanden sind
public function hasForeign( string $ table , $ name ) : bool$table Name der Tabelle, zu der die Fremdschlüsseleinschränkung gehört$name Name der Fremdschlüsseleinschränkung(en).Beispiele:
$ db -> hasForeign ( ' test ' , ' fk_testcol ' );
$ db -> hasForeign ( ' test ' , [ ' fk_testcol ' , ' fk_testcol2 ' ] );Überprüft, ob die Indizes vorhanden sind
public function hasIndex( string $ table , $ name ) : bool$table Name der Tabelle, zu der der Index gehört$name Name des Index oder der IndizesBeispiele:
$ db -> hasIndex ( ' test ' , ' idx_test_col ' );
$ db -> hasIndex ( ' test ' , [ ' idx_test_col ' , ' idx_test_col2 ' ] );Überprüft, ob die Sequenzen vorhanden sind
public function hasSequence( $ name ) : bool$name Name der Sequenz(en).Beispiele:
$ db -> hasSequence ( ' seq_test ' );
$ db -> hasSequence ( [ ' seq_test ' , ' seq_test2 ' ] );Überprüft, ob die Tabellen vorhanden sind
public function hasTable( $ name ) : bool$name Name der Tabelle(n).Beispiele:
$ db -> hasTable ( ' test ' );
$ db -> hasTable ( [ ' test ' , ' test2 ' ] );Überprüft, ob die Ansichten vorhanden sind
public function hasView( $ name ) : bool$name Name der Ansicht oder AnsichtenBeispiele:
$ db -> hasView ( ' test ' );
$ db -> hasView ( [ ' test ' , ' test2 ' ] );Fügt einen Datensatz in die angegebene Tabelle ein
public function insert( string $ table , array $ data ) : self$table Name der Tabelle$data Schlüssel/Wert-Paare aus einzufügendem Spaltennamen/WertBeispiele:
$ db -> insert ( ' test ' , [ ' label ' => ' myvalue ' , ' status ' => true ] );Gibt die ID der zuletzt in eine Datenbanktabelle eingefügten Zeile zurück
public function lastId() : stringAchtung: Dies funktioniert nicht für die Oracle-Plattform, da Doctrine DBAL derzeit keine Oracle IDENTITY-Spalten unterstützt.
Beispiele:
$ db -> lastId ();Gibt den Namen der Datenbank zurück
public function name() : stringBeispiele:
$ db -> name ();Zitiert einen Wert
public function q( $ value , $ type = Doctrine DBAL ParameterType:: STRING ) : string$value Wert zur Verwendung in einer nicht vorbereiteten SQL-Abfrage$type DBAL-ParametertypBeispiele:
$ result = $ db -> stmt ()-> select ( ' * ' )-> from ( ' products ' )
-> where ( ' status = ' . $ db -> q ( $ _GET [ ' status ' ] ) )-> executeQuery ();Zitiert einen Datenbankbezeichner
public function qi( string $ identifier ) : string$identifier Bezeichner wie Tabellen- oder SpaltennameBeispiele:
$ result = $ db -> stmt ()-> select ( $ db -> qi ( ' key ' ) )-> from ( ' products ' )-> executeQuery ();Führt eine benutzerdefinierte SQL-Abfrage aus
public function query( string $ sql , array $ params = [], array $ types = [] ) : Doctrine DBAL Result$sql Benutzerdefinierte SQL-Anweisung$params Liste von Positionsparametern oder assoziative Liste von Platzhaltern und Parametern$types Liste der DBAL-Datentypen für die Positions- oder assoziativen PlatzhalterparameterBeispiele:
$ result = $ db -> query ( ' SELECT id, label, status FROM product WHERE label LIKE ? ' , [ ' test% ' ] );
foreach ( $ result -> iterateAssociative () as $ row ) {
// ...
}Tipp: Weitere Informationen finden Sie in den DBAL-Methoden zum Abrufen von Daten.
Benennt eine Spalte oder eine Liste von Spalten um
public function renameColumn( string $ table , $ from , string $ to = null ) : self$table Name der Tabelle$from Spaltenname oder Array alter/neuer Spaltennamen$to Neuer Spaltenname wird ignoriert, wenn der erste Parameter ein Array ist Wenn die Spalte noch nicht vorhanden ist, ist die Methode erfolgreich, aber es passiert nichts. Es ist kein Aufruf von up() erforderlich.
Einschränkungen
Beispiele:
// single column
$ db -> renameColumn ( ' testtable ' , ' test_col ' , ' test_column ' );
// rename several columns at once
$ db -> renameColumn ( ' testtable ' , [ ' tcol ' => ' testcol ' , ' tcol2 ' => ' testcol2 ' ] );Benennt eine Spalte oder eine Liste von Spalten um
public function renameIndex( string $ table , $ from , string $ to = null ) : self$table Name der Tabelle$from Indexname oder Array alter/neuer Indexnamen$to Neuer Indexname wird ignoriert, wenn der erste Parameter ein Array ist Wenn der Index noch nicht vorhanden ist, ist die Methode erfolgreich, es passiert jedoch nichts. Es ist kein Aufruf von up() erforderlich.
Beispiele:
// single index
$ db -> renameIndex ( ' testtable ' , ' idxcol ' , ' idx_column ' );
// rename several indexes at once
$ db -> renameIndex ( ' testtable ' , [ ' idxcol ' => ' idx_column ' , ' idxcol2 ' => ' idx_column2 ' ] );Benennt eine Tabelle oder eine Liste von Tabellen um
public function renameTable( $ from , string $ to = null ) : self$from Tabellenname oder Array alter/neuer Tabellennamen$to Neuer Tabellenname wird ignoriert, wenn der erste Parameter ein Array ist Wenn die Tabelle noch nicht vorhanden ist, ist die Methode erfolgreich, aber es passiert nichts. Es ist kein Aufruf von up() erforderlich.
Beispiele:
// single table
$ db -> renameTable ( ' testtable ' , ' newtable ' );
// rename several tables at once
$ db -> renameTable ( [ ' testtable ' => ' newtable ' , ' oldtable ' => ' testtable2 ' ] );Lädt das tatsächliche Doctrine-Schema für die aktuelle Datenbank neu
public function reset() : selfBeispiele:
$ db -> reset ();Gibt die Datensätze aus der angegebenen Tabelle zurück
public function select( string $ table , array $ conditions = null ) : array$table Name der Tabelle$conditions Schlüssel/Wert-Paare aus Spaltennamen und Wert, mit denen verglichen werden sollBeispiele:
$ db -> select ( ' test ' , [ ' status ' => false , ' type ' => ' old ' ] );
$ db -> select ( ' test ' ); Mehrere im zweiten Parameter übergebene Bedingungen werden durch „UND“ verknüpft. Wenn Sie komplexere Anweisungen benötigen, verwenden Sie stattdessen die Methode stmt() .
Gibt das Sequenzobjekt für den angegebenen Namen zurück
public function sequence( string $ name , Closure $ fcn = null ) : Sequence$name Name der Sequenz$fcn Anonyme Funktion mit ($sequence)-Parameter zum Erstellen oder Aktualisieren der Sequenzdefinition Wenn die Sequenz noch nicht existiert, wird sie erstellt. Um die Änderungen in der Datenbank beizubehalten, müssen Sie up() aufrufen.
Beispiele:
$ sequence = $ db -> sequence ( ' seq_test ' );
$ sequence = $ db -> sequence ( ' seq_test ' , function ( $ seq ) {
$ seq -> start ( 1000 )-> step ( 2 )-> cache ( 100 );
} )-> up ();Gibt den Abfrage-Builder für eine neue SQL-Anweisung zurück
public function stmt() : Doctrine DBAL Query QueryBuilderBeispiele:
$ 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 ' ];
} **Achtung: ** Sie müssen alle Tabellen- und Spaltennamen selbst mit der Methode $db->qi() in Anführungszeichen setzen!
Weitere Details zu den verfügbaren Doctrine QueryBuilder-Methoden finden Sie in der Doctrine-Dokumentation.
Gibt das Tabellenobjekt für den angegebenen Namen zurück
public function table( string $ name , Closure $ fcn = null ) : Table$name Name der Tabelle$fcn Anonyme Funktion mit ($table)-Parameter zum Erstellen oder Aktualisieren der Tabellendefinition Wenn die Tabelle noch nicht existiert, wird sie erstellt. Um die Änderungen in der Datenbank beizubehalten, müssen Sie up() aufrufen.
Beispiele:
$ table = $ db -> table ( ' test ' );
$ table = $ db -> table ( ' test ' , function ( $ t ) {
$ t -> id ();
$ t -> string ( ' label ' );
$ t -> bool ( ' status ' );
} )-> up ();Führt den angegebenen Abschluss innerhalb einer Transaktion aus
public function transaction( Closure $ fcn ) : selfBeispiele:
$ this -> db ()-> transaction ( function ( $ db ) {
// $db- > insert ( ... )
// $db- > update ( ... )
// $db- > delete ( ... )
} );Gibt die Objekte als Array aus der Datenbank zurück
public function toArray() : arrayBeispiele:
$ this -> db ()-> toArray ();Die Struktur des zurückgegebenen Arrays ist:
[
' 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` '
]
]
]Gibt den Typ der Datenbank zurück
public function type() : stringMögliche Werte sind:
Beispiele:
$ type = $ db -> type ();Wendet die Änderungen auf das Datenbankschema an
public function up() : selfBeispiele:
$ db -> up ();Aktualisiert die Datensätze aus der angegebenen Tabelle
public function update( string $ table , array $ data , array $ conditions = [] ) : self$table Name der Tabelle$data Schlüssel/Wert-Paare aus Spaltenname/Wert, die aktualisiert werden sollen$conditions Schlüssel/Wert-Paare aus Spaltennamen und Wert, mit denen verglichen werden sollBeispiele:
$ db -> update ( ' test ' , [ ' status ' => true ] );
$ db -> update ( ' test ' , [ ' status ' => true ], [ ' status ' => false , ' type ' => ' new ' ] ); Mehrere im zweiten Parameter übergebene Bedingungen werden durch „AND“ verknüpft. Wenn Sie komplexere Anweisungen benötigen, verwenden Sie stattdessen die Methode stmt() .
Erstellt eine Ansicht mit dem angegebenen Namen, falls diese noch nicht existiert
public function view( string $ name , string $ sql , $ for = null ) : self$name Name der Ansicht$sql SELECT-Anweisung zum Auffüllen der Ansicht$for den Datenbanktyp, für den dieses SQL verwendet werden soll („mysql“, „mariadb“, „postgresql“, „sqlite“, „sqlserver“, „oracle“, „db2“)Wenn die Ansicht noch nicht existiert, wird sie erstellt. Sonst passiert nichts.
Beispiele:
$ 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 ' ); Das Tabellenschemaobjekt, das Sie durch den Aufruf von table() in Ihrer Migrationsaufgabe erhalten, gibt Ihnen vollen Zugriff auf die Tabelle und Sie können Spalten, Indizes und Fremdschlüssel hinzufügen, ändern oder entfernen, z. B.:
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
$ table -> id ();
$ table -> string ( ' label ' );
$ table -> col ( ' status ' , ' tinyint ' )-> default ( 0 );
} ); Neben der col() Methode, die Spalten beliebiger Typen hinzufügen kann, gibt es einige Abkürzungsmethoden für Typen, die in allen Datenbankserverimplementierungen verfügbar sind:
| Spaltentyp | Beschreibung |
|---|---|
| bigid | BIGINT-Spalte mit einer Sequenz/Autoinkrementierung und einem zugewiesenen Primärschlüssel |
| bigint | BIGINT-Spalte mit einem Bereich von −9223372036854775808 bis 9223372036854775807 |
| binär | VARBINARY-Spalte mit bis zu 255 Bytes |
| Klecks | BLOB-Spalte mit bis zu 2 GB |
| bool | BOOLEAN/BIT/NUMBER-Spalte, Alias für „boolean“ |
| Boolescher Wert | Spalte BOOLEAN/BIT/NUMBER für TRUE/FALSE bzw. 0/1 Werte |
| verkohlen | CHAR-Spalte mit einer festen Anzahl von Zeichen |
| Datum | DATE-Spalte im ISO-Datumsformat („JJJJ-MM-TT) ohne Uhrzeit und Zeitzone |
| Datum/Uhrzeit | DATETIME-Spalte im ISO-Datums-/Uhrzeitformat („JJJJ-MM-TT HH:mm:ss“) |
| tablesdatetimetz | DATETIMETZ-Spalte im ISO-Datums-/Uhrzeitformat, jedoch mit unterschiedlichem Zeitzonenformat |
| dezimal | DECIMAL-Spalte für numerische Daten mit Festkomma-Präzision (String in PHP) |
| schweben | FLOAT-Spalte für numerische Daten mit einer 8-Byte-Gleitkommagenauigkeit |
| Anleitung | Weltweit eindeutiger Identifikator mit 36 Bytes |
| Ausweis | INTEGER-Spalte mit einer Sequenz/Autoinkrementierung und einem zugewiesenen Primärschlüssel |
| int | INTEGER-Spalte, Alias für „integer“ |
| ganze Zahl | INTEGER-Spalte mit einem Bereich von −2147483648 bis 2147483647 |
| json | JSON-Spalte für UTF-8-codierte JSON-Daten |
| smallint | INTEGER-Spalte mit einem Bereich von −32768 bis 32767 |
| Zeichenfolge | VARCHAR-Spalte mit bis zu 255 Zeichen |
| Text | TEXT/CLOB-Spalte mit bis zu 2 GB Zeichen |
| Zeit | TIME-Spalte im 24-Stunden-Format „HH:MM“, z. B. „05:30“ oder „22:15“ |
| uuid | Weltweit eindeutiger Bezeichner mit 36 Bytes, Alias für „guid“ |
MySQL (oder MariaDB usw.) unterstützt einige Optionen zum Definieren von Aspekten der Tabelle. Die Engine- Option gibt die für die Tabelle verwendete Speicher-Engine an:
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
$ table -> opt ( ' engine ' , ' InnoDB ' );
} );Als Abkürzung ist es auch möglich, die Option als Eigenschaft festzulegen:
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
$ table -> engine = ' InnoDB ' ;
} );Um eine temporäre Tabelle zu erstellen, verwenden Sie:
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
$ table -> temporary = true ;
} );Es ist auch möglich, den Standardzeichensatz und die Standardsortierung für Zeichenfolgen- und Textspalten festzulegen:
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
$ table -> charset = ' utf8mb4 ' ;
$ table -> collation = ' utf8mb4_unicode_ci ' ;
} ); Hinweis: Sortierungen werden auch von PostgreSQL und SQL Server unterstützt, ihre Werte sind jedoch unterschiedlich. Daher ist es nicht möglich, für alle Servertypen denselben Wert zu verwenden. Um dieses Problem zu umgehen, verwenden Sie die Spaltenmethode opt() und übergeben Sie den Datenbankservertyp als dritten Parameter:
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
$ table -> opt ( ' charset ' , ' utf8mb4 ' , ' mysql ' );
$ table -> opt ( ' collation ' , ' utf8mb4_unicode_ci ' , ' mysql ' );
} );Jetzt werden der Standardzeichensatz und die Standardsortierung nur für MySQL-Datenbankserver (oder MariaDB und ähnliche Zweige) festgelegt.
Falls Sie die aktuellen Werte der Tabellenoptionen kennen müssen:
$ 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 ;
} ); Um zu überprüfen, ob eine Tabelle bereits existiert, verwenden Sie die Methode hasTable() :
if ( $ this -> db ()-> hasTable ( ' users ' ) ) {
// The "users" table exists
}Sie können auch nach mehreren Tabellen gleichzeitig suchen:
if ( $ this -> db ()-> hasTable ( [ ' users ' , ' addresses ' ] ) ) {
// The "users" and "addresses" tables exist
} Die Methode hasTable() gibt nur TRUE zurück, wenn alle Tabellen vorhanden sind.
Neben der Erstellung und dem Zugriff auf Tabellen kann die table() Methode des Schemaobjekts auch zum Aktualisieren eines Tabellenschemas verwendet werden. Es akzeptiert den Tabellennamen und einen Abschluss, der das Tabellenschemaobjekt empfängt.
Erstellen wir zunächst eine Tabelle mit dem Namen test, die drei Spalten enthält:
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
$ table -> id ();
$ table -> string ( ' label ' );
$ table -> col ( ' status ' , ' tinyint ' )-> default ( 0 );
} );Jetzt möchten wir die Tabelle in einer weiteren Migration aktualisieren, indem wir eine Codespalte hinzufügen und den Standardwert der vorhandenen Statusspalte ändern:
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
$ table -> string ( ' code ' );
$ table -> col ( ' status ' , ' tinyint ' )-> default ( 1 );
} ); Die Änderungen werden in der Datenbank gespeichert, sobald die Methode table() zurückkehrt, sodass Sie up() anschließend nicht selbst aufrufen müssen. Informationen zu den verfügbaren Spaltentypen und -optionen finden Sie im Abschnitt „Spalten“.
Das von $this->db() zurückgegebene Datenbankobjekt kann Tabellen umbenennen, wenn die Methode renameTable() verwendet wird:
// Renames the table "users" to "accounts"
$ this -> db ()-> renameTable ( ' users ' , ' account ' );Es ist auch möglich, mehrere Tabellen gleichzeitig umzubenennen, wenn Sie ein assoziatives Array übergeben, das alte und neue Namen als Schlüssel/Wert-Paare enthält:
// Renames the table "users" to "accounts" and "blog" to "posts"
$ this -> db ()-> renameTable ( [ ' users ' => ' account ' , ' blog ' => ' posts ' ] );Tabellen werden nur umbenannt, wenn sie vorhanden sind. Wenn eine Tabelle nicht mehr existiert, wird kein Fehler gemeldet:
$ this -> db ()-> renameTable ( ' notexist ' , ' newtable ' );In diesem Fall ist der Methodenaufruf erfolgreich, es passiert jedoch nichts.
Um eine Tabelle zu entfernen, sollten Sie die Methode dropTable() aus dem Datenbankschema verwenden:
$ this -> db ()-> dropTable ( ' users ' );Sie können auch mehrere Tabellen gleichzeitig löschen, indem Sie die Liste als Array übergeben:
$ this -> db ()-> dropTable ( [ ' users ' , ' addresses ' ] );Tabellen werden nur entfernt, wenn sie vorhanden sind. Wenn eine Tabelle nicht mehr existiert, wird kein Fehler gemeldet:
$ this -> db ()-> dropTable ( ' notexist ' );In diesem Fall ist der Methodenaufruf erfolgreich, es passiert jedoch nichts.
Ruft benutzerdefinierte Methoden auf oder übergibt unbekannte Methodenaufrufe an das Doctrine-Tabellenobjekt
public function __call( string $ method , array $ args )$method Name der Methode$args MethodenparameterBeispiele:
Sie können benutzerdefinierte Methoden registrieren, die Zugriff auf die Klasseneigenschaften des Upscheme-Tabellenobjekts haben:
Aimeos Upscheme Schema Table:: macro ( ' addConstraint ' , function ( array $ columns ) {
return $ this -> to -> addUniqueConstraint ( $ columns );
} );
$ table -> addConstraint ( [ ' col1 ' , ' col2 ' ] );Verfügbare Klasseneigenschaften sind:
$this->table : Doctrine-Tabellenschema
$this->up : Upscheme-Objekt
Darüber hinaus können Sie jede Doctrine-Tabellenmethode direkt aufrufen, z. B.:
$ table -> addUniqueConstraint ( [ ' col1 ' , ' col2 ' ] );Gibt den Wert für die angegebene Tabellenoption zurück
public function __get( string $ name )$name TabellenoptionsnameDie Liste der verfügbaren Tabellenoptionen ist:
Beispiele:
$ engine = $ table -> engine ;
// same as
$ engine = $ table -> opt ( ' engine ' );Legt den neuen Wert für die angegebene Tabellenoption fest
public function __set( string $ name , $ value )$name TabellenoptionsnameDie Liste der verfügbaren Tabellenoptionen ist:
Beispiele:
$ table -> engine = ' InnoDB ' ;
// same as
$ table -> opt ( ' engine ' , ' InnoDB ' );Erstellt eine neue ID-Spalte vom Typ „bigint“ oder gibt die vorhandene zurück
public function bigid( string $ name = null ) : Column$name Name der ID-SpalteDer Spalte wird automatisch eine Sequenz (Autoinkrementierung) und ein Primärschlüssel zugewiesen. Wenn die Spalte noch nicht existiert, wird sie erstellt.
Beispiele:
$ table -> bigid ();
$ table -> bigid ( ' uid ' );Erstellt eine neue Spalte vom Typ „bigint“ oder gibt die vorhandene zurück
public function bigint( string $ name ) : Column$name Name der SpalteWenn die Spalte noch nicht existiert, wird sie erstellt.
Beispiele:
$ table -> bigint ( ' testcol ' );Erstellt eine neue Spalte vom Typ „binär“ oder gibt die vorhandene zurück
public function binary( string $ name , int $ length = 255 ) : Column$name Name der Spalte$length Länge der Spalte in BytesWenn die Spalte noch nicht existiert, wird sie erstellt.
Beispiele:
$ table -> binary ( ' testcol ' );
$ table -> binary ( ' testcol ' , 32 );Erstellt eine neue Spalte vom Typ „blob“ oder gibt die vorhandene zurück
public function blob( string $ name , int $ length = 0x7fff ) : Column$name Name der Spalte$length Länge der Spalte in BytesDie maximale Länge einer „Blob“-Spalte beträgt 2 GB. Wenn die Spalte noch nicht existiert, wird sie erstellt.
Beispiele:
$ table -> blob ( ' testcol ' );
$ table -> blob ( ' testcol ' , 0x7fffffff );Erstellt eine neue Spalte vom Typ „boolean“ oder gibt die vorhandene zurück
public function bool( string $ name ) : Column$name Name der SpalteDiese Methode ist ein Alias für boolean(). Wenn die Spalte noch nicht existiert, wird sie erstellt.
Beispiele:
$ table -> bool ( ' testcol ' );Erstellt eine neue Spalte vom Typ „boolean“ oder gibt die vorhandene zurück
public function boolean( string $ name ) : Column$name Name der SpalteWenn die Spalte noch nicht existiert, wird sie erstellt.
Beispiele:
$ table -> boolean ( ' testcol ' );Erstellt eine neue Spalte vom Typ „char“ mit einem festen Typ oder gibt die vorhandene zurück
public function char( string $ name , int $ length ) : Column$name Name der Spalte$length Länge der Spalte in ZeichenWenn die Spalte noch nicht vorhanden ist, wird sie erstellt.
Beispiele:
$ table -> char ( ' testcol ' , 3 );Erstellt eine neue Spalte oder gibt den vorhandenen zurück
public function col( string $ name , string $ type = null ) : Column$name Name der Spalte$type der SpalteWenn die Spalte noch nicht vorhanden ist, wird sie erstellt.
Beispiele:
$ table -> col ( ' testcol ' );
$ table -> col ( ' testcol ' , ' tinyint ' );Erstellt eine neue Spalte vom Typ "Datum" oder gibt den vorhandenen zurück
public function date( string $ name ) : Column$name Name der SpalteWenn die Spalte noch nicht vorhanden ist, wird sie erstellt.
Beispiele:
$ table -> date ( ' testcol ' );Erstellt eine neue Spalte vom Typ "datetime" oder gibt den vorhandenen zurück
public function datetime( string $ name ) : Column$name Name der SpalteWenn die Spalte noch nicht vorhanden ist, wird sie erstellt.
Beispiele:
$ table -> datetime ( ' testcol ' );Erstellt eine neue Spalte vom Typ "DateTimetz" oder gibt die vorhandene zurück
public function datetimetz( string $ name ) : Column$name Name der SpalteWenn die Spalte noch nicht vorhanden ist, wird sie erstellt.
Beispiele:
$ table -> datetimetz ( ' testcol ' );Erstellt eine neue Spalte vom Typ "Dezimal" oder gibt den vorhandenen zurück
public function decimal( string $ name , int $ digits , int $ decimals = 2 ) : Column$name Name der Spalte$digits Gesamtzahl der Dezimalstellen einschließlich Dezimalstellen$decimals Anzahl der Ziffern nach dem DezimalpunktWenn die Spalte noch nicht vorhanden ist, wird sie erstellt.
Beispiele:
$ table -> decimal ( ' testcol ' , 10 ); // 10 digits incl . 2 decimals
$ table -> decimal ( ' testcol ' , 10 , 4 ); // 10 digits incl . 4 decimals Legt die mit ihrem Namen angegebene Spalte ab, wenn sie existiert
public function dropColumn( $ name ) : self$name Name der Spalte oder Spalten Wenn die Spalte oder eine der Spalten nicht vorhanden ist, wird sie stillschweigend ignoriert. Die Änderung wird erst angewendet, wenn die Migrationsaufgabe beendet ist oder up() aufgerufen wird.
Beispiele:
$ table -> dropColumn ( ' testcol ' );
$ table -> dropColumn ( [ ' testcol ' , ' testcol2 ' ] );Lässt den mit seinem Namen angegebenen Index fallen, wenn er existiert
public function dropIndex( $ name ) : self$name Name des Index oder Indizes Wenn der Index oder einer der Indizes nicht vorhanden ist, wird er stillschweigend ignoriert. Die Änderung wird erst angewendet, wenn die Migrationsaufgabe beendet ist oder up() aufgerufen wird.
Beispiele:
$ table -> dropIndex ( ' idx_test_col ' );
$ table -> dropIndex ( [ ' idx_test_col ' , ' idx_test_col2 ' ] );Lässt die durch ihren Namen angegebene fremde Schlüsselbeschränkung fallen, wenn sie existiert
public function dropForeign( $ name ) : self$name Name der fremden Schlüsselbeschränkungen oder Einschränkungen Wenn die fremde Schlüsselbeschränkung oder eine der Einschränkungen nicht vorhanden ist, wird sie stillschweigend ignoriert. Die Änderung wird erst angewendet, wenn die Migrationsaufgabe beendet ist oder up() aufgerufen wird.
Beispiele:
$ table -> dropForeign ( ' fk_test_col ' );
$ table -> dropForeign ( [ ' fk_test_col ' , ' fk_test_col2 ' ] );Lässt den Primärschlüssel fallen, wenn es existiert
public function dropPrimary() : self Wenn der Primärschlüssel nicht existiert, wird er stillschweigend ignoriert. Die Änderung wird erst angewendet, wenn die Migrationsaufgabe beendet ist oder up() aufgerufen wird.
Beispiele:
$ table -> dropPrimary ();Erstellt eine neue Spalte vom Typ "float" oder gibt den vorhandenen zurück
public function float( string $ name ) : Column$name Name der SpalteWenn die Spalte noch nicht vorhanden ist, wird sie erstellt.
Beispiele:
$ table -> float ( ' testcol ' );Erstellt einen neuen Fremdschlüssel oder gibt den vorhandenen zurück
public function foreign( $ localcolumn , string $ foreigntable , $ foreigncolumn = ' id ' , string $ name = null ) : Foreign$localcolumn Name der lokalen Spalte oder Spalten$foreigntable Name der Referenzentabelle$foreigncolumn Namen der referenzierten Spalte oder der Spalten$name Name der Fremdschlüsselbeschränkung und Fremdschlüsselindex oder Null für den autogenerierten NamenDie Länge des Fremdschlüsselnamens sollte nicht länger als 30 Zeichen für maximale Kompatibilität betragen.
Beispiele:
$ table -> foreign ( ' parentid ' , ' test ' );
$ table -> foreign ( ' parentid ' , ' test ' , ' uid ' );
$ table -> foreign ( ' parentid ' , ' test ' , ' id ' , ' fk_test_pid ' );
$ table -> foreign ( [ ' parentid ' , ' siteid ' ], ' test ' , [ ' uid ' , ' siteid ' ] );Erstellt eine neue Spalte vom Typ "Richt" oder gibt den vorhandenen zurück
public function guid( string $ name ) : Column$name Name der SpalteWenn die Spalte noch nicht vorhanden ist, wird sie erstellt.
Beispiele:
$ table -> guid ( ' testcol ' );Überprüft, ob die Spalte existiert
public function hasColumn( $ name ) : bool$name Name der Spalte oder SpaltenBeispiele:
$ table -> hasColumn ( ' testcol ' );
$ table -> hasColumn ( [ ' testcol ' , ' testcol2 ' ] );Überprüft, ob der Index existiert
public function hasIndex( $ name ) : bool$name Name des Index oder IndizesBeispiele:
$ table -> hasIndex ( ' idx_test_col ' );
$ table -> hasIndex ( [ ' idx_test_col ' , ' idx_test_col2 ' ] );Überprüft, ob die ausländische Schlüsselbeschränkung besteht
public function hasForeign( $ name ) : bool$name Name der fremden Schlüsselbeschränkungen oder EinschränkungenBeispiele:
$ table -> hasForeign ( ' fk_test_col ' );
$ table -> hasForeign ( [ ' fk_test_col ' , ' fk_test_col2 ' ] );Erstellt eine neue ID -Spalte vom Typ "Integer" oder gibt den vorhandenen zurück
public function id( string $ name = null ) : Column$name Name der ID -SpalteDie Spalte erhält eine Sequenz (automatisch) und automatisch eine Primärschlüssel. Wenn die Spalte noch nicht vorhanden ist, wird sie erstellt.
Beispiele:
$ table -> id ();
$ table -> id ( ' uid ' );Erstellt einen neuen Index oder ersetzt einen vorhandenen
public function index( $ columns , string $ name = null ) : self$columns Name der Spalten oder Spalten, die den Index hervorbringen$name Index Name oder Null für autogenerierten NamenDie Länge des Indexnamens sollte nicht länger als 30 Zeichen für maximale Kompatibilität betragen.
Beispiele:
$ table -> index ( ' testcol ' );
$ table -> index ( [ ' testcol ' , ' testcol2 ' ] );
$ table ->index( ' testcol ' , 'idx_test_testcol );Erstellt eine neue Spalte vom Typ "Integer" oder gibt den vorhandenen zurück
public function int( string $ name ) : Column$name Name der SpalteDiese Methode ist ein Alias für Integer (). Wenn die Spalte noch nicht vorhanden ist, wird sie erstellt.
Beispiele:
$ table -> int ( ' testcol ' );Erstellt eine neue Spalte vom Typ "Integer" oder gibt den vorhandenen zurück
public function integer( string $ name ) : Column$name Name der SpalteWenn die Spalte noch nicht vorhanden ist, wird sie erstellt.
Beispiele:
$ table -> integer ( ' testcol ' );Erstellt eine neue Spalte vom Typ "json" oder gibt den vorhandenen zurück
public function json( string $ name ) : Column$name Name der SpalteWenn die Spalte noch nicht vorhanden ist, wird sie erstellt.
Beispiele:
$ table -> json ( ' testcol ' );Gibt den Namen der Tabelle zurück
public function name() : stringBeispiele:
$ tablename = $ table -> name ();Legt eine benutzerdefinierte Schema -Option fest oder gibt den aktuellen Wert zurück
public function opt( string $ name , $ value = null )$name Name der tabellbezogenen benutzerdefinierten Schema-Option$value Wertwert der Option Custom SchemaVerfügbare benutzerdefinierte Schema -Optionen sind:
Beispiele:
$ charset = $ table -> opt ( ' charset ' );
$ table -> opt ( ' charset ' , ' utf8 ' )-> opt ( ' collation ' , ' utf8_bin ' );
// Magic methods :
$ charset = $ table -> charset ;
$ table -> charset = ' binary ' ;Erstellt einen neuen Primärindex oder ersetzt einen vorhandenen
public function primary( $ columns , string $ name = null ) : self$columns Name der Spalten oder Spalten, die den Index hervorbringen$name Index Name oder Null für autogenerierten NamenDie Länge des Indexnamens sollte nicht länger als 30 Zeichen für maximale Kompatibilität betragen.
Beispiele:
$ table -> primary ( ' testcol ' );
$ table -> primary ( [ ' testcol ' , ' testcol2 ' ] );
$ table -> primary ( ' testcol ' , ' pk_test_testcol ' );Benennt eine Spalte oder eine Liste von Spalten um
public function renameColumn( $ from , string $ to = null ) : self$from Spaltenname oder Array der alten/neuen Spaltennamen$to neuen Spaltennamen ignoriert, wenn der erste Parameter ein Array istBeispiele:
// single column
$ table -> renameColumn ( ' test_col ' , ' test_column ' );
// rename several columns at once
$ table -> renameColumn ( [ ' tcol ' => ' testcol ' , ' tcol2 ' => ' testcol2 ' ] );Benennt einen Index oder eine Liste von Indizes um
public function renameIndex( $ from , string $ to = null ) : self$from dem Indexnamen oder Array von alten/neuen Indexnamen (wenn der neue Indexname null ist, wird es generiert)$to neuen Indexnamen oder Null für autogenerierten Namen (ignoriert, wenn der erste Parameter ein Array ist)Die Länge des Indexnamens sollte nicht länger als 30 Zeichen für maximale Kompatibilität betragen.
Beispiele:
// 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 ' ] );Erstellt eine neue Spalte vom Typ "smallint" oder gibt den vorhandenen zurück
public function smallint( string $ name ) : Column$name Name der SpalteWenn die Spalte noch nicht vorhanden ist, wird sie erstellt.
Beispiele:
$ table -> smallint ( ' testcol ' );Erstellt einen neuen räumlichen Index oder ersetzt einen vorhandenen
public function spatial( $ columns , string $ name = null ) : self$columns Name der Spalten oder Spalten, die den Index laichen$name Index Name oder Null für autogenerierten NamenDie Länge des Indexnamens sollte nicht länger als 30 Zeichen für maximale Kompatibilität betragen.
Beispiele:
$ table -> spatial ( ' testcol ' );
$ table -> spatial ( [ ' testcol ' , ' testcol2 ' ] );
$ table -> spatial ( ' testcol ' , ' idx_test_testcol ' );Erstellt eine neue Spalte vom Typ "String" oder gibt den vorhandenen zurück
public function string( string $ name , int $ length = 255 ) : Column$name Name der Spalte$length der Spalte in ZeichenDieser Typ sollte für bis zu 255 Zeichen verwendet werden. Für weitere Zeichen verwenden Sie den Typ "Text". Wenn die Spalte noch nicht vorhanden ist, wird sie erstellt.
Beispiele:
$ table -> string ( ' testcol ' );
$ table -> string ( ' testcol ' , 32 );Erstellt eine neue Spalte vom Typ "Text" oder gibt den vorhandenen zurück
public function text( string $ name , int $ length = 0xffff ) : Column$name Name der Spalte$length der Spalte in ZeichenDie maximale Länge einer "Text" -Säule beträgt 2 GB. Wenn die Spalte noch nicht vorhanden ist, wird sie erstellt.
Beispiele:
$ table -> text ( ' testcol ' );
$ table -> text ( ' testcol ' , 0x7fffffff );Erstellt eine neue Spalte vom Typ "Zeit" oder gibt den vorhandenen zurück
public function time( string $ name ) : Column$name Name der SpalteWenn die Spalte noch nicht vorhanden ist, wird sie erstellt. Dieser Datentyp ist bei Verwendung von Oracle -Datenbanken nicht verfügbar.
Beispiele:
$ table -> time ( ' testcol ' );Erstellt einen neuen eindeutigen Index oder ersetzt einen vorhandenen
public function unique( $ columns , string $ name = null ) : self$columns Name der Spalten oder Spalten, die den Index laichen$name Index Name oder Null für autogenerierten NamenDie Länge des Indexnamens sollte nicht länger als 30 Zeichen für maximale Kompatibilität betragen.
Beispiele:
$ table -> unique ( ' testcol ' );
$ table -> unique ( [ ' testcol ' , ' testcol2 ' ] );
$ table -> unique ( ' testcol ' , ' unq_test_testcol ' );Erstellt eine neue Spalte vom Typ "Richt" oder gibt den vorhandenen zurück
public function uuid( string $ name ) : Column$name Name der SpalteDiese Methode ist ein Alias für GUID (). Wenn die Spalte noch nicht vorhanden ist, wird sie erstellt.
Beispiele:
$ table -> uuid ( ' testcol ' );Wendet die Änderungen am Datenbankschema an
public function up() : selfBeispiele:
$ table -> up (); Das Spaltenschema -Objekt, das Sie erhalten, indem Sie col() in Ihrer Migrationsaufgabe aufrufen, erhalten Sie Zugriff auf alle Spalteneigenschaften. Für Spaltentypen sind auch Verknüpfungen verfügbar, die von allen Datenbanken unterstützt werden. Jede Spalte kann durch eine oder mehrere Modifikator -Methoden geändert werden, und Sie können Einzelspalten auch Indizes hinzufügen, z. B.:
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
$ table -> id ()-> unsigned ( true );
$ table -> string ( ' label ' )-> index ();
$ table -> col ( ' status ' , ' tinyint ' )-> default ( 0 );
} );Das Beispiel fügt die folgenden Spalten hinzu:
In allen Datenbankserver -Implementierungen gibt es einige Verknüpfungsmethoden für Spaltentypen:
| Spaltenentyp | Beschreibung |
|---|---|
| groß | Bigint -Spalte mit einer Sequenz/Autoinkrement und einem Primärschlüssel zugewiesen |
| Bigint | Bigint -Kolumne mit einem Bereich von –9223372036854775808 bis 9223372036854775807 |
| binär | Varbarinary Spalte mit bis zu 255 Bytes |
| Klecks | BLOB -Säule mit bis zu 2 GB |
| bool | Boolean/bit/number colum, alias für "boolean" |
| boolean | Boolean/bit/nummer colum für true/false resp. 0/1 Werte |
| verkohlen | Char -Spalte mit einer festen Anzahl von Zeichen |
| Datum | Datumspalte im ISO-Datumsformat ("yjyy-mm-dd) ohne Zeit und Zeitzone |
| datetime | DATETIME-Spalte im ISO-Datum/Uhrzeitformat ("yyyy-mm-dd hh: mm: ss") |
| tablesDatetimetz | DateTimetz -Spalte im ISO -Datum/Uhrzeitformat, jedoch mit unterschiedlichem Zeitzonformat |
| dezimal | Dezimalspalte für numerische Daten mit fester Punktpräzision (String in PHP) |
| schweben | Float-Spalte für numerische Daten mit einer 8-Byte-Gleitkomma-Präzision |
| Anleitung | Global eindeutige Kennung mit 36 Bytes |
| Ausweis | Integer -Spalte mit einer Sequenz/Autoinkrement und einem Primärschlüssel zugewiesen |
| int | Ganzzahl Colum, Alias für "Integer" |
| ganze Zahl | Ganzzahl colum mit einem Bereich von –2147483648 bis 2147483647 |
| JSON | JSON-Spalte für UTF-8 codierte JSON-Daten |
| Smallint | Ganzzahl colum mit einem Bereich von –32768 bis 32767 |
| Zeichenfolge | Varchar -Spalte mit bis zu 255 Zeichen |
| Text | Text-/CLOB -Spalte mit bis zu 2 GB Zeichen |
| Zeit | Zeitspalte in 24 Stunden "HH: mm" von AT, zB "05:30" oder "22:15" |
| Uuid | Global eindeutige Kennung mit 36 Bytes, Alias für "Guid" |
Verwenden Sie die col() -Methode z.
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
$ table -> col ( ' status ' , ' tinyint ' );
} );Es ist auch möglich, Spaltendefinitionen zu ändern, indem Sie ein oder mehrere Methoden des Spaltenmodifikators aufrufen:
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
$ table -> int ( ' number ' )-> null ( true )-> unsigned ( true );
} );Die verfügbaren Methoden zur Spaltenmodifikator sind:
| Spaltenmodifikator | Beschreibung |
|---|---|
| Autoinkrement (wahr) | Setzen Sie Ganzzahlspalten als automatische Inkrementierung (Alias für seq() ) |
| charset ('utf8') | Der Zeichensatz, der von der Spalte verwendet wird (MySQL) |
| Zusammenfassung ('binär') | Die Säulenkollation (MySQL/PostgreSQL/SQLITE/SQLSERVER, aber nicht kompatibel) |
| Kommentar ('Kommentar') | Fügen Sie einer Spalte einen Kommentar hinzu (MySQL/Postgresql/Oracle/SQLServer). |
| Standard (1) | Standardwert der Spalte Wenn kein Wert angegeben wurde (Standard: NULL ) |
| behoben (wahr) | Wenn String- oder Binärspalten eine feste Länge haben sollten |
| index ('idx_col') | Fügen Sie der Spalte einen Index hinzu, der Indexname ist optional |
| Länge (32) | Der max. Länge der Saiten- und Binärspalten |
| null (wahr) | Lassen Sie die Nullwerte in die Spalte eingefügt werden |
| Präzision (12) | Der max. Anzahl der Ziffern, die in Dezimal- und Schwimmerspalten inkl. Dezimalstellen |
| primär ('pk_col') | Fügen Sie der Spalte einen Primärschlüssel hinzu, der Primärschlüsselname ist optional |
| Skala (2) | Die genaue Anzahl der in Dezimal- und Schwimmerspalten verwendeten Dezimalstellen |
| seq (wahr) | Setzen Sie Ganzzahlspalten als automatische Inkrementierung, wenn kein Wert angegeben wurde |
| räumlich ('idx_col') | Fügen Sie der Spalte einen räumlichen Index (GEO) hinzu. Der Indexname ist optional |
| eindeutig ('UNQ_COL') | Fügen Sie der Spalte einen eindeutigen Index hinzu, der Indexname ist optional |
| nicht signiert (wahr) | Erlauben Sie nur unsignierte Ganzzahlwerte (MySQL) |
Um benutzerdefinierte Schema -Optionen für Spalten festzulegen, verwenden Sie die opt() z. B.:
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
$ table -> string ( ' code ' )-> opt ( ' collation ' , ' utf8mb4 ' );
} );Es ist sogar möglich, Spaltenmodifikatoren für eine bestimmte Datenbankimplementierung festzulegen, indem der Datenbanktyp als dritter Parameter bestanden wird:
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
$ table -> string ( ' code ' )-> opt ( ' collation ' , ' utf8mb4 ' , ' mysql ' );
} ); Um zu überprüfen, ob bereits eine Spalte vorhanden ist, verwenden Sie die Methode hasColumn() :
if ( $ this -> db ()-> hasColumn ( ' users ' , ' name ' ) ) {
// The "name" column in the "users" table exists
} Sie können auch mehrere Spalten gleichzeitig überprüfen. In diesem Fall wird die Methode hasColumn() nur dann true zurückgegeben, wenn alle Spalten vorhanden sind:
if ( $ this -> db ()-> hasColumn ( ' users ' , [ ' name ' , ' status ' ] ) ) {
// The "name" and "status" columns in the "users" table exists
} Wenn Sie bereits ein Tabellenobjekt haben, können Sie auch hasColumn() verwenden:
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
}Neben Spalten können Sie auch überprüfen, ob Spaltenmodifikatoren festgelegt sind und welcher Wert sie haben:
if ( $ table -> string ( ' code ' )-> null () ) {
// The "code" columns is nullable
}Das Abrufen der aktuellen Spaltenmodifikatorwerte ist mit diesen Methoden möglich:
| Spaltenmodifikator | Beschreibung |
|---|---|
| Autoinkrement () | True, wenn die Spalte automatisch inkrementiert ist (Alias für seq() ) |
| charset () | Gebrauchtes Zeichensatz (MySQL) |
| Kollation() | Gebrauchtkollation (MySQL/PostgreSQL/SQLite/SQLServer, aber nicht kompatibel) |
| Kommentar() | Kommentar, die der Spalte zugeordnet sind (MySQL/Postgresql/Oracle/SQLServer) |
| Standard() | Standardwert der Spalte |
| fix () | True, wenn die String- oder Binärspalte eine feste Länge hat |
| Länge() | Die maximale Länge der Saiten- oder Binärspalte |
| null () | Wahr, wenn Nullwerte zulässig sind |
| Präzision() | Die maximale Anzahl der Ziffern, die in Dezimal- und Schwimmerspalten inkl. Dezimalstellen |
| Skala() | Die genaue Anzahl der in Dezimal- und Schwimmerspalten verwendeten Dezimalstellen |
| SEQ () | True, wenn die Spalte automatisch inkrementiert ist |
| ohne Vorzeichen() | Wahr, wenn nur unsignierte Ganzzahlwerte zulässig sind (MySQL) |
Verwenden Sie die Option opt() ohne zweiten Parameter, um nach nicht standardmäßigen Spaltenmodifikatoren zu überprüfen. Dann gibt es den aktuellen Wert des Spaltenmodifikators zurück:
if ( $ table -> string ( ' code ' )-> opt ( ' charset ' ) === ' utf8 ' ) {
// The "code" columns uses UTF - 8 charset ( MySQL only)
}Es ist möglich, die meisten Spaltenmodifikatoren wie die Länge einer Stringspalte zu ändern:
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
$ table -> string ( ' code ' )-> length ( 64 );
} );Einige Methoden bieten auch zusätzliche Parameter, die am häufigsten verwendeten Modifikatoren direkt einstellen:
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
$ table -> string ( ' code ' , 64 );
} ); Wenn Sie die Spaltenmodifikatoren sofort ändern müssen, da Sie die Zeilen danach migrieren möchten, verwenden Sie die up() -Methode, um die Änderungen bestehen zu können:
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
$ table -> string ( ' code ' , 64 )-> null ( true )-> up ();
// modify rows from "test" table
} ); Das Ändern des Spaltenentyps ist möglich, indem die neue Methode für den entsprechenden Typ oder die col() -Methode verwendet wird:
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
$ table -> text ( ' code ' );
// or
$ table -> col ( ' code ' , ' text ' );
} );Beachten Sie, dass nicht alle Spaltentypen in einen anderen Typ oder zumindest nicht ohne Datenverlust geändert werden können. Sie können eine Integer -Spalte ohne Problem in eine Bigint -Spalte ändern, aber in der anderen Richtung fällt es aus. Gleiches passiert, wenn Sie eine Varchar -Spalte (Zeichenfolge) in eine Ganzzahlspalte ändern möchten.
Verwenden Sie zum Umbenennen von Spalten die Methode renameColumn() des DB -Schemas:
// single column
$ this -> db ()-> renameColumn ( ' testtable ' , ' label ' , ' name ' );
// multiple columns
$ this -> db ()-> renameColumn ( ' testtable ' , [ ' label ' => ' name ' , ' stat ' => ' status ' ] ); Wenn bereits ein Tabellenobjekt verfügbar ist, können Sie mit seiner Methode renameColumn() eine oder mehrere Spalten umbenennen:
$ this -> db ()-> table ( ' testtable ' , function ( $ table ) {
// single column
$ table -> renameColumn ( ' label ' , ' name ' );
// multiple columns
$ table -> renameColumn ( [ ' label ' => ' name ' , ' stat ' => ' status ' ] );
} );In allen Fällen werden Spalten nur dann entfernt, wenn sie existieren. In der Tabelle wird kein Fehler gemeldet, wenn eine oder mehrere Spalten nicht vorhanden sind.
Verwenden Sie zum Abnehmen von Spalten die Methode dropColumn() aus dem DB -Schema -Objekt:
$ this -> db ()-> dropColumn ( ' users ' , ' name ' );Sie können mehrere Spalten sofort fallen lassen, wenn Sie den Namen aller Spalten übergeben, die Sie als Array fallen möchten:
$ this -> db ()-> dropColumn ( ' users ' , [ ' name ' , ' status ' ] ); Wenn Sie bereits ein Tabellenobjekt haben, können Sie auch dropColumn() verwenden:
// single column
$ table -> dropColumn ( ' name ' );
// multiple columns
$ table -> dropColumn ( [ ' name ' , ' status ' ] );In allen Fällen werden Spalten nur dann entfernt, wenn sie existieren. In der Tabelle wird kein Fehler gemeldet, wenn eine oder mehrere Spalten nicht vorhanden sind.
Ruft benutzerdefinierte Methoden auf oder übergeben unbekannte Methodenaufrufe an das Spaltenobjekt der Doktrin
public function __call( string $ method , array $ args )$method -Name der Methode$args Method -ParameterBeispiele:
Sie können benutzerdefinierte Methoden registrieren, die Zugriff auf die Klasseneigenschaften des UPSCHEME -Spaltenobjekts haben:
Aimeos Upscheme Schema Column:: macro ( ' platform ' , function ( array $ options ) {
return $ this -> to -> setPlatformOptions ( $ options );
} );
$ column -> platform ( [ ' option ' => ' value ' ] );Verfügbare Klasseneigenschaften sind:
$this->db : upscheme db-Objekt
$this->table : Lehre Tabellenschema
$this->column : Doktrinspaltenschema
Darüber hinaus können Sie eine beliebige Doktrinspaltenmethode direkt aufrufen, z. B.:
$ column -> setPlatformOptions ( [ ' option ' => ' value ' ] );Gibt den Wert für die angegebene Spaltenoption zurück
public function __get( string $ name )$name Name SpaltenoptionsnameDie Liste der verfügbaren Spaltenoptionen lautet:
Beispiele:
$ charset = $ column -> charset ;
// same as
$ charset = $ column -> opt ( ' charset ' );Legt den neuen Wert für die angegebene Spaltenoption fest
public function __set( string $ name , $ value )$name Name Spaltenoptionsname$value Spaltenoptionswert WertDie Liste der verfügbaren Spaltenoptionen lautet:
Beispiele:
$ column -> charset = ' utf8 ' ;
// same as
$ column -> opt ( ' charset ' , ' utf8 ' );Legt die Spalte als automatisch fest oder gibt den aktuellen Wert zurück
public function autoincrement( bool $ value = null )$value New AutoIncrement Flag oder Null, um den aktuellen Wert zurückzugeben Diese Methode ist ein Alias für die seq() -Methode.
Beispiele:
$ value = $ column -> autoincrement ();
$ column -> autoincrement ( true );Legt das Spalten -Zeichensatz fest oder gibt den aktuellen Wert zurück
public function charset( string $ value = null )$value New Spalte charset oder null, um den aktuellen Wert zurückzugebenBeispiele:
$ comment = $ column -> charset ();
$ column -> charset ( ' utf8 ' );Legt die Spaltenkollation fest oder gibt den aktuellen Wert zurück
public function collation( string $ value = null )$value New Spalte Collation oder Null, um den aktuellen Wert zurückzugebenBeispiele:
$ comment = $ column -> collation ();
$ column -> collation ( ' binary ' );Legt den Spaltenkommentar fest oder gibt den aktuellen Wert zurück
public function comment( string $ value = null )$value New Spalte Kommentar oder Null, um den aktuellen Wert zurückzugebenBeispiele:
$ comment = $ column -> comment ();
$ column -> comment ( ' column comment ' );Legt den Standardwert der Spalte fest oder gibt den aktuellen Wert zurück
public function default( $ value = null )$value Neuer Spalte Standardwert oder Null, um den aktuellen Wert zurückzugebenBeispiele:
$ value = $ column -> default ();
$ column -> default ( 0 );Legt das Spalten festgelegt oder gibt den aktuellen Wert zurück
public function fixed( bool $ value = null )$value New Spalte Fixed Flag oder Null, um den aktuellen Wert zurückzugebenBeispiele:
$ value = $ column -> fixed ();
$ column -> fixed ( true );Erstellt einen regulären Index für die Spalte
public function index( string $ name = null ) : self$name Name des Index oder Null, um automatisch zu generierenBeispiele:
$ column -> index ();
$ column -> index ( ' idx_col ' );Legt die Spaltenlänge fest oder gibt den aktuellen Wert zurück
public function length( int $ value = null )$value neue Spaltenlänge oder Null, um den aktuellen Wert zurückzugebenBeispiele:
$ value = $ column -> length ();
$ column -> length ( 32 );Gibt den Namen der Spalte zurück
public function name() : stringBeispiele:
$ name = $ column -> name ();Legt das Spalten -Null -Flag fest oder gibt den aktuellen Wert zurück
public function null( bool $ value = null )$value New Spalte Null Flag oder Null, um den aktuellen Wert zurückzugebenBeispiele:
$ value = $ column -> null ();
$ column -> null ( true );Legt den Spaltenoptionswert fest oder gibt den aktuellen Wert zurück
public function opt( string $ option , $ value = null , $ for = null )$option Spaltenoptionsname$value Neuer Spaltenoptionswert oder Null, um den aktuellen Wert zurückzugeben$for Datenbanktyp Diese Option sollte für ("mySQL", "mariadb", "postgresql", "sqlite", "SQLServer", "Oracle", "DB2") verwendet werden.Beispiele:
$ value = $ column -> opt ( ' length ' );
$ column -> opt ( ' length ' , 64 );Legt die Spaltengenauigkeit fest oder gibt den aktuellen Wert zurück
public function precision( int $ value = null )$value neuer Spalten Genisionswert oder Null, um den aktuellen Wert zurückzugebenBeispiele:
$ value = $ column -> precision ();
$ column -> precision ( 10 );Erstellt einen primären Index für die Spalte
public function primary( string $ name = null ) : self$name Name des Index oder Null, um automatisch zu generierenBeispiele:
$ column -> primary ();
$ column -> primary ( ' pk_col ' );Legt die Spaltenskala fest oder gibt den aktuellen Wert zurück
public function scale( int $ value = null )$value neuer Spaltenskala -Wert oder Null, um den aktuellen Wert zurückzugebenBeispiele:
$ value = $ column -> scale ();
$ column -> scale ( 3 );Legt die Spalte als automatisch fest oder gibt den aktuellen Wert zurück
public function seq( bool $ value = null )$value New AutoIncrement Flag oder Null, um den aktuellen Wert zurückzugebenBeispiele:
$ value = $ column -> seq ();
$ column -> seq ( true );Erstellt einen räumlichen Index für die Spalte
public function spatial( string $ name = null ) : self$name Name des Index oder Null, um automatisch zu generierenBeispiele:
$ column -> spatial ();
$ column -> spatial ( ' idx_col ' );Legt den Spaltentyp fest oder gibt den aktuellen Wert zurück
public function type( string $ value = null )$value neuer Spaltentyp oder Null, um den aktuellen Wert zurückzugebenBeispiele:
$ value = $ column -> type ();
$ column -> type ( ' tinyint ' );Erstellt einen eindeutigen Index für die Spalte
public function unique( string $ name = null ) : self$name Name des Index oder Null, um automatisch zu generierenBeispiele:
$ column -> unique ();
$ column -> unique ( ' unq_col ' );Legt das nicht signierte Flag des Spalte fest oder gibt den aktuellen Wert zurück
public function unsigned( bool $ value = null )$value New Spalte vorzeichenloses Flag oder Null, um den aktuellen Wert zurückzugebenBeispiele:
$ value = $ column -> unsigned ();
$ column -> unsigned ( true );Wendet die Änderungen am Datenbankschema an
public function up() : selfBeispiele:
$ column -> up (); UPSCHEME bietet Unterstützung für ausländische Schlüsselbeschränkungen, die die Integrität von Daten zwischen zwei Tabellen durchsetzen. Wenn beispielsweise auf die parentid -Spalte der Tabelle users_address die id -Spalte der users verweist, können in der Tabelle users_address keine Zeilen auftreten, ohne dass in der Tabelle users eine übereinstimmende Zeile entspricht. Wenn Sie die foreign() -Methode aufrufen, wird eine solche Einschränkung erzeugt:
$ this -> db ()-> table ( ' users ' , function ( $ table ) {
$ table -> id ();
} );
$ this -> db ()-> table ( ' users_address ' , function ( $ table ) {
$ table -> foreign ( ' parentid ' , ' users ' );
} ); HINWEIS: Die Spalte ( parentid ) wird denselben Datentyp und Spaltenmodifikatoren wie die Referenzspalte ( id ) aufweisen. Die foreign() -Methode stellt sicher, dass und erstellt und erstellt und erstellt und erstellt ein neuer Index mit dem gleichen Namen wie die fremde Schlüsselbeschränkung automatisch.
Wenn die ID -Spalte in der users unterschiedlich benannt ist, übergeben Sie ihren Namen als dritter Parameter an die foreign() -Methode:
$ this -> db ()-> table ( ' users_address ' , function ( $ table ) {
$ table -> foreign ( ' parentid ' , ' users ' , ' uid ' );
} );Es wird empfohlen, den Namen der Fremdschlüsselbeschränkung als Forth -Parameter zu übergeben, sodass es einfacher ist, sich später zu ändern oder zu fallen.
$ this -> db ()-> table ( ' users_address ' , function ( $ table ) {
$ table -> foreign ( ' parentid ' , ' users ' , ' id ' , ' fk_test_pid ' );
} );Wenn mehr als eine Spalte erforderlich sind, um die eindeutigen Werte zu erhalten, die von Fremdschlüssel erforderlich sind, übergeben Sie die Spaltennamen als Array:
$ this -> db ()-> table ( ' users_address ' , function ( $ table ) {
$ table -> foreign ( [ ' parentid ' , ' siteid ' ], ' users_address ' , [ ' id ' , ' siteid ' ] );
} ); Fremdschlüsseleinschränkungen können unterschiedliche Aktionen ausführen, wenn die Referenzspalte in der Fremdtabelle von aktualisiertem Löschen gelöscht wird. Die Standardaktion besteht darin, das Löschen der Zeile zu beschränken oder den referenzierten ID -Wert zu aktualisieren. Verwenden Sie um das Verhalten zu ändern, und verwenden Sie die Methoden onDelete() und onUpdate() :
$ this -> db ()-> table ( ' users_address ' , function ( $ table ) {
$ table -> foreign ( ' parentid ' , ' users ' )-> onDelete ( ' SET NULL ' )-> onUpdate ( ' RESTRICT ' );
} );Es gibt eine Abkürzung, wenn Sie beide Werte auf denselben Wert einstellen möchten:
$ this -> db ()-> table ( ' users_address ' , function ( $ table ) {
$ table -> foreign ( ' parentid ' , ' users ' )-> do ( ' SET NULL ' );
} );Mögliche Werte für beide Methoden sind:
Die Standardaktion beim Löschen oder Aktualisieren von Zeilen ist die Kaskade, sodass die Werte der Spalte Fremdschlüssel auf die gleichen Werte wie in der Fremdtabelle aktualisiert werden.
Um zu überprüfen, ob bereits ein Fremdschlüssel vorhanden ist, verwenden Sie die Methode hasForeign() :
if ( $ this -> db ()-> hasForeign ( ' users_address ' , ' fk_usrad_parentid ' ) ) {
// The "fk_usrad_parentid" foreign key in the " users_address " table exists
} Es ist auch möglich, mehrere ausländische Schlüsselbeschränkungen gleichzeitig zu überprüfen. Anschließend wird die Methode hasForeign() nur wahr zurückgegeben, wenn alle Einschränkungen in den Tabellen als erstes Argument bestehen:
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
} Wenn ein Tabellenobjekt verfügbar ist, kann stattdessen die Methode von hasForeign() der Tabelle verwendet werden:
$ 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
}
} );Falls Sie die aktuellen Werte einer vorhandenen Einschränkung benötigen:
$ 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 ;
} ); Verwenden Sie die dropForeign() -Methode und übergeben Sie den Namen der Tabelle und des Fremdschlüsselnamens als Argumente:
$ this -> db ()-> dropForeign ( ' users_address ' , ' fk_usrad_parentid ' );Sie können auch mehrere ausländische Schlüsselnamen verabschieden, um sie gleichzeitig fallen zu lassen:
$ this -> db ()-> dropForeign ( ' users_address ' , [ ' fk_usrad_parentid ' , ' fk_usrad_siteid ' ] ); In der anonymen Funktion, die an die Methode table() übergeben wurde, können Sie auch die Methode dropForeign() verwenden:
$ 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 ' ] );
} );Ruft benutzerdefinierte Methoden auf
public function __call( string $ method , array $ args )$method -Name der Methode$args Method -ParameterBeispiele:
Sie können benutzerdefinierte Methoden registrieren, die Zugriff auf die Klasseneigenschaften des UpScheme -Fremdenobjekts haben:
Aimeos Upscheme Schema Foreign:: macro ( ' default ' , function () {
$ this -> opts = [ ' onDelete ' => ' SET NULL ' , ' onUpdate ' => ' SET NULL ' ];
} );
$ foreign -> default ();Verfügbare Klasseneigenschaften sind:
$this->dbaltable : Doktrinentabellenschema
$this->table : upScheme Table-Objekt
$this->localcol : Lokale Spaltenname oder Namen
$this->fktable : Fremdtabellenname
$this->fkcol : Fremdspaltenname oder Namen
$this->name : Fremdschlüsselname
$this->opts : assoziative Liste ausländischer Schlüsseloptionen (hauptsächlich "ontdelete" und "onupdate")
Gibt den Wert für die angegebene Fremdschlüsseloption zurück
public function __get( string $ name )$name FremdschlüsseloptionsnameDie Liste der verfügbaren ausländischen Schlüsseloptionen lautet:
Mögliche Werte für beide Optionen sind:
Beispiele:
$ value = $ foreign -> onDelete ;
// same as
$ value = $ foreign -> opt ( ' onDelete ' );Legt den neuen Wert für die angegebene Fremdschlüsseloption fest
public function __set( string $ name , $ value )$name FremdschlüsseloptionsnameDie Liste der verfügbaren ausländischen Schlüsseloptionen lautet:
Mögliche Werte für beide Optionen sind:
Beispiele:
$ foreign -> onDelete = ' SET NULL ' ;
// same as
$ foreign -> onDelete ( ' SET NULL ' );
$ foreign -> opt ( ' onDelete ' , ' SET NULL ' );Legt den neuen Wert für die angegebene Fremdschlüsseloption fest
public function do( string $ action ) : self$action durchgeführt AktionMögliche Aktionen sind:
Beispiele:
$ foreign -> do ( ' RESTRICT ' ); public function name()Beispiele:
$ fkname = $ foreign -> name (); public function onDelete( string $ value = null ) @param String | Null $value Action oder Null, um den aktuellen Wert zurückzugeben
@Return Self | String Das gleiche Objekt zum Einstellen des Wertes, aktueller Wert ohne Parameter
Verfügbare Aktionen sind:
Beispiele:
$ value = $ foreign -> onDelete ();
$ foreign -> onDelete ( ' SET NULL ' );
// same as
$ foreign -> onDelete = ' SET NULL ' ;
// same as
$ foreign -> opt ( ' onDelete ' , ' SET NULL ' );
$ foreign -> onDelete ( ' SET NULL ' )-> onUpdate ( ' SET NULL ' ); public function onUpdate( string $ value = null ) @param String | Null $value Action oder Null, um den aktuellen Wert zurückzugeben
@Return Self | String Das gleiche Objekt zum Einstellen des Wertes, aktueller Wert ohne Parameter
Verfügbare Aktionen sind:
Beispiele:
$ 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() : selfBeispiele:
$ foreign -> up (); Einige Datenbankimplementierungen bieten Sequenzen anstelle von automatischen Inkrement-/Identitätsspalten, nämlich Oracle und PostgreSQL. Sequenzen sind Funktionen, die nacheinander zunehmende Zahlen erzeugen, die beim Einfügen neuer Zeilen auf eine Tabellenspalte angewendet werden. Um eine neue Sequenz namens SEQ_TEST zu erstellen, verwenden Sie die Methode sequence() :
$ this -> db ()-> sequence ( ' seq_test ' ); Um einen anderen Startwert und eine Schrittbreite als 1 zu verwenden, rufen Sie die Methoden start() und step() auf:
$ this -> db ()-> sequence ( ' seq_test ' , function ( $ seq ) {
$ seq -> start ( 1000 )-> step ( 2 );
} ); Um zu überprüfen, ob bereits eine Sequenz vorliegt, verwenden Sie die hasSequence() -Methode:
if ( $ this -> db ()-> hasSequence ( ' seq_test ' ) ) {
// The "seq_test" sequence exists
} Es ist auch möglich, mehrere Sequenzen gleichzeitig zu überprüfen. Anschließend gibt die hasSequence() -Methode nur dann zurück, wenn alle Sequenzen vorhanden sind:
if ( $ this -> db ()-> hasSequence ( [ ' seq_id ' , ' seq_test ' ] ) ) {
// The "seq_id" and "seq_test" sequences exist
}Falls Sie die aktuellen Werte der Tabellenoptionen kennen müssen:
$ 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 ;
} ); Um eine Sequenz zu entfernen, verwenden Sie die dropSequence() -Methode () und übergeben Sie den Namen der Sequenz als Argument:
$ this -> db ()-> dropSequence ( ' seq_id ' );Sie können auch mehrere Sequenznamen übergeben, um sie gleichzeitig fallen zu lassen:
$ this -> db ()-> dropSequence ( [ ' seq_id ' , ' seq_test ' ] );Ruft benutzerdefinierte Methoden auf oder übergibt unbekannte Methodenaufrufe an das Doktrinentabellenobjekt
public function __call( string $ method , array $ args )$method -Name der Methode$args Method -ParameterBeispiele:
Sie können benutzerdefinierte Methoden registrieren, die Zugriff auf die Klasseneigenschaften des UPSCHEME -Sequenzobjekts haben:
Aimeos Upscheme Schema Sequence:: macro ( ' default ' , function () {
$ this -> start ( 1 )-> step ( 2 );
} );
$ sequence -> default ();Verfügbare Klasseneigenschaften sind:
$this->db : upscheme db-Objekt
$this->sequence : Doktrinsequenzschema
Gibt den Wert für die angegebene Sequenzoption zurück
public function __get( string $ name )$name Sequence Option Name NameBeispiele:
$ value = $ sequence -> getInitialValue ();
// same as
$ value = $ sequence -> start ();Legt den neuen Wert für die angegebene Sequenzoption fest
public function __set( string $ name , $ value )$name Sequence Option Name NameBeispiele:
$ value = $ sequence -> setInitialValue ( 1000 );
// same as
$ value = $ sequence -> start ( 1000 );Legt die zwischengespeicherte Größe der Sequenz fest oder gibt den aktuellen Wert zurück
public function cache( int $ value = null )$value Neue Anzahl von Sequenz -IDs, die vom Client oder Null zwischengespeichert wurden, um den aktuellen Wert zurückzugebenBeispiele:
$ value = $ sequence -> cache ();
$ sequence -> cache ( 100 );Gibt den Namen der Sequenz zurück
public function name() $ name = $ sequence -> name ();Legt den neuen Startwert der Sequenz fest oder gibt den aktuellen Wert zurück
public function start( int $ value = null )$value Neustartwert der Sequenz oder NULL, um den aktuellen Wert zurückzugeben $ value = $ sequence -> start ();
$ sequence -> start ( 1000 );Legt die Schrittgröße neuer Sequenzwerte fest oder gibt den aktuellen Wert zurück
public function step( int $ value = null )$value Neue Schrittgröße Die Sequenz wird durch oder durch NULL inkrementiert oder verringert, um den aktuellen Wert zurückzugeben $ value = $ sequence -> step ();
$ sequence -> step ( 2 );Wendet die Änderungen am Datenbankschema an
public function up() : self $ sequence -> up ();Die Indizes beschleunigen Datenbankabfragen und die Zeit, in der eine Abfrage von einigen Minuten auf Millisekunden sinkt, wenn sie korrekt verwendet werden. Es sind mehrere Indextypen verfügbar:
Alle Indizes können aus einer oder mehreren Spalten bestehen, aber die Reihenfolge der Spalten hat einen großen Einfluss, wenn Indizes für eine Abfrage verwendet werden oder nicht.
Alle Indizes sind an die Tabelle gebunden, die die Spalten enthält, die der Index abdeckt. Die einfachste Möglichkeit, einen Index über eine einzelne Spalte zu erstellen, besteht darin, die Methode des Spaltenobjekts index() zu verwenden:
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
$ table -> string ( ' label ' )-> index ();
} ); Mit dem zweiten Parameter der index() -Methode können Sie einen benutzerdefinierten Namen für den Index festlegen:
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
$ table -> string ( ' label ' )-> index ( ' idx_test_label ' );
} );Hinweis: Für eine maximale Kompatibilität zwischen verschiedenen Datenbanktypen sollte die Länge der Indexnamen 30 Zeichen oder weniger betragen.
Gleiches gilt für primäre, einzigartige und räumliche Indizes:
$ 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 ' );
} ); Für Multi-Säulen-Indizes sind im Tabellenobjekt die Methoden primary() , unique() und index() verfügbar:
$ 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 ' ] );
} ); Räumliche Indizes können nicht mehrere Spalten umfassen, aber das Erstellen ist auch mit der methode spatial() des Tabellenobjekts möglich:
$ this -> db ()-> table ( ' test ' , function ( $ table ) {
$ table -> spatial ( ' location ' );
} ); To check if an index already exists, use the hasIndex() method:
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
