Cosa Sono le Relazioni in Eloquent?<\/h2>\n
Quando si lavora con le tabelle di un database relazionale, le relazioni possono essere definite come connessioni tra tabelle. Queste permettono di organizzare e strutturare i dati, migliorando la leggibilit\u00e0 e la gestione dei dati. In pratica esistono tre tipi di relazioni nei database:<\/p>\n
- \n
- uno-a-uno – Un record di una tabella \u00e8 associato a uno, e uno solo, di un’altra tabella. Ad esempio, una persona e un numero di previdenza sociale.<\/li>\n<\/ul>\n
- \n
- \n
- \n
- uno-a-molti – Un record \u00e8 associato a pi\u00f9 record di un’altra tabella. Ad esempio, uno scrittore e il suo blog.<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n
- \n
- molti-a-molti – Pi\u00f9 record di una tabella sono associati a pi\u00f9 record di un’altra tabella. Ad esempio, gli studenti e i corsi a cui sono iscritti.<\/li>\n<\/ul>\n
Con Laravel \u00e8 semplice interagire e gestire le relazioni tra i database utilizzando la sintassi orientata agli oggetti di Eloquent.<\/p>\n
Oltre a queste definizioni, Laravel introduce altre relazioni, ovvero:<\/p>\n
- \n
- Has Many Through<\/li>\n
- Relazioni polimorfiche<\/li>\n
- Polimorfica molti-a-molti<\/li>\n<\/ul>\n
Prendiamo, ad esempio, un negozio il cui inventario contiene una variet\u00e0 di articoli, ognuno dei quali appartiene a una categoria specifica. Dividere il database in pi\u00f9 tabelle ha senso dal punto di vista commerciale. Ma questo comporta dei problemi, in quanto non si vuole interrogare ogni singola tabella.<\/p>\n
In Laravel possiamo facilmente creare una semplice relazione uno-a-molti. Ad esempio, quando dobbiamo interrogare i prodotti, possiamo farlo utilizzando il modello Product.<\/p>\n
![\"Schema](\"https:\/\/kinqsta.com\/wp-content\/uploads\/2023\/05\/pasted-image-0-6.png\")
Schema di database con tre tabelle e una tabella congiunta che rappresenta una relazione polimorfica<\/figcaption><\/figure>\n Relazione Uno-A-Uno<\/h2>\n
\u00c8 la prima relazione di base offerta da Laravel e associa due tabelle in modo tale che una riga della prima tabella sia correlata a una sola riga dell’altra tabella.<\/p>\n
Per vederla in azione, dobbiamo creare due modelli con la loro migrazione:<\/p>\n
php artisan make:model Tenant \nPhp artisan make:model Rent<\/code><\/pre>\nA questo punto abbiamo due modelli: uno \u00e8 il Tenant (“inquilino”) e l’altro \u00e8 il Rent (“affitto”).<\/p>\n
<?php\n\nnamespace<\/span> App<\/span>\\Models;\nuse Illuminate\\Database<\/span>\\Eloquent\\Model<\/span>;\n\nclass Tenant extends Model\n{\n \/**\n * Get the rent of a Tenant\n *\/\n public function rent() \n {\n return $this->hasOne(Rent::class);\n }\n}<\/code><\/pre>\nPoich\u00e9 eloquent determina la relazione della foreign key<\/em> in base al nome del modello parent<\/em> (Tenant in questo caso), il modello Rent presuppone l’esistenza di una foreign key<\/em> tenant_id<\/strong>.<\/p>\n
Possiamo sovrascriverla aggiungendo un argomento al metodo hasOne<\/strong>:<\/p>\n
return $this- >hasOne(Rent::class, \"custom_key\");<\/code><\/pre>\nEloquent presuppone anche che ci sia una corrispondenza tra la chiave esterna definita e la chiave primaria del modello padre (Tenant). Di default, cercher\u00e0 di far corrispondere tenant_id<\/strong> con la chiave id<\/strong> del record Tenant. Possiamo sovrascrivere questo parametro con un terzo parametro nel metodo hasOne<\/strong>, in modo che corrisponda a un’altra chiave:<\/p>\n
return $this->hasOne(Rent::class, \"custom_key\", \"other_key\"); <\/code><\/pre>\nOra che abbiamo definito la relazione uno-a-uno tra i modelli, possiamo usarla in questo modo:<\/p>\n
$rent = Tenant::find(10)->rent;<\/code><\/pre>\nCon questa riga di codice otteniamo il Rent (“affitto”) del Tenant (“inquilino”) con l’id 10, se esiste.<\/p>\n
Relazione Uno-A-Molti<\/h2>\n
Come la relazione precedente, anche questa definir\u00e0 le relazioni tra un modello monoparentale e pi\u00f9 modelli figli. \u00c8 improbabile che il nostro Tenant abbia una sola bolletta dell’affitto perch\u00e9 si tratta di un pagamento ricorrente, quindi avr\u00e0 pi\u00f9 pagamenti.<\/p>\n
In questo caso, la relazione precedente presenta dei difetti che possiamo correggere:<\/p>\n
<?php\n\nnamespace<\/span> App<\/span>\\Models;\nuse Illuminate\\Database<\/span>\\Eloquent\\Model<\/span>;\n\nclass Tenant extends Model\n{\n \/**\n * Get the rents of a Tenant\n *\/\n public function rent() \n {\n return $this->hasMany(Rent::class);\n }\n}<\/code><\/pre>\nPrima di invocare il metodo per ottenere gli affitti, \u00e8 bene sapere che le relazioni servono a costruire le query, quindi possiamo aggiungere altri vincoli (come le date degli affitti, i pagamenti minimi, ecc.) e concatenarli per ottenere il risultato desiderato:<\/p>\n
$rents = Tenant::find(10)->rent()->where('payment', '>', 500)->first();<\/code><\/pre>\nE come per la relazione precedente, possiamo sovrascrivere le chiavi esterne e locali inserendo altri argomenti:<\/p>\n
return $this->hasMany(Rent::class, \"foreign_key\");<\/code><\/pre>\nreturn $this->hasMany(Rent::class, \"foreign_key\", \"local_key\");<\/code><\/pre>\nOra abbiamo tutti gli affitti di un Tenant, ma cosa facciamo se conosciamo l’affitto e vogliamo capire a chi appartiene? Possiamo utilizzare la propriet\u00e0 belongsTo<\/strong>:<\/p>\n
<?php\n\nnamespace<\/span> App<\/span>\\Models;\nuse Illuminate\\Database<\/span>\\Eloquent\\Model<\/span>;\n\nclass Rent extends Model\n{\n \/**\n * Return the tenant for the rent\n *\/\n public function tenant() \n {\n return $this->belongsTo(Tenant::class);\n }\n}<\/code><\/pre>\nE ora possiamo trovare facilmente il Tenant:<\/p>\n
$tenant = Rent::find(1)->tenant;<\/code><\/pre>\nPer il metodo belongsTo<\/strong>, possiamo anche sovrascrivere le chiavi esterne e locali come abbiamo fatto in precedenza.<\/p>\n
Relazione Has-One-Of-Many<\/h2>\n
Dato che il nostro modello di Tenant pu\u00f2 essere associato a molti modelli di Rent, vogliamo recuperare il modello pi\u00f9 recente o pi\u00f9 vecchio delle relazioni.<\/p>\n
Un modo comodo per farlo \u00e8 combinare i metodi hasOne<\/strong> e ofMany<\/strong>:<\/p>\n
public function latestRent() {\n return $this->hasOne(Rent::class)->latestOfMany();\n}\n\npublic function oldestRent() {\n return $this->hasOne(Rent::class)->oldestOfMany();\n}<\/code><\/pre>\nDi default, otteniamo i dati in base alla chiave primaria, che \u00e8 ordinabile, ma possiamo creare i nostri filtri per il metodo ofMany<\/strong>:<\/p>\n
return $this->hasOne(Rent::class)->ofMany('price', 'min');<\/code><\/pre>\nRelazioni HasOneThrough e HasManyThrough<\/h2>\n
COn i metodi -Through<\/strong>, i nostri modelli dovranno passare attraverso un altro modello per stabilire una relazione con il modello desiderato. Ad esempio, possiamo associare l’Affitto al Locatore, ma l’Affitto deve prima passare attraverso l’Tenantper raggi ungere il Locatore.<\/p>\n
Le chiavi delle tabelle necessarie a questo scopo sarebbero le seguenti:<\/p>\n
rent\n id - integer\n name - string\n value - double\n\ntenants\n id - integer\n name - string\n rent_id - integer\n\nlandlord\n id - integer\n name - string\n tenant_id - integer<\/code><\/pre>\nDopo aver visualizzato l’aspetto delle nostre tabelle, possiamo creare i modelli:<\/p>\n
<?php\n\nnamespace<\/span> App<\/span>\\Models;\nuse Illuminate\\Database<\/span>\\Eloquent\\Model<\/span>;\n\nclass Rent extends Model\n{\n \/**\n * Return the rents' landlord\n *\/\n public function rentLandlord() \n {\n return $this->hasOneThrough(Landlord::class, Tenant::class);\n }\n}<\/code><\/pre>\nIl primo argomento del metodo hasOneThrough<\/strong> \u00e8 il modello a cui accedere e il secondo argomento \u00e8 il modello da attraversare.<\/p>\n
E, proprio come prima, \u00e8 possibile sovrascrivere le chiavi esterne e locali. Ora che abbiamo due modelli, ne abbiamo due di ciascuno da sovrascrivere in questo ordine:<\/p>\n
public function rentLandlord() \n{\n return $this->hasOneThrough(\n Landlord::class,\n Tenant::class,\n \"rent_id\", \/\/ Foreign key on the tenant table\n \"tenant_id\", \/\/ Foreign key on the landlord table\n \"id\", \/\/ Local key on the tenant class\n \"id\" \/\/ Local key on the tenant table\n );\n}<\/code><\/pre>\nAllo stesso modo, la relazione “Has Many Through” di Laravel Eloquent \u00e8 utile per accedere ai record di una tabella lontana attraverso una tabella intermedia. Consideriamo un esempio con tre tabelle:<\/p>\n
- \n
- paese<\/li>\n
- utenti<\/li>\n
- giochi<\/li>\n<\/ul>\n
Ogni Paese ha molti utenti e ogni utente ha molti giochi. Vogliamo recuperare tutti i giochi appartenenti a un Paese attraverso la tabella Utenti.<\/p>\n
Bisognerebbe definire le tabelle in questo modo:<\/p>\n
country\n id - integer\n name - string\n\nuser\n id - integer\n country_id - integer\n name - string\n\ngames\n id - integer\n user_id - integer\n title - string<\/code><\/pre>\nOra bisogna definire il modello Eloquent per ogni singola tabella:<\/p>\n
<?php\n\nnamespace<\/span> App<\/span>\\Models;\nuse Illuminate\\Database<\/span>\\Eloquent\\Model<\/span>;\n\nclass Country extends Model\n{\n protected $fillable = ['name'];\n\n public function users()\n {\n return $this->hasMany(User::class);\n }\n\n public function games()\n {\n return $this->hasManyThrough(Games::class, User::class);\n }\n}<\/code><\/pre>\n<?php\n\nnamespace<\/span> App<\/span>\\Models;\nuse Illuminate\\Database<\/span>\\Eloquent\\Model<\/span>;\n\nclass User extends Model\n{\n protected $fillable = [article_id, 'name'];\n\n public function country()\n {\n return $this->belongsTo(Country::class);\n }\n\n public function posts()\n {\n return $this->hasMany(Post::class);\n }\n}<\/code><\/pre>\n<?php\n\nnamespace<\/span> App<\/span>\\Models;\nuse Illuminate\\Database<\/span>\\Eloquent\\Model<\/span>;\n\nclass Game extends Model\n{\n protected $fillable = ['user_id', 'title'];\n\n public function user()\n {\n return $this->belongsTo(User::class);\n }\n}<\/code><\/pre>\nOra possiamo invocare il metodo games()<\/strong> del modello Country per ottenere tutti i giochi perch\u00e9 abbiamo stabilito la relazione “Has Many Through” tra Country e Game attraverso il modello User.<\/p>\n
<?php\n\n$country = Country::find(159);\n \n\/\/ Retrieve all games for the country\n$games = $country->games;<\/code><\/pre>\nRelazione Molti-A-Molti<\/h2>\n
La relazione molti-a-molti \u00e8 pi\u00f9 complicata. Un buon esempio \u00e8 quello di un dipendente che ha pi\u00f9 ruoli. Un ruolo pu\u00f2 anche essere assegnato a pi\u00f9 dipendenti. Questa \u00e8 la base della relazione molti-a-molti.<\/p>\n
Per questo, dobbiamo avere le tabelle employees<\/strong>, roles<\/strong> e role_employees<\/strong>.<\/p>\n
La struttura delle tabelle del nostro database sar\u00e0 la seguente:<\/p>\n
employees\n id - integer\n name - string\n\nroles \n id - integer\n name - string\n\nrole_employees\n user_id - integer\n role_id - integer<\/code><\/pre>\nConoscendo la struttura delle tabelle della relazione, possiamo facilmente definire il nostro Modello Employee<\/strong> in modo che appartenga al modello belongsToMany Role<\/strong>.<\/p>\n
<?php\n\nnamespace<\/span> App<\/span>\\Models;\nuse Illuminate\\Database<\/span>\\Eloquent\\Model<\/span>;\n\nclass Employee extends Model\n{\n public function roles() \n {\n return $this- >belongsToMany(Role::class);\n }\n}<\/code><\/pre>\nUna volta definito questo, possiamo accedere a tutti i ruoli di un dipendente ed anche filtrarli:<\/p>\n
$employee = Employee::find(1);\n$employee->roles->forEach(function($role) { \/\/ });\n\n\/\/ OR \n\n$employee = Employee::find(1)->roles()->orderBy('name')->where('name', 'admin')->get();<\/code><\/pre>\nCome tutti gli altri metodi, possiamo sovrascrivere le chiavi esterne e locali del metodo belongsToMany<\/strong>.<\/p>\n
Per definire la relazione inversa di belongsToMany<\/strong> \u00e8 sufficiente utilizzare lo stesso metodo, ma con il metodo figlio, e il genitore come argomento.<\/p>\n
<?php\n\nnamespace<\/span> App<\/span>\\Models;\nuse Illuminate\\Database<\/span>\\Eloquent\\Model<\/span>;\n\nclass Role extends Model\n{\n public function employees() \n {\n return $this->belongsToMany(Employee::class);\n }\n}<\/code><\/pre>\nUtilizzi della Tabella Intermedia<\/h3>\n
Come abbiamo notato, quando utilizziamo la relazione molti-a-molti, dobbiamo sempre avere una tabella intermedia. In questo caso, utilizziamo la tabella role_employees<\/strong>.<\/p>\n
Di default, la nostra tabella pivot conterr\u00e0 solo gli attributi id. Se vogliamo altri attributi, dobbiamo specificarli in questo modo:<\/p>\n
return $this->belongsToMany(Employee::class)->withPivot(\"active\", \"created_at\");<\/code><\/pre>\nSe vogliamo ridurre la pivot per i timestamp, possiamo farlo cos\u00ec:<\/p>\n
return $this->belongsToMany(Employee::class)->withTimestamps();<\/code><\/pre>\nPossiamo personalizzare il nome ‘pivot’ con qualsiasi cosa che si adatti meglio alla nostra applicazione:<\/p>\n
return $this->belongsToMany(Employee::class)->as('subscription')->withPivot(\"active\", \"created_by\");<\/code><\/pre>\nFiltrare i risultati di una query Eloquent \u00e8 un’operazione indispensabile per tutti gli sviluppatori che vogliono migliorare e ottimizzare le proprie applicazioni Laravel<\/a>.<\/p>\n
Per questo Laravel offre una fantastica funzione pivot che pu\u00f2 essere utilizzata per filtrare i dati che vogliamo raccogliere. Cos\u00ec, invece di utilizzare altre funzioni come le transazioni del database<\/a> per ottenere i nostri dati in frammenti, possiamo filtrarli con metodi come wherePivot, wherePivotIn, wherePivotNotIn, wherePivotBetween, wherePivotNotBetween, wherePivotNull, wherePivotNotNull<\/strong> e possiamo usarli quando definiamo le relazioni tra le tabelle!<\/p>\n
return $this->belongsToMany(Employee::class)->wherePivot('promoted', 1);\nreturn $this->belongsToMany(Employee::class)->wherePivotIn('level', [1, 2]);\nreturn $this->belongsToMany(Employee::class)->wherePivotNotIn('level', [2, 3]);\nreturn $this->belongsToMany(Employee::class)->wherePivotBetween('posted_at', ['2023-01-01 00:00:00', '2023-01-02 00:00:00']);\nreturn $this->belongsToMany(Employee::class)->wherePivotNull('expired_at');\nreturn $this->belongsToMany(Employee::class)->wherePivotNotNull('posted_at');<\/code><\/pre>\nUn’ultima sorprendente caratteristica \u00e8 la possibilit\u00e0 di ordinare i pivot:<\/p>\n
return $this->belongsToMany(Employee::class)\n ->where('promoted', true)\n ->orderByPivot('hired_at', 'desc');<\/code><\/pre>\nRelazioni Polimorfiche<\/h2>\n
La parola Polimorfico (o polimorfo) deriva dal greco e significa “molte forme”. Un modello nella nostra applicazione pu\u00f2 assumere molte forme, ovvero pu\u00f2 avere pi\u00f9 di un’associazione. Immaginiamo di costruire un’applicazione con blog, video, sondaggi, ecc. Un utente pu\u00f2 creare un commento per ognuno di questi. Pertanto, un modello Comment<\/strong> potrebbe appartenere ai modelli Blog<\/strong>, Video<\/strong> e Sondaggi<\/strong>.<\/p>\n
Polimorfica Uno a Uno<\/h2>\n
Questo tipo di relazione \u00e8 simile a una relazione standard uno-a-uno. L’unica differenza \u00e8 che il modello figlio pu\u00f2 appartenere a pi\u00f9 di un tipo di modello con una singola associazione.<\/p>\n
Ad esempio, un modello Tenant<\/strong> e Landlord<\/strong> pu\u00f2 condividere una relazione polimorfa con un modello WaterBill<\/strong>.<\/p>\n
La struttura della tabella pu\u00f2 essere la seguente:<\/p>\n
tenants\n id \u2013 integer\n name \u2013 string\n\nlandlords\n id \u2013 integer\n name \u2013 string\n\nwaterbills\n id \u2013 integer\n amount \u2013 double\n waterbillable_id\n waterbillable_type<\/code><\/pre>\nUtilizziamo waterbillable_id per l’id del landlord<\/strong> o del tenant<\/strong>, mentre waterbillable_type contiene il nome della classe del modello genitore. La colonna type viene utilizzata da Eloquent per capire quale modello genitore restituire.<\/p>\n
La definizione del modello per questa relazione sar\u00e0 la seguente:<\/p>\n
<?php\n\nnamespace<\/span> App<\/span>\\Models;\nuse Illuminate\\Database<\/span>\\Eloquent\\Model<\/span>;\n\nclass WaterBill extends Model\n{\n public function billable()\n {\n return $this->morphTo();\n }\n}\n\nclass Tenant extends Model\n{\n public function waterBill() \n {\n return $this->morphOne(WaterBill::class, 'billable');\n }\n}\n\nclass Landlord extends Model\n{\n public function waterBill() \n {\n return $this->morphOne(WaterBill::class, 'billable');\n }\n}<\/code><\/pre>\nUna volta che tutto questo \u00e8 stato messo a punto, possiamo accedere ai dati di entrambi i modelli Landlord e Tenant:<\/p>\n
<?php\n\n$tenant = Tenant::find(1)->waterBill;\n$landlord = Landlord::find(1)->waterBill;<\/code><\/pre>\nUna Relazione Polimorfica Uno A Molti<\/h2>\n
\u00c8 simile a una normale relazione uno-a-molti; la differenza principale \u00e8 che il modello figlio pu\u00f2 appartenere a pi\u00f9 di un tipo di modello, utilizzando una singola associazione.<\/p>\n
In un’applicazione come Facebook, gli utenti possono commentare post, video, sondaggi, dirette, ecc. Con un’associazione polimorfa uno a molti, possiamo utilizzare un’unica tabella comments<\/strong> per memorizzare i commenti di tutte le categorie. La struttura delle nostre tabelle sarebbe simile a questa:<\/p>\n
posts \n id \u2013 integer\n title \u2013 string\n body \u2013 text\n\nvideos\n id \u2013 integer\n title \u2013 string\n url \u2013 string\n\npolls\n id \u2013 integer\n title \u2013 string\n\ncomments \n id \u2013 integer\n body \u2013 text\n commentable_id \u2013 integer\n commentable_type \u2013 string<\/code><\/pre>\nIl commentable_id \u00e8 l’id del record e il commentable_type \u00e8 il tipo di classe, in modo che eloquent sappia cosa cercare. Per quanto riguarda la struttura del modello, \u00e8 molto simile a quella polimorfica uno-a-molti:<\/p>\n
<?php\n\nnamespace<\/span> App<\/span>\\Models;\nuse Illuminate\\Database<\/span>\\Eloquent\\Model<\/span>;\n\nclass Comment extends Model \n{\n public function commentable()\n {\n return $this->morphTo();\n }\n}\n\nclass Poll extends Model\n{\n public function comments()\n {\n return $this->morphMany(Comment::class, 'commentable');\n }\n}\n\nclass Live extends Model\n{\n public function comments()\n {\n return $this->morphMany(Comments::class, 'commentable');\n }\n}<\/code><\/pre>\nOra, per recuperare i commenti di un Live, possiamo semplicemente richiamare il metodo find con l’id e ora abbiamo accesso alla classe iterabile dei commenti:<\/p>\n
<?php\n\nuse App<\/span>\\Models\\Live;\n\n$live = Live::find(1);\n\nforeach ($live->comments as $comment) { }\n\n\/\/ OR\n\nLive::find(1)->comments()->each(function($comment) { \/\/ });\nLive::find(1)->comments()->map(function($comment) { \/\/ });\nLive::find(1)->comments()->filter(function($comment) { \/\/ });\n\n\/\/ etc.<\/code><\/pre>\nSe abbiamo un commento e vogliamo scoprire a chi appartiene, possiamo accedere al metodo commentable:<\/p>\n
<?php\n\nuse App<\/span>\\Models\\Comment<\/span>;\n\n$comment = Comment::find(10);\n$commentable = $comment->commentable;\n\n\/\/ commentable \u2013 type of Post, Video, Poll, Live<\/code><\/pre>\nPolimorfica Uno A Molti<\/h2>\n
In molte applicazioni che scalano, vogliamo un modo semplice per interagire con i modelli e tra di essi. Potremmo voler conoscere il primo o l’ultimo post di un utente, il che pu\u00f2 essere fatto con una combinazione di metodi morphOne<\/strong> e ofMany<\/strong>:<\/p>\n
<?php\n\npublic function latestPost()\n{\n return $this->morphOne(Post::class, 'postable')->latestOfMany();\n}\n\npublic function oldestPost()\n{\n return $this->morphOne(Post::class, 'postable')->oldestOfMany();\n}<\/code><\/pre>\nI metodi latestOfMany<\/strong> e oldestOfMany<\/strong> recuperano il modello pi\u00f9 recente o pi\u00f9 vecchio in base alla chiave primaria del modello, ovvero alla condizione che sia ordinabile.<\/p>\n
In alcuni casi, non vogliamo ordinare in base all’ID, magari abbiamo cambiato la data di pubblicazione di alcuni post e li vogliamo in quell’ordine, non in base al loro id.<\/p>\n
Per questo \u00e8 possibile passare due parametri al metodo ofMany<\/strong>. Il primo parametro \u00e8 la chiave<\/strong> per cui vogliamo filtrare e il secondo \u00e8 il metodo di ordinamento<\/strong>:<\/p>\n
<?php\n\npublic function latestPublishedPost()\n{\n return $this->morphOne(Post::class, \"postable\")->ofMany(\"published_at\", \"max\");\n}<\/code><\/pre>\nTenendo conto di questo, \u00e8 possibile costruire relazioni pi\u00f9 avanzate! Immaginiamo di avere questo scenario. Ci viene chiesto di generare un elenco di tutti i post attuali nell’ordine in cui sono stati pubblicati. Il problema sorge quando abbiamo due post con lo stesso valore di published_at e quando i post sono programmati per essere pubblicati in futuro.<\/p>\n
Per farlo, possiamo passare l’ordine in cui vogliamo che i filtri siano applicati al metodo ofMany<\/strong>. In questo modo ordiniamo per published_at e, se sono uguali, ordiniamo per id. In secondo luogo, possiamo applicare una funzione di query al metodo ofMany<\/strong> per escludere tutti i post di cui \u00e8 prevista la pubblicazione!<\/p>\n
<?php\n\npublic function currentPosts()\n{\n return $this->hasOne(Post::class)->ofMany([\n 'published_at' => 'max',\n 'id' => 'max',\n ], function ($query) {\n $query->where('published_at', '<', now());\n });\n}<\/code><\/pre>\nPolimorfica Molti A Molti<\/h2>\n
Il metodo polimorfico molti-a-molti \u00e8 leggermente pi\u00f9 complesso di quello normale. Una situazione frequente \u00e8 quella in cui i tag si applicano a pi\u00f9 risorse nella stessa applicazione. Ad esempio, su TikTok abbiamo tag che possono essere applicati a video, corti, storie, ecc.<\/p>\n
Il metodo polimorfico molti-a-molti ci permette di avere un’unica tabella di tag associati ai Video, ai Corti e alle Storie.<\/p>\n
La struttura della tabella \u00e8 semplice:<\/p>\n
videos\n id \u2013 integer\n description \u2013 string\n\nstories \n id \u2013 integer\n description \u2013 string\n\ntaggables \n tag_id \u2013 integer\n taggable_id \u2013 integer\n taggable_type \u2013 string<\/code><\/pre>\nCon le tabelle pronte, possiamo creare il modello e utilizzare il metodo morphToMany<\/strong>. Questo metodo accetta il nome della classe del modello e il “nome della relazione”:<\/p>\n
<?php\n\nnamespace<\/span> App<\/span>\\Models;\nuse Illuminate\\Database<\/span>\\Eloquent\\Model<\/span>;\n\nclass Video extends Model\n{\n public function tags()\n {\n return $this->morphToMany(Tag::class, 'taggable');\n }\n}<\/code><\/pre>\nCon questo metodo possiamo facilmente definire la relazione inversa. Sappiamo che per ogni modello figlio vogliamo invocare il metodo morphedByMany<\/strong>:<\/p>\n
<?php\n\nnamespace<\/span> App<\/span>\\Models;\nuse Illuminate\\Database<\/span>\\Eloquent\\Model<\/span>;\n\nclass Tag extends Model\n{\n public function stories()\n {\n return $this->morphedByMany(Story::class, 'taggable');\n }\n\n public function videos()\n {\n return $this->morphedByMany(Video::class, 'taggable');\n } \n}<\/code><\/pre>\nE ora, quando otteniamo un Tag, possiamo recuperare tutti i video e le storie correlate a quel tag!<\/p>\n
<?php\nuse App<\/span>\\Model<\/span>\\Tag<\/span>;\n\n$tag = Tag::find(10);\n$posts = $tag->stories;\n$videos = $tag->stories;<\/code><\/pre>\nOttimizzare la Velocit\u00e0 di Eloquent<\/h2>\n
Quando si lavora con l’ORM Eloquent di Laravel, \u00e8 importante capire come ottimizzare le query sul database e ridurre al minimo il tempo e la memoria necessari per recuperare i dati. Uno dei modi per farlo \u00e8 implementare la cache<\/a> nell’applicazione.<\/p>\n
Laravel offre un sistema di caching flessibile che supporta diversi backend, come Redis<\/a>, Memcached<\/a> e la cache basata su file<\/a>. Mettendo in cache i risultati delle query di Eloquent, \u00e8 possibile ridurre il numero di interrogazioni al database, il che permette di rendere un’applicazione pi\u00f9 veloce e ne aumenta il valore.<\/p>\n
Inoltre, si pu\u00f2 utilizzare il query builder<\/a> di Laravel per creare altre query complesse, ottimizzando ancora di pi\u00f9 le prestazioni dell’applicazione.<\/p>\n
Riepilogo<\/h2>\n
In conclusione, le relazioni Eloquent di Laravel permettono agli sviluppatori di lavorare facilmente con dati correlati. Dalle relazioni uno-a-uno a quelle molti-a-molti, Eloquent fornisce una sintassi semplice e intuitiva per definire e interrogare queste relazioni.<\/p>\n
La padronanza delle relazioni di Eloquent pu\u00f2 migliorare notevolmente il flusso di lavoro di uno sviluppatore e rendere il codice pi\u00f9 efficiente e leggibile. Se volete saperne di pi\u00f9 su Laravel, Kinsta offre diverse risorse, tra cui un tutorial<\/a> per iniziare a lavorare con Laravel e un articolo sugli stipendi degli sviluppatori Laravel<\/a>.<\/p>\n
- molti-a-molti – Pi\u00f9 record di una tabella sono associati a pi\u00f9 record di un’altra tabella. Ad esempio, gli studenti e i corsi a cui sono iscritti.<\/li>\n<\/ul>\n
- uno-a-molti – Un record \u00e8 associato a pi\u00f9 record di un’altra tabella. Ad esempio, uno scrittore e il suo blog.<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n
- \n