1
0
Fork 0
mirror of https://github.com/rails/rails.git synced 2022-11-09 12:12:34 -05:00
rails--rails/activerecord/lib/arel/select_manager.rb

272 lines
5.5 KiB
Ruby
Raw Normal View History

# frozen_string_literal: true
2018-02-24 01:45:50 -05:00
2018-02-24 02:41:47 -05:00
module Arel # :nodoc: all
class SelectManager < Arel::TreeManager
include Arel::Crud
STRING_OR_SYMBOL_CLASS = [Symbol, String]
2018-02-24 01:45:50 -05:00
def initialize(table = nil)
super()
2018-02-24 01:45:50 -05:00
@ast = Nodes::SelectStatement.new
@ctx = @ast.cores.last
2010-09-23 18:26:08 -04:00
from table
end
2018-02-24 01:45:50 -05:00
def initialize_copy(other)
super
@ctx = @ast.cores.last
end
2010-12-25 14:14:30 -05:00
def limit
2015-06-18 16:08:04 -04:00
@ast.limit && @ast.limit.expr
end
2010-12-25 14:14:30 -05:00
alias :taken :limit
def constraints
@ctx.wheres
end
def offset
@ast.offset && @ast.offset.expr
end
2018-02-24 01:45:50 -05:00
def skip(amount)
if amount
@ast.offset = Nodes::Offset.new(amount)
else
@ast.offset = nil
end
2010-09-10 12:47:50 -04:00
self
end
alias :offset= :skip
2010-09-10 12:47:50 -04:00
###
# Produces an Arel::Nodes::Exists node
def exists
Arel::Nodes::Exists.new @ast
end
2018-02-24 01:45:50 -05:00
def as(other)
create_table_alias grouping(@ast), Nodes::SqlLiteral.new(other)
end
2018-02-24 01:45:50 -05:00
def lock(locking = Arel.sql("FOR UPDATE"))
case locking
when true
2018-02-24 01:45:50 -05:00
locking = Arel.sql("FOR UPDATE")
when Arel::Nodes::SqlLiteral
when String
locking = Arel.sql locking
end
@ast.lock = Nodes::Lock.new(locking)
2010-09-08 20:32:44 -04:00
self
end
2010-09-11 00:40:59 -04:00
def locked
2010-11-05 17:09:09 -04:00
@ast.lock
2010-09-11 00:40:59 -04:00
end
2018-02-24 01:45:50 -05:00
def on(*exprs)
2010-12-14 12:43:19 -05:00
@ctx.source.right.last.right = Nodes::On.new(collapse(exprs))
2010-08-18 19:32:32 -04:00
self
end
2018-02-24 01:45:50 -05:00
def group(*columns)
2010-09-07 18:47:38 -04:00
columns.each do |column|
2010-09-07 19:09:58 -04:00
# FIXME: backwards compat
column = Nodes::SqlLiteral.new(column) if String === column
column = Nodes::SqlLiteral.new(column.to_s) if Symbol === column
2010-09-07 19:09:58 -04:00
2010-09-07 18:47:38 -04:00
@ctx.groups.push Nodes::Group.new column
end
self
end
2018-02-24 01:45:50 -05:00
def from(table)
table = Nodes::SqlLiteral.new(table) if String === table
2010-12-14 12:43:19 -05:00
case table
when Nodes::Join
@ctx.source.right << table
else
@ctx.source.left = table
end
self
end
def froms
@ast.cores.map { |x| x.from }.compact
end
2018-02-24 01:45:50 -05:00
def join(relation, klass = Nodes::InnerJoin)
2010-09-07 18:27:08 -04:00
return self unless relation
2010-09-07 18:10:27 -04:00
case relation
when String, Nodes::SqlLiteral
2017-01-17 23:13:37 -05:00
raise EmptyJoinError if relation.empty?
klass = Nodes::StringJoin
2010-09-07 18:10:27 -04:00
end
2010-12-14 12:43:19 -05:00
@ctx.source.right << create_join(relation, nil, klass)
self
2010-09-07 18:10:27 -04:00
end
2018-02-24 01:45:50 -05:00
def outer_join(relation)
2013-05-12 13:09:07 -04:00
join(relation, Nodes::OuterJoin)
end
2018-02-24 01:45:50 -05:00
def having(expr)
@ctx.havings << expr
2010-09-08 18:29:22 -04:00
self
end
2018-02-24 01:45:50 -05:00
def window(name)
2012-02-22 09:25:10 -05:00
window = Nodes::NamedWindow.new(name)
@ctx.windows.push window
window
end
2018-02-24 01:45:50 -05:00
def project(*projections)
2010-09-07 14:02:38 -04:00
# FIXME: converting these to SQLLiterals is probably not good, but
# rails tests require it.
@ctx.projections.concat projections.map { |x|
2014-02-05 15:40:52 -05:00
STRING_OR_SYMBOL_CLASS.include?(x.class) ? Nodes::SqlLiteral.new(x.to_s) : x
2010-09-07 14:02:38 -04:00
}
self
end
def projections
@ctx.projections
end
2018-02-24 01:45:50 -05:00
def projections=(projections)
@ctx.projections = projections
end
def optimizer_hints(*hints)
unless hints.empty?
@ctx.optimizer_hints = Arel::Nodes::OptimizerHints.new(hints)
end
self
end
def distinct(value = true)
if value
@ctx.set_quantifier = Arel::Nodes::Distinct.new
else
@ctx.set_quantifier = nil
end
self
end
def distinct_on(value)
if value
@ctx.set_quantifier = Arel::Nodes::DistinctOn.new(value)
else
@ctx.set_quantifier = nil
end
self
end
2018-02-24 01:45:50 -05:00
def order(*expr)
# FIXME: We SHOULD NOT be converting these to SqlLiteral automatically
2010-11-05 17:09:09 -04:00
@ast.orders.concat expr.map { |x|
STRING_OR_SYMBOL_CLASS.include?(x.class) ? Nodes::SqlLiteral.new(x.to_s) : x
}
2010-08-22 21:13:39 -04:00
self
end
2010-09-10 13:45:05 -04:00
def orders
2010-11-05 17:09:09 -04:00
@ast.orders
2010-09-10 13:45:05 -04:00
end
2018-02-24 01:45:50 -05:00
def where_sql(engine = Table.engine)
2010-10-12 17:17:26 -04:00
return if @ctx.wheres.empty?
viz = Visitors::WhereSql.new(engine.connection.visitor, engine.connection)
Nodes::SqlLiteral.new viz.accept(@ctx, Collectors::SQLString.new).value
2010-10-12 17:17:26 -04:00
end
2018-02-24 01:45:50 -05:00
def union(operation, other = nil)
2011-01-22 17:11:01 -05:00
if other
2011-01-21 19:54:58 -05:00
node_class = Nodes.const_get("Union#{operation.to_s.capitalize}")
else
other = operation
node_class = Nodes::Union
end
2011-01-21 19:54:58 -05:00
node_class.new self.ast, other.ast
end
2018-02-24 01:45:50 -05:00
def intersect(other)
2011-01-22 17:08:27 -05:00
Nodes::Intersect.new ast, other.ast
2011-01-22 09:16:53 -05:00
end
2018-02-24 01:45:50 -05:00
def except(other)
2011-01-22 17:08:27 -05:00
Nodes::Except.new ast, other.ast
2011-01-22 09:16:53 -05:00
end
alias :minus :except
2011-01-22 09:16:53 -05:00
2018-02-24 01:45:50 -05:00
def lateral(table_name = nil)
base = table_name.nil? ? ast : as(table_name)
Nodes::Lateral.new(base)
end
2018-02-24 01:45:50 -05:00
def with(*subqueries)
2011-01-21 19:54:58 -05:00
if subqueries.first.is_a? Symbol
node_class = Nodes.const_get("With#{subqueries.shift.to_s.capitalize}")
else
node_class = Nodes::With
end
@ast.with = node_class.new(subqueries.flatten)
2011-01-25 13:27:42 -05:00
self
2011-01-21 19:54:58 -05:00
end
2018-02-24 01:45:50 -05:00
def take(limit)
if limit
2015-06-18 16:08:04 -04:00
@ast.limit = Nodes::Limit.new(limit)
else
@ast.limit = nil
end
self
end
alias limit= take
2010-08-19 13:37:50 -04:00
def join_sources
@ctx.source.right
end
def source
@ctx.source
end
def comment(*values)
@ctx.comment = Nodes::Comment.new(values)
self
end
2010-09-07 20:42:40 -04:00
private
def collapse(exprs)
exprs = exprs.compact
exprs.map! { |expr|
2018-02-24 01:45:50 -05:00
if String === expr
# FIXME: Don't do this automatically
Arel.sql(expr)
else
expr
end
}
if exprs.length == 1
exprs.first
2010-12-09 17:48:28 -05:00
else
2018-02-24 01:45:50 -05:00
create_and exprs
2010-12-09 17:48:28 -05:00
end
end
end
end