Laravel è un framework PHP di tipo MVC (Model, View, Controller) molto usato da molti “web artisans” e programmatori web. Questo framework mette a disposizione una miriade di strumenti che aiutano il programmatore a sviluppare un’app abbastanza velocemente. Uno di questi strumenti è l’ORM che permette la gestione e mappatura tra le classi in PHP e i DB relazionali.

Che cos’é un ORM?

Un’ORM è un’interfaccia che fornisce, tramite programmazione a oggetti, tutti i servizi inerenti alla persistenza dei dati astraendo le caratteristiche del DBMS usato: questo significa che possiamo gestire le entità e le relazioni di un DBMS tramite PHP in modo agevole scrivendo poche righe di codice, avendo una portabilità superiore e scrivendo un’applicazione più stratificata per quanto riguarda la persistenza dati a vantaggio della modularità del sistema.

In questo articolo vedremo l’ORM usato in Laravel chiamato Eloquent. Esso mette a disposizione ai programmatori alcune funzioni che possiamo utilizzare per astrarre relazioni ed entità del nostro DB.

QUERIES

Possiamo selezionare i dati di un’entità User nelle varie queries, ad esempio, definendo prima un modello User in Laravel:

class User extends Eloquent {
    protected $table = 'users';
    protected $primaryKey = 'iduser';
}

Definito il modello User, possiamo usarlo tramite le funzioni dell’ORM in questo modo:

$users = User::all();
//equivale in SQL a
SELECT * FROM users;

$user = User::find(1);
//equivale in SQL a
SELECT * FROM users WHERE iduser = 1;

$users = User::where('votes', '>', 100)->get();
//equivale in SQL a
SELECT * FROM users WHERE votes > 100;

$user = User::create(array('name' => 'John'));
//equivale in SQL a
INSERT INTO users (name) VALUES('John');

$affectedRows = User::where('votes', '>', 100)->delete();
//equivale in SQL a
DELETE FROM users WHERE votes > 100;

RELAZIONI

Abbiamo visto delle queries in Laravel tramite le funzioni che mette a disposizione Eloquent: esse sono queries semplici ma cosa succede se dobbiamo fare dei join tra le relazioni di due o più tabelle? Eloquent ci permette di fare anche questo creando innanzitutto gli altri Models delle entità che verranno coinvolte, in questo caso ad esempio Posts (post associati all’utente, relazione uno a molti) e Phone (numero di telefono associato all’utente, relazione uno a uno):

Posts Model

class Post extends Eloquent {
    protected $table = 'posts';
    protected $primaryKey = 'idpost';
}

Phone Model

class Phone extends Eloquent {
    protected $table = 'phones';
    protected $primaryKey = 'idphone';
}

Relazione uno a uno

class User extends Model
{
    /**
     * Ottengo il telefono  associato all'utente nella tabella phones del DB
     */
    public function get_phone()
    {
        return $this->hasOne('App\Phone');//richiama il Model chiamato Phone
    }
}

//sarà usata così
$phone = App\User::find(1)->get_phone;

Relazione uno a molti

class User extends Model
{
    /**
     * Ottengo i posts associati all'utente nella tabella posts del DB
     */
    public function posts()
    {
        return $this->hasMany('App\Post');//richiama il Model chiamato Post
    }
}

//sarà usata così, ottengo i post associati all'utente con iduser = 1
$posts = App\User::find(1)->posts;

Relazione uno a molti inversa

class User extends Model
{
    /**
     * Ottengo l'utente associato al post nella tabella users del DB
     */
    public function get_user()
    {
        return $this->belongsTo('App\User');//richiama il Model chiamato User
    }
}
//sarà usata così, ottengo l'utente che ha scritto il post con idpost = 1
$user = App\Post::find(1)->get_user;

Come abbiamo visto tramite ORM Eloquent riusciamo a scrivere e a ottenere i dati in modo preciso, come se facessimo delle normali queries ma risparmiando righe di codice SQL ed ottenendo un’ottima manutenibilità. Questo avviene tramite la classe Model di Eloquent che mappa la struttura del DB in uso.

E voi avete mai usato Eloquent per qualche vostro progetto? Fatemelo sapere nei commenti e ditemi come vi siete trovati.