Laravel
Eloquente

introduzione

Osservazioni

class User extends Model
{ 
    protected $table = 'customers';
}

introduzione

Eloquent è l' ORM integrato nel framework di Laravel. Consente di interagire con le tabelle del database in modo orientato agli oggetti, utilizzando il pattern ActiveRecord .

Una singola classe di modello di solito si associa ad una singola tabella di database, e possono anche essere definite relazioni di tipi diversi ( uno-a-uno , uno-a-molti , molti-a-molti , polimorfico) tra diverse classi di modelli.

Section Making a Model descrive la creazione e la definizione di classi di modelli.

Prima di poter iniziare a utilizzare i modelli Eloquent, assicurati che almeno una connessione al database sia stata configurata nel tuo file di configurazione config/database.php .

Per comprendere l'utilizzo di un generatore di query eloquente durante lo sviluppo, è possibile utilizzare php artisan ide-helper:generate command. Ecco il link .

Navigazione sottoargomento

Relazione eloquente

Persistenza

Oltre a leggere i dati con Eloquent, puoi anche usarlo per inserire o aggiornare i dati con il metodo save() . Se hai creato una nuova istanza di modello, verrà inserito il record; in caso contrario, se si è recuperato un modello dal database e si impostano nuovi valori, questo verrà aggiornato .

In questo esempio creiamo un nuovo record User :

$user = new User();
$user->first_name = 'John';
$user->last_name = 'Doe';
$user->email = '[email protected]';
$user->password = bcrypt('my_password');
$user->save();

È inoltre possibile utilizzare il metodo create per popolare i campi utilizzando una matrice di dati:

User::create([
    'first_name'=> 'John',
    'last_name' => 'Doe',
    'email'     => '[email protected]', 
    'password'  => bcrypt('changeme'),
]);

Quando si utilizza il metodo di creazione, gli attributi devono essere dichiarati nell'array fillable all'interno del modello:

class User extends Model
{
    protected $fillable = [
         'first_name',
         'last_name',
         'email',
         'password',
    ];
}

In alternativa, se si desidera rendere tutti gli attributi assegnabili in massa, è possibile definire la proprietà $ guarded come una matrice vuota:

class User extends Model
{
    /**
    * The attributes that aren't mass assignable.
    *
    * @var array
    */
    protected $guarded = [];
}

Ma puoi anche creare un record senza nemmeno modificare l'attributo fillable nel tuo modello usando il metodo forceCreate piuttosto che create metodo

User::forceCreate([
    'first_name'=> 'John',
    'last_name' => 'Doe',
    'email'     => '[email protected]', 
    'password'  => bcrypt('changeme'),
]);

Di seguito è riportato un esempio di aggiornamento di un modello User esistente caricandolo dapprima (utilizzando find ), modificandolo e quindi salvandolo:

$user = User::find(1);
$user->password = bcrypt('my_new_password');
$user->save();

Per ottenere lo stesso risultato con una singola chiamata di funzione, è possibile utilizzare il metodo di update :

$user->update([
    'password' => bcrypt('my_new_password'),
]);

I metodi di create e update rendono molto più semplice l'utilizzo di grandi insiemi di dati rispetto alla necessità di impostare singolarmente ciascuna coppia chiave / valore, come mostrato nei seguenti esempi:

Notare l'uso only e except quando si raccolgono i dati della richiesta. È importante specificare le chiavi esatte che si desidera consentire / non consentire l'aggiornamento, altrimenti è possibile che un utente malintenzionato invii ulteriori campi con la loro richiesta e causi aggiornamenti indesiderati.

// Updating a user from specific request data
$data = Request::only(['first_name', 'email']);
$user->find(1);
$user->update($data);

// Create a user from specific request data
$data = Request::except(['_token', 'profile_picture', 'profile_name']);
$user->create($data);

Eliminazione

È possibile cancellare i dati dopo averli scritti nel database. È possibile eliminare un'istanza del modello se ne è stata recuperata una o specificare le condizioni per i record da eliminare.

Per eliminare un'istanza del modello, recuperarla e chiamare il metodo delete() :

$user = User::find(1);
$user->delete();

In alternativa, è possibile specificare una chiave primaria (o un array di chiavi primarie) dei record che si desidera eliminare tramite il metodo destroy() :

User::destroy(1);
User::destroy([1, 2, 3]);

Puoi anche combinare le query con l'eliminazione:

User::where('age', '<', 21)->delete();

Questo cancellerà tutti gli utenti che corrispondono alla condizione.

Nota: Quando si esegue una massa DELETE tramite Eloquente, la deleting e deleted gli eventi del modello non saranno licenziati per i modelli eliminati. Questo perché i modelli non vengono mai effettivamente recuperati quando si esegue l'istruzione delete.

Cancellazione morbida

Alcune volte non si desidera eliminare definitivamente un record, ma tenerlo in giro per scopi di controllo o di segnalazione. Per questo, Eloquent fornisce funzionalità di cancellazione soft .

Per aggiungere funzionalità soft elimina al modello, è necessario importare il tratto di SoftDeletes e aggiungerlo alla classe del modello Eloquent:

namespace Illuminate\Database\Eloquent\Model;
namespace Illuminate\Database\Eloquent\SoftDeletes;

class User extends Model
{
     use SoftDeletes;
}

Quando si elimina un modello, verrà impostato un timestamp su una colonna timestamp deleted_at nella tabella per il modello, quindi assicurati di creare prima la colonna deleted_at nella tabella. Oppure durante la migrazione dovresti chiamare il metodo softDeletes() sul tuo progetto per aggiungere il timestamp deleted_at . Esempio:

Schema::table('users', function ($table) {
    $table->softDeletes();
});

Qualsiasi query ometterà i record eliminati temporaneamente. Puoi forzarli a mostrarli, se lo desideri, usando l'ambito withTrashed() :

User::withTrashed()->get();

Se si desidera consentire agli utenti di ripristinare un record dopo l'eliminazione graduale (ad esempio in un'area del tipo di cestino), è possibile utilizzare il metodo restore() :

$user = User::find(1);
$user->delete();
$user->restore();

Per eliminare forzatamente un record usa il metodo forceDelete() che rimuoverà veramente il record dal database:

$user = User::find(1);
$user->forceDelete();

Cambia chiave primaria e data e ora

Per impostazione predefinita, i modelli Eloquent prevedono che la chiave primaria sia denominata 'id' . Se non è il tuo caso, puoi cambiare il nome della tua chiave primaria specificando la proprietà $primaryKey .

class Citizen extends Model
{
    protected $primaryKey = 'socialSecurityNo';

    // ...
}

Ora, qualsiasi metodo Eloquent che usa la tua chiave primaria (per esempio find o find findOrFail ) userà questo nuovo nome.

Inoltre, Eloquent si aspetta che la chiave primaria sia un intero autoincrementante. Se la chiave primaria non è un numero intero auto-incrementante (ad es. Un GUID), è necessario comunicare a Eloquent aggiornando la proprietà $incrementing su false :

class Citizen extends Model
{
    protected $primaryKey = 'socialSecurityNo';

    public $incrementing = false;

    // ...
}

Per impostazione predefinita, Eloquente aspetta created_at e updated_at colonne di esistere sulle vostre tavole. Se non desideri che queste colonne siano automaticamente gestite da Eloquent, imposta la proprietà $timestamps sul tuo modello su false:

class Citizen extends Model
{
    public $timestamps = false;

    // ...
}

Se è necessario personalizzare i nomi delle colonne utilizzate per memorizzare i timestamp, è possibile impostare le CREATED_AT e UPDATED_AT nel modello:

class Citizen extends Model
{
    const CREATED_AT = 'date_of_creation';
    const UPDATED_AT = 'date_of_last_update';

    // ...
}

Lancia 404 se l'entità non viene trovata

Se si desidera lanciare automaticamente un'eccezione durante la ricerca di un record che non si trova su una modale, è possibile utilizzare entrambi

Vehicle::findOrFail(1);

o

Vehicle::where('make', 'ford')->firstOrFail();

Se non viene trovato un record con la chiave primaria di 1 , viene generata una ModelNotFoundException . Che è essenzialmente lo stesso della scrittura ( vedi sorgente ):

$vehicle = Vehicle::find($id);

if (!$vehicle) {
    abort(404);
}

Modelli di clonazione

Potresti trovarti a dover clonare una riga, magari cambiare alcuni attributi ma hai bisogno di un modo efficace per mantenere le cose ASCIUTTE. Laravel fornisce una sorta di metodo "nascosto" che ti consente di fare questa funzionalità. Sebbene sia completamente non documentato, devi cercarlo attraverso l'API per trovarlo.

Usando $model->replicate() puoi facilmente clonare un record

$robot = Robot::find(1);
$cloneRobot = $robot->replicate();
// You can add custom attributes here, for example he may want to evolve with an extra arm!
$cloneRobot->arms += 1;
$cloneRobot->save();

Quanto sopra troverà un robot con ID 1, quindi lo clonerà.