Eloquent push() and save() difference
Stefan Izdrail
Founder & Senior Architect · 2026-06-29
Title: Understanding the Differences between Eloquent's push() and save() Methods
In Laravel, working with relationships in your database can be effortless using its powerful ORM (Object Relational Mapping) library called Eloquent. One of the most important methods you may use here is 'save'. However, there can also be confusion surrounding another method, 'push'. This blog post aims to clarify these two methods' differences and help you understand exactly how each one works.
Let us first gain a better understanding of Eloquent relationships before moving on to the push() and save() methods. In Laravel Eloquent ORM, you can establish and manage database relationships in your application models without complex SQL queries or raw queries. There are four types of relationships: one-to-one, many-to-many, one-to-many, and polymorphic relationships.
Now let us delve deeper into the push() method. The primary purpose of the push() method is to establish a one-to-many relationship between two models. Here's an example where a user has many addresses:
```php
hasMany('Address');
}
}
// Address Model
class Address extends Eloquent {
// ... other definitions and validations...
}
```
Now, when you want to create a new user with multiple addresses, use the 'push' method:
```php
name = "John Doe";
$addresses = array(new Address, new Address); // two addresses for John
$user->addresses()->saveMany($addresses); // save user and associated addresses
```
In this scenario, the push() method saves not only the user but also all of its relationships. It is equivalent to executing multiple INSERT queries. This approach can be convenient if you want to ensure that the relationship exists when creating a new model. However, there are cases when you might need more flexibility regarding when or how many relationships to establish.
This is where the save() method comes in. The primary purpose of the save() method is to save a record in the database without affecting its parent-child relationships. This means that the foreign key in the child table will not be automatically updated, but rather left empty until you explicitly set it later:
```php
name = "John Doe";
$address1 = new Address;
$address2 = new Address; // two addresses for John
$user->save(); // save user without associating any addresses yet
$user->addresses()->saveMany($addresses); // associate the user with the addresses later
```
In this case, you first create and save the user model without establishing any relationships. Then, when you want to add the addresses, you can use saveMany() for multiple addresses or push() if you have only one additional address but want to relate it to the existing user.
You should decide which of these methods to use based on your application needs and the specifics of your data model. Each method serves a distinct purpose: push() is designed for when you need to create a new user with associated relationships, while save() simply saves a record without affecting its relationships.
In summary, Laravel's Eloquent framework offers various ways to handle database relationships. Use the push() method for creating new models and their one-to-many relationships simultaneously. For situations where you need more control over when and how many relationships are established, use the save() method to create a model without affecting its existing or future relationships.