Query scopes in Laravel - Step-by-Step Execution

Concept Flow - Query scopes

Define scope method in model

↓

Call scope method on query builder

↓

Scope modifies query

↓

Execute query with modified conditions

↓

Get filtered results

Query scopes let you add reusable filters to database queries by defining methods in your model that modify the query builder.

Execution Sample

Laravel

class Post extends Model {
  public function scopePublished($query) {
    return $query->where('published', true);
  }
}

$posts = Post::published()->get();

Defines a scope 'published' to filter posts where 'published' is true, then fetches those posts.

Execution Table

Step	Action	Query Builder State	Result
1	Call Post::published()	Query builder for Post model	Query builder instance created
2	Inside scopePublished: add where('published', true)	Query builder with where condition added	Query modified to filter published posts
3	Call get() on query builder	Final query ready	SQL executed, returns posts with published = true
4	Receive results	Collection of Post models	Filtered posts returned

💡 Query executed after scope modifies it, returning only published posts

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
$query	null	Query builder instance	Query builder with where('published', true)	Query builder ready to execute	Executed query results
$posts	null	null	null	null	Collection of published posts

Key Moments - 3 Insights

Why does the scope method start with 'scope' in its name?

Laravel requires scope methods to start with 'scope' so it can recognize and call them properly when you use the short form like 'published()' in the query (see execution_table step 1 and 2).

What does the scope method receive as its first argument?

The scope method receives the query builder instance as the first argument, allowing it to add conditions to the query (see execution_table step 2 where the where condition is added).

Can you chain multiple scopes together?

Yes, because each scope returns the modified query builder, you can chain scopes like Post::published()->popular()->get(), building up the query step by step.

Visual Quiz - 3 Questions

Look at the execution_table, what does the query builder contain after step 2?

A A query with a where condition filtering published posts

B An empty query builder with no conditions

C A collection of posts already fetched

D A raw SQL string

💡 Hint

Check the 'Query Builder State' column at step 2 in execution_table

At which step is the SQL query actually executed?

A Step 1

B Step 2

C Step 3

D Step 4

💡 Hint

Look for the step where 'get()' is called in execution_table

If the scope method did not return the query builder, what would happen?

A The query would still work fine

B The query builder would be lost and chaining scopes would fail

C The query would return all posts ignoring filters

D Laravel would throw a syntax error

💡 Hint

Refer to variable_tracker for how $query changes and is returned after step 2

Concept Snapshot

Query scopes in Laravel are methods in models prefixed with 'scope'.
They receive the query builder and add conditions.
Call them as short names on the model query.
Scopes return the modified query builder for chaining.
They help reuse query filters cleanly.

Full Transcript

Query scopes in Laravel let you add reusable filters to database queries by defining methods in your model. These methods start with 'scope' and receive the query builder as the first argument. Inside the scope, you add conditions like where clauses. When you call the scope on the model, Laravel calls the method without the 'scope' prefix and applies the filter. The scope returns the modified query builder so you can chain multiple scopes. Finally, calling get() executes the SQL query and returns filtered results. This visual trace showed how the query builder changes step-by-step from creation, modification by the scope, to execution and result retrieval.

Practice

1. What is the main purpose of using query scopes in a Laravel model?

easy

A. To create database migrations

B. To define database table relationships

C. To handle user authentication

D. To reuse common query filters easily across different queries

Solution

1. Step 1: Understand query scopes role

   Query scopes allow you to write common query parts once and reuse them easily.

2. Step 2: Compare with other options

   Defining relationships, migrations, or authentication are unrelated to query scopes.

3. Final Answer:

   To reuse common query filters easily across different queries -> Option D

4. Quick Check:

   Query scopes = reusable query filters [OK]

Hint: Query scopes = reusable query parts in models [OK]

Common Mistakes:

• Confusing scopes with relationships
• Thinking scopes create migrations
• Mixing scopes with authentication logic

2. Which of the following is the correct way to define a query scope named active in a Laravel model?

easy

A. public function scopeActive($query) { return $query->where('status', 'active'); }

B. public function scopeActive() { return $this->where('status', 'active'); }

C. public function scope_active($query) { return $query->where('status', 'active'); }

D. public function active() { return $this->where('status', 'active'); }

Solution

1. Step 1: Recall scope method naming

   Query scopes must be prefixed with 'scope' and accept $query as first parameter.

2. Step 2: Check method signature and body

   public function scopeActive($query) { return $query->where('status', 'active'); } correctly uses 'scopeActive($query)' and returns $query with condition.

3. Final Answer:

   public function scopeActive($query) { return $query->where('status', 'active'); } -> Option A

4. Quick Check:

   Scope method = scope + $query param [OK]

Hint: Scope methods start with 'scope' and take $query param [OK]

Common Mistakes:

• Omitting $query parameter
• Using underscore in method name
• Not prefixing method with 'scope'

3. Given this scope in a Laravel model:

public function scopePopular($query) {
    return $query->where('votes', '>', 100);
}

What will User::popular()->get() return?

medium

A. All users regardless of votes

B. All users with votes less than or equal to 100

C. All users with votes greater than 100

D. Syntax error because scope is missing

Solution

1. Step 1: Understand the scope condition

   The scope filters users where 'votes' is greater than 100.

2. Step 2: Analyze the query call

   Calling User::popular()->get() applies the scope and returns matching users.

3. Final Answer:

   All users with votes greater than 100 -> Option C

4. Quick Check:

   Scope filters votes > 100 = users returned [OK]

Hint: Scope filters queries; check condition carefully [OK]

Common Mistakes:

• Confusing greater than with less than
• Assuming scope returns all records
• Thinking scope causes syntax error

4. Identify the error in this scope definition:

public function scopeRecent() {
    return $this->orderBy('created_at', 'desc');
}

medium

A. Missing $query parameter in the scope method

B. Incorrect method name, should not start with 'scope'

C. Using orderBy inside scope is not allowed

D. Missing return type declaration

Solution

1. Step 1: Check scope method signature

   Scope methods must accept $query as the first parameter to modify the query.

2. Step 2: Identify missing parameter

   The method lacks the $query parameter, so it cannot modify the query builder.

3. Final Answer:

   Missing $query parameter in the scope method -> Option A

4. Quick Check:

   Scope method needs $query param [OK]

Hint: Scope methods always need $query parameter [OK]

Common Mistakes:

• Forgetting $query parameter
• Thinking orderBy is disallowed in scopes
• Confusing method naming rules

5. You want to create a reusable scope activeAndRecent that returns users who are active and created within the last 30 days. Which of the following scope definitions is correct?

hard

A. public function scopeActiveAndRecent($query) {
return $query->where('status', 'active')
->orWhere('created_at', '>=', now()->subDays(30));
}

B. public function scopeActiveAndRecent($query) {
return $query->where('status', 'active')
->where('created_at', '>=', now()->subDays(30));
}

C. public function scopeActiveAndRecent() {
return $this->where('status', 'active')
->where('created_at', '>=', now()->subDays(30));
}

D. public function activeAndRecent($query) {
return $query->where('status', 'active')
->where('created_at', '>=', now()->subDays(30));
}

Solution

1. Step 1: Verify method signature and parameters

   The scope method must be named with 'scope' prefix and accept $query parameter.

2. Step 2: Check query conditions logic

   Use 'where' twice to combine conditions with AND logic for active status and recent date.

3. Step 3: Compare options

   public function scopeActiveAndRecent($query) { return $query->where('status', 'active') ->where('created_at', '>=', now()->subDays(30)); } correctly uses 'scopeActiveAndRecent($query)' and combines conditions with 'where'.

4. Final Answer:

   public function scopeActiveAndRecent($query) { return $query->where('status', 'active') ->where('created_at', '>=', now()->subDays(30)); } -> Option B

5. Quick Check:

   Scope with $query and AND conditions = public function scopeActiveAndRecent($query) { return $query->where('status', 'active') ->where('created_at', '>=', now()->subDays(30)); } [OK]

Hint: Use 'where' twice for AND, scope method needs $query [OK]

Common Mistakes:

• Using orWhere instead of where for AND logic
• Omitting $query parameter
• Not prefixing method with 'scope'