Get last inserted ID with Laravel Eloquent? [SOLVED]

While working with Eloquent, it's common to find yourself in a situation where you need to retrieve the ID of the last record inserted into the database. Whether you need to create relationships between your tables or for logging purposes, getting the last inserted ID can be of immense utility.

When a new record is inserted into the database using Eloquent's create or save method, the instance itself is updated with the new record's ID.

Consider a scenario where you have a User model and you're inserting a new user into your 'users' table:

$user = new User;
$user->name = 'John Doe';
$user->email = 'john@example.com';
$user->password = Hash::make('password');
$user->save();

Once the save method is called, Eloquent will perform an insert query, create a new record in the 'users' table, and the $user object will be updated with the ID of the newly inserted record. You can access this ID simply by:

echo $user->id;

The id property of the $user object now contains the ID of the last inserted record. This principle applies regardless of the model or table you're working with, as long as the table has an auto-incrementing ID, which is the default in Laravel.

In this article, we will explore this concept more thoroughly, examining different scenarios and ways to handle more complex situations. With Laravel Eloquent, you'll find that retrieving the last inserted ID can be achieved smoothly and elegantly. Stay tuned as we delve deeper into this intriguing feature.

 

Understand Laravel Eloquent ORM

ORM is a programming technique that enables you to work with databases using object-oriented paradigms rather than writing raw SQL queries. ORM systems provide a layer of abstraction between the application code and the database, allowing you to interact with the database using objects and classes.

The main goal of ORM is to bridge the gap between the relational database and the object-oriented programming language. That makes mapping database tables to corresponding objects easier and vice versa. ORM systems handle tasks such as object persistence (storing objects in the database), querying data from the database, and managing relationships between objects.

In the context of Laravel, the Eloquent ORM provides a robust implementation of ORM principles. It allows you to define models that represent database tables. These models extend the base Illuminate\Database\Eloquent\Model class provided by Laravel.

By defining relationships and properties within the model classes, you can map tables, columns, and relationships between tables to objects, attributes, and relationships between models. Eloquent generates the necessary SQL queries behind the scenes, abstracting away the complexities of database operations.

Laravel Eloquent provides various methods and conventions for performing CRUD (Create, Read, Update, Delete) operations. It supports fluent query building, allowing you to chain methods to construct complex queries in a readable and expressive manner.

Eloquent also offers features like eager loading, which helps optimize queries by fetching related data in advance, reducing the number of database queries required. It supports events and hooks that allow developers to perform actions before or after certain model events, such as saving or deleting records.

The following section will show you how to get last inserted Id with Laravel Eloquent.

 

Insert Data into the Database

Here's an example code snippet that demonstrates how to insert data into the database using Laravel:

use App\Models\User;

// Create a new instance of the User model
$user = new User();

// Set the values for the user attributes
$user->name = 'John Doe';
$user->email = 'john@example.com';
$user->password = bcrypt('password123');

// Save the user record to the database
$user->save();

In the above example, we assume there is a User model representing a users table in the database. We create a new instance of the User model and set the desired values for its attributes, such as name, email, and password. The bcrypt() function is used to hash the password for security purposes.

Finally, we call the save() method on the model instance to persist the data in the database. Laravel's Eloquent ORM takes care of generating the appropriate SQL query to insert the data into the corresponding table.

 

Retrieve the Last Inserted ID

To retrieve the last inserted ID of the user we inserted in the previous example, we can use the $user object after calling the save() method. Here's an updated code snippet:

use App\Models\User;

// Create a new instance of the User model
$user = new User();

// Set the values for the user attributes
$user->name = 'John Doe';
$user->email = 'john@example.com';
$user->password = bcrypt('password123');

// Save the user record to the database
$user->save();

// Retrieve the last inserted ID
$lastInsertedId = $user->id;

// Display the last inserted ID
echo "Last Inserted ID: " . $lastInsertedId;

In the updated code snippet, we assign the id property of the $user object to the variable $lastInsertedId after calling the save() method. The id property represents the primary key value of the last inserted record.

We can then use the $lastInsertedId variable as needed, such as displaying it or using it for further operations in our application.

Alternatively, we can retrieve all users from the database and then extract the last inserted ID:

use App\Models\User;

// Retrieve all users from the database
$users = User::all();

// Extract the last inserted ID from the users collection
$lastInsertedId = $users->last()->id;

// Display the last inserted ID
echo "Last Inserted ID: " . $lastInsertedId;

We make use of Laravel's query builder and the all() method to retrieve all users from the users table. The User::all() call fetches all the user records and returns a collection of User objects.

We then use the last() method on the $users collection to extract the last user object. Finally, we access the id property of the last user object to obtain the last inserted ID.

 

Bonus Trick: Use Query Builder

To achieve the same result using Larave Query Builder, we can utilize the insertGetId() method. Here's an example code snippet:

use Illuminate\Support\Facades\DB;

    // Define the user data to be inserted
    $userData = [
        'name' => 'Lorem Ipsum',
        'email' => 'lorem@example.com',
        'password' => bcrypt('password456')
    ];

    // Insert the user data and retrieve the last inserted ID
    $lastInsertedId = DB::table('users')->insertGetId($userData);

    // Display the last inserted ID
    return "Last Inserted ID: " . $lastInsertedId;

In the above code snippet, we first define an array $userData that contains the values for the user's attributes, such as name, email, and password.

Then, we use the insertGetId() method on the DB facade to insert the $userData into the users table and retrieve the last inserted ID in a single step. The insertGetId() method inserts the data into the table and returns the ID of the newly inserted record.

Finally, we display the last inserted ID by returning it.

 

Conclusion

Retrieving the last inserted ID is a common requirement when working with databases in web development projects. In this blog post, we explored how to efficiently accomplish this task using Laravel's Eloquent ORM.

Laravel's Eloquent ORM provides a powerful and intuitive way to interact with databases using object-oriented principles. We learned about the basics of Eloquent ORM, its benefits, and how it simplifies database operations by abstracting away the low-level SQL queries.

We covered the process of inserting data into the database using Eloquent, and then retrieving the last inserted ID. Whether through the save() method on a model instance or the insertGetId() method on the Query Builder, Laravel offers flexible options to achieve this.

 

Further Reading

Get the Last Inserted Id Using Laravel Eloquent - php