Generare un database relazionale con Doctrine Annotations

Doctrine é un ORM (Object-relational mapping), in particoare è open source, la documentazione ufficiale è disponibile al seguente link

Getting Started with Doctrine

Il primo passo è installare Doctrine tramite Composer.

Il file composer.json di cui abbiamo bisogno è il seguente

composer.json

{
    "require": {
        "doctrine/orm": "*"
    }
}

salviamo questo file nella cartella principale del nostro progetto, e tramite il Prompt dei Comandi lanciamo il seguente comando nella stessa cartella

composer install

al termine del processo verrà generata una cartella vendor contenente tutti i file e le cartelle necessarie all'utilizzo di Doctrine.

Il passo successivo è configurare Doctrine con le informazioni del database e per poter utilizzare lo strumento a linea di comando, pertanto creiamo due file bootstrap.php e cli-config.php

bootstrap.php

<?php
require_once __DIR__."/vendor/autoload.php";

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

$isDevMode = true;

$config = Setup::createAnnotationMetadataConfiguration(
       array(__DIR__."/src"),$isDevMode
);

$conn=array(
    'host'     => 'localhost', //nome host
    'driver'   => 'pdo_mysql', // tipo driver
    'user'     => 'root', // user database, es. root
    'password' => 'root', // password database, es. root
    'dbname'   => 'test_doctrine', //nome database, es. test_doctrine
);

return $entityManager = EntityManager::create($conn, $config);

questo file restituisce l'istanza di EntityManager, che è una classe del progetto Doctrine per la gestione delle entità del progetto, in particolare è stata specificata la cartella contenente le classi relative alle tabelle del nostro database, che in questo esempio è /src e sono stati specificati i dati di accesso al database nell'array $conn.

cli-config.php

<?php
use Doctrine\ORM\Tools\Console\ConsoleRunner;
return ConsoleRunner::createHelperSet(require "bootstrap.php");

questo script viene utilizzato per restituire un oggetto di configurazione per lo strumento a linea di comando di Doctrine.

Ora che sono stati creati i file di configurazione, creo due classi di esempio Order e Customer usando la sintassi di Doctrine Annotations e le salvo nella cartella src del progetto

src/Order.php

<?php
/** @Entity @Table(name="orders") */

class Order{
	
	/** @Id @Column(type="integer") @GeneratedValue */
	private $id;
	
	/** @Column(type="string", nullable=false) */
	private $orderDate;	
	
	/* function get */
	public function getID(){
		return $this->orderID;
	}	
	
	public function getOrderDate(){
		return $this->orderDate;
	}	
	
	/* function set */
	public function setOrderDate($orderDate){
		$this->orderDate=$orderDate;
	}	
}

e la classe Customer

src/Customer.php

<?php
/** @Entity @Table(name="customers") */

class Customer{
		
    /** @Id @Column(type="integer") @GeneratedValue */
	private $id;
	
	/** @Column(type="string") */
	private $customerName;
	
	/** @Column(type="string", nullable=true) */
	private $contactName;
	
	/** @Column(type="string", nullable=true) */
	private $country;	
	
	/* function get */
	public function getID(){
		return $this->id;
	}
	
	public function getCustomerName(){
		return $this->customerName;
	}
	
	public function getContactName(){
		return $this->contactName;
	}

	public function getCountry(){
		return $this->country;
	}	
	
	/* function set */	
	public function setCustomerName($customerName){
		$this->customerName=$customerName;
	}	
	
	public function setContactName($contactName){
		$this->contactName=$contactName;
	}			
	
	public function setCountry($country){
		$this->country=$country;
	}	
	
}

come si nota sono state aggiunte delle annotazioni aggiuntive tramite commenti, le classi vengono definite come delle entità (@Entity) e mappate con le rispettive tabelle del database relazionale (@Table), le proprietà di classe sono mappate con i corrispondenti campi della rispettiva tabella del database relazionale, per indicare la chiave primaria si usa l'annotazione @Id e per indicare che un valore è autogenerato si usa l'annotazione @GeneratedValue, la tipologia di dati viene specificata tramite l'annotazione @Column(type=""), per indicare che un campo può essere nullo si usa l'annotazione nullable=true.

A questo punto apriamo il Prompt dei Comandi e lanciamo il seguente comando

php vendor/bin/doctrine

avremo come output un messaggio come questo

Doctrine Command Line Interface v2.7.3@d95e03ba660d50d785a9925f41927fef0ee553cf

Usage:
  command [options] [arguments]

Options:
  -h, --help            Display this help message
  -q, --quiet           Do not output any message

.......
.......

il che ci indica che Doctrine è stato configurato correttamente e possiamo creare il database tramite il seguente comando

php vendor/bin/doctrine orm:schema-tool:create

se tutto va a buon fine avremo un output simile a questo

 ! [CAUTION] This operation should not be executed in a production environment!

 Creating database schema...

 [OK] Database schema created successfully!

e come possiamo notare sono state create due tabelle customers e orders nel database che in questo esempio è test_doctrine.

Oltre al comando che abbiamo visto prima per generare le tabelle (orm:schema-tool:create), è possibile effettuare il drop di tutte le tabelle del database tramite il seguente comando

php vendor/bin/doctrine orm:schema-tool:drop --force

se invece si vuole solo apportare una modifica strutturale senza perdere i dati possiamo farlo tramite il seguente comando

php vendor/bin/doctrine orm:schema-tool:update --force