Laravel Eloquent ist an object-relational-mapper, an ORM, that makes working with databases a joy. While you still need a basic understanding about your database and how writing queries works, Laravel Eloquent provides convenient methos to insert, update and query this data.
Eloquent uses the active record pattern where every column in the database table is accessible via a magic method of the related Eloquent Model. So you can access the name
column of your user model with $user->name
.
For this guide, we use a standard implementation of a blog. The blog has Users
, the Users
have Posts
and these have Comments
. Posts
and Comments
are always connected to a User
and this is how our database looks like.
The Eloquent relationships on the User
model for this setup looks as simple as that:
public function posts(): HasMany{ return $this->hasMany(Post::class);} public function comments(): HasMany{ return $this->hasMany(Comment::class);}
As an example, the Post
relationships are similar:
public function user(): BelongsTo{ return $this->belongsTo(User::class);} public function comments(): HasMany{ return $this->hasMany(Comment::class);}
In the next, step, we use Laravel Eloquent Factories to create test data for our implementation. If you only do this every now and then, you can use Tinkerwell to run these factories, simply create 25 users with generated fake data.
use App\Models\User;use App\Models\Post;use App\Models\Comment; // create 25 users$users = User::factory() ->times(25) ->create(); // create 50 posts from these users$posts = Post::factory() ->times(50) ->recycle($users) ->create(); // use existing users and posts to create commentsComment::factory() ->times(100) ->recycle($users) ->recycle($posts) ->create();
While we use factories for our demo application locally, you can also use the create method of Laravel Eloquent to create records in your normal application. So if you want to create a user manually, you can simply connect to your application with Tinkerwell and create the user via Eloquent.
User::create([ 'name' => 'Sebastian', 'password' => bcrypt('secret'),]);
This creates a user with the password secret
. When using the create
method with a mass assignment where you add all values within an array, make sure that the properties of the model are either explicitely listed in the $fillable
array of the model or that the whole model is unguarded.
When you query your database with Laravel Eloquent, you can add as many where
conditions to the query as you want. They filter the results with an AND
condition, so if we want to get all users of our blog that have a premium account and haven't added their company name to their account, we can do this with the Eloquent query below. Tinkerwell has Magic Comments that you can use within a query to run additional methods on the query – in our case, we run the database count
function to see how many results we'll get.
User::query() ->where("company", null) ->where("premium", true) /*?->count()*/ ->get();
If we want to use the OR
within our where conditions, we can use the orWhere
selector.
User::query() ->where("company", null) ->orWhere("premium", true) /*?->count()*/ ->get();
This query returns all users who haven't set a company name in their profile or who have a premium account.
For convenience, you can use the whereNull
or whereNotNull
method to improve the readability of your Eloquent query.
User::query() ->whereNotNull("company") ->where("premium", true) /*?->count()*/ ->get();
Users
with Posts
Laravel Eloquent is very powerful, especially if you start querying relationships or just their existence.
In the next Example, we use the has
method of Eloquent to filter our existing results even further and return only users who have written at least 3 posts.
User::query() ->whereNotNull("company") ->where("premium", true) ->has('posts', '>=', 3) /*?->count()*/ ->get();
We can become more specific with our query by using the whereHas
method and insert a function into the query that creates a subquery on the actual comments of these users.
User::query() ->whereNotNull("company") ->where("premium", true) ->has('posts', '>=', 3) ->whereHas('posts', function($query) { $query->where('title', 'like', '%eloquent%'); }) /*?->count()*/ ->get();
As you can see, Laravel Eloquent has a powerful query builder that allows you to use multiple where conditions as well as the option to query relationships, their existence and even their content.
Tinkerwell on the other hand is a powerful code runner that makes writing complex Laravel Eloquent queries enjoyable because you can easily test them during development. It speeds up your workflow so much that you will use it all the time, sometimes for things that are as easy as querying your production database so count how many users have a premium account with User::wherePremium(true)->count()
or select a user and update their values without touching your database management tool.
User::wherePremium(true) ->get() ->each(function ($user) { $user->update([ "name" => $user->name . " 🚀" ]); });
“The ability to SSH directly into a server and run diagnostics directly from Tinkerwell is insanely amazing! Can't imagine doing development without it at this point.”Jake Bennett
Director of Technology and Innovation
“Pretty rad man. With the auto reload functionality as I type, it makes it easy to debug a lot of the logic in my apps. Very well done.”
Tony Lea
Developer at Cirricula
The must-have companion to your favorite IDE. Quickly iterate on PHP code within the context of your web application.
Buy now Learn more