When you call User::find(1), Laravel doesn't just return raw database data—it transforms a database row into a fully-featured Eloquent model instance with relationships, mutators, and magic methods. But how does this transformation happen? Let's explore the elegant process that turns SQL results into powerful model objects.
What Is Model::find()?
The find() method retrieves a single model instance by its primary key:
// Find user with ID 1
$user = User::find(1);
// Find multiple users by IDs
$users = User::find([1, 2, 3]);
// With selected columns
$user = User::find(1, ['id', 'name', 'email']);
Simple syntax, but sophisticated object conversion underneath.
The Complete find() Flow
When you call Model::find(), Laravel executes a precise transformation process:
Step 1: Method Resolution
// When you call
$user = User::find(1);
// Behind the scenes
public static function find($id, $columns = ['*'])
{
return static::query()->find($id, $columns);
}
The static method creates a new query builder instance and chains to the instance method.
Step 2: Query Builder Setup
// Behind the scenes
public function find($id, $columns = ['*'])
{
if (is_array($id) || $id instanceof Arrayable) {
return $this->findMany($id, $columns);
}
return $this->whereKey($id)->first($columns);
}
Laravel determines if you're finding one or multiple models.
Step 3: Primary Key Detection
// Behind the scenes in whereKey()
protected $primaryKey = 'id'; // Default
public function whereKey($id)
{
if (is_array($id)) {
return $this->whereIn($this->getQualifiedKeyName(), $id);
}
return $this->where($this->getQualifiedKeyName(), '=', $id);
}
Laravel uses the model's primary key (default: id) to build the WHERE clause.
Step 4: SQL Query Generation
// Behind the scenes
$sql = "SELECT * FROM users WHERE id = ?";
$bindings = [1];
// With selected columns
$sql = "SELECT id, name, email FROM users WHERE id = ?";
The query builder converts the fluent interface to actual SQL.
Step 5: Database Execution
// Behind the scenes
$result = $this->connection->select($sql, $bindings);
// Returns array of stdClass objects
// [
// (object) [
// 'id' => 1,
// 'name' => 'John Doe',
// 'email' => 'john@example.com',
// 'created_at' => '2025-01-01 12:00:00',
// ]
// ]
The database returns raw data as standard PHP objects.
Step 6: Model Hydration
This is where the magic happens—raw data becomes an Eloquent model:
// Behind the scenes
public function newFromBuilder($attributes = [], $connection = null)
{
$model = $this->newInstance([], true);
$model->setRawAttributes((array) $attributes, true);
$model->setConnection($connection ?: $this->getConnectionName());
$model->fireModelEvent('retrieved', false);
return $model;
}
Laravel creates a new model instance and populates it with attributes.
Step 7: Attribute Casting
// Behind the scenes
protected $casts = [
'email_verified_at' => 'datetime',
'is_admin' => 'boolean',
];
// Raw value: '2025-01-01 12:00:00'
// Cast value: Carbon instance
// Raw value: 1
// Cast value: true (boolean)
Laravel automatically casts attributes based on the $casts property.
Step 8: Model Instance Return
// Final result
$user = User::find(1);
// $user is now a fully hydrated User model
echo $user->name; // 'John Doe'
echo $user->email; // 'john@example.com'
$user->posts; // Can access relationships
The database row is now a powerful Eloquent model.
Finding Multiple Models
When finding multiple IDs:
$users = User::find([1, 2, 3]);
// Behind the scenes
SELECT * FROM users WHERE id IN (?, ?, ?)
// Bindings: [1, 2, 3]
// Returns Collection of User models
$users->each(function ($user) {
echo $user->name;
});
Returns a Collection instead of a single model.
The Hydration Process Explained
Hydration is the process of converting raw database data into model instances:
Raw Attributes
// Raw data from database
$attributes = [
'id' => 1,
'name' => 'John Doe',
'email' => 'john@example.com',
'email_verified_at' => '2025-01-01 12:00:00',
'created_at' => '2025-01-01 12:00:00',
'updated_at' => '2025-01-01 12:00:00',
];
Setting Raw Attributes
// Behind the scenes
$model->setRawAttributes($attributes, true);
// Stores in $model->attributes
// Second parameter (true) marks as "existing" record
Attribute Casting During Access
// When you access an attribute
$verifiedAt = $user->email_verified_at;
// Behind the scenes
public function getAttribute($key)
{
if (array_key_exists($key, $this->attributes)) {
return $this->castAttribute($key, $this->attributes[$key]);
}
return $this->getRelationValue($key);
}
Casting happens on-demand when attributes are accessed.
Primary Key Customization
Change the primary key column:
class User extends Model
{
protected $primaryKey = 'user_id';
// Non-incrementing primary key
public $incrementing = false;
// String primary key (UUID)
protected $keyType = 'string';
}
// Finding still works
$user = User::find('550e8400-e29b-41d4-a716-446655440000');
Laravel adapts the query to your custom primary key.
Composite Primary Keys
Laravel doesn't natively support composite keys, but you can work around it:
class UserRole extends Model
{
protected $primaryKey = ['user_id', 'role_id'];
public $incrementing = false;
// Custom find method
public static function findByKeys($userId, $roleId)
{
return static::where('user_id', $userId)
->where('role_id', $roleId)
->first();
}
}
$userRole = UserRole::findByKeys(1, 5);
find() vs findOrFail()
Understanding the difference:
// find() returns null if not found
$user = User::find(999);
if ($user === null) {
// Handle not found
}
// findOrFail() throws exception if not found
$user = User::findOrFail(999);
// Throws: ModelNotFoundException
// Results in 404 response in controllers
findOrFail() is better for route model binding and APIs:
// In controller
public function show($id)
{
$user = User::findOrFail($id); // Automatic 404 if not found
return view('users.show', compact('user'));
}
Performance Considerations
Single Query
$user = User::find(1);
// Executes: SELECT * FROM users WHERE id = ? [1]
// Time: ~5-10ms
Multiple Finds (Inefficient)
// Bad - N+1 queries
$user1 = User::find(1);
$user2 = User::find(2);
$user3 = User::find(3);
// Executes 3 separate queries
// Time: ~15-30ms
Multiple IDs (Efficient)
// Good - Single query
$users = User::find([1, 2, 3]);
// Executes: SELECT * FROM users WHERE id IN (?, ?, ?) [1, 2, 3]
// Time: ~5-10ms
Model Events During find()
The retrieved event fires after hydration:
class User extends Model
{
protected static function booted()
{
static::retrieved(function ($user) {
// Fires every time a user is retrieved from database
Log::info("User {$user->id} retrieved");
});
}
}
$user = User::find(1);
// Triggers 'retrieved' event
Selecting Specific Columns
Optimize queries by selecting only needed columns:
// Select all columns (default)
$user = User::find(1);
// SELECT * FROM users WHERE id = ?
// Select specific columns
$user = User::find(1, ['id', 'name', 'email']);
// SELECT id, name, email FROM users WHERE id = ?
// Using query builder
$user = User::select(['id', 'name'])->find(1);
Important: Always include the primary key when selecting columns:
// Bad - will cause issues with relationships
$user = User::find(1, ['name', 'email']);
// Good - includes primary key
$user = User::find(1, ['id', 'name', 'email']);
Caching find() Results
Laravel doesn't cache find() by default, but you can:
// Manual caching
$user = Cache::remember('user:1', 3600, function () {
return User::find(1);
});
// Or using Laravel's query caching
$user = User::remember(60)->find(1);
Common Patterns
Find with Default
// Return default if not found
$user = User::find(1) ?? User::make([
'name' => 'Guest User',
]);
// Or using firstOr()
$user = User::where('id', 1)->firstOr(function () {
return User::create(['name' => 'Default']);
});
Find and Update
$user = User::find(1);
if ($user) {
$user->update(['last_login' => now()]);
}
// Or use updateOrCreate
User::updateOrCreate(
['id' => 1],
['last_login' => now()]
);
Find with Relationships
// Eager load relationships
$user = User::with('posts', 'comments')->find(1);
// Access relationships without additional queries
$posts = $user->posts;
Debugging find() Queries
// Enable query log
DB::enableQueryLog();
$user = User::find(1);
// View executed queries
dd(DB::getQueryLog());
// Output:
// [
// [
// 'query' => 'select * from users where id = ?',
// 'bindings' => [1],
// 'time' => 5.23
// ]
// ]
Best Practices
1. Use findOrFail in Controllers
// Good - automatic 404
public function show($id)
{
$user = User::findOrFail($id);
}
// Avoid - manual null checking
public function show($id)
{
$user = User::find($id);
if (!$user) {
abort(404);
}
}
2. Select Only Needed Columns
// Optimize large tables
$user = User::find(1, ['id', 'name', 'email']);
3. Find Multiple IDs Efficiently
// Good - single query
$users = User::find([1, 2, 3]);
// Bad - multiple queries
$users = collect([1, 2, 3])->map(fn($id) => User::find($id));
4. Use Caching for Frequently Accessed Models
$user = Cache::remember("user:{$id}", 3600, function () use ($id) {
return User::find($id);
});
Conclusion
Laravel's Model::find() method is a masterpiece of abstraction, seamlessly converting database rows into rich model objects through query building, SQL execution, hydration, and attribute casting. Understanding this process helps you write more efficient queries, debug issues faster, and appreciate the elegance of Eloquent ORM.
Every time you call User::find(1), you're witnessing the beautiful transformation from raw database data to a fully-featured object with relationships, events, and magic methods—all happening in milliseconds.
Need help optimizing Eloquent queries or migrating complex database logic? At NeedLaravelSite, we specialize in Laravel development and application migrations from version 7 to 12. From query optimization to database architecture, we build performant, maintainable applications.
