Module: ActiveRecord::QueryMethods

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 260

def all # :nodoc:
  spawn
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 1135

def and(other)
  if other.is_a?(Relation)
    spawn.and!(other)
  else
    raise ArgumentError, "You have passed #{other.class.name} object to #and. Pass an ActiveRecord::Relation object instead."
  end
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 1143

def and!(other) # :nodoc:
  incompatible_values = structurally_incompatible_values_for(other)

  unless incompatible_values.empty?
    raise ArgumentError, "Relation passed to #and must be structurally compatible. Incompatible values: #{incompatible_values}"
  end

  self.where_clause |= other.where_clause
  self.having_clause |= other.having_clause
  self.references_values |= other.references_values

  self
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 1529

def annotate(*args)
  check_if_method_has_arguments!(__callee__, args)
  spawn.annotate!(*args)
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 1535

def annotate!(*args) # :nodoc:
  self.annotate_values += args
  self
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 1594

def arel(aliases = nil) # :nodoc:
  @arel ||= with_connection { |c| build_arel(c, aliases) }
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 1990

def arel_column(field)
  field = field.name if is_symbol = field.is_a?(Symbol)

  field = model.attribute_aliases[field] || field.to_s
  from = from_clause.name || from_clause.value

  if model.columns_hash.key?(field) && (!from || table_name_matches?(from))
    table[field]
  elsif /\A(?<table>(?:\w\.)?\w)\.(?<column>\w+)\z/ =~ field
    arel_column_with_table(table, column)
  elsif block_given?
    yield field
  elsif Arel.arel_node?(field)
    field
  else
    Arel.sql(is_symbol ? model.adapter_class.quote_table_name(field) : field)
  end
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 2234

def arel_column_aliases_from_hash(fields)
  fields.flat_map do |key, columns_aliases|
    table_name = key.is_a?(Symbol) ? key.name : key
    case columns_aliases
    when Hash
      columns_aliases.map do |column, column_alias|
        arel_column_with_table(table_name, column)
          .as(model.adapter_class.quote_column_name(column_alias.to_s))
      end
    when Array
      columns_aliases.map do |column|
        arel_column_with_table(table_name, column)
      end
    when String, Symbol
      arel_column(key)
        .as(model.adapter_class.quote_column_name(columns_aliases.to_s))
    end
  end
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 1978

def arel_column_with_table(table_name, column_name)
  self.references_values |= [Arel.sql(table_name, retryable: true)]

  if column_name.is_a?(Symbol) || !column_name.match?(/\W/)
    predicate_builder.resolve_arel_attribute(table_name, column_name) do
      lookup_table_klass_from_join_dependencies(table_name)
    end
  else
    Arel.sql("#{model.adapter_class.quote_table_name(table_name)}.#{column_name}")
  end
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 1662

def arel_columns(columns)
  columns.flat_map do |field|
    case field
    when Symbol, String
      arel_column(field)
    when Proc
      field.call
    when Hash
      arel_columns_from_hash(field)
    else
      field
    end
  end
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 1962

def arel_columns_from_hash(fields)
  fields.flat_map do |table_name, columns|
    table_name = table_name.name if table_name.is_a?(Symbol)
    case columns
    when Symbol, String
      arel_column_with_table(table_name, columns)
    when Array
      columns.map do |column|
        arel_column_with_table(table_name, column)
      end
    else
      raise TypeError, "Expected Symbol, String or Array, got: #{columns.class}"
    end
  end
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 1746

def assert_modifiable!
  raise UnmodifiableRelation if @loaded || @arel
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 1678

def async
  spawn.async!
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 1656

def async!
  @async = true
  self
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 1750

def build_arel(connection, aliases = nil)
  arel = Arel::SelectManager.new(table)

  build_joins(arel.join_sources, aliases)

  arel.where(where_clause.ast) unless where_clause.empty?
  arel.having(having_clause.ast) unless having_clause.empty?
  arel.take(build_cast_value("LIMIT", connection.sanitize_limit(limit_value))) if limit_value
  arel.skip(build_cast_value("OFFSET", offset_value.to_i)) if offset_value
  arel.group(*arel_columns(group_values.uniq)) unless group_values.empty?

  build_order(arel)
  build_with(arel)
  build_select(arel)

  arel.optimizer_hints(*optimizer_hints_values) unless optimizer_hints_values.empty?
  arel.distinct(distinct_value)
  arel.from(build_from) unless from_clause.empty?
  arel.lock(lock_value) if lock_value

  unless annotate_values.empty?
    annotates = annotate_values
    annotates = annotates.uniq if annotates.size > 1
    arel.comment(*annotates)
  end

  arel
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 1702

def build_bound_sql_literal(statement, values)
  bound_values = values.map do |value|
    if ActiveRecord::Relation === value
      Arel.sql(value.to_sql)
    elsif value.respond_to?(:map) && !value.acts_like?(:string)
      values = value.map { |v| v.respond_to?(:id_for_database) ? v.id_for_database : v }
      values.empty? ? nil : values
    else
      value = value.id_for_database if value.respond_to?(:id_for_database)
      value
    end
  end

  begin
    Arel::Nodes::BoundSqlLiteral.new("(#{statement})", bound_values, nil)
  rescue Arel::BindError => error
    raise ActiveRecord::PreparedStatementInvalid, error.message
  end
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 2163

def build_case_for_value_position(column, values, filter: true)
  node = Arel::Nodes::Case.new
  values.each.with_index(1) do |value, order|
    node.when(column.eq(value)).then(order)
  end

  node = node.else(values.length + 1) unless filter
  Arel::Nodes::Ascending.new(node)
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 1779

def build_cast_value(name, value)
  ActiveModel::Attribute.with_cast_value(name, value, Type.default_value)
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 1783

def build_from
  opts = from_clause.value
  name = from_clause.name
  case opts
  when Relation
    if opts.eager_loading?
      opts = opts.send(:apply_join_dependency)
    end
    name ||= "subquery"
    opts.arel.as(name.to_s)
  else
    opts
  end
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 1654

alias :build_having_clause :build_where_clause

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 1825

def build_join_buckets
  buckets = Hash.new { |h, k| h[k] = [] }

  unless left_outer_joins_values.empty?
    stashed_left_joins = []
    left_joins = select_named_joins(left_outer_joins_values, stashed_left_joins) do |left_join|
      if left_join.is_a?(CTEJoin)
        buckets[:join_node] << build_with_join_node(left_join.name, Arel::Nodes::OuterJoin)
      else
        raise ArgumentError, "only Hash, Symbol and Array are allowed"
      end
    end

    if joins_values.empty?
      buckets[:named_join] = left_joins
      buckets[:stashed_join] = stashed_left_joins
      return buckets, Arel::Nodes::OuterJoin
    else
      stashed_left_joins.unshift construct_join_dependency(left_joins, Arel::Nodes::OuterJoin)
    end
  end

  joins = joins_values.dup
  if joins.last.is_a?(ActiveRecord::Associations::JoinDependency)
    stashed_eager_load = joins.pop if joins.last.base_klass == model
  end

  joins.each_with_index do |join, i|
    joins[i] = Arel::Nodes::StringJoin.new(Arel.sql(join.strip)) if join.is_a?(String)
  end

  while joins.first.is_a?(Arel::Nodes::Join)
    join_node = joins.shift
    if !join_node.is_a?(Arel::Nodes::LeadingJoin) && (stashed_eager_load || stashed_left_joins)
      buckets[:join_node] << join_node
    else
      buckets[:leading_join] << join_node
    end
  end

  buckets[:named_join] = select_named_joins(joins, buckets[:stashed_join]) do |join|
    if join.is_a?(Arel::Nodes::Join)
      buckets[:join_node] << join
    elsif join.is_a?(CTEJoin)
      buckets[:join_node] << build_with_join_node(join.name)
    else
      raise "unknown class: %s" % join.class.name
    end
  end

  buckets[:stashed_join].concat stashed_left_joins if stashed_left_joins
  buckets[:stashed_join] << stashed_eager_load if stashed_eager_load

  return buckets, Arel::Nodes::InnerJoin
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 1735

def build_join_dependencies
  joins = joins_values | left_outer_joins_values
  joins |= eager_load_values unless eager_load_values.empty?
  joins |= includes_values unless includes_values.empty?

  join_dependencies = []
  join_dependencies.unshift construct_join_dependency(
    select_named_joins(joins, join_dependencies), nil
  )
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 1881

def build_joins(join_sources, aliases = nil)
  return join_sources if joins_values.empty? && left_outer_joins_values.empty?

  buckets, join_type = build_join_buckets

  named_joins   = buckets[:named_join]
  stashed_joins = buckets[:stashed_join]
  leading_joins = buckets[:leading_join]
  join_nodes    = buckets[:join_node]

  join_sources.concat(leading_joins) unless leading_joins.empty?

  unless named_joins.empty? && stashed_joins.empty?
    alias_tracker = alias_tracker(leading_joins + join_nodes, aliases)
    join_dependency = construct_join_dependency(named_joins, join_type)
    join_sources.concat(join_dependency.join_constraints(stashed_joins, alias_tracker, references_values))
  end

  join_sources.concat(join_nodes) unless join_nodes.empty?
  join_sources
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 1682

def build_named_bound_sql_literal(statement, values)
  bound_values = values.transform_values do |value|
    if ActiveRecord::Relation === value
      Arel.sql(value.to_sql)
    elsif value.respond_to?(:map) && !value.acts_like?(:string)
      values = value.map { |v| v.respond_to?(:id_for_database) ? v.id_for_database : v }
      values.empty? ? nil : values
    else
      value = value.id_for_database if value.respond_to?(:id_for_database)
      value
    end
  end

  begin
    Arel::Nodes::BoundSqlLiteral.new("(#{statement})", nil, bound_values)
  rescue Arel::BindError => error
    raise ActiveRecord::PreparedStatementInvalid, error.message
  end
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 2055

def build_order(arel)
  orders = order_values.compact_blank
  arel.order(*orders) unless orders.empty?
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 1903

def build_select(arel)
  if select_values.any?
    arel.project(*arel_columns(select_values))
  elsif model.ignored_columns.any? || model.enumerate_columns_in_select_statements
    arel.project(*model.column_names.map { |field| table[field] })
  else
    arel.project(table[Arel.star])
  end
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 1605

def build_subquery(subquery_alias, select_value) # :nodoc:
  subquery = except(:optimizer_hints).arel.as(subquery_alias)

  Arel::SelectManager.new(subquery).project(select_value).tap do |arel|
    arel.optimizer_hints(*optimizer_hints_values) unless optimizer_hints_values.empty?
  end
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 1613

def build_where_clause(opts, rest = []) # :nodoc:
  opts = sanitize_forbidden_attributes(opts)

  if opts.is_a?(Array)
    opts, *rest = opts
  end

  case opts
  when String
    if rest.empty?
      parts = [Arel.sql(opts)]
    elsif rest.first.is_a?(Hash) && /:\w+/.match?(opts)
      parts = [build_named_bound_sql_literal(opts, rest.first)]
    elsif opts.include?("?")
      parts = [build_bound_sql_literal(opts, rest)]
    else
      parts = [model.sanitize_sql(rest.empty? ? opts : [opts, *rest])]
    end
  when Hash
    opts = opts.transform_keys do |key|
      if key.is_a?(Array)
        key.map { |k| model.attribute_aliases[k.to_s] || k.to_s }
      else
        key = key.to_s
        model.attribute_aliases[key] || key
      end
    end
    references = PredicateBuilder.references(opts)
    self.references_values |= references unless references.empty?

    parts = predicate_builder.build_from_hash(opts) do |table_name|
      lookup_table_klass_from_join_dependencies(table_name)
    end
  when Arel::Nodes::Node
    parts = [opts]
  else
    raise ArgumentError, "Unsupported argument type: #{opts} (#{opts.class})"
  end

  Relation::WhereClause.new(parts)
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 1913

def build_with(arel)
  return if with_values.empty?

  with_statements = with_values.map do |with_value|
    build_with_value_from_hash(with_value)
  end

  @with_is_recursive ? arel.with(:recursive, with_statements) : arel.with(with_statements)
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 1929

def build_with_expression_from_value(value, nested = false)
  case value
  when Arel::Nodes::SqlLiteral then Arel::Nodes::Grouping.new(value)
  when ActiveRecord::Relation
    if nested
      value.arel.ast
    else
      value.arel
    end
  when Arel::SelectManager then value
  when Array
    return build_with_expression_from_value(value.first, false) if value.size == 1

    parts = value.map do |query|
      build_with_expression_from_value(query, true)
    end

    parts.reduce do |result, value|
      Arel::Nodes::UnionAll.new(result, value)
    end
  else
    raise ArgumentError, "Unsupported argument type: `#{value}` #{value.class}"
  end
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 1954

def build_with_join_node(name, kind = Arel::Nodes::InnerJoin)
  with_table = Arel::Table.new(name)

  table.join(with_table, kind).on(
    with_table[model.model_name.to_s.foreign_key].eq(table[model.primary_key])
  ).join_sources.first
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 1923

def build_with_value_from_hash(hash)
  hash.map do |name, value|
    Arel::Nodes::TableAlias.new(build_with_expression_from_value(value), name)
  end
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 2213

def check_if_method_has_arguments!(method_name, args, message = nil)
  if args.blank?
    raise ArgumentError, message || "The method .#{method_name}() must contain arguments."
  else
    yield args if block_given?

    args.flatten!
    args.compact_blank!
  end
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 2124

def column_references(order_args)
  order_args.flat_map do |arg|
    case arg
    when String, Symbol
      extract_table_name_from(arg)
    when Hash
      arg
        .map do |key, value|
          case value
          when Hash
            key.to_s
          else
            extract_table_name_from(key) if key.is_a?(String) || key.is_a?(Symbol)
          end
        end
    when Arel::Attribute
      arg.relation.name
    when Arel::Nodes::Ordering
      if arg.expr.is_a?(Arel::Attribute)
        arg.expr.relation.name
      end
    end
  end.filter_map { |ref| Arel.sql(ref, retryable: true) if ref }
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 1598

def construct_join_dependency(associations, join_type) # :nodoc:
  ActiveRecord::Associations::JoinDependency.new(
    model, table, associations, join_type
  )
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 1346

def create_with(value)
  spawn.create_with!(value)
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 1350

def create_with!(value) # :nodoc:
  if value
    value = sanitize_forbidden_attributes(value)
    self.create_with_value = create_with_value.merge(value)
  else
    self.create_with_value = FROZEN_EMPTY_HASH
  end

  self
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 1410

def distinct(value = true)
  spawn.distinct!(value)
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 1415

def distinct!(value = true) # :nodoc:
  self.distinct_value = value
  self
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 2044

def does_not_support_reverse?(order)
  # Account for String subclasses like Arel::Nodes::SqlLiteral that
  # override methods like #count.
  order = String.new(order) unless order.instance_of?(String)

  # Uses SQL function with multiple arguments.
  (order.include?(",") && order.split(",").find { |section| section.count("(") != section.count(")") }) ||
    # Uses "nulls first" like construction.
    /\bnulls\s+(?:first|last)\b/i.match?(order)
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 1729

def each_join_dependencies(join_dependencies = build_join_dependencies, &block)
  join_dependencies.each do |join_dependency|
    join_dependency.each(&block)
  end
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 290

def eager_load(*args)
  check_if_method_has_arguments!(__callee__, args)
  spawn.eager_load!(*args)
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 295

def eager_load!(*args) # :nodoc:
  self.eager_load_values |= args
  self
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 1574

def excluding(*records)
  relations = records.extract! { |element| element.is_a?(Relation) }
  records.flatten!(1)
  records.compact!

  unless records.all?(model) && relations.all? { |relation| relation.model == model }
    raise ArgumentError, "You must only pass a single or collection of #{model.name} objects to ##{__callee__}."
  end

  spawn.excluding!(records + relations.flat_map(&:ids))
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 1587

def excluding!(records) # :nodoc:
  predicates = [ predicate_builder[primary_key, records].invert ]
  self.where_clause += Relation::WhereClause.new(predicates)
  self
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 1456

def extending(*modules, &block)
  if modules.any? || block
    spawn.extending!(*modules, &block)
  else
    self
  end
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 1464

def extending!(*modules, &block) # :nodoc:
  modules << Module.new(&block) if block
  modules.flatten!

  self.extending_values += modules
  extend(*extending_values) if extending_values.any?

  self
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 185

alias extensions extending_values

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 341

def extract_associated(association)
  preload(association).collect(&association)
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 2149

def extract_table_name_from(string)
  string.match(/^\W?(\w+)\W?\./) && $1
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 2077

def flattened_args(args)
  args.flat_map { |e| (e.is_a?(Hash) || e.is_a?(Array)) ? flattened_args(e.to_a) : e }
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 1391

def from(value, subquery_name = nil)
  spawn.from!(value, subquery_name)
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 1395

def from!(value, subquery_name = nil) # :nodoc:
  self.from_clause = Relation::FromClause.new(value, subquery_name)
  self
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 573

def group(*args)
  check_if_method_has_arguments!(__callee__, args)
  spawn.group!(*args)
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 578

def group!(*args) # :nodoc:
  self.group_values += args
  self
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 1197

def having(opts, *rest)
  opts.blank? ? self : spawn.having!(opts, *rest)
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 1201

def having!(opts, *rest) # :nodoc:
  self.having_clause += build_having_clause(opts, rest)
  self
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 717

def in_order_of(column, values, filter: true)
  model.disallow_raw_sql!([column], permit: model.adapter_class.column_name_with_order_matcher)
  return spawn.none! if values.empty?

  references = column_references([column])
  self.references_values |= references unless references.empty?

  values = values.map { |value| model.type_caster.type_cast_for_database(column, value) }
  arel_column = column.is_a?(Arel::Nodes::SqlLiteral) ? column : order_column(column.to_s)

  scope = spawn.order!(build_case_for_value_position(arel_column, values, filter: filter))

  if filter
    where_clause =
      if values.include?(nil)
        arel_column.in(values.compact).or(arel_column.eq(nil))
      else
        arel_column.in(values)
      end

    scope = scope.where!(where_clause)
  end

  scope
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 250

def includes(*args)
  check_if_method_has_arguments!(__callee__, args)
  spawn.includes!(*args)
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 255

def includes!(*args) # :nodoc:
  self.includes_values |= args
  self
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 1101

def invert_where
  spawn.invert_where!
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 1105

def invert_where! # :nodoc:
  self.where_clause = where_clause.invert
  self
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 868

def joins(*args)
  check_if_method_has_arguments!(__callee__, args)
  spawn.joins!(*args)
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 873

def joins!(*args) # :nodoc:
  self.joins_values |= args
  self
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 887

alias :left_joins :left_outer_joins

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 883

def left_outer_joins(*args)
  check_if_method_has_arguments!(__callee__, args)
  spawn.left_outer_joins!(*args)
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 889

def left_outer_joins!(*args) # :nodoc:
  self.left_outer_joins_values |= args
  self
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 1211

def limit(value)
  spawn.limit!(value)
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 1215

def limit!(value) # :nodoc:
  self.limit_value = value
  self
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 1238

def lock(locks = true)
  spawn.lock!(locks)
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 1242

def lock!(locks = true) # :nodoc:
  case locks
  when String, TrueClass, NilClass
    self.lock_value = locks || true
  else
    self.lock_value = false
  end

  self
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 1722

def lookup_table_klass_from_join_dependencies(table_name)
  each_join_dependencies do |join|
    return join.base_klass if table_name == join.table_name
  end
  nil
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 1281

def none
  spawn.none!
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 1285

def none! # :nodoc:
  unless @none
    where!("1=0")
    @none = true
  end
  self
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 1227

def offset(value)
  spawn.offset!(value)
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 1231

def offset!(value) # :nodoc:
  self.offset_value = value
  self
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 1485

def optimizer_hints(*args)
  check_if_method_has_arguments!(__callee__, args)
  spawn.optimizer_hints!(*args)
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 1490

def optimizer_hints!(*args) # :nodoc:
  self.optimizer_hints_values |= args
  self
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 1167

def or(other)
  if other.is_a?(Relation)
    if @none
      other.spawn
    else
      spawn.or!(other)
    end
  else
    raise ArgumentError, "You have passed #{other.class.name} object to #or. Pass an ActiveRecord::Relation object instead."
  end
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 1179

def or!(other) # :nodoc:
  incompatible_values = structurally_incompatible_values_for(other)

  unless incompatible_values.empty?
    raise ArgumentError, "Relation passed to #or must be structurally compatible. Incompatible values: #{incompatible_values}"
  end

  self.where_clause = where_clause.or(other.where_clause)
  self.having_clause = having_clause.or(other.having_clause)
  self.references_values |= other.references_values

  self
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 656

def order(*args)
  check_if_method_has_arguments!(__callee__, args) do
    sanitize_order_arguments(args)
  end
  spawn.order!(*args)
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 664

def order!(*args) # :nodoc:
  preprocess_order_args(args) unless args.empty?
  self.order_values |= args
  self
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 2153

def order_column(field)
  arel_column(field) do |attr_name|
    if attr_name == "count" && !group_values.empty?
      table[attr_name]
    else
      Arel.sql(model.adapter_class.quote_table_name(attr_name), retryable: true)
    end
  end
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 322

def preload(*args)
  check_if_method_has_arguments!(__callee__, args)
  spawn.preload!(*args)
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 327

def preload!(*args) # :nodoc:
  self.preload_values |= args
  self
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 2081

def preprocess_order_args(order_args)
  model.disallow_raw_sql!(
    flattened_args(order_args),
    permit: model.adapter_class.column_name_with_order_matcher
  )

  validate_order_args(order_args)

  references = column_references(order_args)
  self.references_values |= references unless references.empty?

  # if a symbol is given we prepend the quoted table name
  order_args.map! do |arg|
    case arg
    when Symbol
      order_column(arg.to_s).asc
    when Hash
      arg.map do |key, value|
        if value.is_a?(Hash)
          value.map do |field, dir|
            order_column([key.to_s, field.to_s].join(".")).public_send(dir.downcase)
          end
        else
          case key
          when Arel::Nodes::SqlLiteral, Arel::Nodes::Node, Arel::Attribute
            key.public_send(value.downcase)
          else
            order_column(key.to_s).public_send(value.downcase)
          end
        end
      end
    else
      arg
    end
  end.flatten!
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 2224

def process_select_args(fields)
  fields.flat_map do |field|
    if field.is_a?(Hash)
      arel_column_aliases_from_hash(field)
    else
      field
    end
  end
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 2254

def process_with_args(args)
  args.flat_map do |arg|
    raise ArgumentError, "Unsupported argument type: #{arg} #{arg.class}" unless arg.is_a?(Hash)
    arg.map { |k, v| { k => v } }
  end
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 1309

def readonly(value = true)
  spawn.readonly!(value)
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 1313

def readonly!(value = true) # :nodoc:
  self.readonly_value = value
  self
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 355

def references(*table_names)
  check_if_method_has_arguments!(__callee__, table_names)
  spawn.references!(*table_names)
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 360

def references!(*table_names) # :nodoc:
  self.references_values |= table_names
  self
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 593

def regroup(*args)
  check_if_method_has_arguments!(__callee__, args)
  spawn.regroup!(*args)
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 599

def regroup!(*args) # :nodoc:
  self.group_values = args
  self
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 752

def reorder(*args)
  check_if_method_has_arguments!(__callee__, args) do
    sanitize_order_arguments(args)
  end
  spawn.reorder!(*args)
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 760

def reorder!(*args) # :nodoc:
  preprocess_order_args(args)
  args.uniq!
  self.reordering_value = true
  self.order_values = args
  self
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 541

def reselect(*args)
  check_if_method_has_arguments!(__callee__, args)
  args = process_select_args(args)
  spawn.reselect!(*args)
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 548

def reselect!(*args) # :nodoc:
  self.select_values = args
  self
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 2173

def resolve_arel_attributes(attrs)
  attrs.flat_map do |attr|
    case attr
    when Arel::Predications
      attr
    when Hash
      attr.flat_map do |table, columns|
        table = table.to_s
        Array(columns).map do |column|
          predicate_builder.resolve_arel_attribute(table, column)
        end
      end
    else
      attr = attr.to_s
      if attr.include?(".")
        table, column = attr.split(".", 2)
        predicate_builder.resolve_arel_attribute(table, column)
      else
        attr
      end
    end
  end
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 1498

def reverse_order
  spawn.reverse_order!
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 1502

def reverse_order! # :nodoc:
  orders = order_values.compact_blank
  self.order_values = reverse_sql_order(orders)
  self
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 2015

def reverse_sql_order(order_query)
  if order_query.empty?
    return [table[primary_key].desc] if primary_key
    raise IrreversibleOrderError,
      "Relation has no current order and table has no primary key to be used as default order"
  end

  order_query.flat_map do |o|
    case o
    when Arel::Attribute
      o.desc
    when Arel::Nodes::Ordering
      o.reverse
    when Arel::Nodes::NodeExpression
      o.desc
    when String
      if does_not_support_reverse?(o)
        raise IrreversibleOrderError, "Order #{o.inspect} cannot be reversed automatically"
      end
      o.split(",").map! do |s|
        s.strip!
        s.gsub!(/\sasc\Z/i, " DESC") || s.gsub!(/\sdesc\Z/i, " ASC") || (s << " DESC")
      end
    else
      o
    end
  end
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 1061

def rewhere(conditions)
  return unscope(:where) if conditions.nil?

  scope = spawn
  where_clause = scope.build_where_clause(conditions)

  scope.unscope!(where: where_clause.extract_attributes)
  scope.where_clause += where_clause
  scope
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 2118

def sanitize_order_arguments(order_args)
  order_args.map! do |arg|
    model.sanitize_sql_for_order(arg)
  end
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 413

def select(*fields)
  if block_given?
    if fields.any?
      raise ArgumentError, "`select' with block doesn't take arguments."
    end

    return super()
  end

  check_if_method_has_arguments!(__callee__, fields, "Call `select' with at least one field.")

  fields = process_select_args(fields)
  spawn._select!(*fields)
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 1810

def select_association_list(associations, stashed_joins = nil)
  result = []
  associations.each do |association|
    case association
    when Hash, Symbol, Array
      result << association
    when ActiveRecord::Associations::JoinDependency
      stashed_joins&.<< association
    else
      yield association if block_given?
    end
  end
  result
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 1798

def select_named_joins(join_names, stashed_joins = nil, &block)
  cte_joins, associations = join_names.partition do |join_name|
    Symbol === join_name && with_values.any? { _1.key?(join_name) }
  end

  cte_joins.each do |cte_name|
    block&.call(CTEJoin.new(cte_name))
  end

  select_association_list(associations, stashed_joins, &block)
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 1513

def skip_preloading! # :nodoc:
  self.skip_preloading_value = true
  self
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 1508

def skip_query_cache!(value = true) # :nodoc:
  self.skip_query_cache_value = value
  self
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 1324

def strict_loading(value = true)
  spawn.strict_loading!(value)
end

# File 'activerecord/lib/active_record/relation/query_methods.rb', line 1328

def strict_loading!(value = true) # :nodoc:
  self.strict_loading_value = value
  self
end