ChatGPT解决这个技术问题 Extra ChatGPT

Automatically deleting related rows in Laravel (Eloquent ORM)

When I delete a row using this syntax:

$user->delete();

Is there a way to attach a callback of sorts, so that it would e.g. do this automatically:

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

Preferably inside the model-class.


P
Paras

I believe this is a perfect use-case for Eloquent events (http://laravel.com/docs/eloquent#model-events). You can use the "deleting" event to do the cleanup:

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...
        });
    }
}

You should probably also put the whole thing inside a transaction, to ensure the referential integrity..


Note: I spend some time until I got this working. I needed to add first() into the query so I could access the model-event e.g. User::where('id', '=', $id)->first()->delete(); Source
@MichelAyres: yes, you need to call delete() on a model instance, not on Query Builder. Builder has it's own delete() method which basically just runs a DELETE sql query, so I presume it doesn't know anything about orm events...
This is the way to go for soft-deletes. I believe the new / preferred Laravel way is to stick all of these in the AppServiceProvider's boot() method in this way: \App\User::deleting(function ($u) { $u->photos()->delete(); });
Almost worked in Laravel 5.5, I had to add a foreach($user->photos as $photo), then $photo->delete() to make sure each child had its children removed on all levels, instead of only one as it was happening for some reason.
This doesn't cascade it further though. For example if Photos has tags and you do the same in Photos model (i.e. on deleting method: $photo->tags()->delete();) it never gets trigger. But if I make it a for loop and do something like for($user->photos as $photo) { $photo->delete(); } then the tags also get deleted! just FYI
N
NathanOliver

You can actually set this up in your migrations:

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

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

You may also specify the desired action for the "on delete" and "on update" properties of the constraint: $table->foreign('user_id') ->references('id')->on('users') ->onDelete('cascade');


Yeah, I guess I should have clarified that dependency.
But not if you're using soft deletes, since the rows are not then really deleted.
Also - this will delete the record in the DB, but will not run your delete method, so if you are doing extra work on delete (for example - delete files), it will not run
This approach relies on DB to do the cascade delete, but not all DBs support this, so extra care is required. For instance MySQL with MyISAM engine doesn't, nor any NoSQL DBs, SQLite in the default setup, etc. Additional problem is that artisan will not warn you about this when you run migrations, it will just not create foreign keys on MyISAM tables and when you later delete a record no cascade will happen. I had this problem once and believe me it's very hard to debug.
@kehinde The approach shown by you does NOT invoke deletion events on the relations to-be-deleted. You should iterate over the relation and call delete individually.
a
akhy

Note: This answer was written for Laravel 3. Thus might or might not works well in more recent version of Laravel.

You can delete all related photos before actually deleting the user.

<?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();
    }
}

Hope it helps.


You have to use: foreach($this->photos as $photo) ($this->photos instead of $this->photos()) Otherwise, good tip!
To make it more efficient, use one query: Photo::where("user_id", $this->id)->delete(); Not the nicest way, but only 1 query, way better performance if a user has 1.000.000 photo's.
actually you can call: $this->photos()->delete(); no need for loop – ivanhoe
@ivanhoe I noticed that the deleting event will not fire in photo if you delete the collection, however, iterating through as akhyar suggests will cause the deleting event to fire. Is this a bug?
Yes, I'm on L4. Doesn't work. The deleting event doesn't fire. I tried it a couple of times. I haven't had time to comb through Laravel's code to find out why.
C
Calin Blaga

Relation in User model:

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

Delete record and related:

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

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

$user->delete();

This works, but use care to use $user()->relation()->detach() if there is a piviot table involved (in case of hasMany / belongsToMany relations), or else you will delete the reference, not the relation.
This works for me laravel 6. @Calin can you explain more pls?
P
Paras

There are 3 approaches to solving this:

1. Using Eloquent Events On Model Boot (ref: 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. Using Eloquent Event Observers (ref: https://laravel.com/docs/5.7/eloquent#observers)

In your AppServiceProvider, register the observer like so:

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

Next, add an Observer class like so:

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

3. Using Foreign Key Constraints (ref: https://laravel.com/docs/5.7/migrations#foreign-key-constraints)

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

I think that the 3 options is the most elegant since is building the constraint into the database itself. I test it and works just fine.
You better mention what's the differences, the first and second are great for only one change at a time, not batching and also when you using databases that don't support the cascade the third one work on multiple rows but not on all of the databases.
m
mpen

As of Laravel 5.2, the documentation states that these kinds of event handlers should be registered in the AppServiceProvider:

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

I even suppose to move them to separate classes instead of closures for better application structure.


Laravel 5.3 recommends putting them in separate classes called Observers - while it's only documented in 5.3 though, the Eloquent::observe() method is available in 5.2 as well and can be used from the AppServiceProvider.
If you have any 'hasMany' relations from your photos(), you'll also need to be careful - this process will not delete grandchildren because you're not loading models. You'll need to loop over photos (note, not photos()) and fire the delete() method on them as models in order to fire the delete-related events.
@Leith The observe Method is also available in 5.1.
b
budhajeewa

It is better if you override the delete method for this. That way, you can incorporate DB transactions within the delete method itself. If you use the event way, you will have to cover your call of delete method with a DB transaction every time you call it.

In your User model.

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

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

    $result = parent::delete();

    \DB::commit();

    return $result;
}

S
Steve Bauman

To elaborate on the selected answer, if your relationships also have child relationships that must be deleted, you have to retrieve all child relationship records first, then call the delete() method so their delete events are fired properly as well.

You can do this easily with higher order messages.

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();
        });
    }
}

You can also improve performance by querying only the relationships ID column:

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();
        });
    }
}

B
BABAK ASHRAFI

Using Constrained()

After Laravel 7, new foreignId() and constrained() methods are available for defining relationship constraint in database. OnDelete() method can be used on these methods to automatically delete related records.

Old style

$table->unsignedBigInterer('user_id');

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

New style

$table->foreignId('user_id')
      ->constrained()
      ->onDelete('cascade');

a
agm1984

I would iterate through the collection detaching everything before deleting the object itself.

here's an example:

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);
    }

I know it is not automatic but it is very simple.

Another simple approach would be to provide the model with a method. Like this:

public function detach(){
       try {
            
            if ($this->has('photos')) {
                foreach ($this->photos as $photo) {
    
                    $this->photos()->detach($photo);
                }
            }
           
        } catch (Exception $e) {
            dd($e);
        }
}

Then you can simply call this where you need:

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

A
AnasSafi

This way worked for me on Laravel 8:

public static function boot() {

    parent::boot();
    
    static::deleted(function($item){
        $item->deleted_by = \Auth::id(); // to know who delete item, you can delete this row
        $item->save();  // to know who delete item, you can delete this row
        foreach ($item->photos as $photo){
            $photo->delete();
        }
    });
}

public function photos()
{
    return $this->hasMany('App\Models\Photos');
}

Note: deleting in this syntax $user->photos()->delete(); not worked for me...


C
Cyber5h13ld

Add delete function on model that you want to delete Define relations of models

for example in this instance:

/**
 * @return bool|null
 */
public function delete(): ?bool
{
    $this->profile()->delete();
    $this->userInterests()->delete();
    $this->userActivities()->delete();
    $this->lastLocation()->delete();

    return parent::delete();
}

And relations in user model are:

public function profile()
{
    return $this->hasOne(Profile::class, 'user_id', 'id');
}

public function userInterests()
{
    return $this->hasMany(userInterest::class, 'user_id', 'id');
}

public function userActivities()
{
    return $this->hasMany(userActivity::class, 'user_id', 'id');
}

public function lastLocation()
{
    return $this->hasOne(LastLocation::class, 'user_id', 'id');
}

A
Alex

In my case it was pretty simple because my database tables are InnoDB with foreign keys with Cascade on Delete.

So in this case if your photos table contains a foreign key reference for the user than all you have to do is to delete the hotel and the cleanup will be done by the Data Base, the data base will delete all the photos records from the data base.


As has been noted in other Answers, cascading deletions at the database layer will not work when using Soft Deletes. Buyer beware. :)
P
Pri Nce

Here are the perfect solutions.

# model

public function order_item_properties()
{
    return $this->hasMany(OrderItemProperty::class, 'order_id', 'id');
}

public function order_variations()
{
    return $this->hasMany(OrderItemVariation::class, 'order_id', 'id');
}

# controller

$order_item = OrderItem::find($request->order_id);

$order_item->order_item_properties()->delete();
$order_item->order_variations()->delete();

$order_item->delete();

return response()->json([
    'message' => 'Deleted',
]);

Define "Perfect solution". Its not delete automatically related data
D
Darren Powers

Or you can do this if you wanted, just another option:

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);
}

Note if you are not using the default laravel db connection then you need to do the following:

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

L
Leena Patel

It’s better to use onDelete cascade when defining your model’s migration. This takes care of deleting the model’s relations for you:

e.g.

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

If you happen to find yourself thinking about how to delete a model and its relations to a level greater than 3 or 4 nested relations, then you should consider redefining your model's relationships.


R
Rajib Bin Alam
$table->foreignId('user_id')->constrained('user')->cascadeOnDelete();

or

$table->foreignId('user_id')->constrained()->cascadeOnDelete();

a
ascripter

yeah, but as @supersan stated upper in a comment, if you delete() on a QueryBuilder, the model event will not be fired, because we are not loading the model itself, then calling delete() on that model.

The events are fired only if we use the delete function on a Model Instance.

So, this beeing said:

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

in order to delete the post tags when deleting the user, we would have to iterate over $user->posts and calling $post->delete()

foreach($user->posts as $post) { $post->delete(); } -> this will fire the deleting event on Post

VS

$user->posts()->delete() -> this will not fire the deleting event on post because we do not actually load the Post Model (we only run a SQL like: DELETE * from posts where user_id = $user->id and thus, the Post model is not even loaded)


D
Daanzel

You can use this method as an alternative.

What will happen is that we take all the tables associated with the users table and delete the related data using looping

$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]);
}

I don't think all these queries are necessary since eloquent orm can handle this if you specify it clearly.