2014-04-08 19:23:39 -04:00
|
|
|
require 'arel/collectors/sql_string'
|
|
|
|
|
2010-08-13 18:30:22 -04:00
|
|
|
module Arel
|
|
|
|
class SelectManager < Arel::TreeManager
|
2010-08-16 17:56:56 -04:00
|
|
|
include Arel::Crud
|
|
|
|
|
2014-01-07 08:30:55 -05:00
|
|
|
STRING_OR_SYMBOL_CLASS = [Symbol, String]
|
|
|
|
|
2010-09-23 18:26:08 -04:00
|
|
|
def initialize engine, table = nil
|
|
|
|
super(engine)
|
2010-11-05 17:09:09 -04:00
|
|
|
@ast = Nodes::SelectStatement.new
|
|
|
|
@ctx = @ast.cores.last
|
2010-09-23 18:26:08 -04:00
|
|
|
from table
|
2010-08-13 18:30:22 -04:00
|
|
|
end
|
|
|
|
|
2011-04-15 10:34:18 -04:00
|
|
|
def initialize_copy other
|
|
|
|
super
|
|
|
|
@ctx = @ast.cores.last
|
|
|
|
end
|
|
|
|
|
2010-12-25 14:14:30 -05:00
|
|
|
def limit
|
2014-03-25 13:01:44 -04:00
|
|
|
@ast.limit && @ast.limit.expr.expr
|
2010-09-09 18:58:06 -04:00
|
|
|
end
|
2010-12-25 14:14:30 -05:00
|
|
|
alias :taken :limit
|
2010-09-09 18:58:06 -04:00
|
|
|
|
2010-09-20 16:29:12 -04:00
|
|
|
def constraints
|
|
|
|
@ctx.wheres
|
|
|
|
end
|
|
|
|
|
2011-02-25 18:23:21 -05:00
|
|
|
def offset
|
|
|
|
@ast.offset && @ast.offset.expr
|
|
|
|
end
|
|
|
|
|
2010-09-10 12:47:50 -04:00
|
|
|
def skip amount
|
2011-02-25 18:23:21 -05:00
|
|
|
if amount
|
|
|
|
@ast.offset = Nodes::Offset.new(amount)
|
|
|
|
else
|
|
|
|
@ast.offset = nil
|
|
|
|
end
|
2010-09-10 12:47:50 -04:00
|
|
|
self
|
|
|
|
end
|
2011-02-25 18:23:21 -05:00
|
|
|
alias :offset= :skip
|
2010-09-10 12:47:50 -04:00
|
|
|
|
2010-11-05 19:33:26 -04:00
|
|
|
###
|
|
|
|
# Produces an Arel::Nodes::Exists node
|
|
|
|
def exists
|
|
|
|
Arel::Nodes::Exists.new @ast
|
|
|
|
end
|
|
|
|
|
2011-03-24 14:13:21 -04:00
|
|
|
def as other
|
2011-03-30 12:54:23 -04:00
|
|
|
create_table_alias grouping(@ast), Nodes::SqlLiteral.new(other)
|
2011-03-23 20:55:03 -04:00
|
|
|
end
|
|
|
|
|
2011-02-21 18:40:38 -05:00
|
|
|
def lock locking = Arel.sql('FOR UPDATE')
|
|
|
|
case locking
|
|
|
|
when true
|
|
|
|
locking = Arel.sql('FOR UPDATE')
|
|
|
|
when Arel::Nodes::SqlLiteral
|
|
|
|
when String
|
|
|
|
locking = Arel.sql locking
|
|
|
|
end
|
|
|
|
|
2011-01-20 00:37:05 -05:00
|
|
|
@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
|
|
|
|
|
2010-09-07 20:42:40 -04: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
|
|
|
|
|
2010-09-07 18:47:38 -04:00
|
|
|
def group *columns
|
|
|
|
columns.each do |column|
|
2010-09-07 19:09:58 -04:00
|
|
|
# FIXME: backwards compat
|
|
|
|
column = Nodes::SqlLiteral.new(column) if String === column
|
2010-09-12 21:23:28 -04:00
|
|
|
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
|
|
|
|
|
2010-08-13 18:30:22 -04:00
|
|
|
def from table
|
2010-09-18 16:42:54 -04:00
|
|
|
table = Nodes::SqlLiteral.new(table) if String === table
|
2010-09-20 16:29:12 -04:00
|
|
|
|
2010-12-14 12:43:19 -05:00
|
|
|
case table
|
|
|
|
when Nodes::Join
|
|
|
|
@ctx.source.right << table
|
2011-03-23 20:55:03 -04:00
|
|
|
else
|
|
|
|
@ctx.source.left = table
|
2010-09-20 16:29:12 -04:00
|
|
|
end
|
|
|
|
|
2010-08-13 18:30:22 -04:00
|
|
|
self
|
|
|
|
end
|
|
|
|
|
2010-12-07 18:05:51 -05:00
|
|
|
def froms
|
|
|
|
@ast.cores.map { |x| x.from }.compact
|
|
|
|
end
|
|
|
|
|
2010-09-07 18:10:27 -04: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
|
2014-06-01 09:25:14 -04:00
|
|
|
raise if relation.empty?
|
2010-12-09 18:52:12 -05:00
|
|
|
klass = Nodes::StringJoin
|
2010-09-07 18:10:27 -04:00
|
|
|
end
|
2010-12-09 18:52:12 -05:00
|
|
|
|
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
|
|
|
|
|
2013-05-12 13:09:07 -04:00
|
|
|
def outer_join relation
|
|
|
|
join(relation, Nodes::OuterJoin)
|
|
|
|
end
|
|
|
|
|
2011-01-03 18:11:34 -05:00
|
|
|
def having *exprs
|
|
|
|
@ctx.having = Nodes::Having.new(collapse(exprs, @ctx.having))
|
2010-09-08 18:29:22 -04:00
|
|
|
self
|
|
|
|
end
|
|
|
|
|
2012-02-22 09:25:10 -05:00
|
|
|
def window name
|
|
|
|
window = Nodes::NamedWindow.new(name)
|
|
|
|
@ctx.windows.push window
|
|
|
|
window
|
|
|
|
end
|
|
|
|
|
2010-08-23 17:59:53 -04: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
|
|
|
}
|
2010-08-13 18:30:22 -04:00
|
|
|
self
|
|
|
|
end
|
|
|
|
|
2012-09-21 06:12:49 -04:00
|
|
|
def projections
|
|
|
|
@ctx.projections
|
|
|
|
end
|
|
|
|
|
2011-08-11 03:43:21 -04:00
|
|
|
def projections= projections
|
|
|
|
@ctx.projections = projections
|
|
|
|
end
|
|
|
|
|
2011-11-04 12:55:40 -04:00
|
|
|
def distinct(value = true)
|
|
|
|
if value
|
|
|
|
@ctx.set_quantifier = Arel::Nodes::Distinct.new
|
|
|
|
else
|
|
|
|
@ctx.set_quantifier = nil
|
|
|
|
end
|
2014-05-06 16:38:26 -04:00
|
|
|
self
|
2011-11-04 12:55:40 -04:00
|
|
|
end
|
|
|
|
|
2010-08-22 21:13:39 -04:00
|
|
|
def order *expr
|
2010-08-24 21:36:59 -04:00
|
|
|
# FIXME: We SHOULD NOT be converting these to SqlLiteral automatically
|
2010-11-05 17:09:09 -04:00
|
|
|
@ast.orders.concat expr.map { |x|
|
2014-01-07 08:30:55 -05:00
|
|
|
STRING_OR_SYMBOL_CLASS.include?(x.class) ? Nodes::SqlLiteral.new(x.to_s) : x
|
2010-08-24 21:36:59 -04:00
|
|
|
}
|
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
|
|
|
|
|
2010-10-12 17:17:26 -04:00
|
|
|
def where_sql
|
|
|
|
return if @ctx.wheres.empty?
|
|
|
|
|
2011-11-19 21:57:36 -05:00
|
|
|
viz = Visitors::WhereSql.new @engine.connection
|
2014-04-08 19:23:39 -04:00
|
|
|
Nodes::SqlLiteral.new viz.accept(@ctx, Collectors::SQLString.new).value
|
2010-10-12 17:17:26 -04:00
|
|
|
end
|
|
|
|
|
2011-01-20 14:56:08 -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-20 14:56:08 -05:00
|
|
|
|
2011-01-21 19:54:58 -05:00
|
|
|
node_class.new self.ast, other.ast
|
|
|
|
end
|
2011-01-20 14:56:08 -05:00
|
|
|
|
2011-01-22 17:08:27 -05:00
|
|
|
def intersect other
|
|
|
|
Nodes::Intersect.new ast, other.ast
|
2011-01-22 09:16:53 -05:00
|
|
|
end
|
|
|
|
|
2011-01-22 17:08:27 -05:00
|
|
|
def except other
|
|
|
|
Nodes::Except.new ast, other.ast
|
2011-01-22 09:16:53 -05:00
|
|
|
end
|
2011-01-23 11:54:00 -05:00
|
|
|
alias :minus :except
|
2011-01-22 09:16:53 -05:00
|
|
|
|
2011-01-20 14:56:08 -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
|
2011-01-20 14:56:08 -05:00
|
|
|
|
2010-08-13 18:30:22 -04:00
|
|
|
def take limit
|
2011-02-25 18:19:11 -05:00
|
|
|
if limit
|
2014-03-24 19:50:34 -04:00
|
|
|
@ast.limit = Nodes::Limit.new(Nodes.build_quoted(limit))
|
|
|
|
@ctx.top = Nodes::Top.new(Nodes.build_quoted(limit))
|
2011-02-25 18:19:11 -05:00
|
|
|
else
|
|
|
|
@ast.limit = nil
|
|
|
|
@ctx.top = nil
|
|
|
|
end
|
2010-08-13 18:30:22 -04:00
|
|
|
self
|
|
|
|
end
|
2011-02-25 18:19:11 -05:00
|
|
|
alias limit= take
|
2010-08-19 13:37:50 -04:00
|
|
|
|
2010-12-14 17:56:15 -05:00
|
|
|
def join_sources
|
|
|
|
@ctx.source.right
|
|
|
|
end
|
|
|
|
|
2011-08-11 03:51:13 -04:00
|
|
|
def source
|
|
|
|
@ctx.source
|
|
|
|
end
|
|
|
|
|
2010-09-20 16:29:12 -04:00
|
|
|
class Row < Struct.new(:data) # :nodoc:
|
|
|
|
def id
|
|
|
|
data['id']
|
|
|
|
end
|
|
|
|
|
|
|
|
def method_missing(name, *args)
|
|
|
|
name = name.to_s
|
|
|
|
return data[name] if data.key?(name)
|
|
|
|
super
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2010-09-07 20:42:40 -04:00
|
|
|
private
|
2011-01-03 18:11:34 -05:00
|
|
|
def collapse exprs, existing = nil
|
|
|
|
exprs = exprs.unshift(existing.expr) if existing
|
|
|
|
exprs = exprs.compact.map { |expr|
|
2010-12-09 17:48:28 -05:00
|
|
|
if String === expr
|
2011-01-03 18:11:34 -05:00
|
|
|
# FIXME: Don't do this automatically
|
2010-12-09 17:48:28 -05:00
|
|
|
Arel.sql(expr)
|
|
|
|
else
|
|
|
|
expr
|
|
|
|
end
|
2010-09-15 15:01:43 -04:00
|
|
|
}
|
2011-01-03 18:11:34 -05:00
|
|
|
|
|
|
|
if exprs.length == 1
|
|
|
|
exprs.first
|
|
|
|
else
|
|
|
|
create_and exprs
|
|
|
|
end
|
2010-09-07 20:42:40 -04:00
|
|
|
end
|
2010-08-13 18:30:22 -04:00
|
|
|
end
|
|
|
|
end
|