ActiveRecord exists? and blank? under the hood.

When should I use exists? or blank? to check records existence? Does this choice has an impact on our application?

Asking those questions is a good sign of curiosity! So we will see together how those methods work under the hood and without a long introduction let’s unpack ActiveRecord and dive deep into the source code.

Putting exists? under the scope:

Let’s try to call exists? on a Post model:

Post.all.exists?

We will notice this output line in the console:

Post Exists (0.4ms) SELECT 1 AS one FROM "posts" LIMIT ? [["LIMIT", 1]]

So let’s try to see the code behind it to understand how it works, I tried to share only the relevant snippets of code, for reference please visit this file for ActiveRecord 5.2

# lib/active_record/relation/finder_methods.rb

module ActiveRecord
  module FinderMethods
    ONE_AS_ONE = "1 AS one"
 
    def exists?(conditions = :none)
      # conditions verification
      ....

      # in case of eager loading
      ....

      relation = construct_relation_for_exists(conditions)
      
      # name method returns the model name which is used to build
      # the log output for the query.
      # In our examlpe it will be "Post"
      skip_query_cache_if_necessary { connection.select_value(relation.arel, "#{name} Exists") } ? true : false
    rescue ::RangeError
      false
    end

    # This method is responsible for constructing the Exist query that we can see in logs
    # exp: SELECT 1 AS one FROM "posts" LIMIT ? [["LIMIT", 1]]
    #
    def construct_relation_for_exists(conditions)
      relation = except(:select, :distinct, :order)._select!(ONE_AS_ONE).limit!(1)

      case conditions
      when Array, Hash
        relation.where!(conditions)
      else
        relation.where!(primary_key => conditions) unless conditions == :none
      end

      relation
    end
  end
end

and we need to check select_value method to get the complete picture:

# lib/active_record/connection_adapters/abstract/database_statements.rb

module ActiveRecord
  module ConnectionAdapters # :nodoc:
    module DatabaseStatements

      # Returns a single value from a record
      def select_value(arel, name = nil, binds = [])
        single_value_from_rows(select_rows(arel, name, binds))
      end

      def single_value_from_rows(rows)
        row = rows.first
        row && row.first
      end

    end
  end
end

Now we can understand how ActiveRecord is building the exists? query. We can also see that the query check whether there is a row or not  overlook columns by using:

SELECT  1 AS one FROM "posts" LIMIT ?  [["LIMIT", 1]]

There are different discussions and opinions about this query, but for us, it’s important to know that this check doesn’t instantiate records and perform the check by confirming the existence of a row in our model table.

Putting blank? under the scope:

The reference source code for the simplified snippet below can be found here.

# lib/active_record/relation.rb

module ActiveRecord
  class Relation

    alias :loaded? :loaded

    def initialize(args)
      .....
      @loaded = false
      ....
    end

    def blank?
      records.blank?
    end

    def records # :nodoc:
      load
      @records
    end

    # Causes the records to be loaded from the database if they have not
    # been loaded already. You can use this if for some reason you need
    # to explicitly load some records before actually using them. The
    # return value is the relation itself, not the records.
    #
    #   Post.where(published: true).load # => #<ActiveRecord::Relation>
    def load(&block)
      exec_queries(&block) unless loaded?

      self
    end

    def exec_queries(&block)

        skip_query_cache_if_necessary do
          # We care mostly about this part where records are built
          @records =
            if eager_loading?
              apply_join_dependency do |relation, join_dependency|
                if ActiveRecord::NullRelation === relation
                  []
                else
                  rows = connection.select_all(relation.arel, "SQL")
                  join_dependency.instantiate(rows, &block) # <== Records instantiation
                end.freeze
              end
            else
              klass.find_by_sql(arel, &block).freeze
            end
          
          # preload associations
          ....

          @records.each(&:readonly!) if readonly_value

          # Note the update of the variable loaded to true
          @loaded = true
          @records
        end
      end


   end
end

and the code for find_by_sql method:

# lib/active_record/querying.rb

module ActiveRecord
  module Querying
    def find_by_sql(sql, binds = [], preparable: nil, &block)
      result_set = connection.select_all(sanitize_sql(sql), "#{name} Load", binds, preparable: preparable)
      column_types = result_set.column_types.dup
      columns_hash.each_key { |k| column_types.delete k }
      message_bus = ActiveSupport::Notifications.instrumenter

      payload = {
        record_count: result_set.length,
        class_name: name
      }

      message_bus.instrument("instantiation.active_record", payload) do
        # Instantiation of records
        result_set.map { |record| instantiate(record, column_types, &block) }
      end
    end
  end
end

We checked together how blank? method loads records to perform this check. But before saying that we should always use exists? let’s step back and analyze the shared code. I suggest checking the load method again, it loads the records from the database only if they haven’t been loaded already.

That comment is very important to grasp. For example, if we are performing an existence check on records that we need as part of the application logic then we should use blank? which results in hitting the database once for the select query. But if we opted for exists? we will end up by hitting the database twice, the first query to perform the check and the second one to fetch the data.

Conclusion

Inspecting the source code of those methods was a good exercise to improve our knowledge and understand how the framework is working under the hood.

We should remember these two points:

  • Use blank? if you need to use the records in the application logic.
  • Prefer exists? if you care only about the existence check.

That’s it, so have fun and keep coding 🙂


© 2017-2019 Marouen Bousnina. All rights reserved.

Powered by Hydejack v8.5.2