Eliminazione automatica delle righe correlate in Laravel (Eloquent ORM)

Quando cancello una riga usando questa sintassi:

$user->delete();

C'è un modo per allegare una sorta di callback, in modo che, ad esempio, lo faccia automaticamente:

$this->photo()->delete();

Preferibilmente all'interno della classe del modello.

Credo che questo sia un caso d'uso perfetto per eventi Eloquent ( http://laravel.com/docs/eloquent#model-events ). È possibile utilizzare l'evento "eliminazione" per eseguire la pulizia:

class User extends Eloquent
{
    public function photos()
    {
        return $this->has_many('Photo');
    }

    // this is a recommended way to declare event handlers
    public static function boot() {
        parent::boot();

        static::deleting(function($user) { // before delete() method call this
             $user->photos()->delete();
             // do the rest of the cleanup...
        });
    }
}

Probabilmente dovresti anche inserire tutto all'interno di una transazione, per garantire l'integrità referenziale.

Puoi effettivamente configurarlo nelle tue migrazioni:

$table->foreign('user_id')->references('id')->on('users')->onDelete('cascade');

Fonte: http://laravel.com/docs/5.1/migrations#foreign-key-constraints

È inoltre possibile specificare l'azione desiderata per le proprietà "on delete" e "on update" del vincolo:

$table->foreign('user_id')
      ->references('id')->on('users')
      ->onDelete('cascade');

Nota : questa risposta è stata scritta per Laravel 3 . Quindi potrebbe o meno funzionare bene nella versione più recente di Laravel.

È possibile eliminare tutte le foto correlate prima di eliminare effettivamente l'utente.

<?php

class User extends Eloquent
{

    public function photos()
    {
        return $this->has_many('Photo');
    }

    public function delete()
    {
        // delete all related photos 
        $this->photos()->delete();
        // as suggested by Dirk in comment,
        // it's an uglier alternative, but faster
        // Photo::where("user_id", $this->id)->delete()

        // delete the user
        return parent::delete();
    }
}

Spero che sia d'aiuto.

Relazione nel modello utente:

public function photos()
{
    return $this->hasMany('Photo');
}

Elimina record e relativi:

$user = User::find($id);

// delete related   
$user->photos()->delete();

$user->delete();

Ci sono 3 approcci per risolvere questo:

1. Uso degli eventi eloquenti all'avvio del modello (rif: https://laravel.com/docs/5.7/eloquent#events )

class User extends Eloquent
{
    public static function boot() {
        parent::boot();

        static::deleting(function($user) {
             $user->photos()->delete();
        });
    }
}

2. Utilizzo di Eloquent Event Observers (rif: https://laravel.com/docs/5.7/eloquent#observers )

Nel tuo AppServiceProvider, registra l'osservatore in questo modo:

public function boot()
{
    User::observe(UserObserver::class);
}

Quindi, aggiungi una classe Observer in questo modo:

class UserObserver
{
    public function deleting(User $user)
    {
         $user->photos()->delete();
    }
}

3. Utilizzo dei vincoli di chiave esterna (rif: https://laravel.com/docs/5.7/migrations#foreign-key-constraints )

$table->foreign('user_id')->references('id')->on('users')->onDelete('cascade');

A partire da Laravel 5.2, la documentazione afferma che questi tipi di gestori di eventi devono essere registrati in AppServiceProvider:

<?php
class AppServiceProvider extends ServiceProvider
{
    /**
     * Bootstrap any application services.
     *
     * @return void
     */
    public function boot()
    {
        User::deleting(function ($user) {
            $user->photos()->delete();
        });
    }

Suppongo persino di spostarli in classi separate anziché in chiusure per una migliore struttura dell'applicazione.

È meglio se si ignora il deletemetodo per questo. In questo modo, è possibile incorporare transazioni DB all'interno del deletemetodo stesso. Se usi la modalità evento, dovrai coprire la tua chiamata didelete metodo con una transazione DB ogni volta che la chiami.

Nel tuo Usermodello.

public function delete()
{
    \DB::beginTransaction();

     $this
        ->photo()
        ->delete()
    ;

    $result = parent::delete();

    \DB::commit();

    return $result;
}

Nel mio caso è stato piuttosto semplice perché le tabelle del mio database sono InnoDB con chiavi esterne con Cascade su Elimina.

Quindi, in questo caso se la tabella delle foto contiene un riferimento di chiave esterna per l'utente di tutto ciò che devi fare è eliminare l'hotel e la pulizia verrà effettuata dal database, il database eliminerà tutti i record di foto dai dati base.

Vorrei scorrere la raccolta staccando tutto prima di eliminare l'oggetto stesso.

ecco un esempio:

try {
        $user = user::findOrFail($id);
        if ($user->has('photos')) {
            foreach ($user->photos as $photo) {

                $user->photos()->detach($photo);
            }
        }
        $user->delete();
        return 'User deleted';
    } catch (Exception $e) {
        dd($e);
    }

So che non è automatico ma è molto semplice.

Un altro approccio semplice sarebbe quello di fornire un modello al modello. Come questo:

public function detach(){
       try {

            if ($this->has('photos')) {
                foreach ($this->photos as $photo) {

                    $this->photos()->detach($photo);
                }
            }

        } catch (Exception $e) {
            dd($e);
        }
}

Quindi puoi semplicemente chiamare questo dove ti serve:

$user->detach();
$user->delete();

Oppure puoi farlo se lo desideri, solo un'altra opzione:

try {
    DB::connection()->pdo->beginTransaction();

    $photos = Photo::where('user_id', '=', $user_id)->delete(); // Delete all photos for user
    $user = Geofence::where('id', '=', $user_id)->delete(); // Delete users

    DB::connection()->pdo->commit();

}catch(\Laravel\Database\Exception $e) {
    DB::connection()->pdo->rollBack();
    Log::exception($e);
}

Nota se non si utilizza la connessione db laravel predefinita, è necessario effettuare le seguenti operazioni:

DB::connection('connection_name')->pdo->beginTransaction();
DB::connection('connection_name')->pdo->commit();
DB::connection('connection_name')->pdo->rollBack();

Per elaborare la risposta selezionata, se le relazioni hanno anche relazioni secondarie che devono essere eliminate, è necessario prima recuperare tutti i record delle relazioni secondarie, quindi chiamare il delete() metodo in modo che anche i loro eventi di eliminazione vengano generati correttamente.

Puoi farlo facilmente con messaggi di ordine superiore .

class User extends Eloquent
{
    /**
     * The "booting" method of the model.
     *
     * @return void
     */
    public static function boot() {
        parent::boot();

        static::deleting(function($user) {
             $user->photos()->get()->each->delete();
        });
    }
}

Puoi anche migliorare le prestazioni eseguendo una query solo sulla colonna ID relazioni:

class User extends Eloquent
{
    /**
     * The "booting" method of the model.
     *
     * @return void
     */
    public static function boot() {
        parent::boot();

        static::deleting(function($user) {
             $user->photos()->get(['id'])->each->delete();
        });
    }
}

sì, ma come @supersan ha affermato in alto in un commento, se si elimina () su un QueryBuilder, l'evento modello non verrà generato, perché non stiamo caricando il modello stesso, quindi chiamando delete () su quel modello.

Gli eventi vengono generati solo se utilizziamo la funzione di eliminazione su un'istanza del modello.

Quindi, questo beeing ha detto:

if user->hasMany(post)
and if post->hasMany(tags)

al fine di eliminare i tag post quando si elimina l'utente, dovremmo scorrere $user->postse chiamare$post->delete()

foreach($user->posts as $post) { $post->delete(); } -> questo genererà l'evento di eliminazione su Post

VS

$user->posts()->delete()-> questo non genererà l'evento di eliminazione sul post perché in realtà non cariciamo il modello di post (eseguiamo solo un SQL come: DELETE * from posts where user_id = $user->ide quindi il modello di post non viene nemmeno caricato)

Puoi usare questo metodo come alternativa.

Quello che accadrà è che prendiamo tutte le tabelle associate alla tabella degli utenti ed eliminiamo i dati relativi usando il loop

$tables = DB::select("
    SELECT
        TABLE_NAME,
        COLUMN_NAME,
        CONSTRAINT_NAME,
        REFERENCED_TABLE_NAME,
        REFERENCED_COLUMN_NAME
    FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE
    WHERE REFERENCED_TABLE_NAME = 'users'
");

foreach($tables as $table){
    $table_name =  $table->TABLE_NAME;
    $column_name = $table->COLUMN_NAME;

    DB::delete("delete from $table_name where $column_name = ?", [$id]);
}