Prefer returning chainable ActiveRecord objects
Tags: ruby, rails, webdev
Published: 2021-03-18 14:06:02

---
title: Prefer returning chainable ActiveRecord objects
published: true
date: 2021-03-18 13:00:00 UTC
tags: ruby,rails,webdev
canonical_url: https://boringrails.com/tips/chainable-activerecord-queries
---

One of the best parts about ActiveRecord is the chainable query interface:

```ruby
Post.includes(:comments)
  .where(published: true)
  .where(author: Current.user)
  .order(:name)
```

To take advantage of this strength and give you flexibility in your code, always try to return chainable objects when querying data.

## Usage

It’s common to extract complex queries as your application grows.

```ruby
class SpecialOffer

  def self.find_eligible_products(store, shopper)
    return [] if store.restricted?

    store.products
      .where('price >= ?', 100)
      .select{ |p| shopper.can_order?(p) }
  end
end

@products = SpecialOffer.find_eligible_products(store, shopper)
#=> [#<Product:0x00007fb1719b7ec0>, #<Product:0x00007fb174744de8>, ...]
```

While this code may work, what happens if you need to order the `@products` in a certain way? Or add additional logic? Or lazy-load some associations?

In this case, the return type of our `SpecialOffer` method are arrays. We would have to switch to using Ruby array methods like `sort` and `select` and maybe accidentally introduce an N+1 bug if we need more data.

Let’s refactor this code to make it return chainable objects.

```ruby
class SpecialOffer

  def self.find_eligible_products(store, shopper)
    return Product.none if store.restricted?

    product_ids = store.products
      .where('price >= ?', 100)
      .select{ |p| shopper.can_order?(p) }
      .map(&:id)

    Product.where(id: product_ids)
  end
end

@products = SpecialOffer.find_eligible_products(store, shopper)
#=> Product::ActiveRecord_Relation
```

First, we make use of the `none` query method: this returns an empty (but still chainable!) result. You can call ActiveRecord methods like `order`, `includes`, or `where` on this empty relation and it will simply return no results.

Second, instead of returning the result of our complex product query directly, we collect up the right products and then return “fresh” results for just those `id`s. While this does incur an additional database query, we can also manipulate the results as needed.

If we want to sort the results or load an association, we can do it in the database and not be worried about any existing conditions that were run as part of the computations.

```ruby
@products = SpecialOffer.find_eligible_products(store, shopper)
  .includes(:variants)
  .order(:price)

@products = SpecialOffer.find_eligible_products(store, shopper)
  .joins(:sales)
  .where("sales.count > 15")
  .order(:sku)
```

I’ve found this pattern to be extremely helpful for pulling out complex queries, while still maintaining flexibility to massage the data into the correct shape.

## Additional Resources

Rails API: [ActiveRecord::QueryMethods#none](https://api.rubyonrails.org/classes/ActiveRecord/QueryMethods.html#method-i-none)

Rails Docs: [Active Record Query Interface](https://guides.rubyonrails.org/active_record_querying.html)

* * *
[![](https://boringrails.com/images/twitter-banner.png)](https://twitter.com/_swanson)