Ricerca…
Interrogare sulle relazioni
Eloquent ti consente anche di eseguire query su relazioni definite, come mostrato di seguito:
User::whereHas('articles', function (Builder $query) {
$query->where('published', '!=', true);
})->get();
Ciò richiede che il nome del tuo metodo di relazione sia articles in questo caso. L'argomento passato alla chiusura è il Query Builder per il modello correlato, quindi puoi utilizzare qualsiasi query qui che puoi altrove.
Carico
Supponiamo che il modello utente abbia una relazione con il modello di articolo e che tu voglia caricare gli articoli correlati. Ciò significa che gli articoli dell'utente verranno caricati durante il recupero dell'utente.
articles è il nome della relazione (metodo) nel modello Utente.
User::with('articles')->get();
se hai più relazioni. per esempio articoli e post.
User::with('articles','posts')->get();
e per selezionare le relazioni annidate
User::with('posts.comments')->get();
Chiama più di una relazione annidata
User::with('posts.comments.likes')->get()
Inserimento di modelli correlati
Supponiamo che tu abbia un modello Post con una relazione hasMany con Comment . Puoi inserire un oggetto Comment relativo a un post procedendo come segue:
$post = Post::find(1);
$commentToAdd = new Comment(['message' => 'This is a comment.']);
$post->comments()->save($commentToAdd);
Puoi salvare più modelli contemporaneamente usando la funzione saveMany :
$post = Post::find(1);
$post->comments()->saveMany([
new Comment(['message' => 'This a new comment']),
new Comment(['message' => 'Me too!']),
new Comment(['message' => 'Eloquent is awesome!'])
]);
In alternativa, esiste anche un metodo create che accetta un array PHP semplice invece di un'istanza di modello Eloquent.
$post = Post::find(1);
$post->comments()->create([
'message' => 'This is a new comment message'
]);
introduzione
Le relazioni eloquenti sono definite come funzioni nelle classi del modello Eloquent. Poiché, come gli stessi modelli Eloquent, le relazioni fungono anche da potenti costruttori di query, definendo le relazioni come funzioni che forniscono potenti funzionalità di concatenamento e interrogazione dei metodi. Ad esempio, possiamo aggiungere ulteriori vincoli alla relazione di questo post:
$user->posts()->where('active', 1)->get();
Passa all'argomento principale
Tipi di relazione
Uno a molti
Diciamo che ogni post può avere uno o più commenti e ogni commento appartiene a un solo post.
quindi la tabella dei commenti avrà post_id . In questo caso le relazioni saranno le seguenti.
Post Model
public function comments()
{
return $this->belongsTo(Post::class);
}
Se la chiave esterna è diversa da post_id , ad esempio la chiave esterna è example_post_id .
public function comments()
{
return $this->belongsTo(Post::class, 'example_post_id');
}
e inoltre, se la chiave locale è diversa da id , ad esempio la chiave locale è other_id
public function comments()
{
return $this->belongsTo(Post::class, 'example_post_id', 'other_id');
}
Commenta il modello
definendo l'inverso di uno a molti
public function post()
{
return $this->hasMany(Comment::class);
}
Uno a uno
Come associare tra due modelli (esempio: modello User e Phone )
App\User
<?php
namespace App;
use Illuminate\Database\Eloquent\Model;
class User extends Model
{
/**
* Get the phone record associated with the user.
*/
public function phone()
{
return $this->hasOne('Phone::class', 'foreign_key', 'local_key');
}
}
App\Phone
<?php
namespace App;
use Illuminate\Database\Eloquent\Model;
class Phone extends Model
{
/**
* Get the user that owns the phone.
*/
public function user()
{
return $this->belongsTo('User::class', 'foreign_key', 'local_key');
}
}
foreign_key : Per default eloquenti assumerà questo valore da other_model_name_id (in questo caso user_id e phone_id ), cambiarlo se non è il caso.
local_key : per impostazione predefinita, Eloquent assume che questo valore sia id (chiave primaria del modello corrente), modificarlo se non è il caso.
Se il nome del database è archiviato secondo lo standard laravel, non è necessario fornire la chiave esterna e la chiave locale nella dichiarazione della relazione
Spiegazione
Molti a molti
Diciamo che ci sono ruoli e permessi. Ogni ruolo può appartenere a molte autorizzazioni e ogni autorizzazione può appartenere a molti ruoli. quindi ci saranno 3 tavoli. due modelli e un tavolo pivot. roles , users e tabella permission_role .
Modello di ruolo
public function permissions()
{
return $this->belongsToMany(Permission::class);
}
Modello di autorizzazione
public function roles()
{
return $this->belongsToMany(Roles::class);
}
Nota 1
considerare di seguire mentre si utilizza un nome di tabella diverso per la tabella pivot.
Supponiamo che si desideri utilizzare role_permission anziché permission_role , poiché eloquent utilizza l'ordine alfabetico per la costruzione dei nomi delle chiavi pivot. sarà necessario passare il nome della tabella pivot come secondo parametro come segue.
Modello di ruolo
public function permissions()
{
return $this->belongsToMany(Permission::class, 'role_permission');
}
Modello di autorizzazione
public function roles()
{
return $this->belongsToMany(Roles::class, 'role_permission');
}
Nota 2
considerare di seguire durante l'utilizzo di nomi di chiavi diversi nella tabella pivot.
Eloquent presuppone che se non vengono passati tasti come terzo e quarto parametro, saranno i nomi di tabella singolari con _id . quindi suppone che il pivot avrà i campi role_id e permission_id . Se si devono usare chiavi diverse da queste, dovrebbe essere passato come terzo e quarto parametro.
Diciamo se other_role_id essere usato other_role_id invece di role_id e other_permission_id invece di permission_id . Quindi sarebbe come segue.
Modello di ruolo
public function permissions()
{
return $this->belongsToMany(Permission::class, 'role_permission', 'other_role_id', 'other_permission_id');
}
Modello di autorizzazione
public function roles()
{
return $this->belongsToMany(Roles::class, 'role_permission', 'other_permission_id', 'other_role_id');
}
polimorfo
Le relazioni polimorfiche consentono a un modello di appartenere a più di un altro modello su una singola associazione. Un buon esempio potrebbero essere le immagini, sia un utente che un prodotto possono avere un'immagine. La struttura della tabella potrebbe avere il seguente aspetto:
user
id - integer
name - string
email - string
product
id - integer
title - string
SKU - string
image
id - integer
url - string
imageable_id - integer
imageable_type - string
Le colonne importanti da guardare sono nella tabella delle immagini. La colonna imageable_id conterrà il valore ID dell'utente o del prodotto, mentre la colonna imageable_type conterrà il nome classe del modello proprietario. Nei tuoi modelli, hai impostato le relazioni come segue:
<?php
namespace App;
use Illuminate\Database\Eloquent\Model;
class Image extends Model
{
/**
* Get all of the owning imageable models.
*/
public function imageable()
{
return $this->morphTo();
}
}
class User extends Model
{
/**
* Get all of the user's images.
*/
public function images()
{
return $this->morphMany('Image::class', 'imageable');
}
}
class Product extends Model
{
/**
* Get all of the product's images.
*/
public function images()
{
return $this->morphMany('Image::class', 'imageable');
}
}
Puoi anche recuperare il proprietario di una relazione polimorfica dal modello polimorfico accedendo al nome del metodo che esegue la chiamata a morphTo . Nel nostro caso, questo è il metodo imageable sul modello Image. Quindi, accederemo a tale metodo come una proprietà dinamica
$image = App\Image::find(1);
$imageable = $image->imageable;
Questo imageable restituirà un utente o un prodotto.
Molti a molti
Diciamo che ci sono ruoli e permessi. Ogni ruolo può appartenere a molte autorizzazioni e ogni autorizzazione può appartenere a molti ruoli. quindi ci saranno 3 tavoli. due modelli e un tavolo pivot. roles , users e tabella permission_role .
Modello di ruolo
public function permissions()
{
return $this->belongsToMany(Permission::class);
}
Modello di autorizzazione
public function roles()
{
return $this->belongsToMany(Roles::class);
}
Nota 1
considerare di seguire mentre si utilizza un nome di tabella diverso per la tabella pivot.
Supponiamo che si desideri utilizzare role_permission anziché permission_role , poiché eloquent utilizza l'ordine alfabetico per la costruzione dei nomi delle chiavi pivot. sarà necessario passare il nome della tabella pivot come secondo parametro come segue.
Modello di ruolo
public function permissions()
{
return $this->belongsToMany(Permission::class, 'role_permission');
}
Modello di autorizzazione
public function roles()
{
return $this->belongsToMany(Roles::class, 'role_permission');
}
Nota 2
considerare di seguire durante l'utilizzo di nomi di chiavi diversi nella tabella pivot.
Eloquent presuppone che se non vengono passati tasti come terzo e quarto parametro, saranno i nomi di tabella singolari con _id . quindi suppone che il pivot avrà i campi role_id e permission_id . Se si devono usare chiavi diverse da queste, dovrebbe essere passato come terzo e quarto parametro.
Diciamo se other_role_id essere usato other_role_id invece di role_id e other_permission_id invece di permission_id . Quindi sarebbe come segue.
Modello di ruolo
public function permissions()
{
return $this->belongsToMany(Permission::class, 'role_permission', 'other_role_id', 'other_permission_id');
}
Modello di autorizzazione
public function roles()
{
return $this->belongsToMany(Roles::class, 'role_permission', 'other_permission_id', 'other_role_id');
}
Accesso alla tabella intermedia utilizzando withPivot ()
Supponiamo di avere una terza colonna ' permission_assigned_date ' nella tabella pivot. Per impostazione predefinita, solo le chiavi del modello saranno presenti sull'oggetto pivot. Ora per ottenere questa colonna nel risultato della query è necessario aggiungere il nome con la funzione Pivot ().
public function permissions()
{
return $this->belongsToMany(Permission::class, 'role_permission', 'other_role_id', 'other_permission_id')->withPivot('permission_assigned_date');
}
Attaccare / staccare
Eloquent fornisce anche alcuni metodi di supporto aggiuntivi per rendere più conveniente il lavoro con i modelli correlati. Ad esempio, immaginiamo che un utente possa avere molti ruoli e che un ruolo possa avere molte autorizzazioni. Per assegnare un ruolo a un'autorizzazione inserendo un record nella tabella intermedia che unisce i modelli, utilizzare il metodo attach:
$role= App\Role::find(1);
$role->permissions()->attach($permissionId);
Quando si collega una relazione a un modello, è possibile anche passare una serie di dati aggiuntivi da inserire nella tabella intermedia:
$rol->roles()->attach($permissionId, ['permission_assigned_date' => $date]);
Allo stesso modo, per rimuovere un'autorizzazione specifica contro un ruolo, utilizzare la funzione di scollegamento
$role= App\Role::find(1);
//will remove permission 1,2,3 against role 1
$role->permissions()->detach([1, 2, 3]);
Sincronizzazione delle associazioni
Puoi anche utilizzare il metodo di sincronizzazione per costruire associazioni molti a molti. Il metodo di sincronizzazione accetta un array di ID da inserire nella tabella intermedia. Tutti gli ID che non si trovano nell'array specificato verranno rimossi dalla tabella intermedia. Quindi, una volta completata questa operazione, nella tabella intermedia saranno presenti solo gli ID presenti nell'array specificato:
//will keep permission id's 1,2,3 against Role id 1
$role= App\Role::find(1)
$role->permissions()->sync([1, 2, 3]);
