One-to-one (hasOne, belongsTo) in Laravel - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output of accessing a related model using hasOne?

Consider a Laravel User model with a hasOne relation to Profile. If you run $user->profile->bio and the user has a profile with bio 'Loves coding', what will be the output?

Laravel

<?php
class User extends Model {
  public function profile() {
    return $this->hasOne(Profile::class);
  }
}

$user = User::find(1);
echo $user->profile->bio;

A Loves coding

B null

C Error: Undefined property

D Empty string

💡 Hint

Remember that hasOne returns the related model instance if it exists.

The hasOne relation returns the related Profile model. Accessing ->bio on it returns the stored bio string.

❓ state_output

intermediate

What happens if belongsTo relation is accessed but related model is missing?

Given a Profile model with a belongsTo relation to User, what is the result of $profile->user->name if the user record was deleted?

Laravel

<?php
class Profile extends Model {
  public function user() {
    return $this->belongsTo(User::class);
  }
}

$profile = Profile::find(1);
echo $profile->user->name;

A null

B Error: Trying to get property 'name' of non-object

C Empty string

D User name string

💡 Hint

Think about what happens if the related user does not exist.

If the related user is missing, $profile->user returns null. Accessing ->name on null causes an error.

📝 Syntax

advanced

Which code correctly defines a one-to-one inverse relation using belongsTo?

Choose the correct belongsTo relation definition inside the Profile model pointing to User.

A public function user() { return $this->hasOne(User::class); }

B public function user() { return $this->hasMany(User::class); }

C public function user() { return $this->belongsTo('User'); }

D public function user() { return $this->belongsTo(User::class); }

💡 Hint

belongsTo is used on the child model to point to the parent.

belongsTo defines the inverse of hasOne. It requires the related class name as a class reference.

🔧 Debug

advanced

Why does eager loading a hasOne relation return an empty collection?

You run $users = User::with('profile')->get(); but $users[0]->profile is null even though the profile exists. What is the most likely cause?

A The profile table is empty

B The hasOne relation is defined with belongsTo instead

C The foreign key in Profile does not match the User primary key

D Eager loading does not work with hasOne relations

💡 Hint

Check the foreign key column names in the database and relation definition.

If the foreign key column in Profile does not match the User primary key, Laravel cannot link the models, so profile is null.

🧠 Conceptual

expert

How does Laravel determine the foreign key name in a hasOne relation by default?

When defining public function profile() { return $this->hasOne(Profile::class); } in User, what foreign key column does Laravel expect in the profiles table by default?

A user_id

B profile_id

C id

D userId

💡 Hint

Laravel uses the parent model name in snake_case plus _id.

By default, Laravel expects the foreign key to be the snake_case of the parent model name plus _id, so 'user_id' in profiles table.

Practice

1. In Laravel, when defining a one-to-one relationship, which method should you use on the model that owns the other model?

easy

A. hasOne

B. belongsTo

C. hasMany

D. belongsToMany

Solution

1. Step 1: Understand ownership in one-to-one

   The model that owns the other model is the one that does not have the foreign key.

2. Step 2: Identify the correct method for ownership

   In Laravel, the owning model uses hasOne to define the relationship.

3. Final Answer:

   hasOne -> Option A

4. Quick Check:

   Owning model uses hasOne [OK]

Hint: Owning model uses hasOne, foreign key model uses belongsTo [OK]

Common Mistakes:

• Using belongsTo on the owning model
• Confusing hasOne with hasMany
• Using belongsToMany for one-to-one

2. Which of the following is the correct syntax to define a belongsTo relationship in a Laravel model?

easy

A. public function user() { return $this->belongsTo(User::class); }

B. public function user() { return $this->belongsToMany(User::class); }

C. public function user() { return $this->hasMany(User::class); }

D. public function user() { return $this->hasOne(User::class); }

Solution

1. Step 1: Recall belongsTo syntax

   The belongsTo method is used on the model with the foreign key and is called like return $this->belongsTo(Model::class);.

2. Step 2: Match the correct syntax

   public function user() { return $this->belongsTo(User::class); } matches the correct belongsTo syntax exactly.

3. Final Answer:

   public function user() { return $this->belongsTo(User::class); } -> Option A

4. Quick Check:

   belongsTo syntax uses belongsTo(Model::class) [OK]

Hint: belongsTo uses return $this->belongsTo(Model::class) [OK]

Common Mistakes:

• Using hasOne instead of belongsTo
• Forgetting parentheses after belongsTo
• Using belongsToMany for one-to-one

3. Given these two Laravel models:

class User extends Model {
  public function profile() {
    return $this->hasOne(Profile::class);
  }
}

class Profile extends Model {
  public function user() {
    return $this->belongsTo(User::class);
  }
}

What will $user->profile->phone return if the user has a profile with phone number '123-456-7890'?

medium

A. An array of profiles

B. null

C. An error because profile() is not defined

D. '123-456-7890'

Solution

1. Step 1: Understand the relationship

   User has one Profile, so $user->profile returns the related Profile model instance.

2. Step 2: Access the phone attribute

   Accessing $user->profile->phone returns the phone value from the Profile model, which is '123-456-7890'.

3. Final Answer:

   '123-456-7890' -> Option D

4. Quick Check:

   hasOne returns single related model [OK]

Hint: hasOne returns single model, access attributes directly [OK]

Common Mistakes:

• Expecting an array instead of a single model
• Confusing belongsTo and hasOne roles
• Assuming null when profile exists

4. You have these models:

class Author extends Model {
  public function biography() {
    return $this->hasOne(Biography::class);
  }
}

class Biography extends Model {
  public function author() {
    return $this->belongsTo(Author::class);
  }
}

But when you try $author->biography, it returns null even though the biography exists in the database. What is the most likely cause?

medium

A. The Biography model is missing the hasOne method.

B. The Author model should use belongsTo instead of hasOne.

C. The Biography model's foreign key column name doesn't match Laravel's default 'author_id'.

D. The database table for Biography is missing entirely.

Solution

1. Step 1: Check foreign key conventions

   Laravel expects the foreign key in Biography table to be 'author_id' by default for belongsTo.

2. Step 2: Identify mismatch causes null

   If the foreign key column is named differently, Laravel cannot find the related record, so $author->biography returns null.

3. Final Answer:

   The Biography model's foreign key column name doesn't match Laravel's default 'author_id'. -> Option C

4. Quick Check:

   Foreign key name mismatch causes null relation [OK]

Hint: Check foreign key column names match Laravel defaults [OK]

Common Mistakes:

• Switching hasOne and belongsTo methods incorrectly
• Assuming missing method causes null instead of key mismatch
• Ignoring database schema foreign key names

5. You want to create a one-to-one relationship between Car and Engine models where each car has exactly one engine. The engines table has a foreign key car_id. Which is the correct way to define the relationship in both models?

hard

A. In Car model: public function engine() { return $this->belongsTo(Engine::class); }In Engine model: public function car() { return $this->hasOne(Car::class); }

B. In Car model: public function engine() { return $this->hasOne(Engine::class); }In Engine model: public function car() { return $this->belongsTo(Car::class); }

C. In Car model: public function engine() { return $this->hasMany(Engine::class); }In Engine model: public function car() { return $this->belongsTo(Car::class); }

D. In Car model: public function engine() { return $this->belongsToMany(Engine::class); }In Engine model: public function car() { return $this->belongsToMany(Car::class); }

Solution

1. Step 1: Identify foreign key location

   The foreign key car_id is in the engines table, so Engine belongs to Car.

2. Step 2: Define relationships accordingly

   Car has one Engine (hasOne), Engine belongs to Car (belongsTo).

3. Final Answer:

   Car uses hasOne, Engine uses belongsTo -> Option B

4. Quick Check:

   Foreign key in engines means Engine belongsTo Car [OK]

Hint: Foreign key in table means that model belongsTo owner [OK]

Common Mistakes:

• Reversing hasOne and belongsTo roles
• Using hasMany for one-to-one
• Using belongsToMany for one-to-one