upscheme

Upscheme : les mises à jour des schémas de base de données simplifiées

Package PHP facile à utiliser pour mettre à jour le schéma de base de données de votre application et migrer les données entre les versions.

composer req aimeos/upscheme

Table des matières

• Pourquoi Upscheme
• Prise en charge de la base de données
• Intégration du système Upschem
• Écriture des migrations
  • Appellation
  • Dépendances
  • Messages
  • Schémas
  • Générer à partir d'une base de données
• Base de données
  • Accéder aux objets
  • Vérification de l'existence
  • Renommer des objets
  • Supprimer des objets
  • Interroger/modifier les lignes du tableau
  • Exécution de SQL personnalisé
  • Méthodes de base de données
• Tableaux
  • Création de tableaux
  • Définition des options du tableau
  • Vérification de l'existence d'une table
  • Tables à langer
  • Renommer les tables
  • Suppression de tables
  • Méthodes de table
• Colonnes
  • Ajout de colonnes
  • Types de colonnes disponibles
  • Modificateurs de colonne
  • Vérifier l'existence d'une colonne
  • Changer de colonnes
  • Renommer les colonnes
  • Suppression de colonnes
  • Méthodes de colonnes
• Clés étrangères
  • Création de clés étrangères
  • Vérification de l'existence d'une clé étrangère
  • Supprimer les clés étrangères
  • Méthodes de clé étrangère
• Séquences
  • Ajout de séquences
  • Vérification de l'existence d'une séquence
  • Suppression de séquences
  • Méthodes de séquence
• Index
  • Ajout d'index
  • Vérification de l'existence de l'index
  • Renommer les index
  • Suppression d'index
  • Dénomination d'index personnalisée
• Personnalisation du schéma supérieur
  • Ajout de méthodes personnalisées
  • Implémentation de colonnes personnalisées
• Programme de mise à niveau

Pourquoi Upscheme

Les migrations sont comme un contrôle de version pour votre base de données. Ils vous permettent d'obtenir exactement le même état dans chaque installation. En utilisant Upscheme, vous obtenez :

• un seul endroit pour définir facilement des tables, des colonnes, des index, etc.
• mises à niveau de n'importe quel état intermédiaire vers le schéma attendu
• mises à niveau de schéma cohérentes, fiables et sans tracas
• code minimal requis pour l'écriture des migrations
• solution parfaite pour les déploiements continus
• meilleur package pour les applications PHP basées sur le cloud

Voici un exemple de définition de tableau que vous pouvez adapter chaque fois que la disposition de votre tableau doit changer. Ensuite, Upscheme ajoutera et modifiera automatiquement les colonnes et propriétés de table existantes (mais ne supprimera rien pour des raisons de sécurité) :

 $ 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 ' ] );
} );

Pour la mise à niveau des schémas de bases de données relationnelles, deux packages sont actuellement les plus souvent utilisés : Doctrine DBAL et Doctrine migrations. Bien que Doctrine DBAL fasse du bon travail en résumant les différences entre plusieurs implémentations de bases de données, son API nécessite l'écriture de beaucoup de code. Les migrations de doctrine sur l'autre site présentent certains inconvénients qui rendent difficile leur utilisation dans toutes les applications prenant en charge les extensions tierces.

Inconvénients de la doctrine DBAL

L'API de DBAL est très verbeuse et vous devez écrire beaucoup de code même pour des choses simples. Upscheme utilise Doctrine DBAL pour offrir une API facile à utiliser permettant de mettre à niveau le schéma de base de données de votre application avec un minimum de code. Pour l'exemple Upscheme ci-dessus, ces lignes de code sont l'équivalent de DBAL dans une 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 );
}

Inconvénients de la migration de doctrine

Doctrine Migration s'appuie sur des classes de migration qui sont nommées au moment où elles ont été créées pour garantir un certain ordre. De plus, il stocke les migrations exécutées dans une table de votre base de données. Trois problèmes majeurs en découlent :

• dépendances entre extensions tierces
• le suivi des modifications n'est pas synchronisé
• perte de données lors de l'utilisation down()

Si votre application prend en charge les extensions tierces, ces extensions sont susceptibles d'ajouter des colonnes aux tables existantes et de migrer elles-mêmes les données. Comme il n'existe aucun moyen de définir les dépendances entre les migrations, il peut devenir presque impossible d'exécuter des migrations dans une application comportant plusieurs extensions tierces sans conflits. Pour éviter cela, Upscheme propose des méthodes before() et after() faciles à utiliser dans chaque tâche de migration, où les tâches peuvent définir leurs dépendances par rapport à d'autres tâches.

Étant donné que Doctrine Migrations utilise une table de base de données pour enregistrer quelle migration a déjà été exécutée, ces enregistrements peuvent facilement se désynchroniser en cas de problèmes. Au contraire, Upscheme s'appuie uniquement sur le schéma réel, il est donc possible d'effectuer une mise à niveau à partir de n'importe quel état, indépendamment de ce qui s'est passé auparavant.

Doctrine Migrations prend également en charge les opérations inverses dans les méthodes down() afin que vous puissiez annuler les migrations, ce que Upscheme ne fait pas. L'expérience a montré qu'il est souvent impossible d'annuler les migrations, par exemple après avoir ajouté une nouvelle colonne, migré les données d'une colonne existante et supprimé ensuite l'ancienne colonne. Si la migration des données s'est produite avec perte, vous ne pouvez pas recréer le même état dans une méthode down() . Il en va de même si vous avez supprimé une table. Ainsi, Upscheme propose uniquement une mise à niveau du schéma mais pas de rétrogradation pour éviter la perte implicite de données.

Prise en charge de la base de données

Upscheme utilise Doctrine DBAL pour extraire différentes implémentations de serveurs de bases de données. DBAL prend en charge tous les principaux systèmes de gestion de bases de données relationnelles (SGBDR), mais avec un niveau de prise en charge différent pour les fonctionnalités disponibles :

Bon accompagnement :

• MySQL
• MariaDB
• PostgreSQL
• SQLite
• serveur SQL

Prise en charge limitée :

• DB2
• Oracle
• SQL n'importe où

Intégration du système Upschem

Après avoir installé le package aimeos/upscheme à l'aide de composer, vous pouvez utiliser la classe Up pour exécuter vos tâches de migration :

 $ config = [
	' driver ' => ' pdo_mysql ' ,
	' host ' => ' 127.0.0.1 ' ,
	' dbname ' => ' <database> ' ,
	' user ' => ' <dbuser> ' ,
	' password ' => ' <secret> '
];

 Aimeos  Upscheme Up:: use ( $ config , ' src/migrations ' )-> up ();

La méthode Up::use() nécessite deux paramètres : la configuration de la base de données et le(s) chemin(s) d'accès aux tâches de migration. Pour la configuration, les clés du tableau et les valeurs du pilote doivent être prises en charge par Doctrine DBAL. Les pilotes disponibles sont :

• pdo_mysql
• pdo_pgsql
• pdo_sqlite
• pdo_sqlsrv
• pdo_oci
• ibm_db2
• mysqli
• oci8
• sqlanywhere
• sqlsrv

Certaines bases de données nécessitent des paramètres différents, notamment SQLite et Oracle :

SQLite :

 $ config = [
	' driver ' => ' pdo_sqlite ' ,
	' path ' => ' path/to/file.sq3 '
];

Oracle:

 $ config = [
	' driver ' => ' pdo_oci ' ,
	' host ' => ' <host or IP> ' ,
	' dbname ' => ' <SID or service name (Oracle 18+)> ' ,
	' service ' => true , // for Oracle 18 + only
	' user ' => ' <dbuser> ' ,
	' password ' => ' <secret> '
];

Si vous n'avez jamais utilisé Doctrine DBAL auparavant, la configuration de votre base de données peut avoir une structure différente et/ou utiliser des valeurs différentes pour le type de base de données. Upscheme vous permet d'enregistrer une méthode personnalisée qui transforme votre configuration en paramètres DBAL valides, par exemple :

 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 prend également en charge plusieurs connexions à des bases de données que vous pouvez distinguer par leur nom de clé :

 $ 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 ();

Bien entendu, vous pouvez également passer plusieurs chemins de migration vers la classe Up :

 Aimeos  Upscheme Up:: use ( $ config , [ ' src/migrations ' , ' ext/migrations ' ] )-> up ();

Pour activer la sortie (débogage), utilisez la méthode 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 

Écriture des migrations

Une tâche de migration nécessite uniquement l'implémentation de la méthode up() et doit être stockée dans l'un des répertoires passés à la classe Up :

 <?php

namespace Aimeos  Upscheme  Task ;
use Aimeos  Upscheme  Schema  Table ;


return new class ( $ this ) extends Base {

	public function up ()
	{
		$ this -> db ()-> table ( ' test ' , function ( Table $ t ) {
			$ t -> id ();
			$ t -> string ( ' label ' );
			$ t -> bool ( ' status ' );
		} );
	}
};

Dans votre fichier PHP, incluez toujours l'instruction namespace en premier. L'instruction use est facultative et n'est nécessaire que comme raccourci pour l'indication de type pour l'argument de la fonction de fermeture. Votre classe doit également s'étendre à partir de la classe de tâches "Base" ou implémenter l'interface de tâches "Iface".

Alternativement aux classes anonymes, vous pouvez utiliser des classes nommées pour les tâches de migration :

 <?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 ' );
		} );
	}
}

Le fichier dans lequel votre classe est stockée doit avoir le même nom (sensible à la casse) que la classe elle-même et le suffixe .php , par exemple :

 class TestTable -> TestTable.php

Nommer les migrations

Il n'existe pas de convention stricte sur la manière de nommer les fichiers de tâches de migration. Vous pouvez soit les nommer par ce qu'ils font (par exemple "CreateTestTable.php"), ce sur quoi ils opèrent (par exemple "TestTable.php") ou même utiliser un horodatage (par exemple "20201231_Test.php").

Si les tâches ne contiennent pas de dépendances, elles sont triées et exécutées par ordre alphabétique selon le nom du fichier et le tri serait :

 20201231_Test.php
CreateTestTable.php
TestTable.php

Dépendances

Pour spécifier des dépendances avec d'autres tâches de migration, utilisez les méthodes after() et before() . Votre tâche est exécutée après les tâches renvoyées par after() et avant les tâches renvoyées par before() :

 return new class ( $ this ) extends Base {

	public function after () : array
	{
		return [ ' CreateRefTable ' ];
	}

	public function before () : array
	{
		return [ ' InsertTestData ' ];
	}
}

Les noms de tâches sont les noms de fichiers des tâches sans le suffixe .php . Si l'exemple de migration est stocké dans le fichier TestTable.php , l'ordre d'exécution serait :

 CreateRefTable.php -> TestTable.php -> InsertTestData.php

Messages

Pour afficher des messages dans votre tâche de migration, utilisez la méthode info() :

 $ this -> info ( ' some message ' );
$ this -> info ( ' more verbose message ' , ' vv ' );
$ this -> info ( ' very verbose debug message ' , ' vvv ' );

Le deuxième paramètre est le niveau de verbosité et none ou v sont des messages standard, vv sont des messages qui ne sont affichés que si plus de verbosité est souhaitée tandis que vvv est destiné aux messages de débogage. Il existe également un troisième paramètre pour indenter les messages :

 $ this -> info ( ' some message ' );
$ this -> info ( ' second level message ' , ' v ' , 1 );
$ this -> info ( ' third level message ' , ' v ' , 2 );

Cela affichera :

 some message
  second level message
    third level message

La condition préalable est que la méthode verbose() de la classe Up ait déjà été appelée :

 Aimeos  Upscheme Up:: use ( $ config , ' ... ' )-> verbose ()-> up ();

Schémas

Dans la méthode up() , vous avez accès au schéma de la base de données à l'aide de la méthode db() . Si vous avez transmis plusieurs configurations de base de données à Up::use() , vous pouvez accéder aux différents schémas par leur clé de configuration :

 // $config = [ 'db' => [ ... ] , 'temp' => [ ... ] ] ;
// Aimeos  UpschemeUp::use( $config , '...' )->up() ;

$ this -> db ();
$ this -> db ( ' db ' );
$ this -> db ( ' temp ' );

Si vous ne transmettez aucune clé de configuration ou une clé qui n'existe pas, la première configuration est renvoyée ("db" dans ce cas). En utilisant les méthodes disponibles de l'objet schéma de base de données, vous pouvez ajouter, mettre à jour ou supprimer des tables, des colonnes, des index et d'autres objets de base de données. Vous pouvez également utiliser insert() , select() , update() , delete() et stmt() pour manipuler les enregistrements des tables.

Après chaque tâche de migration, les mises à jour de schéma effectuées dans la tâche sont automatiquement appliquées à la base de données. Si vous devez conserver une modification immédiatement parce que vous souhaitez insérer des données, appelez vous-même $this->db()->up() . La méthode up() est également disponible dans n’importe quel objet table, séquence et colonne afin que vous puissiez appeler up() partout.

Dans les cas où vous avez besoin de deux connexions de base de données différentes parce que vous souhaitez exécuter les instructions SELECT et INSERT/UPDATE/DELETE en même temps, transmettez TRUE comme deuxième paramètre à db() pour obtenir le schéma de base de données incluant une nouvelle connexion :

 $ 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 ] );

Toutes les modifications apportées au schéma sont appliquées à la base de données avant que le schéma avec la nouvelle connexion ne soit renvoyé. Pour éviter que les connexions à la base de données ne s'accumulent jusqu'à ce que le serveur de base de données rejette les nouvelles connexions, appelez toujours close() pour les nouvelles connexions créées par db( '<name>', true ) :

 $ db2 -> close ();

Générer à partir d'une base de données

Au lieu d'écrire manuellement les migrations pour vos objets de base de données, vous pouvez générer automatiquement les fichiers de migration en utilisant :

 $ config = [
	' db ' => [
		' driver ' => ' pdo_mysql ' ,
		' host ' => ' 127.0.0.1 ' ,
		' dbname ' => ' <database> ' ,
		' user ' => ' <dbuser> ' ,
		' password ' => ' <secret> '
	]
];

 Aimeos  Upscheme Up:: use ( $ config , ' migrations ' )-> create ();

Cela générera un fichier pour chaque séquence, table et vue dans le répertoire passé ( ./migrations/ dans cet exemple). Si vous disposez de plusieurs bases de données et souhaitez créer des migrations pour toutes en même temps, transmettez les clés de connexion de la configuration à create() :

 $ config = [
	' db ' => [
		' driver ' => ' pdo_mysql ' ,
		// ...
	],
	' order ' => [
		' driver ' => ' pdo_oci ' ,
		// ...
	]
];

 Aimeos  Upscheme Up:: use ( $ config , ' migrations ' )-> create ( [ ' db ' , ' order ' ] );

Base de données

Accéder aux objets

Vous obtenez l'objet schéma de base de données dans votre tâche en appelant $this->db() comme décrit dans la section schéma. Il vous donne un accès complet au schéma de la base de données, y compris toutes les tables, séquences et autres objets du schéma :

 $ table = $ this -> db ()-> table ( ' users ' );
$ seq = $ this -> db ()-> sequence ( ' seq_users ' );

Si la table ou la séquence n'existe pas, elle sera créée. Sinon, l'objet table ou séquence existant est renvoyé. Dans les deux cas, vous pouvez modifier les objets par la suite et ajouter par exemple de nouvelles colonnes au tableau.

Vérification de l'existence

Vous pouvez tester les tables, colonnes, index, clés étrangères et séquences en utilisant le schéma de base de données renvoyé par $this->db() :

 $ db = $ this -> db ();

if ( $ db -> hasTable ( ' users ' ) ) {
    // The "users" table exists
}

if ( $ db -> hasColumn ( ' users ' , ' name ' ) ) {
    // The "name" column in the "users" table exists
}

if ( $ db -> hasIndex ( ' users ' , ' idx_name ' ) ) {
    // The "idx_name" index in the "users" table exists
}

if ( $ db -> hasForeign ( ' users_address ' , ' fk_users_id ' ) ) {
    // The foreign key "fk_users_id" in the " users_address " table exists
}

if ( $ db -> hasSequence ( ' seq_users ' ) ) {
    // The "seq_users" sequence exists
}

if ( $ db -> hasView ( ' testview ' ) ) {
    // The "testview" view exists
}

Renommer des objets

L'objet base de données renvoyé par $this->db() offre la possibilité de renommer des tables, des colonnes et des index en utilisant renameTable() , renameColumn() et renameIndex() :

 $ db = $ this -> db ();

// Renames the table "users" to "accounts"
$ db -> renameTable ( ' users ' , ' account ' );

// Renames the column "label" to "name" in the "users" table
$ db -> renameColumn ( ' users ' , ' label ' , ' name ' );

// Renames the column "idx_label" to "idx_name" in the "users" table
$ db -> renameIndex ( ' users ' , ' idx_label ' , ' idx_name ' );

Supprimer des objets

L'objet de base de données renvoyé par $this->db() possède également des méthodes pour supprimer des tables, des colonnes, des index, des clés étrangères et des séquences :

 $ db = $ this -> db ();

// Drops the foreign key " fk_users_id " from the " users_address " table
$ db -> dropForeign ( ' users_address ' , ' fk_users_id ' );

// Drops the " idx_name " index from the " users " table
$ db -> dropIndex ( ' users ' , ' idx_name ' );

// Drops the " name " column from the " users " table
$ db -> dropColumn ( ' users ' , ' name ' );

// Drops the "seq_users" sequence
$ db -> dropSequence ( ' seq_users ' );

// Drops the "users" table
$ db -> dropTable ( ' users ' );

// Drops the "testview" view
$ db -> dropView ( ' testview ' );

Si la table, la colonne, l'index, la clé étrangère ou la séquence n'existe pas, elle est ignorée en silence. Dans les cas où vous avez besoin de savoir s'ils existent, utilisez les méthodes hasTable() , hasColumn() , hasIndex() , hasForeign() et hasSeqence() avant, comme décrit dans la section "Vérification de l'existence".

Interroger/modifier les lignes du tableau

Les méthodes insert() , select() , update() et delete() sont un moyen simple d'ajouter, de récupérer, de modifier et de supprimer des lignes dans n'importe quelle table :

 $ this -> db ()-> transaction ( function ( $ db ) {

	$ db2 = $ this -> db ( ' db ' , true );

	foreach ( $ db2 -> select ( ' users ' , [ ' status ' => false ] ) as $ row )
	{
		$ db -> insert ( ' newusers ' , [ ' userid ' => $ row [ ' id ' ], ' status ' => true ] );
		$ db -> update ( ' users ' , [ ' refid ' => $ db -> lastId ()], [ ' id ' => $ row [ ' id ' ]] );
	}

	$ db -> delete ( ' newusers ' , [ ' status ' => false ] );
	$ db2 -> close ();
} );

Si vous utilisez select() simultanément avec insert() , update() ou delete() , vous devez créer une deuxième connexion à la base de données car l'instruction select() renverra des lignes pendant que vous enverrez de nouvelles commandes au serveur de base de données. Cela ne fonctionne que sur des connexions distinctes, pas sur les mêmes.

Pour encapsuler toutes les opérations de suppression/insertion/mise à jour dans une transaction, vous devez utiliser la méthode transaction() de l'objet de base de données :

 $ this -> db ()-> transaction ( function ( $ db ) {
	// $db- > insert ( ... )
	// $db- > update ( ... )
	// $db- > delete ( ... )
} );

Cela garantit que toutes les opérations d'écriture sont effectuées de manière atomique ou aucune d'entre elles en cas d'erreur. La méthode transaction() garantit que la transaction est validée ou annulée automatiquement une fois que votre fonction anonyme a rendu le contrôle à la méthode.

Si vous avez besoin de paramètres supplémentaires au sein de votre fonction anonyme, vous pouvez les fournir dans la liste use de votre fonction :

 $ userid = 123 ;
$ this -> db ()-> transaction ( function ( $ db ) use ( $ userid ) {
	$ db -> insert ( ' newusers ' , [ ' userid ' => userid, ' status ' => true ] );
} );

Vous ne pouvez transmettre que de simples paires clé/valeur pour les conditions aux méthodes combinées par AND. Si vous avez besoin de requêtes plus complexes, utilisez plutôt 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 ();

La méthode stmt() renvoie un objet DoctrineDBALQueryQueryBuilder qui vous permet de créer une instruction plus avancée. Veuillez consulter la documentation de Doctrine Query Builder pour plus de détails.

Si vous souhaitez utiliser des valeurs directement dans une instruction SQL (utilisez des instructions préparées pour des raisons de sécurité autant que possible !), vous devez citer les valeurs à l'aide de la méthode q() :

 $ db = $ this -> db ();

$ result = $ db -> stmt ()-> select ( ' * ' )-> from ( ' products ' )
	-> where ( ' status = ' . $ db -> q ( $ _GET [ ' status ' ] ) )-> executeQuery ();

De même, si votre schéma contient des mots-clés réservés, par exemple en tant que noms de colonnes, vous devez également les citer en utilisant la méthode qi() :

 $ db = $ this -> db ();

$ result = $ db -> stmt ()-> select ( $ db -> qi ( ' key ' ) )-> from ( ' products ' )-> executeQuery ();

Exécution de SQL personnalisé

Doctrine ne prend en charge qu'un sous-ensemble commun d'instructions SQL et ne prend pas en charge toutes les possibilités mises en œuvre par les fournisseurs de bases de données. Pour supprimer cette limite, Upscheme propose les méthodes exec() , for() et query() pour exécuter des instructions SQL personnalisées non prises en charge par Doctrine DBAL.

Pour exécuter des requêtes SQL personnalisées, utilisez la méthode query() qui renvoie un ensemble de résultats sur lequel vous pouvez parcourir :

 $ sql = ' SELECT id, label, status FROM product WHERE label LIKE ? ' ;
$ result = $ this -> db ()-> query ( $ sql , [ ' test% ' ] );

foreach ( $ result -> iterateAssociative () as $ row ) {
	// ...
}

Pour toutes les autres instructions SQL, utilisez la méthode exec() qui renvoie le nombre de lignes affectées :

 $ sql = ' UPDATE product SET status=? WHERE status=? ' ;
$ num = $ this -> db ()-> exec ( $ sql , [ 1 , 0 ] );

En utilisant la méthode for() , vous pouvez également exécuter des instructions en fonction de la plateforme de base de données :

 $ this -> db ()-> for ( ' mysql ' , ' CREATE FULLTEXT INDEX idx_text ON product (text) ' );

La spécification de la plate-forme de base de données est très utile pour créer des types spéciaux d'index où la syntaxe diffère selon les implémentations de base de données.

Méthodes de base de données

Base de données

• __appel()
• fermer()
• supprimer()
• dropColumn()
• dropForeign()
• dropIndex()
• dropSequence()
• dropTable()
• dropView()
• exécutable()
• pour()
• hasColumn()
• hasForeign()
• hasIndex()
• hasSequence()
• hasTable()
• hasView()
• insérer()
• dernierId()
• nom()
• q()
• qi()
• requête()
• renommerColonne()
• renommerIndex()
• renommerTable()
• réinitialiser()
• sélectionner()
• séquence()
• stmt()
• tableau()
• versArray()
• transaction()
• taper()
• en haut()
• mise à jour()
• voir()

DB::__appel()

Appelle des méthodes personnalisées ou transmet des appels de méthodes inconnues à l'objet schéma Doctrine

 public function __call( string $ method , array $ args )

• @param string $method Nom de la méthode
• @param array<mixed> $args Paramètres de la méthode
• @return Mixed Valeur de retour de la méthode appelée

Exemples :

Vous pouvez enregistrer des méthodes personnalisées ayant accès aux propriétés de classe de l'objet Upscheme DB :

 Aimeos  Upscheme  Schema  DB :: macro ( ' hasFkIndexes ' , function ( $ val ) {
	return $ this -> to -> hasExplicitForeignKeyIndexes ();
} );

$ db -> hasFkIndexes ();
// returns true / false

Les propriétés de classe disponibles sont :

$this->from : Schéma de la base de données Doctrine originale représentant la base de données actuelle

$this->to : Schéma de la base de données Doctrine contenant les modifications apportées jusqu'à présent

$this->conn : Connexion à la base de données Doctrine

$this->up : objet Upscheme

De plus, vous pouvez appeler directement n'importe quelle méthode de schéma Doctrine, par exemple :

 $ db -> hasExplicitForeignKeyIndexes ();

DB::fermer()

Ferme la connexion à la base de données

 public function close() : void

Appelez close() uniquement pour les objets de schéma DB créés avec $this->db( '...', true ) . Sinon, vous fermerez la connexion principale et DBAL devra se reconnecter au serveur, ce qui dégradera les performances !

Exemples :

 $ db = $ this -> db ( ' temp ' , true );
$ db -> dropTable ( ' test ' );
$ db -> close ();

DB::supprimer()

Supprime les enregistrements de la table donnée

 public function delete( string $ table , array $ conditions = [] ) : self

• @param string $table Nom de la table
• @param array<string,mixed> $conditions Paires clé/valeur de noms de colonnes et de valeurs à comparer
• @return self Même objet pour les appels de méthode fluide

Attention : les valeurs de condition sont échappées, mais pas le nom de la table et les noms des colonnes de condition ! Utilisez uniquement des chaînes fixes pour le nom de la table et les noms des colonnes de conditions, mais aucune entrée externe !

Exemples :

 $ db -> delete ( ' test ' , [ ' status ' => false , ' type ' => ' old ' ] );
$ db -> delete ( ' test ' );

Plusieurs conditions passées en deuxième paramètre sont combinées par "ET". Si vous avez besoin d’instructions plus complexes, utilisez plutôt la méthode stmt() .

DB::dropColumn()

Supprime la colonne donnée par son nom si elle existe

 public function dropColumn( string $ table , $ name ) : self

• @param string $table Nom de la table à laquelle appartient la colonne
• @param array<string>|string $name Nom de la ou des colonnes
• @return self Même objet pour les appels de méthode fluide

Exemples :

 $ db -> dropColumn ( ' test ' , ' oldcol ' );
$ db -> dropColumn ( ' test ' , [ ' oldcol ' , ' oldcol2 ' ] );

Si la colonne ou l'une des colonnes n'existe pas, elle sera ignorée en silence.

DB::dropForeign()

Supprime la contrainte de clé étrangère donnée par son nom si elle existe

 public function dropForeign( string $ table , $ name ) : self

• @param string $table Nom de la table à laquelle appartient la contrainte de clé étrangère
• @param array<string>|string $name Nom de la ou des contraintes de clé étrangère
• @return self Même objet pour les appels de méthode fluide

Exemples :

 $ db -> dropForeign ( ' test ' , ' fk_old ' );
$ db -> dropForeign ( ' test ' , [ ' fk_old ' , ' fk_old2 ' ] );

Si la contrainte de clé étrangère ou l'une des contraintes n'existe pas, elle sera ignorée en silence.

DB::dropIndex()

Supprime l'index donné par son nom s'il existe

 public function dropIndex( string $ table , $ name ) : self

• @param string $table Nom de la table à laquelle appartient l'index
• @param array<string>|string $name Nom du ou des index
• @return self Même objet pour les appels de méthode fluide

Exemples :

 $ db -> dropIndex ( ' test ' , ' idx_old ' );
$ db -> dropIndex ( ' test ' , [ ' idx_old ' , ' idx_old2 ' ] );

Si l'index ou l'un des index n'existe pas, il sera ignoré en silence.

DB::dropSequence()

Supprime la séquence donnée par son nom si elle existe

 public function dropSequence( $ name ) : self

• @param array<string>|string $name Nom de la ou des séquences
• @return self Même objet pour les appels de méthode fluide

Exemples :

 $ db -> dropSequence ( ' seq_old ' );
$ db -> dropSequence ( [ ' seq_old ' , ' seq_old2 ' ] );

Si la séquence ou l'une des séquences n'existe pas, elle sera silencieusement ignorée.

DB::dropTable()

Supprime la table donnée par son nom si elle existe

 public function dropTable( $ name ) : self

• @param array<string>|string $name Nom de la ou des tables
• @return self Même objet pour les appels de méthode fluide

Exemples :

 $ db -> dropTable ( ' test ' );
$ db -> dropTable ( [ ' test ' , ' test2 ' ] );

Si la table ou l'une des tables n'existe pas, elle sera ignorée en silence.

DB::dropView()

Supprime la vue donnée par son nom si elle existe

 public function dropView( $ name ) : self

• @param array<string>|string $name Nom de la ou des vues
• @return self Même objet pour les appels de méthode fluide

Exemples :

 $ db -> dropView ( ' test ' );
$ db -> dropView ( [ ' test ' , ' test2 ' ] );

Si la vue ou l'une des vues n'existe pas, elle sera silencieusement ignorée.

DB::exec()

Exécute une instruction SQL personnalisée

 public function exec( string $ sql , array $ params = [], array $ types = [] ) : int

• @param chaîne $sql Instruction SQL personnalisée
• @param array<int|string,mixed> $params Liste des paramètres positionnels ou liste associative d'espaces réservés et de paramètres
• @param array<int|string,mixed> $types Liste des types de données DBAL pour les paramètres d'espace réservé positionnel ou associatif
• @return int Nombre de lignes affectées

Les modifications de la base de données ne sont pas appliquées immédiatement, alors appelez toujours up() avant d'exécuter des instructions personnalisées pour vous assurer que les tables que vous souhaitez utiliser ont déjà été créées !

Exemples :

 $ sql = ' UPDATE product SET status=? WHERE status=? ' ;
$ num = $ this -> db ()-> exec ( $ sql , [ 1 , 0 ] );

DB::pour()

Exécute une instruction SQL personnalisée si la base de données est du type donné

 public function for( $ type , $ sql ) : self

• @param array<string>|string $type Type de base de données pour lequel l'instruction doit être exécutée
• @param array<string>|string $sql Instruction ou instructions SQL personnalisées
• @return self Même objet pour les appels de méthode fluide

Les types de plates-formes de base de données disponibles sont :

• mysql
• mariadb
• postgresql
• SQLite
• serveur SQL
• oracle
• db2

Les modifications de la base de données ne sont pas appliquées immédiatement, alors appelez toujours up() avant d'exécuter des instructions personnalisées pour vous assurer que les tables que vous souhaitez utiliser ont déjà été créées !

Exemples :

 $ 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 ' ,
] );

DB::hasColumn()

Vérifie si la ou les colonnes existent

 public function hasColumn( string $ table , $ name ) : bool

• @param string $table Nom de la table à laquelle appartient la colonne
• @param array<string>|string $name Nom de la ou des colonnes
• @return bool TRUE si les colonnes existent, FALSE sinon

Exemples :

 $ db -> hasColumn ( ' test ' , ' testcol ' );
$ db -> hasColumn ( ' test ' , [ ' testcol ' , ' testcol2 ' ] );

DB::hasForeign()

Vérifie si les contraintes de clé étrangère existent

 public function hasForeign( string $ table , $ name ) : bool

• @param string $table Nom de la table à laquelle appartient la contrainte de clé étrangère
• @param array<string>|string $name Nom de la ou des contraintes de clé étrangère
• @return bool TRUE si la contrainte de clé étrangère existe, FALSE sinon

Exemples :

 $ db -> hasForeign ( ' test ' , ' fk_testcol ' );
$ db -> hasForeign ( ' test ' , [ ' fk_testcol ' , ' fk_testcol2 ' ] );

DB::hasIndex()

Vérifie si les index existent

 public function hasIndex( string $ table , $ name ) : bool

• @param string $table Nom de la table à laquelle appartient l'index
• @param array<string>|string $name Nom du ou des index
• @return bool TRUE si l'index existe, FALSE sinon

Exemples :

 $ db -> hasIndex ( ' test ' , ' idx_test_col ' );
$ db -> hasIndex ( ' test ' , [ ' idx_test_col ' , ' idx_test_col2 ' ] );

DB::hasSequence()

Vérifie si les séquences existent

 public function hasSequence( $ name ) : bool

• @param array<string>|string $name Nom de la ou des séquences
• @return bool TRUE si la séquence existe, FALSE sinon

Exemples :

 $ db -> hasSequence ( ' seq_test ' );
$ db -> hasSequence ( [ ' seq_test ' , ' seq_test2 ' ] );

DB::hasTable()

Vérifie si les tables existent

 public function hasTable( $ name ) : bool

• @param array<string>|string $name Nom de la ou des tables
• @return bool TRUE si la table existe, FALSE sinon

Exemples :

 $ db -> hasTable ( ' test ' );
$ db -> hasTable ( [ ' test ' , ' test2 ' ] );

DB::hasView()

Vérifie si les vues existent

 public function hasView( $ name ) : bool

• @param array<string>|string $name Nom de la ou des vues
• @return bool TRUE si la vue existe, FALSE sinon

Exemples :

 $ db -> hasView ( ' test ' );
$ db -> hasView ( [ ' test ' , ' test2 ' ] );

DB::insérer()

Insère un enregistrement dans la table donnée

	public function insert( string $ table , array $ data ) : self

• @param string $table Nom de la table
• @param array<string,mixed> $data Paires clé/valeur du nom/valeur de la colonne à insérer
• @return self Même objet pour les appels de méthode fluide

Exemples :

 $ db -> insert ( ' test ' , [ ' label ' => ' myvalue ' , ' status ' => true ] );

DB::lastId()

Renvoie l'ID de la dernière ligne insérée dans n'importe quelle table de base de données

 public function lastId() : string

• @return string ID généré à partir de la base de données

Attention : Cela ne fonctionne pas pour la plateforme Oracle car Doctrine DBAL ne prend pas en charge les colonnes Oracle IDENTITY pour le moment.

Exemples :

 $ db -> lastId ();

DB::nom()

Renvoie le nom de la base de données

 public function name() : string

• @return string Nom de la base de données

Exemples :

 $ db -> name ();

DB::q()

Cite une valeur

 public function q( $ value , $ type =  Doctrine  DBAL ParameterType:: STRING ) : string

• @param Mixed $value Valeur à utiliser dans une requête SQL non préparée
• @param type de paramètre DBAL $type mixte
• @return chaîne Valeur citée

Exemples :

 $ result = $ db -> stmt ()-> select ( ' * ' )-> from ( ' products ' )
	-> where ( ' status = ' . $ db -> q ( $ _GET [ ' status ' ] ) )-> executeQuery ();

DB::qi()

Cite un identifiant de base de données

 public function qi( string $ identifier ) : string

• @param string $identifier Identifiant comme le nom de la table ou de la colonne
• @return string Identifiant cité

Exemples :

 $ result = $ db -> stmt ()-> select ( $ db -> qi ( ' key ' ) )-> from ( ' products ' )-> executeQuery ();

DB::requête()

Exécute une requête SQL personnalisée

 public function query( string $ sql , array $ params = [], array $ types = [] ) :  Doctrine  DBAL  Result

• @param chaîne $sql Instruction SQL personnalisée
• @param array<int|string,mixed> $params Liste des paramètres positionnels ou liste associative d'espaces réservés et de paramètres
• @param array<int|string,mixed> $types Liste des types de données DBAL pour les paramètres d'espace réservé positionnel ou associatif
• @return DoctrineDBALResult Objet de jeu de résultats DBAL

Exemples :

 $ result = $ db -> query ( ' SELECT id, label, status FROM product WHERE label LIKE ? ' , [ ' test% ' ] );

foreach ( $ result -> iterateAssociative () as $ row ) {
	// ...
}

Astuce : Vérifiez les méthodes DBAL de récupération de données pour plus d'informations.

DB::renameColumn()

Renomme une colonne ou une liste de colonnes

 public function renameColumn( string $ table , $ from , string $ to = null ) : self

• @param string $table Nom de la table
• @param array<string,string>|string $from Nom de colonne ou tableau d'anciens/nouveaux noms de colonnes
• @param string|null $to Nouveau nom de colonne ignoré si le premier paramètre est un tableau
• @return self Même objet pour les appels de méthode fluide

Si la colonne n'existe pas encore, la méthode réussira mais rien ne se passera. Aucun appel à up() n'est requis.

Limites

• SQLite depuis 3.25.0

Exemples :

 // single column
$ db -> renameColumn ( ' testtable ' , ' test_col ' , ' test_column ' );

// rename several columns at once
$ db -> renameColumn ( ' testtable ' , [ ' tcol ' => ' testcol ' , ' tcol2 ' => ' testcol2 ' ] );

DB::renameIndex()

Renomme une colonne ou une liste de colonnes

 public function renameIndex( string $ table , $ from , string $ to = null ) : self

• @param string $table Nom de la table
• @param array<string,string>|string $from Nom de l'index ou tableau d'anciens/nouveaux noms d'index
• @param string|null $to Nouveau nom d'index ignoré si le premier paramètre est un tableau
• @return self Même objet pour les appels de méthode fluide

Si l'index n'existe pas encore, la méthode réussira mais rien ne se passera. Aucun appel à up() n'est requis.

Exemples :

 // single index
$ db -> renameIndex ( ' testtable ' , ' idxcol ' , ' idx_column ' );

// rename several indexes at once
$ db -> renameIndex ( ' testtable ' , [ ' idxcol ' => ' idx_column ' , ' idxcol2 ' => ' idx_column2 ' ] );

DB::renameTable()

Renomme une table ou une liste de tables

 public function renameTable( $ from , string $ to = null ) : self

• @param array<string,string>|string $from Nom de la table ou tableau d'anciens/nouveaux noms de table
• @param string|null $to Nouveau nom de table ignoré si le premier paramètre est un tableau
• @return self Même objet pour les appels de méthode fluide
• @throws RuntimeException Si une erreur s'est produite

Si la table n'existe pas encore, la méthode réussira mais rien ne se passera. Aucun appel à up() n'est requis.

Exemples :

 // single table
$ db -> renameTable ( ' testtable ' , ' newtable ' );

// rename several tables at once
$ db -> renameTable ( [ ' testtable ' => ' newtable ' , ' oldtable ' => ' testtable2 ' ] );

DB :: réinitialiser ()

Recharge le schéma de doctrine actuel pour la base de données actuelle

 public function reset() : self

• @return self Même objet pour les appels de méthode fluide

Exemples :

 $ db -> reset ();

DB::sélectionner()

Renvoie les enregistrements de la table donnée

 public function select( string $ table , array $ conditions = null ) : array

• @param string $table Nom de la table
• @param array<string>|null $conditions Paires clé/valeur de noms de colonnes et de valeurs à comparer
• @return array<int,array<string,mixed>> Liste des tableaux associatifs contenant des paires nom/valeur de colonne

Exemples :

 $ db -> select ( ' test ' , [ ' status ' => false , ' type ' => ' old ' ] );
$ db -> select ( ' test ' );

Plusieurs conditions passées en deuxième paramètre sont combinées par "ET". Si vous avez besoin d’instructions plus complexes, utilisez plutôt la méthode stmt() .

DB::séquence()

Renvoie l'objet séquence pour le nom donné

 public function sequence( string $ name ,  Closure $ fcn = null ) : Sequence

• @param string $name Nom de la séquence
• @param Closure|null $fcn Fonction anonyme avec paramètre ($sequence) créant ou mettant à jour la définition de séquence
• @return AimeosUpschemeSchemaSequence Objet séquence

Si la séquence n'existe pas encore, elle sera créée. Pour conserver les modifications dans la base de données, vous devez appeler up() .

Exemples :

 $ sequence = $ db -> sequence ( ' seq_test ' );

$ sequence = $ db -> sequence ( ' seq_test ' , function ( $ seq ) {
	$ seq -> start ( 1000 )-> step ( 2 )-> cache ( 100 );
} )-> up ();

DB::stmt()

Renvoie le générateur de requêtes pour une nouvelle instruction SQL

 public function stmt() :  Doctrine  DBAL  Query  QueryBuilder

• @return DoctrineDBALQueryQueryBuilder Objet générateur de requête

Exemples :

 $ 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 ' ];
}

**Attention : ** Vous devez citer vous-même tous les noms de tables et de colonnes en utilisant la méthode $db->qi() !

Pour plus de détails sur les méthodes Doctrine QueryBuilder disponibles, veuillez consulter la documentation Doctrine.

DB::table()

Renvoie l'objet table pour le nom donné

 public function table( string $ name ,  Closure $ fcn = null ) : Table

• @param string $name Nom de la table
• @param Closure|null $fcn Fonction anonyme avec paramètre ($table) créant ou mettant à jour la définition de la table
• @return AimeosUpschemeSchemaTable Objet table

Si la table n'existe pas encore, elle sera créée. Pour conserver les modifications dans la base de données, vous devez appeler up() .

Exemples :

 $ table = $ db -> table ( ' test ' );

$ table = $ db -> table ( ' test ' , function ( $ t ) {
	$ t -> id ();
	$ t -> string ( ' label ' );
	$ t -> bool ( ' status ' );
} )-> up ();

DB::transaction()

Exécute la clôture donnée dans une transaction

 public function transaction(  Closure $ fcn ) : self

• @param Closure $fcn Fonction anonyme avec le paramètre (AimeosUpschemeSchema $db)
• @return self Même objet pour les appels de méthode fluide
• @throws Exception Si une erreur s'est produite

Exemples :

 $ this -> db ()-> transaction ( function ( $ db ) {
	// $db- > insert ( ... )
	// $db- > update ( ... )
	// $db- > delete ( ... )
} );

DB::toArray()

Renvoie les objets sous forme de tableau de la base de données

 public function toArray() : array

• @return array Liste associative de séquences, tables et vues

Exemples :

 $ this -> db ()-> toArray ();

La structure du tableau renvoyé est :

[
	' 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` '
		]
	]
]

DB::type()

Renvoie le type de la base de données

 public function type() : string

• @return string Type de base de données

Les valeurs possibles sont :

• db2
• mariadb
• mysql
• oracle
• postgresql
• SQLite
• serveur SQL

Exemples :

 $ type = $ db -> type ();

DB::up()

Applique les modifications au schéma de la base de données

 public function up() : self

• @return self Même objet pour les appels de méthode fluide

Exemples :

 $ db -> up ();

DB::mise à jour()

Met à jour les enregistrements de la table donnée

 public function update( string $ table , array $ data , array $ conditions = [] ) : self

• @param string $table Nom de la table
• @param array<string,mixed> $data Paires clé/valeur du nom/valeur de la colonne à mettre à jour
• @param array<string,mixed> $conditions Paires clé/valeur de noms de colonnes et de valeurs à comparer
• @return self Même objet pour les appels de méthode fluide

Exemples :

 $ db -> update ( ' test ' , [ ' status ' => true ] );
$ db -> update ( ' test ' , [ ' status ' => true ], [ ' status ' => false , ' type ' => ' new ' ] );

Plusieurs conditions passées en deuxième paramètre sont combinées par "ET". Si vous avez besoin d’instructions plus complexes, utilisez plutôt la méthode stmt() .

DB::view()

Crée une vue avec le nom donné si elle n'existe pas encore

 public function view( string $ name , string $ sql , $ for = null ) : self

• @param string $name Nom de la vue
• @param string $sql SELECT instruction pour remplir la vue
• @param array<string>|string|null $for le type de base de données pour lequel ce SQL doit être utilisé ("mysql", "mariadb", "postgresql", "sqlite", "sqlserver", "oracle", "db2")
• @return self Même objet pour les appels de méthode fluide

Si la vue n'existe pas encore, elle sera créée. Sinon, rien ne se passera.

Exemples :

 $ 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 ' );

Tableaux

Création de tableaux

L'objet de schéma de table que vous obtenez en appelant table() dans votre tâche de migration vous donne un accès complet à la table et vous pouvez ajouter, modifier ou supprimer des colonnes, des index et des clés étrangères, par exemple :

 $ this -> db ()-> table ( ' test ' , function ( $ table ) {
	$ table -> id ();
	$ table -> string ( ' label ' );
	$ table -> col ( ' status ' , ' tinyint ' )-> default ( 0 );
} );

Outre la méthode col() qui peut ajouter des colonnes de types arbitraires, il existe des méthodes de raccourci pour les types disponibles dans toutes les implémentations de serveur de base de données :

Type de colonne	Description
bigide	Colonne BIGINT avec une séquence/auto-incrémentation et une clé primaire attribuée
bigint	Colonne BIGINT avec une plage allant de −9223372036854775808 à 9223372036854775807
binaire	Colonne VARBINARY avec jusqu'à 255 octets
goutte	Colonne BLOB avec jusqu'à 2 Go
bouffon	Colonne BOOLEAN/BIT/NUMBER, alias pour "boolean"
booléen	Colonne BOOLEAN/BIT/NUMBER pour VRAI/FAUX resp. valeurs 0/1
carboniser	Colonne CHAR avec un nombre fixe de caractères
date	Colonne DATE au format de date ISO ("AAAA-MM-JJ) sans heure ni fuseau horaire
dateheure	Colonne DATETIME au format date/heure ISO ("AAAA-MM-JJ HH:mm:ss")
tablesdatetimetz	Colonne DATETIMETZ au format date/heure ISO mais avec un format de fuseau horaire variable
décimal	Colonne DECIMAL pour les données numériques avec une précision en virgule fixe (chaîne en PHP)
flotter	Colonne FLOAT pour les données numériques avec une précision en virgule flottante de 8 octets
guide	Identifiant global unique de 36 octets
identifiant	Colonne INTEGER avec une séquence/auto-incrémentation et une clé primaire attribuée
int	Colonne INTEGER, alias pour "entier"
entier	Colonne INTEGER avec une plage allant de −2147483648 à 2147483647
json	Colonne JSON pour les données JSON codées en UTF-8
petit entier	Colonne INTEGER avec une plage de −32768 à 32767
chaîne	Colonne VARCHAR comportant jusqu'à 255 caractères
texte	Colonne TEXT/CLOB avec jusqu'à 2 Go de caractères
temps	Colonne TIME en 24 heures "HH:MM", par exemple "05:30" ou "22:15"
uuide	Identifiant global unique de 36 octets, alias pour "guid"

Définition des options du tableau

MySQL (ou MariaDB, etc.) prend en charge quelques options pour définir des aspects de la table. L'option moteur précisera le moteur de stockage utilisé pour la table :

 $ this -> db ()-> table ( ' test ' , function ( $ table ) {
	$ table -> opt ( ' engine ' , ' InnoDB ' );
} );

En guise de raccourci, il est également possible de définir l'option comme propriété :

 $ this -> db ()-> table ( ' test ' , function ( $ table ) {
	$ table -> engine = ' InnoDB ' ;
} );

Pour créer une table temporaire , utilisez :

 $ this -> db ()-> table ( ' test ' , function ( $ table ) {
	$ table -> temporary = true ;
} );

Il est également possible de définir le jeu de caractères et le classement par défaut pour les colonnes de chaîne et de texte :

 $ this -> db ()-> table ( ' test ' , function ( $ table ) {
	$ table -> charset = ' utf8mb4 ' ;
	$ table -> collation = ' utf8mb4_unicode_ci ' ;
} );

Remarque : Les classements sont également pris en charge par PostgreSQL et SQL Server, mais leurs valeurs sont différentes. Il n'est donc pas possible d'utiliser la même valeur pour tous les types de serveurs. Pour contourner ce problème, utilisez la méthode column opt() et transmettez le type de serveur de base de données comme troisième paramètre :

 $ this -> db ()-> table ( ' test ' , function ( $ table ) {
	$ table -> opt ( ' charset ' , ' utf8mb4 ' , ' mysql ' );
	$ table -> opt ( ' collation ' , ' utf8mb4_unicode_ci ' , ' mysql ' );
} );

Désormais, le jeu de caractères et le classement par défaut ne seront définis que pour les serveurs de base de données MySQL (ou MariaDB et forks similaires).

Au cas où vous auriez besoin de connaître les valeurs actuelles des options du tableau :

 $ 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 ;
} );

Vérification de l'existence d'une table

Pour vérifier si une table existe déjà, utilisez la méthode hasTable() :

 if ( $ this -> db ()-> hasTable ( ' users ' ) ) {
    // The "users" table exists
}

Vous pouvez également rechercher plusieurs tables à la fois :

 if ( $ this -> db ()-> hasTable ( [ ' users ' , ' addresses ' ] ) ) {
    // The "users" and "addresses" tables exist
}

La méthode hasTable() ne retournera TRUE que si toutes les tables existent.

Tables à langer

Outre la création et l'accès aux tables, la méthode table() de l'objet schéma peut également être utilisée pour mettre à jour un schéma de table. Il accepte le nom de la table et une fermeture qui recevra l'objet schéma de table.

Créons d'abord une table nommée test comprenant trois colonnes :

 $ this -> db ()-> table ( ' test ' , function ( $ table ) {
	$ table -> id ();
	$ table -> string ( ' label ' );
	$ table -> col ( ' status ' , ' tinyint ' )-> default ( 0 );
} );

Maintenant, nous souhaitons mettre à jour la table dans une autre migration en ajoutant une colonne de code et en modifiant la valeur par défaut de la colonne de statut existante :

 $ this -> db ()-> table ( ' test ' , function ( $ table ) {
	$ table -> string ( ' code ' );
	$ table -> col ( ' status ' , ' tinyint ' )-> default ( 1 );
} );

Les modifications seront conservées dans la base de données dès le retour de la méthode table() , il n'est donc pas nécessaire d'appeler vous-même up() par la suite. Pour les types et options de colonnes disponibles, reportez-vous à la section Colonnes.

Renommer les tables

L'objet de base de données renvoyé par $this->db() peut renommer les tables lors de l'utilisation de la méthode renameTable() :

 // Renames the table "users" to "accounts"
$ this -> db ()-> renameTable ( ' users ' , ' account ' );

Il est également possible de renommer plusieurs tables à la fois si vous transmettez un tableau associatif dont l'ancien et le nouveau nom sont des paires clé/valeur :

 // Renames the table "users" to "accounts" and "blog" to "posts"
$ this -> db ()-> renameTable ( [ ' users ' => ' account ' , ' blog ' => ' posts ' ] );

Les tables ne sont renommées que si elles existent. Si une table n'existe plus, aucune erreur n'est signalée :

 $ this -> db ()-> renameTable ( ' notexist ' , ' newtable ' );

Dans ce cas, l’appel de méthode réussira mais rien ne se passera.

Suppression de tables

Pour supprimer une table, vous devez utiliser la méthode dropTable() du schéma de la base de données :

 $ this -> db ()-> dropTable ( ' users ' );

Vous pouvez également supprimer plusieurs tables à la fois en passant la liste sous forme de tableau :

 $ this -> db ()-> dropTable ( [ ' users ' , ' addresses ' ] );

Les tables ne sont supprimées que si elles existent. Si une table n'existe plus, aucune erreur n'est signalée :

 $ this -> db ()-> dropTable ( ' notexist ' );

Dans ce cas, l’appel de méthode réussira mais rien ne se passera.

Méthodes de table

Tableaux

• __appel()
• __obtenir()
• __ensemble()
• bigide()
• bigint()
• binaire()
• goutte()
• bool()
• booléen()
• carboniser()
• col()
• date()
• dateheure()
• datetimetz()
• décimal()
• dropColumn()
• dropIndex()
• dropForeign()
• dropPrimaire()
• flotter()
• étranger()
• guid()
• hasColumn()
• hasIndex()
• hasForeign()
• identifiant()
• indice()
• int()
• entier()
• json()
• nom()
• opter()
• primaire()
• renommerColonne()
• renommerIndex()
• petitint()
• spatial()
• chaîne()
• texte()
• temps()
• unique()
• uuid()
• en haut()

Tableau ::__appel()

Appelle des méthodes personnalisées ou transmet des appels de méthodes inconnues à l'objet de table Doctrine

 public function __call( string $ method , array $ args )

• @param string $method Nom de la méthode
• @param array<mixed> $args Paramètres de la méthode
• @return Mixed Valeur de retour de la méthode appelée

Exemples :

Vous pouvez enregistrer des méthodes personnalisées ayant accès aux propriétés de classe de l'objet Upscheme Table :

 Aimeos  Upscheme  Schema Table:: macro ( ' addConstraint ' , function ( array $ columns ) {
	return $ this -> to -> addUniqueConstraint ( $ columns );
} );

$ table -> addConstraint ( [ ' col1 ' , ' col2 ' ] );

Les propriétés de classe disponibles sont :

$this->table : Schéma de la table de doctrine

$this->up : objet Upscheme

De plus, vous pouvez appeler directement n'importe quelle méthode de table Doctrine, par exemple :

 $ table -> addUniqueConstraint ( [ ' col1 ' , ' col2 ' ] );

Tableau ::__get()

Renvoie la valeur de l'option de table donnée

 public function __get( string $ name )

• @param string $name Nom de l'option de table
• @return valeur de l'option de table mixte

La liste des options de table disponibles est la suivante :

• jeu de caractères (MySQL)
• classement (MySQL)
• moteur (MySQL)
• temporaire (MySQL)

Exemples :

 $ engine = $ table -> engine ;

// same as
$ engine = $ table -> opt ( ' engine ' );

Tableau ::__set()

Définit la nouvelle valeur pour l'option de table donnée

 public function __set( string $ name , $ value )

• @param string $name Nom de l'option de table
• @param valeur de l'option de table mixte

La liste des options de table disponibles est la suivante :

• jeu de caractères (MySQL)
• classement (MySQL)
• moteur (MySQL)
• temporaire (MySQL)

Exemples :

 $ table -> engine = ' InnoDB ' ;

// same as
$ table -> opt ( ' engine ' , ' InnoDB ' );

Table::bigid()

Crée une nouvelle colonne ID de type "bigint" ou renvoie celle existante

 public function bigid( string $ name = null ) : Column

• @param string|null $name Nom de la colonne ID
• @return AimeosUpschemeSchemaColumn Objet colonne

La colonne reçoit une séquence (auto-incrémentation) et une clé primaire attribuée automatiquement. Si la colonne n'existe pas encore, elle sera créée.

Exemples :

 $ table -> bigid ();
$ table -> bigid ( ' uid ' );

Tableau :: bigint()

Crée une nouvelle colonne de type "bigint" ou renvoie celle existante

 public function bigint( string $ name ) : Column

• @param string $name Nom de la colonne
• @return AimeosUpschemeSchemaColumn Objet colonne

Si la colonne n'existe pas encore, elle sera créée.

Exemples :

 $ table -> bigint ( ' testcol ' );

Table :: binaire ()

Crée une nouvelle colonne de type "binaire" ou renvoie celle existante

 public function binary( string $ name , int $ length = 255 ) : Column

• @param string $name Nom de la colonne
• @param int $length Longueur de la colonne en octets
• @return AimeosUpschemeSchemaColumn Objet colonne

Si la colonne n'existe pas encore, elle sera créée.

Exemples :

 $ table -> binary ( ' testcol ' );
$ table -> binary ( ' testcol ' , 32 );

Table::blob()

Crée une nouvelle colonne de type "blob" ou renvoie celle existante

 public function blob( string $ name , int $ length = 0x7fff ) : Column

• @param string $name Nom de la colonne
• @param int $length Longueur de la colonne en octets
• @return AimeosUpschemeSchemaColumn Objet colonne

La longueur maximale d'une colonne "blob" est de 2 Go. Si la colonne n'existe pas encore, elle sera créée.

Exemples :

 $ table -> blob ( ' testcol ' );
$ table -> blob ( ' testcol ' , 0x7fffffff );

Tableau ::bool()

Crée une nouvelle colonne de type "booléen" ou renvoie celle existante

 public function bool( string $ name ) : Column

• @param string $name Nom de la colonne
• @return AimeosUpschemeSchemaColumn Objet colonne

Cette méthode est un alias pour boolean(). Si la colonne n'existe pas encore, elle sera créée.

Exemples :

 $ table -> bool ( ' testcol ' );

Table::booléen()

Crée une nouvelle colonne de type "booléen" ou renvoie celle existante

 public function boolean( string $ name ) : Column

• @param string $name Nom de la colonne
• @return AimeosUpschemeSchemaColumn Objet colonne

Si la colonne n'existe pas encore, elle sera créée.

Exemples :

 $ table -> boolean ( ' testcol ' );

Table ::char()

Crée une nouvelle colonne de type "char" avec un type fixe ou renvoie celle existante

 public function char( string $ name , int $ length ) : Column

• @param string $name Nom de la colonne
• @param int $length Longueur de la colonne en caractères
• @return AimeosUpschemeSchemaColumn Objet colonne

Si la colonne n'existe pas encore, elle sera créée.

Exemples :

 $ table -> char ( ' testcol ' , 3 );

Tableau ::col()

Crée une nouvelle colonne ou renvoie celui existant

 public function col( string $ name , string $ type = null ) : Column

• @param string $name nom de la colonne
• Type de chaîne @param | NULL $type Type de la colonne
• @return aimeos upscheme schema colonne objet de colonne

Si la colonne n'existe pas encore, elle sera créée.

Exemples :

 $ table -> col ( ' testcol ' );
$ table -> col ( ' testcol ' , ' tinyint ' );

Tableau :: Date ()

Crée une nouvelle colonne de type "Date" ou renvoie celui existant

 public function date( string $ name ) : Column

• @param string $name nom de la colonne
• @return aimeos upscheme schema colonne objet de colonne

Si la colonne n'existe pas encore, elle sera créée.

Exemples :

 $ table -> date ( ' testcol ' );

Tableau :: DateTime ()

Crée une nouvelle colonne de type "DateTime" ou renvoie le existant

 public function datetime( string $ name ) : Column

• @param string $name nom de la colonne
• @return aimeos upscheme schema colonne objet de colonne

Si la colonne n'existe pas encore, elle sera créée.

Exemples :

 $ table -> datetime ( ' testcol ' );

Tableau :: Datetimetz ()

Crée une nouvelle colonne de type "Datetimetz" ou renvoie le existant

 public function datetimetz( string $ name ) : Column

• @param string $name nom de la colonne
• @return aimeos upscheme schema colonne objet de colonne

Si la colonne n'existe pas encore, elle sera créée.

Exemples :

 $ table -> datetimetz ( ' testcol ' );

Tableau :: décimal ()

Crée une nouvelle colonne de type "décimal" ou renvoie la

 public function decimal( string $ name , int $ digits , int $ decimals = 2 ) : Column

• @param string $name nom de la colonne
• @param int $digits Nombre total de chiffres décimaux, y compris les décimales
• @param int $decimals Nombre de chiffres après le point décimal
• @return aimeos upscheme schema colonne objet de colonne

Si la colonne n'existe pas encore, elle sera créée.

Exemples :

 $ table -> decimal ( ' testcol ' , 10 ); // 10 digits incl . 2 decimals
$ table -> decimal ( ' testcol ' , 10 , 4 ); // 10 digits incl . 4 decimals 

Tableau :: DropColumn ()

Laisse tomber la colonne donnée par son nom si elle existe

 public function dropColumn( $ name ) : self

• @param array <string> | string $name nom de la colonne ou des colonnes
• @return self même objet pour les appels de méthode fluide

Si la colonne ou l'une des colonnes n'existe pas, elle sera ignorée silencieusement. Le changement ne sera pas appliqué tant que la tâche de migration se termine ou up() n'est pas appelée.

Exemples :

 $ table -> dropColumn ( ' testcol ' );
$ table -> dropColumn ( [ ' testcol ' , ' testcol2 ' ] );

Tableau :: DropIndex ()

Laisse tomber l'index donné par son nom s'il existe

 public function dropIndex( $ name ) : self

• @param array <string> | string $name nom de l'index ou des index
• @return self même objet pour les appels de méthode fluide

Si l'index ou l'un des index n'existe pas, il sera ignoré silencieusement. Le changement ne sera pas appliqué tant que la tâche de migration se termine ou up() n'est pas appelée.

Exemples :

 $ table -> dropIndex ( ' idx_test_col ' );
$ table -> dropIndex ( [ ' idx_test_col ' , ' idx_test_col2 ' ] );

Tableau :: Dropforeign ()

Laisse tomber la contrainte de clé étrangère donnée par son nom si elle existe

 public function dropForeign( $ name ) : self

• @param array <string> | chaîne $name nom de la clé étrangère contrainte ou contraintes
• @return self même objet pour les appels de méthode fluide

Si la contrainte de clé étrangère ou l'une des contraintes n'existe pas, elle sera ignorée silencieusement. Le changement ne sera pas appliqué tant que la tâche de migration se termine ou up() n'est pas appelée.

Exemples :

 $ table -> dropForeign ( ' fk_test_col ' );
$ table -> dropForeign ( [ ' fk_test_col ' , ' fk_test_col2 ' ] );

Tableau :: Dropprimary ()

Laisse tomber la clé primaire si elle existe

 public function dropPrimary() : self

• @return self même objet pour les appels de méthode fluide

Si la clé primaire n'existe pas, elle sera ignorée silencieusement. Le changement ne sera pas appliqué tant que la tâche de migration se termine ou up() n'est pas appelée.

Exemples :

 $ table -> dropPrimary ();

Tableau :: float ()

Crée une nouvelle colonne de type "float" ou renvoie celui existant

 public function float( string $ name ) : Column

• @param string $name nom de la colonne
• @return aimeos upscheme schema colonne objet de colonne

Si la colonne n'existe pas encore, elle sera créée.

Exemples :

 $ table -> float ( ' testcol ' );

Tableau :: Foreign ()

Crée une nouvelle clé étrangère ou renvoie celui existant

 public function foreign( $ localcolumn , string $ foreigntable , $ foreigncolumn = ' id ' , string $ name = null ) : Foreign

• @param array <string> | string $localcolumn Nom de la colonne ou des colonnes locales
• @param String $foreigntable de la table référencée
• @param array <string> | String $foreigncolumn Nom de la colonne ou des colonnes référencées
• @param String | null $name nom de la contrainte de clé étrangère et de l'indice de clé étrangère ou null pour nom automatique
• @return aimeos upscheme schema objet de contrainte de clé étrangère étrangère

La longueur du nom de la clé étrangère ne doit pas être plus longue de 30 caractères pour une compatibilité maximale.

Exemples :

 $ table -> foreign ( ' parentid ' , ' test ' );
$ table -> foreign ( ' parentid ' , ' test ' , ' uid ' );
$ table -> foreign ( ' parentid ' , ' test ' , ' id ' , ' fk_test_pid ' );
$ table -> foreign ( [ ' parentid ' , ' siteid ' ], ' test ' , [ ' uid ' , ' siteid ' ] );

Tableau :: GUID ()

Crée une nouvelle colonne de type "GUID" ou renvoie celui existant

 public function guid( string $ name ) : Column

• @param string $name nom de la colonne
• @return aimeos upscheme schema colonne objet de colonne

Si la colonne n'existe pas encore, elle sera créée.

Exemples :

 $ table -> guid ( ' testcol ' );

Tableau :: HasColumn ()

Vérifie si la colonne existe

 public function hasColumn( $ name ) : bool

• @param array <string> | string $name nom de la colonne ou des colonnes
• @return bool true si les colonnes existent, faux sinon

Exemples :

 $ table -> hasColumn ( ' testcol ' );
$ table -> hasColumn ( [ ' testcol ' , ' testcol2 ' ] );

Tableau :: HasIndex ()

Vérifie si l'index existe

 public function hasIndex( $ name ) : bool

• @param array <string> | string $name nom de l'index ou des index
• @return bool true si les index existent, faux sinon

Exemples :

 $ table -> hasIndex ( ' idx_test_col ' );
$ table -> hasIndex ( [ ' idx_test_col ' , ' idx_test_col2 ' ] );

Tableau :: HasForeign ()

Vérifie si la contrainte de clé étrangère existe

 public function hasForeign( $ name ) : bool

• @param array <string> | chaîne $name nom de la clé étrangère contrainte ou contraintes
• @return bool true si les contraintes de clés étrangères existent, faux sinon

Exemples :

 $ table -> hasForeign ( ' fk_test_col ' );
$ table -> hasForeign ( [ ' fk_test_col ' , ' fk_test_col2 ' ] );

Tableau :: id ()

Crée une nouvelle colonne d'ID de type "entier" ou renvoie le existant

 public function id( string $ name = null ) : Column

• @param String | null $name nom de la colonne d'ID
• @return aimeos upscheme schema colonne objet de colonne

La colonne obtient une séquence (auto-oncement) et une clé primaire attribuée automatiquement. Si la colonne n'existe pas encore, elle sera créée.

Exemples :

 $ table -> id ();
$ table -> id ( ' uid ' );

Tableau :: index ()

Crée un nouvel index ou remplace un existant

 public function index( $ columns , string $ name = null ) : self

• @param array <string> | string $columns nom des colonnes ou colonnes engendrant l'index
• @param String | null $name index nom ou null pour le nom autoogénéré
• @return self même objet pour les appels de méthode fluide

La longueur du nom d'index ne doit pas être plus longue de 30 caractères pour une compatibilité maximale.

Exemples :

 $ table -> index ( ' testcol ' );
$ table -> index ( [ ' testcol ' , ' testcol2 ' ] );
$ table ->index( ' testcol ' , 'idx_test_testcol );

Tableau :: int ()

Crée une nouvelle colonne de type "entier" ou renvoie le existant

 public function int( string $ name ) : Column

• @param string $name nom de la colonne
• @return aimeos upscheme schema colonne objet de colonne

Cette méthode est un alias pour Integer (). Si la colonne n'existe pas encore, elle sera créée.

Exemples :

 $ table -> int ( ' testcol ' );

Tableau :: Integer ()

Crée une nouvelle colonne de type "entier" ou renvoie le existant

 public function integer( string $ name ) : Column

• @param string $name nom de la colonne
• @return aimeos upscheme schema colonne objet de colonne

Si la colonne n'existe pas encore, elle sera créée.

Exemples :

 $ table -> integer ( ' testcol ' );

Tableau :: JSON ()

Crée une nouvelle colonne de type "JSON" ou renvoie la

 public function json( string $ name ) : Column

• @param string $name nom de la colonne
• @return aimeos upscheme schema colonne objet de colonne

Si la colonne n'existe pas encore, elle sera créée.

Exemples :

 $ table -> json ( ' testcol ' );

Table :: name ()

Renvoie le nom de la table

 public function name() : string

• @return String Nom du tableau

Exemples :

 $ tablename = $ table -> name ();

Tableau :: opt ()

Définit une option de schéma personnalisé ou renvoie la valeur actuelle

 public function opt( string $ name , $ value = null )

• @param string $name nom de l'option de schéma personnalisé lié au tableau
• @param mix mix $value valeur de la valeur de l'option de schéma personnalisé
• @return self | Mélange le même objet pour régler la valeur, valeur actuelle sans deuxième paramètre

Les options de schéma personnalisé disponibles sont:

• Charset (MySQL)
• collation (mysql)
• moteur (mysql)
• Temporaire (MySQL)

Exemples :

 $ charset = $ table -> opt ( ' charset ' );
$ table -> opt ( ' charset ' , ' utf8 ' )-> opt ( ' collation ' , ' utf8_bin ' );

// Magic methods :
$ charset = $ table -> charset ;
$ table -> charset = ' binary ' ;

Tableau :: primaire ()

Crée un nouvel index primaire ou remplace un existant

 public function primary( $ columns , string $ name = null ) : self

• @param array <string> | string $columns nom des colonnes ou colonnes engendrant l'index
• @param String | null $name index nom ou null pour le nom autoogénéré
• @return self même objet pour les appels de méthode fluide

La longueur du nom d'index ne doit pas être plus longue de 30 caractères pour une compatibilité maximale.

Exemples :

 $ table -> primary ( ' testcol ' );
$ table -> primary ( [ ' testcol ' , ' testcol2 ' ] );
$ table -> primary ( ' testcol ' , ' pk_test_testcol ' );

Tableau :: RenameColumn ()

Renomme une colonne ou une liste de colonnes

 public function renameColumn( $ from , string $ to = null ) : self

• @param Array <String, String> | String $from Colonne Nom ou Array of Old / New Colonne Names
• @param String | null $to nouveau nom de colonne ignoré si le premier paramètre est un tableau
• @return self même objet pour les appels de méthode fluide
• @Throws RuntimeeException si une erreur s'est produite

Exemples :

 // single column
$ table -> renameColumn ( ' test_col ' , ' test_column ' );

// rename several columns at once
$ table -> renameColumn ( [ ' tcol ' => ' testcol ' , ' tcol2 ' => ' testcol2 ' ] );

Tableau :: RenameIndex ()

Renomme un index ou une liste d'index

 public function renameIndex( $ from , string $ to = null ) : self

• @param Array | String $from Index Name ou Array of Ancien / Nouveaux noms d'index (si le nouveau nom d'index est nul, il sera généré)
• @param String | null $to nouveau nom d'index ou null pour le nom automatique (ignoré si le premier paramètre est un tableau)
• @return self même objet pour les appels de méthode fluide

La longueur du nom des index ne doit pas compter plus de 30 caractères pour une compatibilité maximale.

Exemples :

 // 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 ' ] );

Tableau :: smallInt ()

Crée une nouvelle colonne de type "smallInt" ou renvoie celui existant

 public function smallint( string $ name ) : Column

• @param string $name nom de la colonne
• @return aimeos upscheme schema colonne objet de colonne

Si la colonne n'existe pas encore, elle sera créée.

Exemples :

 $ table -> smallint ( ' testcol ' );

Tableau :: Spatial ()

Crée un nouvel index spatial ou remplace un existant

 public function spatial( $ columns , string $ name = null ) : self

• @param Array | String $columns Nom des colonnes ou colonnes engendrant l'index
• @param String | null $name index nom ou null pour le nom autoogénéré
• @return self même objet pour les appels de méthode fluide

La longueur du nom d'index ne doit pas être plus longue de 30 caractères pour une compatibilité maximale.

Exemples :

 $ table -> spatial ( ' testcol ' );
$ table -> spatial ( [ ' testcol ' , ' testcol2 ' ] );
$ table -> spatial ( ' testcol ' , ' idx_test_testcol ' );

Table :: String ()

Crée une nouvelle colonne de type "String" ou renvoie la celle existante

 public function string( string $ name , int $ length = 255 ) : Column

• @param string $name nom de la colonne
• @param int $length longueur de la colonne en caractères
• @return aimeos upscheme schema colonne objet de colonne

Ce type doit être utilisé pour jusqu'à 255 caractères. Pour plus de caractères, utilisez le type "texte". Si la colonne n'existe pas encore, elle sera créée.

Exemples :

 $ table -> string ( ' testcol ' );
$ table -> string ( ' testcol ' , 32 );

Tableau :: Text ()

Crée une nouvelle colonne de type "texte" ou renvoie celui existant

 public function text( string $ name , int $ length = 0xffff ) : Column

• @param string $name nom de la colonne
• @param int $length longueur de la colonne en caractères
• @return aimeos upscheme schema colonne objet de colonne

La longueur maximale d'une colonne "texte" est de 2 Go. Si la colonne n'existe pas encore, elle sera créée.

Exemples :

 $ table -> text ( ' testcol ' );
$ table -> text ( ' testcol ' , 0x7fffffff );

Tableau :: Time ()

Crée une nouvelle colonne de type "temps" ou renvoie celui existant

 public function time( string $ name ) : Column

• @param string $name nom de la colonne
• @return aimeos upscheme schema colonne objet de colonne

Si la colonne n'existe pas encore, elle sera créée. Ce type de données n'est pas disponible lors de l'utilisation de bases de données Oracle.

Exemples :

 $ table -> time ( ' testcol ' );

Tableau :: unique ()

Crée un nouvel index unique ou remplace un existant

 public function unique( $ columns , string $ name = null ) : self

• @param Array | String $columns Nom des colonnes ou colonnes engendrant l'index
• @param String | null $name index nom ou null pour le nom autoogénéré
• @return self même objet pour les appels de méthode fluide

La longueur du nom d'index ne doit pas être plus longue de 30 caractères pour une compatibilité maximale.

Exemples :

 $ table -> unique ( ' testcol ' );
$ table -> unique ( [ ' testcol ' , ' testcol2 ' ] );
$ table -> unique ( ' testcol ' , ' unq_test_testcol ' );

Tableau :: UUID ()

Crée une nouvelle colonne de type "GUID" ou renvoie celui existant

 public function uuid( string $ name ) : Column

• @param string $name nom de la colonne
• @return aimeos upscheme schema colonne objet de colonne

Cette méthode est un alias pour GUID (). Si la colonne n'existe pas encore, elle sera créée.

Exemples :

 $ table -> uuid ( ' testcol ' );

Tableau :: UP ()

Applique les modifications au schéma de la base de données

 public function up() : self

• @return self même objet pour les appels de méthode fluide

Exemples :

 $ table -> up ();

Colonnes

Ajout de colonnes

L'objet de schéma de colonne que vous obtenez en appelant col() dans votre tâche de migration vous donne accès à toutes les propriétés de colonne. Il existe également des raccourcis disponibles pour les types de colonnes pris en charge par toutes les bases de données. Chaque colonne peut être modifiée par une ou plusieurs méthodes de modificateur et vous pouvez également ajouter des index à des colonnes uniques, par exemple:

 $ this -> db ()-> table ( ' test ' , function ( $ table ) {
	$ table -> id ()-> unsigned ( true );
	$ table -> string ( ' label ' )-> index ();
	$ table -> col ( ' status ' , ' tinyint ' )-> default ( 0 );
} );

L'exemple ajoutera les colonnes suivantes:

• ID de type entier avec modificateur insensible
• Étiquette de la chaîne de type avec 255 caractères et un index
• Statut de Type Tinyint (MySQL uniquement) avec une valeur par défaut de zéro

Types de colonnes disponibles

Il existe des méthodes de raccourci pour les types de colonnes disponibles dans toutes les implémentations de serveur de base de données:

Type de colonne	Description
Bigid	Colonne Bigint avec une séquence / auto-onole et une clé primaire attribuée
grand	Colonne Bigint avec une plage de -922337203685475808 à 922337203685475807
binaire	Colonne varbinaire avec jusqu'à 255 octets
goutte	Colonne blob avec jusqu'à 2 Go
bouffon	Booléen / bit / nombre Colum, alias pour "booléen"
booléen	Boolean / bit / Number Colum pour True / Faux resp. Valeurs 0/1
carboniser	Colonne de char avec un nombre fixe de caractères
date	Colonne de date au format de date ISO ("Yyyy-mm-dd) sans temps et fuseau horaire
DateTime	Colonne DateTime au format ISO Date / Heure ("Yyyy-mm-dd HH: MM: SS")
tablesdatetimetz	Colonne Datetimetz au format Date / Heure ISO mais avec un format de fuseau horaire variable
décimal	Colonne décimale pour les données numériques avec précision à virgule fixe (chaîne en php)
flotter	Colonne flottante pour les données numériques avec une précision à virgule flottante de 8 octets
guide	Identificateur unique à l'échelle mondiale avec 36 octets
identifiant	Colonne entière avec une séquence / auto-onole et une clé primaire attribuée
int	Entier Colum, alias pour "entier"
entier	Colum entier avec une plage de −2147483648 à 2147483647
json	Colonne JSON pour les données JSON encodées UTF-8
petit	Colum entier avec une plage de −32768 à 32767
chaîne	Colonne varchar avec jusqu'à 255 caractères
texte	Colonne de texte / Clob avec jusqu'à 2 Go de caractères
temps	Colonne de temps en 24 heures "HH: MM" Fromat, par exemple "05:30" ou "22:15"
uuide	Identifiant mondial unique avec 36 octets, alias pour "GUID"

Pour ajouter des types de colonnes spécifiques à la base de données, utilisez la méthode col() , par exemple:

 $ this -> db ()-> table ( ' test ' , function ( $ table ) {
	$ table -> col ( ' status ' , ' tinyint ' );
} );

Modificateurs de colonne

Il est également possible de modifier les définitions de colonne en appelant une ou plusieurs méthodes de modificateur de colonne:

 $ this -> db ()-> table ( ' test ' , function ( $ table ) {
	$ table -> int ( ' number ' )-> null ( true )-> unsigned ( true );
} );

Les méthodes de modificateur de colonne disponible sont:

Modificateur de colonne	Description
AutoSine Crament (vrai)	Définir les colonnes entières en tant qu'auto-incrément (alias pour seq() )
Charset ('UTF8')	Le jeu de caractères utilisé par la colonne (MySQL)
collation («binaire»)	La collation de colonne (mysql / postgresql / sqlite / sqlserver mais pas compatible)
Commentaire («commentaire»)	Ajoutez un commentaire à une colonne (MySQL / PostgreSQL / Oracle / SqlServer)
par défaut (1)	Valeur par défaut de la colonne si aucune valeur n'a été spécifiée (par défaut: NULL )
Fixe (vrai)	Si la chaîne ou les colonnes binaires devraient avoir une longueur fixe
index ('idx_col')	Ajouter un index à la colonne, le nom d'index est facultatif
longueur (32)	Le max. Longueur de la chaîne et des colonnes binaires
null (vrai)	Permettez à l'insertion des valeurs nulles dans la colonne
précision (12)	Le max. Nombre de chiffres stockés dans des colonnes décimales et flottantes incl. chiffres décimaux
primaire ('pk_col')	Ajouter une clé primaire à la colonne, le nom de la clé principale est facultatif
échelle (2)	Le nombre exact de chiffres décimaux utilisés dans les colonnes décimales et flottantes
seq (true)	Définir les colonnes entières en tant qu'incriture automatique si aucune valeur n'a été spécifiée
spatial ('idx_col')	Ajouter un index spatial (GEO) à la colonne, le nom de l'index est facultatif
unique ('unq_col')	Ajouter un index unique à la colonne, le nom d'index est facultatif
non signé (vrai)	Autoriser les valeurs entières non signées uniquement (MySQL)

Pour définir des options de schéma personnalisé pour les colonnes, utilisez la méthode opt() , par exemple:

 $ this -> db ()-> table ( ' test ' , function ( $ table ) {
	$ table -> string ( ' code ' )-> opt ( ' collation ' , ' utf8mb4 ' );
} );

Il est même possible de définir des modificateurs de colonne pour une implémentation de base de données spécifique en passant le type de base de données comme troisième paramètre:

 $ this -> db ()-> table ( ' test ' , function ( $ table ) {
	$ table -> string ( ' code ' )-> opt ( ' collation ' , ' utf8mb4 ' , ' mysql ' );
} );

Vérification de l'existence de la colonne

Pour vérifier si une colonne existe déjà, utilisez la méthode hasColumn() :

 if ( $ this -> db ()-> hasColumn ( ' users ' , ' name ' ) ) {
    // The "name" column in the "users" table exists
}

Vous pouvez également vérifier plusieurs colonnes à la fois. Dans ce cas, la méthode hasColumn() ne renvoie que si toutes les colonnes existent:

 if ( $ this -> db ()-> hasColumn ( ' users ' , [ ' name ' , ' status ' ] ) ) {
    // The "name" and "status" columns in the "users" table exists
}

Si vous avez déjà un objet de table, vous pouvez également utiliser hasColumn() :

 if ( $ table -> hasColumn ( ' name ' ) ) {
    // The "name" column in the table exists
}

if ( $ table -> hasColumn ( [ ' name ' , ' status ' ] ) ) {
    // The "name" and "status" columns in the table exists
}

Outre les colonnes, vous pouvez également vérifier si les modificateurs de colonne sont définis et quelle valeur ils ont:

 if ( $ table -> string ( ' code ' )-> null () ) {
	// The "code" columns is nullable
}

La récupération des valeurs de modificateur de colonne actuelle est possible en utilisant ces méthodes:

Modificateur de colonne	Description
AutoIncrement ()	Vrai si la colonne est auto-incrémente (alias pour seq() )
Charset ()	Set de caractères utilisé (MySQL)
collation()	Collation utilisée (mysql / postgresql / sqlite / sqlserver mais pas compatible)
commentaire()	Commentaire associé à la colonne (MySQL / PostgreSQL / Oracle / SqlServer)
défaut()	Valeur par défaut de la colonne
fixé()	Vrai si la chaîne ou la colonne binaire a une longueur fixe
longueur()	La longueur maximale de la chaîne ou de la colonne binaire
nul()	Vrai si les valeurs nulles sont autorisées
précision()	Le nombre maximum de chiffres stockés dans des colonnes décimales et flottantes incl. chiffres décimaux
échelle()	Le nombre exact de chiffres décimaux utilisés dans les colonnes décimales et flottantes
seq ()	Vrai si la colonne est automatiquement
unsigned ()	Vrai si seulement les valeurs entières non signées sont autorisées (MySQL)

Pour vérifier les modificateurs de colonnes non standard, utilisez la méthode opt() sans deuxième paramètre. Ensuite, il renverra la valeur actuelle du modificateur de colonne:

 if ( $ table -> string ( ' code ' )-> opt ( ' charset ' ) === ' utf8 ' ) {
	// The "code" columns uses UTF - 8 charset ( MySQL only)
}

Changer les colonnes

Il est possible de modifier la plupart des modificateurs de colonne comme la longueur d'une colonne de chaîne:

 $ this -> db ()-> table ( ' test ' , function ( $ table ) {
	$ table -> string ( ' code ' )-> length ( 64 );
} );

Certaines méthodes offrent également des paramètres supplémentaires à définir directement les modificateurs utilisés:

 $ this -> db ()-> table ( ' test ' , function ( $ table ) {
	$ table -> string ( ' code ' , 64 );
} );

Si vous devez modifier immédiatement les modificateurs de colonne parce que vous souhaitez migrer les lignes par la suite, utilisez la méthode up() pour persister les modifications:

 $ this -> db ()-> table ( ' test ' , function ( $ table ) {
	$ table -> string ( ' code ' , 64 )-> null ( true )-> up ();
	// modify rows from "test" table
} );

La modification du type de colonne est possible en utilisant la nouvelle méthode pour le type approprié ou la méthode col() :

 $ this -> db ()-> table ( ' test ' , function ( $ table ) {
	$ table -> text ( ' code ' );
	// or
	$ table -> col ( ' code ' , ' text ' );
} );

Sachez que tous les types de colonnes ne peuvent pas être transformés en un autre type ou du moins pas sans perte de données. Vous pouvez modifier une colonne entière en une colonne BigInt sans problème, mais l'inverse rond échouera. Il en va de même si vous souhaitez modifier une colonne VARCHAR (String) en colonne entière.

Colonnes de renommée

Pour renommer les colonnes, utilisez la méthode renameColumn() du schéma DB:

 // single column
$ this -> db ()-> renameColumn ( ' testtable ' , ' label ' , ' name ' );

// multiple columns
$ this -> db ()-> renameColumn ( ' testtable ' , [ ' label ' => ' name ' , ' stat ' => ' status ' ] );

Si un objet de table est déjà disponible, vous pouvez utiliser sa méthode renameColumn() pour renommer une ou plusieurs colonnes:

 $ this -> db ()-> table ( ' testtable ' , function ( $ table ) {
	// single column
	$ table -> renameColumn ( ' label ' , ' name ' );

	// multiple columns
	$ table -> renameColumn ( [ ' label ' => ' name ' , ' stat ' => ' status ' ] );
} );

Dans tous les cas, les colonnes ne sont supprimées que si elles existent. Aucune erreur n'est signalée si une ou plusieurs colonnes n'existent pas dans le tableau.

Colonnes de décrochage

Pour déposer des colonnes, utilisez la méthode dropColumn() à partir de l'objet DB Schema:

 $ this -> db ()-> dropColumn ( ' users ' , ' name ' );

Vous pouvez déposer plusieurs colonnes à la fois si vous passez le nom de toutes les colonnes que vous souhaitez laisser tomber en tant que tableau:

 $ this -> db ()-> dropColumn ( ' users ' , [ ' name ' , ' status ' ] );

Si vous avez déjà un objet de table, vous pouvez également utiliser dropColumn() :

 // single column
$ table -> dropColumn ( ' name ' );

// multiple columns
$ table -> dropColumn ( [ ' name ' , ' status ' ] );

Dans tous les cas, les colonnes ne sont supprimées que si elles existent. Aucune erreur n'est signalée si une ou plusieurs colonnes n'existent pas dans le tableau.

Méthodes de colonne

Colonnes

• __appel()
• __obtenir()
• __ensemble()
• AutoIncrement ()
• Charset ()
• collation()
• commentaire()
• défaut()
• fixé()
• indice()
• longueur()
• nom()
• nul()
• opter()
• précision()
• primaire()
• échelle()
• seq ()
• spatial()
• taper()
• unique()
• unsigned ()
• en haut()

Colonne :: __ Call ()

Appelle des méthodes personnalisées ou transmet des appels de méthode inconnus à l'objet de colonne de doctrine

 public function __call( string $ method , array $ args )

• @param String $method Nom de la méthode
• Paramètres de la méthode @param array <mixtes> $args
• @Return Valeur de retour mixte de la méthode appelée

Exemples :

Vous pouvez enregistrer des méthodes personnalisées qui ont accès aux propriétés de classe de l'objet de colonne Upscheme:

 Aimeos  Upscheme  Schema Column:: macro ( ' platform ' , function ( array $ options ) {
	return $ this -> to -> setPlatformOptions ( $ options );
} );

$ column -> platform ( [ ' option ' => ' value ' ] );

Les propriétés de classe disponibles sont:

$this->db : objet Upscheme db

$this->table : Doctrine Table Schema

$this->column : schéma de colonne de doctrine

De plus, vous pouvez appeler directement n'importe quelle méthode de colonne de doctrine, par exemple:

 $ column -> setPlatformOptions ( [ ' option ' => ' value ' ] );

Colonne :: __ get ()

Renvoie la valeur de l'option de colonne donnée

 public function __get( string $ name )

• @param string $name Colonne Nom de l'option
• Valeur d'option de colonne mixte @return

La liste des options de colonne disponibles est:

• Charset (MySQL)
• Collation (MySQL, PostgreSQL, SQLite et SQL Server)
• vérifier
• unique (tout)

Exemples :

 $ charset = $ column -> charset ;

// same as
$ charset = $ column -> opt ( ' charset ' );

Colonne :: __ set ()

Définit la nouvelle valeur de l'option de colonne donnée

 public function __set( string $ name , $ value )

• @param string $name Colonne Nom de l'option
• Valeur option de colonne de $value mixte @param

La liste des options de colonne disponibles est:

• Charset (MySQL)
• Collation (MySQL, PostgreSQL, SQLite et SQL Server)
• vérifier
• unique (tout)

Exemples :

 $ column -> charset = ' utf8 ' ;

// same as
$ column -> opt ( ' charset ' , ' utf8 ' );

Colonne :: AutoIncrement ()

Définit la colonne comme auto-ondant ou renvoie la valeur actuelle

 public function autoincrement( bool $ value = null )

• @param bool | null $value Nouveau indicateur automatique ou null pour renvoyer la valeur actuelle
• @return self | bool même objet pour définir la valeur, valeur actuelle sans paramètre

Cette méthode est un alias pour la méthode seq() .

Exemples :

 $ value = $ column -> autoincrement ();
$ column -> autoincrement ( true );

Colonne :: charse ()

Définit le charme de colonne ou renvoie la valeur actuelle

 public function charset( string $ value = null )

• @param String | null $value nouvelle colonne Charset ou null pour renvoyer la valeur actuelle
• @return self | String Même objet pour définir la valeur, valeur actuelle sans paramètre

Exemples :

 $ comment = $ column -> charset ();
$ column -> charset ( ' utf8 ' );

Colonne :: collation ()

Définit la collation de colonne ou renvoie la valeur actuelle

 public function collation( string $ value = null )

• @param String | null $value Nouvelle colonne Collation ou null pour renvoyer la valeur actuelle
• @return self | String Même objet pour définir la valeur, valeur actuelle sans paramètre

Exemples :

 $ comment = $ column -> collation ();
$ column -> collation ( ' binary ' );

Colonne :: commentaire ()

Définit le commentaire de la colonne ou renvoie la valeur actuelle

 public function comment( string $ value = null )

• @param String | null $value nouveau commentaire de colonne ou null pour renvoyer la valeur actuelle
• @return self | String Même objet pour définir la valeur, valeur actuelle sans paramètre

Exemples :

 $ comment = $ column -> comment ();
$ column -> comment ( ' column comment ' );

Colonne :: default ()

Définit la valeur par défaut de la colonne ou renvoie la valeur actuelle

 public function default( $ value = null )

• @param mix mixt $value Nouvelle colonne Valeur par défaut ou null pour renvoyer la valeur actuelle
• @return self | Mélange du même objet pour définir la valeur, valeur actuelle sans paramètre

Exemples :

 $ value = $ column -> default ();
$ column -> default ( 0 );

Colonne :: fixe ()

Définit l'indicateur fixe de la colonne ou renvoie la valeur actuelle

 public function fixed( bool $ value = null )

• @param bool | null $value nouvelle colonne fixe inducteur ou null pour renvoyer la valeur actuelle
• @return self | bool même objet pour définir la valeur, valeur actuelle sans paramètre

Exemples :

 $ value = $ column -> fixed ();
$ column -> fixed ( true );

Colonne :: index ()

Crée un index régulier pour la colonne

 public function index( string $ name = null ) : self

• @param string | null $name nom de l'index ou null pour générer automatiquement
• @return self même objet pour les appels de méthode fluide

Exemples :

 $ column -> index ();
$ column -> index ( ' idx_col ' );

Colonne :: Length ()

Définit la longueur de la colonne ou renvoie la valeur actuelle

 public function length( int $ value = null )

• @param int | null $value nouvelle longueur de colonne ou null pour renvoyer la valeur actuelle
• @return self | int même objet pour définir la valeur, valeur actuelle sans paramètre

Exemples :

 $ value = $ column -> length ();
$ column -> length ( 32 );

Colonne :: name ()

Renvoie le nom de la colonne

 public function name() : string

• Nom de la colonne de chaîne @return

Exemples :

 $ name = $ column -> name ();

Colonne :: null ()

Définit l'indicateur NULL de la colonne ou renvoie la valeur actuelle

 public function null( bool $ value = null )

• @param bool | null $value nouvelle colonne null indicateur ou null pour renvoyer la valeur actuelle
• @return self | bool même objet pour définir la valeur, valeur actuelle sans paramètre

Exemples :

 $ value = $ column -> null ();
$ column -> null ( true );

Colonne :: opt ()

Définit la valeur de l'option de colonne ou renvoie la valeur actuelle

 public function opt( string $ option , $ value = null , $ for = null )

• Nom de l'option de colonne d'option @param string $option
• @Param mixte $value nouvelle valeur d'option de colonne ou null pour renvoyer la valeur actuelle
• @param array <string> | string | null $for database type Cette option doit être utilisée pour ("mysql", "mariaDb", "postgresql", "sqlite", "sqlServer", "oracle", "db2")
• @return self | Mélange du même objet pour définir la valeur, valeur actuelle sans paramètre

Exemples :

 $ value = $ column -> opt ( ' length ' );
$ column -> opt ( ' length ' , 64 );

Colonne :: Precision ()

Définit la précision de la colonne ou renvoie la valeur actuelle

 public function precision( int $ value = null )

• @param int | null $value nouvelle valeur de précision de colonne ou null pour renvoyer la valeur actuelle
• @return self | int même objet pour définir la valeur, valeur actuelle sans paramètre

Exemples :

 $ value = $ column -> precision ();
$ column -> precision ( 10 );

Colonne :: primaire ()

Crée un index principal pour la colonne

 public function primary( string $ name = null ) : self

• @param string | null $name nom de l'index ou null pour générer automatiquement
• @return self même objet pour les appels de méthode fluide

Exemples :

 $ column -> primary ();
$ column -> primary ( ' pk_col ' );

Colonne :: Scale ()

Définit l'échelle de colonne ou renvoie la valeur actuelle

 public function scale( int $ value = null )

• @param int | null $value nouvelle valeur d'échelle de colonne ou null pour renvoyer la valeur actuelle
• @return self | int même objet pour définir la valeur, valeur actuelle sans paramètre

Exemples :

 $ value = $ column -> scale ();
$ column -> scale ( 3 );

Colonne :: seq ()

Définit la colonne comme auto-ondant ou renvoie la valeur actuelle

 public function seq( bool $ value = null )

• @param bool | null $value Nouveau indicateur automatique ou null pour renvoyer la valeur actuelle
• @return self | bool même objet pour définir la valeur, valeur actuelle sans paramètre

Exemples :

 $ value = $ column -> seq ();
$ column -> seq ( true );

Colonne :: spatial ()

Crée un index spatial pour la colonne

 public function spatial( string $ name = null ) : self

• @param string | null $name nom de l'index ou null pour générer automatiquement
• @return self même objet pour les appels de méthode fluide

Exemples :

 $ column -> spatial ();
$ column -> spatial ( ' idx_col ' );

Colonne :: type ()

Définit le type de colonne ou renvoie la valeur actuelle

 public function type( string $ value = null )

• @param String | null $value nouveau type de colonne ou null pour renvoyer la valeur actuelle
• @return self | String Même objet pour définir la valeur, valeur actuelle sans paramètre

Exemples :

 $ value = $ column -> type ();
$ column -> type ( ' tinyint ' );

Colonne :: unique ()

Crée un index unique pour la colonne

 public function unique( string $ name = null ) : self

• @param string | null $name nom de l'index ou null pour générer automatiquement
• @return self même objet pour les appels de méthode fluide

Exemples :

 $ column -> unique ();
$ column -> unique ( ' unq_col ' );

Colonne :: unsigned ()

Définit l'indicateur de colonne non signé ou renvoie la valeur actuelle

 public function unsigned( bool $ value = null )

• @param bool | null $value Nouvelle colonne indigne indigne ou null pour renvoyer la valeur actuelle
• @return self | bool même objet pour définir la valeur, valeur actuelle sans paramètre

Exemples :

 $ value = $ column -> unsigned ();
$ column -> unsigned ( true );

Colonne :: up ()

Applique les modifications au schéma de la base de données

 public function up() : self

• @return self même objet pour les appels de méthode fluide

Exemples :

 $ column -> up ();

Clés étrangères

Créer des clés étrangères

Upscheme offre une prise en charge des contraintes de clés étrangères, qui appliquent l'intégrité des données entre deux tables. Par exemple, si la colonne parentid de la table users_address fait référence à la colonne id de la table users , il ne peut y avoir de lignes dans la table users_address sans ligne correspondante dans la table users . L'appel de la méthode foreign() créera une telle contrainte:

 $ this -> db ()-> table ( ' users ' , function ( $ table ) {
	$ table -> id ();
} );

$ this -> db ()-> table ( ' users_address ' , function ( $ table ) {
	$ table -> foreign ( ' parentid ' , ' users ' );
} );

Remarque: La colonne ( parentid ) aura et doit avoir le même type de données et modificateurs de colonne que la colonne référencée ( id ). La méthode foreign() garantit cela et créera un nouvel index avec le même nom que la contrainte de clé étrangère automatiquement.

Si la colonne ID dans la table users est nommée différemment, passez son nom en troisième paramètre à la méthode foreign() :

 $ this -> db ()-> table ( ' users_address ' , function ( $ table ) {
	$ table -> foreign ( ' parentid ' , ' users ' , ' uid ' );
} );

Il est recommandé de passer le nom de la contrainte de clé étrangère en tant que paramètre Forth, il est donc plus facile de modifier ou de supprimer les contraintes plus tard:

 $ this -> db ()-> table ( ' users_address ' , function ( $ table ) {
	$ table -> foreign ( ' parentid ' , ' users ' , ' id ' , ' fk_test_pid ' );
} );

Dans le cas où il y a plus d'une colonne requise pour obtenir les valeurs uniques requises par les touches étrangères, passez les noms de colonne comme tableau:

 $ this -> db ()-> table ( ' users_address ' , function ( $ table ) {
	$ table -> foreign ( [ ' parentid ' , ' siteid ' ], ' users_address ' , [ ' id ' , ' siteid ' ] );
} );

Les contraintes de clé étrangère peuvent effectuer différentes actions si la colonne référencée dans le tableau étranger est supprimée de mise à jour. L'action standard consiste à restreindre la suppression de la ligne ou à mettre à jour la valeur d'ID référencée. Pour modifier le comportement, utilisez les méthodes onDelete() et onUpdate() :

 $ this -> db ()-> table ( ' users_address ' , function ( $ table ) {
	$ table -> foreign ( ' parentid ' , ' users ' )-> onDelete ( ' SET NULL ' )-> onUpdate ( ' RESTRICT ' );
} );

Il y a un raccourci si vous souhaitez définir les deux valeurs sur la même valeur:

 $ this -> db ()-> table ( ' users_address ' , function ( $ table ) {
	$ table -> foreign ( ' parentid ' , ' users ' )-> do ( ' SET NULL ' );
} );

Les valeurs possibles pour les deux méthodes sont:

• Cascade: mise à jour de la valeur référencée
• Aucune action: pas de changement de valeur référencée (identique à la restriction)
• Restreindre: interdire changer les valeurs
• Définir la valeur par défaut: définir la valeur référencée sur la valeur par défaut
• Définir NULL: Définissez la valeur référencée sur NULL

L'action par défaut lors de la suppression ou de la mise à jour des lignes est en cascade afin que les valeurs de la colonne de clé étrangère soient mises à jour aux mêmes valeurs que dans le tableau étranger.

Vérifier l'existence des clés étrangères

Pour vérifier si une clé étrangère existe déjà, utilisez la méthode hasForeign() :

 if ( $ this -> db ()-> hasForeign ( ' users_address ' , ' fk_usrad_parentid ' ) ) {
    // The "fk_usrad_parentid" foreign key in the " users_address " table exists
}

Il est également possible de vérifier plusieurs contraintes de clés étrangères à la fois. Ensuite, la méthode hasForeign() ne renvoie pas True que si toutes les contraintes existent dans les tableaux passés comme premier argument:

 if ( $ this -> db ()-> hasForeign ( ' users_address ' , [ ' fk_usrad_parentid ' , ' fk_usrad_siteid ' ] ) ) {
    // The "fk_usrad_parentid" and "fk_usrad_siteid" foreign keys exist in the "users_address" table
}

Si un objet de table disponible, la méthode hasForeign() de la table peut être utilisée à la place:

 $ 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
	}
} );

Dans le cas où vous avez besoin des valeurs actuelles d'une contrainte existante:

 $ 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 ;
} );

Laisser tomber les clés étrangères

Pour supprimer une contrainte de clé étrangère d'une table, utilisez la méthode dropForeign() et passez le nom de la table et le nom de la clé étrangère comme arguments:

 $ this -> db ()-> dropForeign ( ' users_address ' , ' fk_usrad_parentid ' );

Vous pouvez également passer plusieurs noms de clés étrangères pour les laisser tomber immédiatement:

 $ this -> db ()-> dropForeign ( ' users_address ' , [ ' fk_usrad_parentid ' , ' fk_usrad_siteid ' ] );

Dans la fonction anonyme transmise à la méthode table() , vous pouvez également utiliser la méthode dropForeign() :

 $ this -> db ()-> table ( ' users_address ' , function ( $ table ) {
	$ table -> dropForeign ( ' fk_usrad_parentid ' );
} );

$ this -> db ()-> table ( ' users_address ' , function ( $ table ) {
	$ table -> dropForeign ( [ ' fk_usrad_parentid ' , ' fk_usrad_siteid ' ] );
} );

Méthodes de clé étrangère

Clés étrangères

• __appel()
• __obtenir()
• __ensemble()
• nom()
• ondelete ()
• onupdate ()
• en haut()

Étranger :: __ Call ()

Appels des méthodes personnalisées

 public function __call( string $ method , array $ args )

• @param String $method Nom de la méthode
• Paramètres de la méthode @param array <mixtes> $args
• @Return Valeur de retour mixte de la méthode appelée

Exemples :

Vous pouvez enregistrer des méthodes personnalisées qui ont accès aux propriétés de classe de l'objet étranger Upscheme:

 Aimeos  Upscheme  Schema Foreign:: macro ( ' default ' , function () {
	$ this -> opts = [ ' onDelete ' => ' SET NULL ' , ' onUpdate ' => ' SET NULL ' ];
} );

$ foreign -> default ();

Les propriétés de classe disponibles sont:

$this->dbaltable : schéma de table doctrine

$this->table : Objet de table Upscheme

$this->localcol : nom ou nom de colonne locale

$this->fktable : nom de table étranger

$this->fkcol : nom ou nom de colonne étrangère

$this->name : Nom de la clé étrangère

$this->opts : liste associative des options de clés étrangères (principalement "ondelete" et "onupdate")

Étranger :: __ get ()

Renvoie la valeur de l'option de clé étrangère donnée

 public function __get( string $ name )

• @param string $name Nom de l'option de clé étrangère
• @Return Valeur d'option de clé étrangère mixte

La liste des options de clés étrangères disponibles est:

• ondelete
• ondupdate

Les valeurs possibles pour les deux options sont:

• Cascade: mise à jour de la valeur référencée
• Aucune action: pas de changement de valeur référencée (identique à la restriction)
• Restreindre: interdire changer les valeurs
• Définir la valeur par défaut: définir la valeur référencée sur la valeur par défaut
• Définir NULL: Définissez la valeur référencée sur NULL

Exemples :

 $ value = $ foreign -> onDelete ;
// same as
$ value = $ foreign -> opt ( ' onDelete ' );

Étranger :: __ set ()

Définit la nouvelle valeur de l'option de clé étrangère donnée

 public function __set( string $ name , $ value )

• @param string $name Nom de l'option de clé étrangère
• @param Valeur d'option de clé étrangère mixte

La liste des options de clés étrangères disponibles est:

• ondelete
• ondupdate

Les valeurs possibles pour les deux options sont:

• Cascade: mise à jour de la valeur référencée
• Aucune action: pas de changement de valeur référencée (identique à la restriction)
• Restreindre: interdire changer les valeurs
• Définir la valeur par défaut: définir la valeur référencée sur la valeur par défaut
• Définir NULL: Définissez la valeur référencée sur NULL

Exemples :

 $ foreign -> onDelete = ' SET NULL ' ;
// same as
$ foreign -> onDelete ( ' SET NULL ' );
$ foreign -> opt ( ' onDelete ' , ' SET NULL ' );

Étranger :: do ()

Définit la nouvelle valeur de l'option de clé étrangère donnée

 public function do( string $ action ) : self

• @param string $action exécutée Action
• @return self même objet pour les appels de méthode fluide

Les actions possibles sont:

• Cascade: supprimer ou mettre à jour la valeur référencée
• Aucune action: pas de changement de valeur référencée (identique à la restriction)
• Restreindre: interdire changer les valeurs
• Définir la valeur par défaut: définir la valeur référencée sur la valeur par défaut
• Définir NULL: Définissez la valeur référencée sur NULL

Exemples :

 $ foreign -> do ( ' RESTRICT ' );

Foreign :: name ()

• Renvoie le nom actuel de la contrainte de clé étrangère

 public function name()

• @return String | Nom null de la contrainte ou null si aucun nom n'est disponible

Exemples :

 $ fkname = $ foreign -> name ();

Étranger :: ondelete ()

• Définit l'action si la ligne référencée est supprimée ou renvoie la valeur actuelle

 public function onDelete( string $ value = null )

• @param String | null $value effectuée Action ou null pour renvoyer la valeur actuelle

• @return self | String Même objet pour définir la valeur, valeur actuelle sans paramètre

• Les actions disponibles sont:

• • Cascade: supprimer la valeur référencée
• • Aucune action: aucun changement de valeur référencée
• • Restreindre: interdire changer les valeurs
• • Définir la valeur par défaut: définir la valeur référencée sur la valeur par défaut
• • Définir NULL: Définissez la valeur référencée sur NULL

Exemples :

 $ 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 ' );

Étranger :: onupdate ()

• Définit l'action si la ligne référencée est mise à jour ou renvoie la valeur actuelle

 public function onUpdate( string $ value = null )

• @param String | null $value effectuée Action ou null pour renvoyer la valeur actuelle

• @return self | String Même objet pour définir la valeur, valeur actuelle sans paramètre

• Les actions disponibles sont:

• • Cascade: mise à jour de la valeur référencée
• • Aucune action: aucun changement de valeur référencée
• • Restreindre: interdire changer les valeurs
• • Définir la valeur par défaut: définir la valeur référencée sur la valeur par défaut
• • Définir NULL: Définissez la valeur référencée sur NULL

Exemples :

 $ 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 ' );

Étranger :: up ()

• Applique les modifications au schéma de la base de données

 public function up() : self

• @return self même objet pour les appels de méthode fluide

Exemples :

 $ foreign -> up ();

Séquences

Ajout de séquences

Quelques implémentations de base de données offrent des séquences au lieu de colonnes auto-incidences / identités, à savoir Oracle et PostgreSQL. Les séquences sont des fonctions qui créent des nombres augmentés séquentiellement qui sont appliqués à une colonne de table lors de l'insertion de nouvelles lignes. Pour créer une nouvelle séquence nommée Seq_Test, utilisez la méthode sequence() :

 $ this -> db ()-> sequence ( ' seq_test ' );

Pour utiliser une valeur de démarrage et une largeur de pas différente de 1 , appelez les méthodes start() et step() :

 $ this -> db ()-> sequence ( ' seq_test ' , function ( $ seq ) {
	$ seq -> start ( 1000 )-> step ( 2 );
} );

Vérifier l'existence de la séquence

Pour vérifier si une séquence existe déjà, utilisez la méthode hasSequence() :

 if ( $ this -> db ()-> hasSequence ( ' seq_test ' ) ) {
    // The "seq_test" sequence exists
}

Il est également possible de vérifier plusieurs séquences à la fois. Ensuite, la méthode hasSequence() ne renverra True que si toutes les séquences existent:

 if ( $ this -> db ()-> hasSequence ( [ ' seq_id ' , ' seq_test ' ] ) ) {
    // The "seq_id" and "seq_test" sequences exist
}

Dans le cas où vous avez besoin de connaître les valeurs actuelles des options de table:

 $ 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 ;
} );

Séquences de dépôt

Pour supprimer une séquence, utilisez la méthode dropSequence() et passez le nom de la séquence comme argument:

 $ this -> db ()-> dropSequence ( ' seq_id ' );

Vous pouvez également passer plusieurs noms de séquence pour les déposer immédiatement:

 $ this -> db ()-> dropSequence ( [ ' seq_id ' , ' seq_test ' ] );

Méthodes de séquence

Séquences

• __appel()
• __obtenir()
• __ensemble()
• cache ()
• nom()
• commencer()
• étape()
• en haut()

Séquence :: __ Call ()

Appelle des méthodes personnalisées ou transmet des appels de méthode inconnus à l'objet de table de doctrine

 public function __call( string $ method , array $ args )

• @param String $method Nom de la méthode
• Paramètres de la méthode @param array <mixtes> $args
• @Return Valeur de retour mixte de la méthode appelée

Exemples :

Vous pouvez enregistrer des méthodes personnalisées qui ont accès aux propriétés de classe de l'objet de séquence Upscheme:

 Aimeos  Upscheme  Schema Sequence:: macro ( ' default ' , function () {
	$ this -> start ( 1 )-> step ( 2 );
} );

$ sequence -> default ();

Les propriétés de classe disponibles sont:

$this->db : objet Upscheme db

$this->sequence : schéma de séquence de doctrine

Séquence :: __ get ()

Renvoie la valeur de l'option de séquence donnée

 public function __get( string $ name )

• Nom de l'option de séquence de nom de nom de chaîne @param $name
• Valeur d'option de séquence mixte @return

Exemples :

 $ value = $ sequence -> getInitialValue ();
// same as
$ value = $ sequence -> start ();

Séquence :: __ set ()

Définit la nouvelle valeur de l'option de séquence donnée

 public function __set( string $ name , $ value )

• Nom de l'option de séquence de nom de nom de chaîne @param $name
• Valeur d'option de séquence mixte @param

Exemples :

 $ value = $ sequence -> setInitialValue ( 1000 );
// same as
$ value = $ sequence -> start ( 1000 );

Séquence :: cache ()

Définit la taille en cache de la séquence ou renvoie la valeur actuelle

 public function cache( int $ value = null )

• @param int $value nouveau nombre d'identifices de séquence mis en cache par le client ou null pour renvoyer la valeur actuelle
• @return self | int même objet pour régler la valeur, valeur actuelle sans paramètre

Exemples :

 $ value = $ sequence -> cache ();
$ sequence -> cache ( 100 );

Séquence :: name ()

Renvoie le nom de la séquence

 public function name()

• Nom de séquence de chaîne @return

 $ name = $ sequence -> name ();

Séquence :: start ()

Définit la nouvelle valeur de démarrage de la séquence ou renvoie la valeur actuelle

 public function start( int $ value = null )

• @param int $value nouvelle valeur de démarrage de la séquence ou null pour renvoyer la valeur actuelle
• @return self | int même objet pour régler la valeur, valeur actuelle sans paramètre

 $ value = $ sequence -> start ();
$ sequence -> start ( 1000 );

Séquence :: Step ()

Définit la taille de pas des nouvelles valeurs de séquence ou renvoie la valeur actuelle

 public function step( int $ value = null )

• @param int $value nouvelle taille étape La séquence est incrémentée ou décrémentée par ou null pour retourner la valeur actuelle
• @return self | int même objet pour régler la valeur, valeur actuelle sans paramètre

 $ value = $ sequence -> step ();
$ sequence -> step ( 2 );

Séquence :: up ()

Applique les modifications au schéma de la base de données

 public function up() : self

• @return self même objet pour les appels de méthode fluide

 $ sequence -> up ();

Index

Les index accélérent les requêtes de base de données et le temps dont une requête a besoin peut passer de plusieurs minutes à des millisecondes si elle est utilisée correctement. Il existe plusieurs types d'index disponibles:

• Primaire: toutes les valeurs doivent être uniques, aucune valeur nulle et un seul indice par table est autorisé
• unique: les valeurs doivent être uniques mais les valeurs nulles sont autorisées (et plus d'une fois)
• Index: Index standard sans restrictions
• Spatial: recherche rapide dans les systèmes coordonnés comme les cartes géographiques

Tous les index peuvent être composés d'une ou plusieurs colonnes, mais l'ordre des colonnes a un grand impact si des index sont utilisés pour une requête ou non.

Ajout d'index

Tous les index sont liés à la table qui contient les colonnes que l'index couvre. La façon la plus simple de créer un index sur une seule colonne consiste à utiliser la méthode index() de l'objet de colonne:

 $ this -> db ()-> table ( ' test ' , function ( $ table ) {
	$ table -> string ( ' label ' )-> index ();
} );

Le deuxième paramètre de la méthode index() vous permet de définir un nom personnalisé pour l'index:

 $ this -> db ()-> table ( ' test ' , function ( $ table ) {
	$ table -> string ( ' label ' )-> index ( ' idx_test_label ' );
} );

Remarque: Pour une compatibilité maximale entre les différents types de bases de données, la longueur des noms d'index doit être de 30 caractères ou moins.

La même chose est possible pour les index primaires, uniques et spatiaux:

 $ 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 ' );
} );

Pour les index multi-colonnes, les méthodes primary() , unique() et index() sont disponibles dans l'objet de table:

 $ 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 ' ] );
} );

Les index spatiaux ne peuvent pas courir plusieurs colonnes, mais les créer sont également possibles en utilisant la méthode spatial() de l'objet de table:

 $ this -> db ()-> table ( ' test ' , function ( $ table ) {
	$ table -> spatial ( ' location ' );
} );

Vérification de l'existence de l'index

Pour vérifier si un index existe déjà, utilisez la méthode hasIndex() :

 if ( $ this -> db ()-> hasIndex ( ' users ' , ' idx_users_name ' ) ) {
    // The "idx_users_name" index in the "users" table exists
}

Vous pouvez également vérifier plusieurs index à la fois. 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
}

Renaming indexes

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.

Dropping indexes

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.

Custom index naming

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:

• idx : Regular and spatial indexes
• fk : Foreign key index
• pk : Primary key index
• unq : Unique index

Note: For compatibility to all supported database types, the maximum length of the index names must be not longer than 30 characters!

Customizing Upscheme

Adding custom methods

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 ();

Implementing custom columns

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 ' );
} );

Upgrade Upscheme

To 0.9.0

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 database
• DB::type() returns sqlserver instead of mssql for Microsoft SQLServer database
• DB::for() , DB::view() and Column::opt require ['mariadb', 'mysql'] to get the same results
• DB::lastId() doesn't require/support passing a sequence name because Doctrine DBAL removed it but doesn't support Oracle IDENTITY columns at the moment