Mastering the Select Method in Rails: A Comprehensive Guide - Part II


Hey guys, how've you been? It's AC, Alexandre Calaça here. Hope you enjoy this new article.

By the way, I would be glad to receive your feedback about it.


This article Mastering the Select Method in Rails: A Comprehensive Guide - Part II focuses on how to use the Active Record Select method.

I definitely suggest that you check Part I of the article Mastering the Select Method in Rails: A Comprehensive Guide, since it provides an introduction to the Select method.

It's important to remember that the select method can also be used as an Array class method (Array#select).

So, just to make sure we're on the same page, this article is not going to cover how to use the Array#select method.

The Select Method

The select(*fields) public method behaves in two distinct ways: one as an Array class method (Array#select) method, the other one as an ActiveRecord::QueryMethods.

In Rails, the select method is used to retrieve a collection of objects from the database that meet certain conditions specified in the method. This is going to become easier as you read this article.


This information is available in Mastering the Select Method in Rails: A Comprehensive Guide - Part I article.


This information is available in Mastering the Select Method in Rails: A Comprehensive Guide - Part I article.


This information is available in Mastering the Select Method in Rails: A Comprehensive Guide - Part I article.

Russian blue cat wearing yellow sunglasses

The Select Method (Advanced topics)

Method chaining

Method chaining is a technique in object-oriented programming where multiple methods are called on an object in a single statement by chaining them together with dots.

In other words, the return value of one method is used as the receiver of the next method call, allowing a sequence of operations to be performed on the object in a concise and readable way.

Most recent programming languages use dots in order to chain methods.

This is an example

articles = Article.where(published: true).order(created_at: :desc).select(:title, :body)

The previous code is divided into 3 parts:

  • Article.where(published: true) - It specifies the conditions that should be met by the records being selected in the Article model. In this case, it is selecting only articles that have been published.

  • .order(created_at: :desc) - Based on the previous result, it orders the selected records by their creation date, with the most recent ones appearing first.

  • .select(:title, :body) - Based on the previous result, it specifies which attributes of the selected records should be returned. In this case, only the title and body attributes will be returned.

We might deep dive into this topic in another article.

Common errors


ArgumentError can be raised if the arguments passed to the select method are not in the correct format.

For instance, in Rails 3, if you pass multiple arguments without wrapping them in an array, you might see an error like "wrong number of arguments (given 2, expected 0..1)". In Rails 4 and above, this error is not applied.

A common example is the following.

Let's suppose you have a Product model with name, description, and price attributes.

Let's say you want to select name and price attributes for all products where the price is greater than or equal to a certain value."name, price").where("price >= ?", min_price)

However, this will raise an ArgumentError if min_price is nil or not a valid value.


The ActiveRecord::StatementInvalid error can be raised when there is a problem with the SQL query that is generated by the select method. For instance, in case you try to select a column that does not exist in the database table, you might see an error like "PG::UndefinedColumn: ERROR: column "foo" does not exist". The exact error message may vary on the database you're using.

In Rails 3, this error message does not occur with the select method. A nil ActiveRecord relation is returned instead.

In Rails 4 and later versions, ActiveRecord raises an ActiveRecord::StatementInvalid error when selecting a non-existent column. This characteristic was added to the new Rails versions in order to improve consistency with other ActiveRecord query methods that raise an error when encountering an invalid query condition, such as where, joins and so on.


This error can be raised in 2 different ways. One way is if you try to call a method on the result of a select method that is not available on an Active Record relation.

You'll get this error if you run the following code:'type').loop

The previous code raises an error because the loop method is not valid in ActiveRecord. The loop method is a method on Ruby's Enumerator class, which is used to iterate over a collection repeatedly.

Let's move on.

Another way is if you call the select method in an object that does not respond to it. You'll get this error if you run the following code:


The code "string".select(:type) generates a NoMethodError because the select method is not defined on the String class in Ruby.

The select method is a method provided by the ActiveRecord library in Rails, and it can only be used on ActiveRecord models or ActiveRecord::Relation objects. It is used to specify which columns to select from a database table.

Handling exceptions

There's a possibility of getting a complete list of errors raised by the select method in Rails by wrapping the method call in a begin...rescue block. The result (error message) can be printed to the console or returned to the user interface. Here's an example:

begin"type", "status")
rescue => e
  puts "Error: #{e.message}"

This code block is an example of how to rescue an exception that might be raised by the select method in ActiveRecord.

The begin and rescue keywords are used to wrap a block of code that might raise an exception, and then handle that exception if it is raised.

In this case, the block of code is"type", "status"), which might raise an ActiveRecord::StatementInvalid exception if the query is invalid, such as selecting a non-existent column.

The rescue => e part specifies that any exception that is caught will be stored in the e variable, which can then be used to access information about the exception, such as the error message.

The puts method is then used to output an error message to the console, which will contain the error message from the caught exception. Anything could be used to output the error message, such as appending it to a file.

This code block is useful for debugging and handling exceptions in ActiveRecord queries, and can be modified to handle different types of exceptions and error messages as needed.


In this article, we practiced an important characteristic of object-oriented programming, which is method chaining.

In order to understand more about the Select method, we reviewed the most common errors.

We also learned how to handle exceptions.


Way to go! Time to celebrate because you read the article. Way to go! you did a great job.


That's all for today. Thanks for reading the article Mastering the Select Method in Rails: A Comprehensive Guide - Part II.

I hope this article helped you. Let me know if you have any questions.

Your thoughts, suggestions and corrections are more than welcome.

By the way, feel free to drop your suggestions on new blog articles.

Hope to see you next time.