arel 2.0.1 → 2.0.2

data/lib/arel/crud.rb

@@ -13,8 +13,8 @@ module Arel
       end
       um.table relation
       um.set values
-      um.take @head.limit
-      um.order(*@head.orders)
+      um.take @ast.limit
+      um.order(*@ast.orders)
       um.wheres = @ctx.wheres
 
       @engine.connection.update um.to_sql, 'AREL'

data/lib/arel/delete_manager.rb

@@ -2,21 +2,21 @@ module Arel
   class DeleteManager < Arel::TreeManager
     def initialize engine
       super
-      @head = Nodes::DeleteStatement.new
+      @ast = Nodes::DeleteStatement.new
     end
 
     def from relation
-      @head.relation = relation
+      @ast.relation = relation
       self
     end
 
     def where expression
-      @head.wheres << expression
+      @ast.wheres << expression
       self
     end
 
     def wheres= list
-      @head.wheres = list
+      @ast.wheres = list
     end
   end
 end

data/lib/arel/insert_manager.rb

@@ -2,32 +2,32 @@ module Arel
   class InsertManager < Arel::TreeManager
     def initialize engine
       super
-      @head = Nodes::InsertStatement.new
+      @ast = Nodes::InsertStatement.new
     end
 
     def into table
-      @head.relation = table
+      @ast.relation = table
       self
     end
 
-    def columns; @head.columns end
-    def values= val; @head.values = val; end
+    def columns; @ast.columns end
+    def values= val; @ast.values = val; end
 
     def insert fields
       return if fields.empty?
 
       if String === fields
-        @head.values = SqlLiteral.new(fields)
+        @ast.values = SqlLiteral.new(fields)
       else
-        @head.relation ||= fields.first.first.relation
+        @ast.relation ||= fields.first.first.relation
 
         values = []
 
         fields.each do |column, value|
-          @head.columns << column
+          @ast.columns << column
           values << value
         end
-        @head.values = Nodes::Values.new values, @head.columns
+        @ast.values = Nodes::Values.new values, @ast.columns
       end
     end
   end

data/lib/arel/nodes/exists.rb

@@ -1,11 +1,7 @@
 module Arel
   module Nodes
-    class Exists
-      attr_reader :select_stmt
-
-      def initialize select_stmt
-        @select_stmt = select_stmt
-      end
+    class Exists < Arel::Nodes::Function
+      alias :select_stmt :expressions
     end
   end
 end

data/lib/arel/nodes/sql_literal.rb

@@ -2,6 +2,7 @@ module Arel
   module Nodes
     class SqlLiteral < String
       include Arel::Expressions
+      include Arel::Predications
     end
   end
 end

data/lib/arel/predications.rb

@@ -0,0 +1,177 @@
+module Arel
+  module Predications
+    def not_eq other
+      Nodes::NotEqual.new self, other
+    end
+
+    def not_eq_any others
+      grouping_any :not_eq, others
+    end
+
+    def not_eq_all others
+      grouping_all :not_eq, others
+    end
+
+    def eq other
+      Nodes::Equality.new self, other
+    end
+
+    def eq_any others
+      grouping_any :eq, others
+    end
+
+    def eq_all others
+      grouping_all :eq, others
+    end
+
+    def in other
+      case other
+      when Arel::SelectManager
+        Nodes::In.new self, other.to_a.map { |x| x.id }
+      when Range
+        if other.exclude_end?
+          left  = Nodes::GreaterThanOrEqual.new(self, other.min)
+          right = Nodes::LessThan.new(self, other.max + 1)
+          Nodes::And.new left, right
+        else
+          Nodes::Between.new(self, Nodes::And.new(other.min, other.max))
+        end
+      else
+        Nodes::In.new self, other
+      end
+    end
+
+    def in_any others
+      grouping_any :in, others
+    end
+
+    def in_all others
+      grouping_all :in, others
+    end
+
+    def not_in other
+      case other
+      when Arel::SelectManager
+        Nodes::NotIn.new self, other.to_a.map { |x| x.id }
+      when Range
+        if other.exclude_end?
+          left  = Nodes::LessThan.new(self, other.min)
+          right = Nodes::GreaterThanOrEqual.new(self, other.max)
+          Nodes::Or.new left, right
+        else
+          left  = Nodes::LessThan.new(self, other.min)
+          right = Nodes::GreaterThan.new(self, other.max)
+          Nodes::Or.new left, right
+        end
+      else
+        Nodes::NotIn.new self, other
+      end
+    end
+
+    def not_in_any others
+      grouping_any :not_in, others
+    end
+
+    def not_in_all others
+      grouping_all :not_in, others
+    end
+
+    def matches other
+      Nodes::Matches.new self, other
+    end
+
+    def matches_any others
+      grouping_any :matches, others
+    end
+
+    def matches_all others
+      grouping_all :matches, others
+    end
+
+    def does_not_match other
+      Nodes::DoesNotMatch.new self, other
+    end
+
+    def does_not_match_any others
+      grouping_any :does_not_match, others
+    end
+
+    def does_not_match_all others
+      grouping_all :does_not_match, others
+    end
+
+    def gteq right
+      Nodes::GreaterThanOrEqual.new self, right
+    end
+
+    def gteq_any others
+      grouping_any :gteq, others
+    end
+
+    def gteq_all others
+      grouping_all :gteq, others
+    end
+
+    def gt right
+      Nodes::GreaterThan.new self, right
+    end
+
+    def gt_any others
+      grouping_any :gt, others
+    end
+
+    def gt_all others
+      grouping_all :gt, others
+    end
+
+    def lt right
+      Nodes::LessThan.new self, right
+    end
+
+    def lt_any others
+      grouping_any :lt, others
+    end
+
+    def lt_all others
+      grouping_all :lt, others
+    end
+
+    def lteq right
+      Nodes::LessThanOrEqual.new self, right
+    end
+
+    def lteq_any others
+      grouping_any :lteq, others
+    end
+
+    def lteq_all others
+      grouping_all :lteq, others
+    end
+
+    def asc
+      Nodes::Ordering.new self, :asc
+    end
+
+    def desc
+      Nodes::Ordering.new self, :desc
+    end
+
+    private
+
+    def grouping_any method_id, others
+      first = send method_id, others.shift
+
+      Nodes::Grouping.new others.inject(first) { |memo,expr|
+        Nodes::Or.new(memo, send(method_id, expr))
+      }
+    end
+
+    def grouping_all method_id, others
+      first = send method_id, others.shift
+
+      Nodes::Grouping.new others.inject(first) { |memo,expr|
+        Nodes::And.new(memo, send(method_id, expr))
+      }
+    end
+  end
+end

data/lib/arel/select_manager.rb

@@ -4,13 +4,13 @@ module Arel
 
     def initialize engine, table = nil
       super(engine)
-      @head   = Nodes::SelectStatement.new
-      @ctx    = @head.cores.last
+      @ast   = Nodes::SelectStatement.new
+      @ctx    = @ast.cores.last
       from table
     end
 
     def taken
-      @head.limit
+      @ast.limit
     end
 
     def constraints
@@ -18,10 +18,16 @@ module Arel
     end
 
     def skip amount
-      @head.offset = Nodes::Offset.new(amount)
+      @ast.offset = Nodes::Offset.new(amount)
       self
     end
 
+    ###
+    # Produces an Arel::Nodes::Exists node
+    def exists
+      Arel::Nodes::Exists.new @ast
+    end
+
     def where_clauses
       #warn "where_clauses is deprecated" if $VERBOSE
       to_sql = Visitors::ToSql.new @engine
@@ -31,12 +37,12 @@ module Arel
     def lock locking = true
       # FIXME: do we even need to store this?  If locking is +false+ shouldn't
       # we just remove the node from the AST?
-      @head.lock = Nodes::Lock.new
+      @ast.lock = Nodes::Lock.new
       self
     end
 
     def locked
-      @head.lock
+      @ast.lock
     end
 
     def on *exprs
@@ -96,7 +102,7 @@ module Arel
       # FIXME: converting these to SQLLiterals is probably not good, but
       # rails tests require it.
       @ctx.projections.concat projections.map { |x|
-        String == x.class ? SqlLiteral.new(x) : x
+        [Symbol, String].include?(x.class) ? SqlLiteral.new(x.to_s) : x
       }
       self
     end
@@ -108,14 +114,14 @@ module Arel
 
     def order *expr
       # FIXME: We SHOULD NOT be converting these to SqlLiteral automatically
-      @head.orders.concat expr.map { |x|
+      @ast.orders.concat expr.map { |x|
         String === x || Symbol === x ? Nodes::SqlLiteral.new(x.to_s) : x
       }
       self
     end
 
     def orders
-      @head.orders
+      @ast.orders
     end
 
     def wheres
@@ -130,7 +136,7 @@ module Arel
     end
 
     def take limit
-      @head.limit = limit
+      @ast.limit = limit
       self
     end
 
@@ -142,7 +148,7 @@ module Arel
     end
 
     def order_clauses
-      Visitors::OrderClauses.new(@engine).accept(@head).map { |x|
+      Visitors::OrderClauses.new(@engine).accept(@ast).map { |x|
         Nodes::SqlLiteral.new x
       }
     end

data/lib/arel/table.rb

@@ -80,6 +80,10 @@ module Arel
       from(self).take amount
     end
 
+    def skip amount
+      from(self).skip amount
+    end
+
     def having expr
       from(self).having expr
     end

data/lib/arel/tree_manager.rb

@@ -4,6 +4,7 @@ module Arel
     include Arel::Relation
 
     attr_accessor :visitor
+    attr_reader :ast, :engine
 
     def initialize engine
       @engine  = engine
@@ -11,16 +12,16 @@ module Arel
     end
 
     def to_dot
-      Visitors::Dot.new.accept @head
+      Visitors::Dot.new.accept @ast
     end
 
     def to_sql
-      @visitor.accept @head
+      @visitor.accept @ast
     end
 
     def initialize_copy other
       super
-      @head = @head.clone
+      @ast = @ast.clone
     end
   end
 end

data/lib/arel/update_manager.rb

@@ -2,40 +2,40 @@ module Arel
   class UpdateManager < Arel::TreeManager
     def initialize engine
       super
-      @head = Nodes::UpdateStatement.new
+      @ast = Nodes::UpdateStatement.new
     end
 
     def take limit
-      @head.limit = limit
+      @ast.limit = limit
       self
     end
 
     def order *expr
-      @head.orders = expr
+      @ast.orders = expr
       self
     end
 
     ###
     # UPDATE +table+
     def table table
-      @head.relation = table
+      @ast.relation = table
       self
     end
 
     def wheres= exprs
-      @head.wheres = exprs
+      @ast.wheres = exprs
     end
 
     def where expr
-      @head.wheres << expr
+      @ast.wheres << expr
       self
     end
 
     def set values
       if String === values
-        @head.values = [values]
+        @ast.values = [values]
       else
-        @head.values = values.map { |column,value|
+        @ast.values = values.map { |column,value|
           Nodes::Assignment.new(
             Nodes::UnqualifiedColumn.new(column),
             value