Module: ActiveRecord::QueryMethods

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

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 1042

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 1428

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

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

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

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

def arel(aliases = nil) # :nodoc:
  @arel ||= build_arel(aliases)
end

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

def arel_column(field)
  field = klass.attribute_aliases[field] || field
  from = from_clause.name || from_clause.value

  if klass.columns_hash.key?(field) && (!from || table_name_matches?(from))
    table[field]
  elsif field.match?(/\A\w\.\w\z/)
    table, column = field.split(".")
    predicate_builder.resolve_arel_attribute(table, column) do
      lookup_table_klass_from_join_dependencies(table)
    end
  else
    yield field
  end
end

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

def arel_columns(columns)
  columns.flat_map do |field|
    case field
    when Symbol
      arel_column(field.to_s) do |attr_name|
        connection.quote_table_name(attr_name)
      end
    when String
      arel_column(field, &:itself)
    when Proc
      field.call
    else
      field
    end
  end
end

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

def assert_mutability!
  raise ImmutableRelation if @loaded
  raise ImmutableRelation if defined?(@arel) && @arel
end

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

def async
  spawn.async!
end

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

def async!
  @async = true
  self
end

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

def build_arel(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 1936

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

  Arel::Nodes::Ascending.new(node)
end

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

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 1611

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 1537

alias :build_having_clause :build_where_clause

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

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 == klass
  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 1562

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 1709

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 1854

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 1731

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

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

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 1508

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

  case opts
  when String, Array
    parts = [klass.sanitize_sql(rest.empty? ? opts : [opts, *rest])]
  when Hash
    opts = opts.transform_keys do |key|
      if key.is_a?(Array)
        key.map { |k| klass.attribute_aliases[k.to_s] || k.to_s }
      else
        key = key.to_s
        klass.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 1741

def build_with(arel)
  return if with_values.empty?

  with_statements = with_values.map do |with_value|
    raise ArgumentError, "Unsupported argument type: #{with_value} #{with_value.class}" unless with_value.is_a?(Hash)

    build_with_value_from_hash(with_value)
  end

  arel.with(with_statements)
end

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

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

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

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

def build_with_value_from_hash(hash)
  hash.map do |name, value|
    expression =
      case value
      when Arel::Nodes::SqlLiteral then Arel::Nodes::Grouping.new(value)
      when ActiveRecord::Relation then value.arel
      when Arel::SelectManager then value
      else
        raise ArgumentError, "Unsupported argument type: `#{value}` #{value.class}"
      end
    Arel::Nodes::TableAlias.new(expression, name)
  end
end

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

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 1911

def column_references(order_args)
  references = order_args.flat_map do |arg|
    case arg
    when String, Symbol
      arg
    when Hash
      arg.keys.map do |key|
        key if key.is_a?(String) || key.is_a?(Symbol)
      end
    end
  end
  references.map! { |arg| arg =~ /^\W?(\w+)\W?\./ && $1 }.compact!
  references
end

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

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

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

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

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

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 1309

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

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

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

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

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 1556

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 267

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 272

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

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

def excluding(*records)
  records.flatten!(1)
  records.compact!

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

  spawn.excluding!(records)
end

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

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 1355

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 1363

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 166

alias extensions extending_values

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

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

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

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

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

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 512

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

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

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

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

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

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

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 620

def in_order_of(column, values)
  klass.disallow_raw_sql!([column], permit: connection.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| type_caster.type_cast_for_database(column, value) }
  arel_column = column.is_a?(Arel::Nodes::SqlLiteral) ? column : order_column(column.to_s)

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

  spawn
    .order!(build_case_for_value_position(arel_column, values))
    .where!(where_clause)
end

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

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

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

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

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

def invert_where
  spawn.invert_where!
end

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

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

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

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

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

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

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

alias :left_joins :left_outer_joins

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

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 788

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

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

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

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

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

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

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

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

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 1549

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 1180

def none
  spawn.none!
end

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

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

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

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

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

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

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

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 1389

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

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

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 1078

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 = self.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 595

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 603

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 1926

def order_column(field)
  arel_column(field) do |attr_name|
    if attr_name == "count" && !group_values.empty?
      table[attr_name]
    else
      Arel.sql(connection.quote_table_name(attr_name))
    end
  end
end

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

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

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

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

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

def preprocess_order_args(order_args)
  @klass.disallow_raw_sql!(
    order_args.flat_map { |a| a.is_a?(Hash) ? a.keys : a },
    permit: connection.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 { |field, dir|
        case field
        when Arel::Nodes::SqlLiteral, Arel::Nodes::Node, Arel::Attribute
          field.public_send(dir.downcase)
        else
          order_column(field.to_s).public_send(dir.downcase)
        end
      }
    else
      arg
    end
  end.flatten!
end

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

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

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

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

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

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

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

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 337

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

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

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

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

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

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

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 659

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 480

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 487

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

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

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 1397

def reverse_order
  spawn.reverse_order!
end

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

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 1814

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 960

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 1905

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

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

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 1638

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 1626

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 1412

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

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

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 1223

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

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

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

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

def structurally_compatible?(other)
  structurally_incompatible_values_for(other).empty?
end

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

def structurally_incompatible_values_for(other)
  values = other.values
  STRUCTURAL_VALUE_METHODS.reject do |method|
    v1, v2 = @values[method], values[method]
    if v1.is_a?(Array)
      next true unless v2.is_a?(Array)
      v1 = v1.uniq
      v2 = v2.uniq
    end
    v1 == v2
  end
end

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

def table_name_matches?(from)
  table_name = Regexp.escape(table.name)
  quoted_table_name = Regexp.escape(connection.quote_table_name(table.name))
  /(?:\A|(?<!FROM)\s)(?:\b#{table_name}\b|#{quoted_table_name})(?!\.)/i.match?(from.to_s)
end

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

def transform_select_hash_values(fields)
  fields.flat_map do |key, columns_aliases|
    case columns_aliases
    when Hash
      columns_aliases.map do |column, column_alias|
        if values[:joins]&.include?(key)
          references = PredicateBuilder.references({ key.to_s => fields[key] })
          self.references_values |= references unless references.empty?
        end
        arel_column("#{key}.#{column}") do
          predicate_builder.resolve_arel_attribute(key.to_s, column)
        end.as(column_alias.to_s)
      end
    when Array
      columns_aliases.map do |column|
        arel_column("#{key}.#{column}", &:itself)
      end
    when String, Symbol
      arel_column(key.to_s) do
        predicate_builder.resolve_arel_attribute(klass.table_name, key.to_s)
      end.as(columns_aliases.to_s)
    end
  end
end

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

def uniq!(name)
  if values = @values[name]
    values.uniq! if values.is_a?(Array) && !values.empty?
  end
  self
end

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

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

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

def unscope!(*args) # :nodoc:
  self.unscope_values += args

  args.each do |scope|
    case scope
    when Symbol
      scope = :left_outer_joins if scope == :left_joins
      if !VALID_UNSCOPING_VALUES.include?(scope)
        raise ArgumentError, "Called unscope() with invalid unscoping argument ':#{scope}'. Valid arguments are :#{VALID_UNSCOPING_VALUES.to_a.join(", :")}."
      end
      assert_mutability!
      @values.delete(scope)
    when Hash
      scope.each do |key, target_value|
        if key != :where
          raise ArgumentError, "Hash arguments in .unscope(*args) must have :where as the key."
        end

        target_values = resolve_arel_attributes(Array.wrap(target_value))
        self.where_clause = where_clause.except(*target_values)
      end
    else
      raise ArgumentError, "Unrecognized scoping: #{args.inspect}. Use .unscope(where: :attribute_name) or .unscope(:order), for example."
    end
  end

  self
end

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

def validate_order_args(args)
  args.each do |arg|
    next unless arg.is_a?(Hash)
    arg.each do |_key, value|
      unless VALID_DIRECTIONS.include?(value)
        raise ArgumentError,
          "Direction \"#{value}\" is invalid. Valid directions are: #{VALID_DIRECTIONS.to_a.inspect}"
      end
    end
  end
end

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