// you’re reading...

Datenbank

Mit PHP-Doctrine Datenbank-Schema erzeugen

Es gibt unterschiedliche Ansätze, wie man Entitäten und Datenbanktabellen erzeugt bzw. erzeugen lässt. Bei Verwendung von UML-Tools wird meist erst ein Klassendiagramm bzw. ER-Modell erstellt, aus welchem die konkreten Entitätsklassen und Datenbanktabellen erstellt werden. Wenn Sie einen ORM-Mapper verwenden möchten, ist eine mögliche Variante die Erzeugung der Datenbanktabellen durch den Mapper durchführen zu lassen. In diesem Fall müssen Sie nur die Entitätsklassen erstellt oder durch ein UML-Tool erzeugt haben. Viele Mapping-Tools können anhand von konkreten Klassen Datenbankschemata erzeugen. Im folgenden Beispiel mache ich dies mit der Sprache PHP und dem Tool Doctrine.

ORM-Mapper Doctrine

Unter Java sind Hibernate und JPA weit verbreitet, unter PHP ist ein bekanntes Object-Relational-Mapping-Tool Doctrine. Wie bereits anfangs beschrieben kann aus konkreten PHP-Klassen die Datenbank erzeugt werden.  Dieses Tutorial zeigt Ihnen die wichtigsten Schritte, welche Sie durchführen sollten, um schnell aus PHP-Klassen ein Datenbankschema erzeugen zu können. Zugriffe auf die Tabellen ist nicht Teil dieser Anleitung.

Installation

Sie können die aktuelle Version hier herunterladen: doctrine-project.org/projects/orm.html. Entpacken Sie das Archiv, sodass Sie in Ihrem Hauptverzeichnis folgende Verzeichnisstruktur erhalten:

  • htdocs/
    • Doctrine/
      • Common/
      • DBAL/
      • ORM/
      • Symfony/

Entitäten erzeugen

Erstellen Sie in das Hauptverzeichnis htdocs ein Verzeichnhnis entity, welches die Enitätsklassen enthalten soll. Erstellen Sie hier Ihre Klassen. In meinem Beispiel habe ich eine Klasse User erstellt:

/**
 * @Entity @Table(name="user")
 */
class User 
{
    /** @Id @GeneratedValue @Column(type="integer") **/
      protected $id;
      /** @Column(type="string") **/
      protected $mail;
      /** @Column(type="string", nullable=true) **/
      protected $firstname;
      /** @Column(type="string", nullable=true) **/
      protected $lastname;
      /** @Column(type="string", nullable=true) **/

      public function getId()          { return $this->id; } 
      public function getMail()        { return $this->mail; } 
      public function getFirstname()   { return $this->firstname; } 
      public function getLastname()    { return $this->lastname; } 
      public function setMail($x)      { $this->mail = $x; } 
      public function setFirstname($x) { $this->firstname = $x; } 
      public function setLastname($x)  { $this->lastname = $x; } 
}

Es sind hier schon einige Annotationen genannt, welche in der Dokumentation ausführlicher beschrieben sind. Wichtig ist die Nennung der @Entity Annotation, damit der Mapper weißt, dass es sich bei dieser Klasse um eine Entität handelt. Weiterhin habe ich dem Attribut id mit den Annotationen @Id und @GeneratedValue einen Primärschlüssel mit automatisch vergebener Id definiert.

Datenbankschema erzeugen

Um mit dem Installierten Programm und der erstellten PHP-Klasse nun das Schema automatisch erzeugen lassen zu können, habe ich folgendes Skript im Hauptverzeichnis htdocs geschrieben:

<?php
require 'Doctrine/ORM/Tools/Setup.php';

use Doctrine\ORM\Tools\Setup;
use Doctrine\ORM\EntityManager;

Setup::registerAutoloadPEAR();

$paths = array("/entity");
$isDevMode = true;

// dbconnection 
$dbParams = array(
    'driver'   => 'pdo_mysql',
    'user'     => 'root',
    'password' => '',
    'dbname'   => 'dbname',
);

$config = Setup::createAnnotationMetadataConfiguration($paths, $isDevMode);
$em = EntityManager::create($dbParams, $config);

$tool = new \Doctrine\ORM\Tools\SchemaTool($em);
$classes = array(
  $em->getClassMetadata('User'),
);

$tool->createSchema($classes);

Das Skript lädt die notwendigen Entitätsdateien sowie Doctrine-Abhängigkeiten. Im Anschluss wird die Datenbankverbindung/Connection hergestellt. Dem SchemaTool wird ein Array der zu erzeugenden Entitätstabellen mitgegeben und mit der Funktion createSchema() werden diese in der Datenbank erzeugt.

Fazit

Wenn Sie immer mit dem Erstellen der Entitätsklassen begonnen haben, kann Ihnen Doctrine den Schritt der Datenbankerstellung abnehmen. Auch Änderungen an den Klassen können Sie problemlos während der Entwicklung in der Datenbank aktualisieren lassen. Mit den Annotationen können nicht nur einfache Definitionen festgemacht werden, sondern auch Beziehungen (OneToMany, OneToOne, ManyToMany) zwischen PHP-Klassen erzeugt werden. Doctrine erstellt hierzu in Ihrer Datenbank auch direkt die entsprechenden Constraints. Weiterhin unterstützt Doctrine auch viele DBMS (Oracle, MySQL, MSSQL, …)

Für die Entwicklung mit PHP und Datenbanken ist ein ORM-Tool wie Doctrine ein hilfreiches Tool, welches schon allein beim Erstellen der Datenbank unterstützt. Später werde ich zeigen, wie Daten gelesen und geschrieben werden können, sowie die Verwendung der Relationen per Annotationen.

Empfehlen:    
   

Diskussion

Keine Kommentare für “Mit PHP-Doctrine Datenbank-Schema erzeugen”

Kommentar schreiben


(Eingegebener Name wird unter Impressum/Kontakt der Website validiert)

*