Accedere al database con Doctrine e Symfony2

Doctrine è una libreria di classi PHP sviluppate per consentire l'accesso ad una base di dati relazionale come MySQL fornendo degli strumenti che semplificano le operazioni con i database.

Finora abbiamo visto come gestire una chiamata HTTP e visualizzare un template con dei dati a seconda della richiesta ricevuta. In questa lezione vedremo come accedere e comunicare con un un database relazionale in Symfony attraverso Doctrine.

Chiaramente Symfony non obbliga ad utilizzare Doctrine. Quanto vedremo in questa lezione potrebbe essere realizzato utilizzando anche altri strumenti come ad esempio la classe PDO.

Installare Doctrine

Prima di iniziare dobbiamo assicurarci che Doctrine sia installato e correttamente funzionante. Apriamo quindi il file composer.json e verifichiamo che all'interno delle dipendenze siano presenti le seguenti voci, aggiungendole in caso contrario:

"doctrine/orm": "~2.2,>=2.2.3",
"doctrine/doctrine-bundle": "~1.2",

Se abbiamo dovuto aggiungere manualmente le dipendenze, lanciamo un composer update in maniera da installarle automaticamente.

A questo punto, per verificare che Doctrine sia installato ed accessibile da Symfony, lanciamo il seguente comando nella console con cui effettuiamo una query diretta al database:

>php app/console doctrine:schema:update

Se il comando non restituisce errori, dovrebbe notificare un messaggio del tipo:

Nothing to update - your database is already in sync with the current entity metadata.

il quale ci avvisa di non avere bisogno di aggiornare il database. Vedremo tra poco come utilizzare il comando.

La configurazione del database l'abbiamo inserita in fase di installazione di Symfony. Nel caso si avesse la necessità di aggiornare i parametri, possiamo farlo all'interno del file app/config/parameters.yml o, se non presente, all'interno dei vari file app/config/config_* di ogni ambiente.

Creazione database

Se nella fase precedente abbiamo ricevuto un errore dovuto al fatto che il database non è stato creato, ma possiamo chiedere a Doctrine di crearlo per noi. Per fare ciò abbiamo bisogno del seguente comando:

php app/console doctrine:database:create

Nel caso in cui, invece, volessimo svuotare un database, possiamo usare il seguente comando:

php app/console doctrine:database:drop --force

Symfony e le entity

A questo punto possiamo procedere con la creazione delle tabelle nel nostro database e dei relativi "modelli" in Symfony. Visto l'esempio precedente si potrebbe pensare di creare le tabelle attraverso il comando doctrine:query:sql, manualmente. Doctrine, invece, ci consente di fare molto di più con più facilità.

Prima di vedere come, però, mettiamo un attimo Doctrine da parte ed immaginiamo la struttura che vogliamo realizzare.

Supponiamo di voler gestire un database di libri e che le informazioni di cui abbiamo bisogno siano le seguenti:

• id
• titolo
• isbn
• autore
• descrizione
• prezzo

Possiamo immaginare da subito i tipi di dato che conterranno i singoli campi:

Campo	Tipo di dato
id	integer chiave primaria con auto increment
titolo	varchar
isbn	varchar
autore	varchar
descrizione	varchar
prezzo	decimal

Data una struttura del genere, potremmo iniziare a pensare anche alla classe model che conterrà le informazioni:

class Book {
    protected $id;
    protected $title;
    protected $isbn;
    protected $author;
    protected $description;
    protected $price;
}

La classe che abbiamo appena visto sarà il nostro modello. In Symfony un modello è chiamato Entity (entità) e i modelli possono essere creati all'interno della cartella Entity nel nostro Bundle. Creiamo quindi un file Book.php all'interno della path src/Acme/DemoBundle/Entity.

Data una struttura del genere, possiamo tornare a parlare di Doctrine e della sua capacità di persistere oggetti nella base di dati. Questo ci consente di mappare una classe PHP su una tabella del database e le proprietà della classe PHP sulle colonne della tabella.

Ciò avviene attraverso l'utilizzo delle annotations oppure dei file di configurazione YAML, XML, etc. Nel nostro esempio useremo le annotazioni.

Riscriviamo la classe appena visto in questa maniera:

namespace Acme\DemoBundle\Entity;
use Doctrine\ORM\Mapping as ORM;
/**
 * @ORM\Entity
 * @ORM\Table(name="book")
 */
class Book {
    /**
     * @ORM\Column(type="integer")
     * @ORM\Id
     * @ORM\GeneratedValue(strategy="AUTO")
     */
    protected $id;
    /**
     * @ORM\Column(type="string", length=100)
     */
    protected $title;
    /**
     * @ORM\Column(type="string", length=30)
     */
    protected $isbn;
    /**
     * @ORM\Column(type="string", length=100)
     */
    protected $author;
    /**
     * @ORM\Column(type="string", length=200)
     */
    protected $description;
    /**
     * @ORM\Column(type="decimal", precision=10, scale=2)
     */
    protected $price;
}

Possiamo notare che prima della definizione della classe e di ogni attributo, abbiamo inserito un commento con cui, attraverso una sintassi compatibile con Doctrine definiamo il nome della tabella (book) e, per ogni attributo il tipo di dato.

Per l'attributo id, inoltre, abbiamo aggiunto altre due righe in cui definiamo che è una chiave primaria e che verrà incrementata automaticamente.

Le proprietà che abbiamo definito nella classe sono tutte protette, dunque non accessibili dall'esterno. Abbiamo quindi bisogno dei vari metodi setter e getter per ognuna di esse. Non abbiamo però bisogno di farlo manualmente, Doctrine ci aiuta con il seguente comando:

php app/console doctrine:generate:entities AcmeDemoBundle:Book

Se riapriamo ora il nostro file, notiamo che sono stati creati diversi metodi, come ad esempio:

/**
 * Set title
 *
 * @param string $title
 * @return Book
 */
public function setTitle($title)
{
    $this->title = $title;
    return $this;
}
/**
 * Get title
 *
 * @return string
 */
public function getTitle()
{
    return $this->title;
}

Ovviamente in caso di esigenza, possiamo modificare manualmente i metodi aggiungendo la nostra logica.

A questo punto, l'unica operazione che manca è creare il database. Anche in questo caso non abbiamo bisogno di effettuare l'operazione manualmente ma è Doctrine che ci viene in aiuto:

php app/console doctrine:schema:update --force

Se tutto è andato a buon fine, avremo un output simile al seguente:

Updating database schema...
Database schema updated successfully! "1" queries were executed

Se accediamo al nostro database, noteremo che una tabella "book" è stata creata ed ha la seguente struttura:

Abbiamo visto come usare Doctrine per creare il database e le tabelle al suo interno senza la necessità di scrivere una sola riga di codice SQL. Nella prossima lezione vedremo come effettuare le operazioni più comuni: creare, eliminare, aggiornare ed interrogare il database.