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
|
|
|
|
|
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
|
2010-12-27 11:16:18 -05:00
|
|
|
@ast.limit && @ast.limit.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
|
|
|
|
|
2010-09-09 18:50:14 -04:00
|
|
|
def where_clauses
|
2010-12-26 21:56:07 -05:00
|
|
|
if $VERBOSE
|
2012-01-12 14:36:24 -05:00
|
|
|
warn "(#{caller.first}) where_clauses is deprecated and will be removed in arel 4.0.0 with no replacement"
|
2010-12-26 21:56:07 -05:00
|
|
|
end
|
2011-11-19 21:57:36 -05:00
|
|
|
to_sql = Visitors::ToSql.new @engine.connection
|
2010-09-09 18:50:14 -04:00
|
|
|
@ctx.wheres.map { |c| to_sql.accept c }
|
|
|
|
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
|
|
|
# FIXME: this is a hack to support
|
|
|
|
# test_with_two_tables_in_from_without_getting_double_quoted
|
|
|
|
# from the AR tests.
|
|
|
|
|
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
|
|
|
|
raise if relation.blank?
|
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
|
|
|
|
|
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
|
|
|
|
|
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|
|
2010-10-15 18:45:55 -04:00
|
|
|
[Symbol, String].include?(x.class) ? SqlLiteral.new(x.to_s) : x
|
2010-09-07 14:02:38 -04:00
|
|
|
}
|
2010-08-13 18:30:22 -04:00
|
|
|
self
|
|
|
|
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
|
|
|
|
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|
|
2010-09-12 22:27:54 -04:00
|
|
|
String === x || Symbol === x ? 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-08-16 20:44:48 -04:00
|
|
|
def wheres
|
2012-01-12 14:36:24 -05:00
|
|
|
warn "#{caller[0]}: SelectManager#wheres is deprecated and will be removed in ARel 4.0.0 with no replacement"
|
2011-11-19 21:57:36 -05:00
|
|
|
Compatibility::Wheres.new @engine.connection, @ctx.wheres
|
2010-08-16 20:44:48 -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
|
2010-10-12 17:17:26 -04:00
|
|
|
Nodes::SqlLiteral.new viz.accept @ctx
|
|
|
|
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
|
|
|
|
@ast.limit = Nodes::Limit.new(limit)
|
|
|
|
@ctx.top = Nodes::Top.new(limit)
|
|
|
|
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
|
|
|
|
|
|
|
def join_sql
|
2010-12-14 12:43:19 -05:00
|
|
|
return nil if @ctx.source.right.empty?
|
2010-09-28 19:57:33 -04:00
|
|
|
|
2011-08-08 18:23:51 -04:00
|
|
|
sql = visitor.dup.extend(Visitors::JoinSql).accept @ctx
|
2010-12-03 18:24:30 -05:00
|
|
|
Nodes::SqlLiteral.new sql
|
2010-08-19 13:37:50 -04:00
|
|
|
end
|
|
|
|
|
2010-08-24 21:36:59 -04:00
|
|
|
def order_clauses
|
2011-11-19 21:57:36 -05:00
|
|
|
visitor = Visitors::OrderClauses.new(@engine.connection)
|
2011-08-08 18:23:51 -04:00
|
|
|
visitor.accept(@ast).map { |x|
|
2010-08-24 21:38:15 -04:00
|
|
|
Nodes::SqlLiteral.new x
|
|
|
|
}
|
2010-08-24 21:36:59 -04:00
|
|
|
end
|
|
|
|
|
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-08-19 13:37:50 -04:00
|
|
|
def joins manager
|
2010-11-30 19:57:55 -05:00
|
|
|
if $VERBOSE
|
2012-01-12 14:36:24 -05:00
|
|
|
warn "joins is deprecated and will be removed in 4.0.0"
|
2010-11-30 19:57:55 -05:00
|
|
|
warn "please remove your call to joins from #{caller.first}"
|
|
|
|
end
|
2010-08-19 13:37:50 -04:00
|
|
|
manager.join_sql
|
|
|
|
end
|
2010-08-23 19:07:32 -04:00
|
|
|
|
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
|
|
|
|
|
|
|
|
def to_a # :nodoc:
|
|
|
|
warn "to_a is deprecated. Please remove it from #{caller[0]}"
|
|
|
|
# FIXME: I think `select` should be made public...
|
|
|
|
@engine.connection.send(:select, to_sql, 'AREL').map { |x| Row.new(x) }
|
2010-08-23 19:07:32 -04:00
|
|
|
end
|
2010-09-07 20:42:40 -04:00
|
|
|
|
2010-09-09 18:20:25 -04:00
|
|
|
# FIXME: this method should go away
|
|
|
|
def insert values
|
2010-12-13 16:20:45 -05:00
|
|
|
if $VERBOSE
|
|
|
|
warn <<-eowarn
|
2012-01-12 14:36:24 -05:00
|
|
|
insert (#{caller.first}) is deprecated and will be removed in ARel 4.0.0. Please
|
2010-12-13 16:20:45 -05:00
|
|
|
switch to `compile_insert`
|
|
|
|
eowarn
|
|
|
|
end
|
|
|
|
|
|
|
|
im = compile_insert(values)
|
2010-09-28 09:15:35 -04:00
|
|
|
table = @ctx.froms
|
2010-12-13 16:20:45 -05:00
|
|
|
|
|
|
|
primary_key = table.primary_key
|
|
|
|
primary_key_name = primary_key.name if primary_key
|
|
|
|
|
2010-09-28 09:15:35 -04:00
|
|
|
# FIXME: in AR tests values sometimes were Array and not Hash therefore is_a?(Hash) check is added
|
|
|
|
primary_key_value = primary_key && values.is_a?(Hash) && values[primary_key]
|
|
|
|
im.into table
|
|
|
|
# Oracle adapter needs primary key name to generate RETURNING ... INTO ... clause
|
|
|
|
# for tables which assign primary key value using trigger.
|
|
|
|
# RETURNING ... INTO ... clause will be added only if primary_key_value is nil
|
|
|
|
# therefore it is necessary to pass primary key value as well
|
|
|
|
@engine.connection.insert im.to_sql, 'AREL', primary_key_name, primary_key_value
|
2010-09-09 18:20:25 -04:00
|
|
|
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
|