Scopes for reusable queries in Ruby on Rails - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define a scope named active that returns only active users.

Ruby on Rails

scope :active, -> { where(status: [1]) }

Drag options to blanks, or click blank then click option'

Aactive

B:active

C"active"

Dtrue

Attempts:

3 left

💡 Hint

Common Mistakes

Using a symbol instead of a string for the status value.

Leaving out quotes causing a NameError.

The scope uses where with the status set to the string "active" to filter active users.

2fill in blank

medium

Complete the code to define a scope named recent that returns users created in the last 7 days.

Ruby on Rails

scope :recent, -> { where('created_at >= ?', [1]) }

Drag options to blanks, or click blank then click option'

A7.days.ago

BTime.current + 7.days

CDate.today - 7

DTime.now - 7.days

Attempts:

3 left

💡 Hint

Common Mistakes

Using Time.now - 7.days which works but is less idiomatic.

Using a future date like Time.current + 7.days.

The scope uses 7.days.ago to get the timestamp 7 days before now, filtering recent users.

3fill in blank

hard

Fix the error in the scope that filters users by minimum age.

Ruby on Rails

scope :min_age, ->(age) { where('age >= [1]', age) }

Drag options to blanks, or click blank then click option'

A:age

B?

C$1

Dage

Attempts:

3 left

💡 Hint

Common Mistakes

Using the variable name directly inside the SQL string.

Using symbols or numbered placeholders which are not supported here.

The SQL query uses a question mark ? as a placeholder for the parameter age.

4fill in blank

hard

Fill both blanks to define a scope by_role that filters users by a given role.

Ruby on Rails

scope :by_role, ->(role) { where([1]: [2]) }

Drag options to blanks, or click blank then click option'

A:role

Brole

C:status

Dstatus

Attempts:

3 left

💡 Hint

Common Mistakes

Using the wrong key like :status instead of :role.

Using the symbol :role as the value instead of the variable role.

The scope uses a hash with the key :role and the value from the parameter role to filter users by role.

5fill in blank

hard

Fill all three blanks to define a scope search_by_name that finds users with names containing a search term, case-insensitive.

Ruby on Rails

scope :search_by_name, ->(term) { where("LOWER(name) [1] LOWER([2])", [3]) }

Drag options to blanks, or click blank then click option'

ALIKE

Bterm

C'%' || ? || '%'

DILIKE

Attempts:

3 left

💡 Hint

Common Mistakes

Using ILIKE which is PostgreSQL specific and not always supported.

Not using LOWER to make the search case-insensitive.

Passing the term directly without wildcards.

The scope uses SQL LIKE with LOWER(name) and a pattern built by concatenating '%' before and after the search term to find matching names case-insensitively.

Practice

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

easy

A. To define database table columns

B. To write controller actions

C. To create new database tables

D. To reuse common database queries easily

Solution

1. Step 1: Understand what scopes do

   Scopes are defined in models to encapsulate common queries for reuse.

2. Step 2: Identify the correct purpose

   They help avoid repeating query code by providing reusable query methods.

3. Final Answer:

   To reuse common database queries easily -> Option D

4. Quick Check:

   Scopes = reusable queries [OK]

Hint: Scopes are for reusable queries inside models [OK]

Common Mistakes:

• Confusing scopes with database schema definitions
• Thinking scopes create tables or columns
• Mixing scopes with controller logic

2. Which of the following is the correct syntax to define a scope named active that selects records with status: 'active'?

easy

A. scope :active, -> { where(status: 'active') }

B. scope active: where(status: 'active')

C. def scope :active; where(status: 'active'); end

D. scope :active { where(status: 'active') }

Solution

1. Step 1: Recall scope syntax

   Scopes use the syntax: scope :name, -> { query }.

2. Step 2: Match the correct option

   scope :active, -> { where(status: 'active') } matches this syntax exactly with a lambda returning the query.

3. Final Answer:

   scope :active, -> { where(status: 'active') } -> Option A

4. Quick Check:

   Scope syntax = scope :name, -> { ... } [OK]

Hint: Use lambda with -> { ... } for scope queries [OK]

Common Mistakes:

• Omitting the lambda syntax -> { ... }
• Using incorrect method definitions for scopes
• Missing colon before scope name

3. Given the following scopes in a Rails model:

scope :published, -> { where(published: true) }
scope :recent, -> { order(created_at: :desc) }

What will Article.published.recent.to_sql return?

medium

A. SELECT * FROM "articles" WHERE "articles"."published" = FALSE ORDER BY "articles"."created_at" ASC

B. SELECT * FROM "articles" ORDER BY "articles"."created_at" DESC WHERE "articles"."published" = TRUE

C. SELECT * FROM "articles" WHERE "articles"."published" = TRUE ORDER BY "articles"."created_at" DESC

D. SELECT * FROM "articles" WHERE "articles"."published" = TRUE

Solution

1. Step 1: Understand scope chaining

   Chaining scopes combines their queries in order: published adds a WHERE clause, recent adds ORDER BY.

2. Step 2: Analyze the SQL generated

   The SQL will filter published = true and order by created_at descending.

3. Final Answer:

   SELECT * FROM "articles" WHERE "articles"."published" = TRUE ORDER BY "articles"."created_at" DESC -> Option C

4. Quick Check:

   Chained scopes combine WHERE and ORDER BY [OK]

Hint: Chained scopes combine queries in order [OK]

Common Mistakes:

• Placing ORDER BY before WHERE in SQL
• Confusing true/false values in conditions
• Ignoring scope chaining order

4. Identify the error in this scope definition:

scope :recent, { order(created_at: :desc) }

medium

A. Missing lambda syntax -> { ... } around the query

B. Incorrect scope name format

C. Using order instead of where

D. Scope must be defined in controller, not model

Solution

1. Step 1: Check scope syntax requirements

   Scopes require a lambda (-> { ... }) to wrap the query for lazy evaluation.

2. Step 2: Identify missing lambda

   The given scope uses curly braces without the lambda arrow, causing a syntax error.

3. Final Answer:

   Missing lambda syntax -> { ... } around the query -> Option A

4. Quick Check:

   Scopes need -> { ... } [OK]

Hint: Always wrap scope queries in -> { ... } [OK]

Common Mistakes:

• Omitting the lambda arrow ->
• Defining scopes outside models
• Confusing order and where methods

5. You want to create a scope recent_active that returns records which are both active: true and created in the last 7 days. Which is the correct way to define this scope?

hard

A. scope :recent_active, -> { where(active: true).order('created_at >= 7.days.ago') }

B. scope :recent_active, -> { where(active: true).where('created_at >= ?', 7.days.ago) }

C. scope :recent_active, -> { where(active: true && created_at >= 7.days.ago) }

D. scope :recent_active, -> { where(active: true).where(created_at: 7.days.ago) }

Solution

1. Step 1: Combine conditions with where

   Use chained where calls to combine multiple conditions logically ANDed.

2. Step 2: Use correct date comparison syntax

   Use a SQL fragment with placeholder and 7.days.ago to compare dates properly.

3. Final Answer:

   scope :recent_active, -> { where(active: true).where('created_at >= ?', 7.days.ago) } -> Option B

4. Quick Check:

   Chain where with SQL and placeholders [OK]

Hint: Chain where with SQL and placeholders for complex conditions [OK]

Common Mistakes:

• Using && inside where hash instead of chaining
• Using order for filtering conditions
• Comparing created_at with exact date instead of range