Agence web et solutions IT, Experts Symfony contact@avanim-prod.com

Plusieurs connexions avec Symfony et Doctrine

18 octobre 2010 jravouna Symfony Étiquettes : , , , , 0 Comments

Introduction

En ce chapitre nous expliquerons quelques choses au sujet des raccordements de doctrine, comment configurer les raccordements multiples, des modèles de grippage, et comment créer et laisser tomber vos bases de données et tout autre raccordement ont rapporté des activités.

Les config de défaut/databases.yml devraient ressembler au suivant.

tous :
  propulsez :
    classe :      sfPropelDatabase
    param :
      DSN :      mysql : host=localhost ; dbname=dbname
      username : utilisateur

La seule différence entre propulsent et la doctrine ici est que la classe doit être sfDoctrineDatabase au lieu de sfPropelDatabase et le nom de raccordement est doctrine au lieu de propulsent. La doctrine et propulsent les éléments de données de PHP d’utilisation (PDO) comme couche d’abstraction de base de données.

Propulsez cependant exige au moins un raccordement appelé propulsent, doctrine n’exige pas que le raccordement soit appelé doctrine ainsi vous pouvez l’appeler celui que vous aimiez.

Vous pouvez configurer les raccordements dans les config/databases.yml avec la configuration : tâche de base de données comme le suivant.

$ ./symfony configurent : base de données --name=doctrine --mysql de « : host=localhost ; secret d'utilisateur de dbname=dbname »

Maintenant vous verrez un nouveau raccordement défini comme ce qui suit :

doctrine :
  classe : sfDoctrineDatabase
  param :
    DSN : « mysql : host=localhost ; dbname=dbname »
    username : utilisateur
    mot de passe : secret

Vous devez supprimer complètement les références pour propulser dans les config/databases.yml si vous faites désactiver le sfPropelPlugin.

Conducteurs soutenus

La doctrine soutient tous les conducteurs que PDO soutient. Le PHP doit être compilé avec PDO et les conducteurs de PDO_* que vous souhaitez employer. Est ci-dessous une liste de bases de données que PDO fonctionnera avec.

Nom Description
Serveur de la milliseconde SQL Le serveur et le Sybase de Microsoft SQL fonctionne (PDO_DBLIB)
Firebird/Interbase Firebird/fonctions Interbase (PDO_FIREBIRD)
IBM IBM fonctionne (PDO_IBM)
Informix Informix fonctionne (PDO_INFORMIX)
MySQL MySQL fonctionne (PDO_MYSQL)
Oracle Oracle fonctionne (PDO_OCI)
ODBC et DB2 ODBC et DB2 fonctionne (PDO_ODBC)
PostgreSQL PostgreSQL fonctionne (PDO_PGSQL)
SQLite SQLite fonctionne (PDO_SQLITE)

Vous pouvez lire plus au sujet de PDO chez http://www.php.net/pdo.

Nom de point d’émission de données (DSN)

La doctrine offre deux manières de spécifier votre information de DSN. Vous pouvez employer le modèle DSN de doctrine ou employer le modèle indigène de PDO.

Modèle de doctrine

La doctrine a une syntaxe de DSN qui est basée au loin de la POIRE MDB2.

tous :
  doctrine :
    classe :          sfDoctrineDatabase
    param :
      DSN :          conducteur : //username : password@host/database_name

Modèle de PDO

Vous pouvez alternativement spécifier votre information de DSN dans la syntaxe de modèle de PDO.

tous :
  doctrine :
    classe :          sfDoctrineDatabase
    param :
      DSN :          conducteur : dbname=database_name ; host=localhost
      username :     username
      mot de passe :     mot de passe

Utilisant le modèle de PDO la syntaxe offre plus de flexibilité et de capacité de spécifier des informations non standard sur votre raccordement à PDO. Par exemple, en spécifiant les chemins ou les ports non standard d’unix_socket pour employer quand se relier, la spécifiant en syntaxe de PDO est plus flexible. La configuration : la commande impliquant l’accès à la base de données fonctionne également seulement avec le modèle de PDO.

Importation en provenance de base de données

La doctrine a la capacité de produire d’un dossier de schéma dans les config/doctrine/schema.yml d'une base de données existante. Configurez juste votre raccordement de doctrine pour la base de données que vous souhaitez importer et courir la commande suivante.

C’est une bonne manière de convertir le votre propulsent le schéma à la doctrine. Créez simplement votre base de données utilisant propulsent, et puis produisent du schéma dans la doctrine de votre base de données créée.

doctrine de $ ./symfony : construire-schéma
>> doctrine  produisant du schéma de yaml de la base de données

Allez voir maintenant dans les config/doctrine/schema.yml et vous verrez le yaml pour la base de données. Dans cet exemple nous avons une table d’utilisateur.

CRÉEZ l'utilisateur de TABLE (identification BIGINT AUTO_INCREMENT, username VARCHAR (255), mot de passe VARCHAR (255), CLÉ PRIMAIRE (l'identification)) MOTEUR = INNODB ;

La table ci-dessus de mysql produirait d’un schéma de yaml comme le suivant dans les config/doctrine/schema.yml

Utilisateur :
  tableName : utilisateur
  colonnes :
    identification :
      type : nombre entier (8)
      primaire : vrai
      auto-incrément : vrai
    username : corde (255)
    mot de passe : corde (255)

Raccordements multiples

La doctrine offre la capacité d’avoir les raccordements multiples. Vous pouvez facilement lier des modèles aux raccordements de sorte que des questions soient exécutées sur le raccordement approprié. Tellement d’abord nous devons ajouter les raccordements multiples avec la configuration : la commande impliquant l’accès à la base de données aiment le suivant.

$ ./symfony configurent : base de données --name=master --mysql de « : host=localhost ; secret d'utilisateur de dbname=master »
$ ./symfony configurent : base de données --name=client --mysql de « : host=localhost ;  » secret dbname=client d'utilisateur

Enlevez le raccordement original que nous avons créé et vos config/databases.yml ressembleront au suivant.

tous :
  maître :
    classe : sfDoctrineDatabase
    param :
      DSN : « mysql : host=localhost ; dbname=master »
      username : utilisateur
      mot de passe : secret
  client :
    classe : sfDoctrineDatabase
    param :
      DSN : « mysql : host=localhost ; dbname=client »
      username : utilisateur
      mot de passe : secret

Dites maintenant que nous avons un modèle de client que vous voulez lier à la base de données principale. Vous pouvez simplement faire ceci directement dans la définition du modèle comme ci-dessous. Placez le code suivant de YAML dans les config/doctrine/schema.yml

Client :
  raccordement : maître
  colonnes :
    nom : corde (255)
    username : corde (255)
    mot de passe : corde (255)

Maintenant chaque client peut avoir des magasins mais ils sont sauvés dans une base de données séparée des clients.

Magasin :
  raccordement : client
  attributs :
    exportation : tables
  colonnes :
    nom : corde (255)
    description : corde (500)
    client_id : nombre entier
  relations :
    Client :
     foreignAlias : Magasins

Puisque les tables sont dans les bases de données séparées les données peuvent seulement être paresseux chargées. La doctrine ne soutient pas actuellement produire du SQL pour les tables de jointure à travers des bases de données. En outre, notez l’attribut d’exportation étant placé aux tables. Ceci indique la doctrine n’exporter seulement le rapport de table de création et aucune contrainte principale étrangère.

Attributs de raccordement

le sfDoctrinePlugin te permet de spécifier des attributs de raccordement directement dans le dossier des config/databases.yml comme le suivant.

  doctrine :
    classe : sfDoctrineDatabase
    param :
      DSN : « mysql : host=localhost ; dbname=dbname »
      username : utilisateur
      mot de passe : secret
      attributs :
        use_dql_callbacks : vrai

Les attributs que vous spécifiez ici seront placés sur les exemples de Doctrine_Connection quand le raccordement est créé.

Les attributs dans la doctrine sont pour les dispositifs de configuration et de contrôle. Vous pouvez lire plus au sujet des attributs dans la documentation de doctrine.

Construction tout

Maintenant que nous avons nos raccordements et schéma nous ont définis peuvent construire tout avec le suivant commandent.

doctrine de $ ./symfony : construire-tout-rechargez

  Cette commande enlèvera toutes les données dans votre base de données.  
  Êtes-vous sûr vous voulez-vous procéder ? (y/N)              

y
>> bases de données  chutantes de doctrine
>> doctrine  créant des bases de données
>> doctrine  produisant des classes modèles
>> doctrine  produisant du SQL pour des modèles
>> doctrine  produisant des classes grilles
>> doctrine  produisant des classes grilles de filtre
>> la doctrine  a créé des tables avec succès
>> montages  de données de chargement de doctrine de « /Us… ymfony12doctrine/data/fixtures »

Le fonctionnement des commandes ci-dessus est égal à courir les commandes suivantes séparément.

doctrine de $ ./symfony : baisse-DB

  Cette commande enlèvera toutes les données dans votre base de données.  
  Êtes-vous sûr vous voulez-vous procéder ? (y/N)              

y
>> bases de données  chutantes de doctrine
doctrine de $ ./symfony : construire-DB
>> doctrine  créant des bases de données
doctrine de $ ./symfony : construire-modèle
>> doctrine  produisant des classes modèles
doctrine de $ ./symfony : construire-SQL
>> doctrine  produisant du SQL pour des modèles
doctrine de $ ./symfony : construire-forme
>> doctrine  produisant des classes grilles
doctrine de $ ./symfony : construire-filtres
>> doctrine  produisant des classes grilles de filtre
doctrine de $ ./symfony : insérer-SQL
>> la doctrine  a créé des tables avec succès
doctrine de $ ./symfony : donnée-charge
>> montages  de données de chargement de doctrine de « /Us… ymfony12doctrine/data/fixtures »

Vous pouvez jeter un coup d’oeil aux modèles qui ont été produits à partir de vos dossiers de schéma de YAML dans la bibliothèque/modèle/doctrine et la bibliothèque/modèle/doctrine/base. Les dossiers dans le dossier produit sont récrits chaque fois que vous établissez vos modèles tandis que ceux au-dessous de l’annuaire bas ne sont pas. Vous pouvez adapter vos modèles en éditant les classes dans la bibliothèque/modèle/doctrine.

Voici à ce que la bibliothèque/modèle/doctrine/base/BaseClient.class.php devraient ressembler.

< ? PHP
Attache composante de raccordement de //
Doctrine_Manager : : getInstance () - >bindComponent (« client », « maître ") ;

/**
 * Cette classe automatique-a été produite par le cadre de la doctrine ORM
 *
la classe abstraite BaseClient prolonge le sfDoctrineRecord
{
  setTableDefinition public de fonction ()
  {
    $this->setTableName (« client ") ;
    $this->hasColumn (« nom », « corde », 255, rangée (« type » de « longueur » de => => « 255 » de « corde »,));
    $this->hasColumn (« username », « corde », 255, rangée (« type » de « longueur » de => => « 255 » de « corde »,));
    $this->hasColumn (« mot de passe », « corde », 255, rangée (« type » de « longueur » de => => « 255 » de « corde »,));
  }

  la fonction publique a installé ()
  {
    $this->hasMany (« magasin comme stocke », rangée (=> « local » « identification »,
                                            client_id de => « ") « étranger ») ;
  }
}

Il est pratique commune de courir la doctrine de ./symfony : construire-tout-recharger-essai-toute commande en se développant. Ceci reconstruira votre environnement entier et courra la pleine suite d’essai. C’est une bonne commande de courir avant de commettre le nouveau code pour s’assurer que nouvelle régression ne s’est pas produite.

Davantage peut être eu connaissance des raccordements du manuel de doctrine ici.

Submit a comment