module ActiveRecord::Querying

def _load_from_sql(result_set, &block) # :nodoc:

:nodoc: 
def _load_from_sql(result_set, &block) # :nodoc:
  column_types = result_set.column_types
  unless column_types.empty?
    column_types = column_types.reject { |k, _| attribute_types.key?(k) }
  end
  message_bus = ActiveSupport::Notifications.instrumenter
  payload = {
    record_count: result_set.length,
    class_name: name
  }
  message_bus.instrument("instantiation.active_record", payload) do
    if result_set.includes_column?(inheritance_column)
      result_set.map { |record| instantiate(record, column_types, &block) }
    else
      # Instantiate a homogeneous set
      result_set.map { |record| instantiate_instance_of(self, record, column_types, &block) }
    end
  end
end

def _query_by_sql(sql, binds = [], preparable: nil, async: false) # :nodoc:

:nodoc: 
def _query_by_sql(sql, binds = [], preparable: nil, async: false) # :nodoc:
  connection.select_all(sanitize_sql(sql), "#{name} Load", binds, preparable: preparable, async: async)
end

def count_by_sql(sql)

* +sql+ - An SQL statement which should return a count query from the database, see the example above.

==== Parameters

# => 12
Product.count_by_sql "SELECT COUNT(*) FROM sales s, customers c WHERE s.customer_id = c.id"

database engines.
as it could lock you into a specific database engine or require a code change to switch
using the ActiveRecord::Calculations class methods. Look into those before using this method,
The use of this method should be restricted to complicated SQL queries that can't be executed
Returns the result of an SQL statement that should only include a COUNT(*) in the SELECT part. 
def count_by_sql(sql)
  connection.select_value(sanitize_sql(sql), "#{name} Count").to_i
end

def find_by_sql(sql, binds = [], preparable: nil, &block)

injection attacks (https://guides.rubyonrails.org/security.html#sql-injection).
Note that building your own SQL query string from user input may expose your application to

Post.find_by_sql ["SELECT body FROM comments WHERE author = :user_id OR approved_by = :user_id", { :user_id => user_id }]
Post.find_by_sql ["SELECT title FROM posts WHERE author = ? AND created > ?", author_id, start_date]

You can use the same string replacement techniques as you can with ActiveRecord::QueryMethods#where :

# => [#"Ruby Meetup", "author"=>"Quentin"}>, ...]
Post.find_by_sql "SELECT p.title, c.author FROM posts p, comments c WHERE p.id = c.post_id"
# A simple SQL query spanning multiple tables

change your call if you switch engines.
database-specific terms will lock you into using that particular database engine, or require you to
no database agnostic conversions performed. This should be a last resort because using
The +sql+ parameter is a full SQL query as a string. It will be called as is; there will be

table.
SELECT will be attributes of the model, whether or not they are columns of the corresponding
If you call a complicated SQL query which spans multiple tables, the columns specified by the

a +Product+ object with the attributes you specified in the SQL query.
this method from. For example, if you call Product.find_by_sql, then the results will be returned in
be returned as an array, with the requested columns encapsulated as attributes of the model you call
Executes a custom SQL query against your database and returns all the results. The results will 
def find_by_sql(sql, binds = [], preparable: nil, &block)
  _load_from_sql(_query_by_sql(sql, binds, preparable: preparable), &block)
end