Doctrine e Symfony2: lettura, aggiornamento e cancellazione dei dati

Leggere un contenuto dal database

Una volta che abbiamo inserito il nostro oggetto nel database, possiamo recuperarlo e mostrarne le informazioni in una pagina ad esso dedicata. Per fare questo creiamo il metodo view con il seguente listato:

public function viewAction( $id )
{
    $book = $this->getDoctrine()
                 ->getRepository('AcmeDemoBundle:Book')
                 ->find($id);
    if (!$book) {
        throw $this->createNotFoundException(
            'Nessun libro presente nel database con l\'id '.$id
        );
    }
    return $this->render(
        'AcmeDemoBundle:Book:view.html.twig',
        array(
            'book' => $book
        )
    );
}

Anche in questo caso l'operazione è molto semplice. Per prima cosa richiamiamo il repository da Doctrine e poi invochiamo su di esso il metodo find con l'id del libro richiesto.

Il repository è una classe che ci aiuta ad effettuare operazioni su un determinato oggetto. In questo caso ci aiuta a recuperare le informazioni del libro attraverso il metodo find.

In realtà avremmo potuto recuperare il libro anche attraverso gli altri suoi campi, questo grazie i metodi magici che vengono gestiti automaticamente. Supponiamo quindi di voler recuperare il libro dal suo titolo, in tal caso avremmo potuto eseguire la seguente istruzione:

$book = $this->getDoctrine()
              ->getRepository('AcmeDemoBundle:Book')
              ->findOneByTitle("Il Signore degli Anelli");

Il metodo findOneByTitle non lo abbiamo creato noi ma attraverso i metodi magici di PHP, Doctrine automaticamente andrà a cercare all'interno del campo title.

Una volta recuperato il libro, andiamo quindi a visualizzare i dati all'interno del file view.html.twig:

<h1>Informazioni sul libro richiesto</h1>
<p>Di seguito i dati del libro richiesto:</p>
<table>
    <tbody>
        <tr>
            <th>Titolo</th>
            <td>{{ book.title }}</td>
        </tr>
        <tr>
            <th>Autore</th>
            <td>{{ book.author }}</td>
        </tr>
        <tr>
            <th>ISBN</th>
            <td>{{ book.isbn }}</td>
        </tr>
        <tr>
            <th>Descrizione</th>
            <td>{{ book.description }}</td>
        </tr>
        <tr>
            <th>Prezzo</th>
            <td>{{ book.price }}</td>
        </tr>
    </tbody>
</table>

Recuperare una lista di oggetti dal database

Supponiamo di visualizzare la lista dei libri contenuti all'interno del database, se avessimo effettuato la query manualmente avremmo lanciato un'istruzione del tipo SELECT * FROM book. Vediamo con Doctrine come eseguire l'operazione:

public function indexAction()
{
    $books = $this->getDoctrine()
                 ->getRepository('AcmeDemoBundle:Book')
                 ->findAll();
    return $this->render(
        'AcmeDemoBundle:Book:index.html.twig',
        array(
            'books' => $books
        )
    );
}

Abbiamo utilizzato il metodo findAll() che si occupa di recuperare tutte le entry contenute nel database.

Se volessimo filtrare i dati in base ad un parametro potremmo, invece, utilizzare il metodo findBy:

$books = $repository->findBy(
    array('author' => 'John Ronald Reuel Tolkien'),
    array('price' => 'ASC')
);

Con il codice appena visto recuperiamo tutti i libri di Tolkien ordinandoli per prezzo ascendente.

A questo punto possiamo ciclare i libri presenti nel database e mostrarli nella pagina index.html.twig:

<h1>I miei libri</h1>
{% if books is not empty %}
<table>
    <thead>
    <tr>
        <th>Titolo</th>
        <th>Autore</th>
        <th>ISBN</th>
        <th>Descrizione</th>
        <th>Prezzo</th>
    </tr>
    </thead>
    <tbody>
    {% for book in books %}
    <tr>
        <td>{{ book.title }}</td>
        <td>{{ book.author }}</td>
        <td>{{ book.isbn }}</td>
        <td>{{ book.description }}</td>
        <td>{{ book.price }}</td>
    </tr>
    {% endfor %}
    </tbody>
</table>
{% else %}
    <p>Nessun libro trovato</p>
{% endif %}

Aggiornare un elemento del database

L'update è un insieme di operazioni e metodi già visti in precedenza:

public function updateAction()
{
    $id = 1;
    $em = $this->getDoctrine()->getManager();
    $book = $em->getRepository('AcmeDemoBundle:Book')->find($id);
    if (!$book) {
        throw $this->createNotFoundException(
            'Nessun libro presente nel database con l\'id '.$id
        );
    }
    $book->setPrice('25.00');
    $em->flush();
    return $this->render(
        'AcmeDemoBundle:Book:view.html.twig',
        array(
            'book' => $book
        )
    );
}

Per aggiornare un elemento nel database è sufficiente recuperarlo, utilizzare i metodi setter su di esso e richiamare il flush() al termine delle operazioni.

Eliminare un elemento dal database

Anche l'eliminazione degli elementi risulta essere un'operazione molto veloce:

public function deleteAction()
{
    $id = 1;
    $em = $this->getDoctrine()->getManager();
    $book = $em->getRepository('AcmeDemoBundle:Book')->find($id);
    if (!$book) {
        throw $this->createNotFoundException(
            'Nessun libro presente nel database con l\'id '.$id
        );
    }
    $em->remove($book);
    $em->flush();
    return $this->redirect($this->generateUrl('_book'));
}

In questo caso prima del metodo flush() richiamiamo il metodo remove().

Nelle ultime due lezioni ci siamo occupati di accedere al database, creare tabelle ed eseguire query senza aver scritto una sola riga di codice SQL. Tutto questo grazie a Symfony ma soprattutto a Doctrine. Le potenzialità del framework e del'ORM, però, non finiscono qui e scopriremo nella prossima lezione come creare relazioni tra tabelle e query più complesse attraverso il binomio Symfony/Doctrine.