Scopes for reusable queries in Ruby on Rails - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a scope in Rails?

A scope is a way to define reusable, named queries in a Rails model. It helps keep code clean by grouping common query logic.

beginner

How do you define a simple scope in a Rails model?

Use the scope method with a name and a lambda. Example:
scope :active, -> { where(active: true) }

beginner

Why use scopes instead of repeating query code?

Scopes make code easier to read, maintain, and reuse. They avoid repeating the same query logic in many places.

intermediate

Can scopes accept parameters? How?

Yes. You can pass parameters to scopes by using lambdas with arguments. Example:
scope :created_after, ->(date) { where('created_at > ?', date) }

intermediate

How do scopes chain together in Rails?

Scopes return ActiveRecord relations, so you can chain them like methods. Example:
User.active.created_after(Date.today) runs both queries together.

What does a Rails scope return?

A A SQL string

B An ActiveRecord relation

C A plain Ruby array

D A controller action

Scopes return ActiveRecord relations, allowing further chaining and lazy loading.

How do you define a scope named 'recent' that returns records created in the last 7 days?

A scope :recent, -> { where('created_at >= ?', 7.days.ago) }

B def recent; where('created_at >= ?', 7.days.ago); end

C scope recent = where('created_at >= ?', 7.days.ago)

D scope :recent { where('created_at >= ?', 7.days.ago) }

The correct syntax uses scope :name, -> { ... } with a lambda.

Which is a benefit of using scopes?

A They speed up the database

B They replace migrations

C They make queries reusable and readable

D They handle user authentication

Scopes help reuse query logic and improve code clarity.

Can you chain multiple scopes in Rails?

A Yes, scopes return relations that can be chained

B No, scopes must be called separately

C Only if they have no parameters

D Only inside controllers

Scopes return ActiveRecord relations, so chaining is supported.

How do you pass a parameter to a scope?

A Parameters are not supported in scopes

B Define a method instead of a scope

C Use a global variable inside the scope

D Use a lambda with an argument, e.g., <code>scope :by_status, ->(status) { where(status: status) }</code>

Scopes can accept parameters by defining lambdas with arguments.

Explain what a scope is in Rails and why it is useful.

Think about how you can avoid repeating the same query code.

Describe how to define a scope that accepts a parameter and how to use it.

Remember scopes are like methods that return queries.

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