arel 6.0.0.beta1 → 6.0.0.beta2

data/lib/arel/select_manager.rb

@@ -155,6 +155,15 @@ module Arel
       self
     end
 
+    def distinct_on(value)
+      if value
+        @ctx.set_quantifier = Arel::Nodes::DistinctOn.new(value)
+      else
+        @ctx.set_quantifier = nil
+      end
+      self
+    end
+
     def order *expr
       # FIXME: We SHOULD NOT be converting these to SqlLiteral automatically
       @ast.orders.concat expr.map { |x|

data/lib/arel/visitors/depth_first.rb

@@ -3,6 +3,7 @@ module Arel
     class DepthFirst < Arel::Visitors::Visitor
       def initialize block = nil
         @block = block || Proc.new
+        super()
       end
 
       private
@@ -86,6 +87,7 @@ module Arel
       alias :visit_Arel_Nodes_RightOuterJoin     :binary
       alias :visit_Arel_Nodes_TableAlias         :binary
       alias :visit_Arel_Nodes_Values             :binary
+      alias :visit_Arel_Nodes_Union              :binary
 
       def visit_Arel_Nodes_StringJoin o
         visit o.left
@@ -116,6 +118,8 @@ module Arel
       alias :visit_Arel_Nodes_SqlLiteral         :terminal
       alias :visit_Arel_Nodes_BindParam          :terminal
       alias :visit_Arel_Nodes_Window             :terminal
+      alias :visit_Arel_Nodes_True               :terminal
+      alias :visit_Arel_Nodes_False              :terminal
       alias :visit_BigDecimal                    :terminal
       alias :visit_Bignum                        :terminal
       alias :visit_Class                         :terminal
@@ -164,6 +168,7 @@ module Arel
       def visit_Array o
         o.each { |i| visit i }
       end
+      alias :visit_Set :visit_Array
 
       def visit_Hash o
         o.each { |k,v| visit(k); visit(v) }

data/lib/arel/visitors/dot.rb

@@ -15,6 +15,7 @@ module Arel
       end
 
       def initialize
+        super()
         @nodes      = []
         @edges      = []
         @node_stack = []
@@ -216,6 +217,7 @@ module Arel
           edge(i) { visit x }
         end
       end
+      alias :visit_Set :visit_Array
 
       def visit_edge o, method
         edge(method) { visit o.send(method) }

data/lib/arel/visitors/informix.rb

@@ -41,7 +41,7 @@ module Arel
         visit o.expr, collector
       end
       def visit_Arel_Nodes_Limit o, collector
-        collector << "LIMIT "
+        collector << "FIRST "
         visit o.expr, collector
         collector << " "
       end

data/lib/arel/visitors/mysql.rb

@@ -69,12 +69,7 @@ module Arel
           collector = inject_join o.orders, collector, ', '
         end
 
-        if o.limit
-          collector << " "
-          visit(o.limit, collector)
-        else
-          collector
-        end
+        maybe_visit o.limit, collector
       end
 
     end

data/lib/arel/visitors/oracle.rb

@@ -8,7 +8,7 @@ module Arel
 
         # if need to select first records without ORDER BY and GROUP BY and without DISTINCT
         # then can use simple ROWNUM in WHERE clause
-        if o.limit && o.orders.empty? && !o.offset && o.cores.first.set_quantifier.class.to_s !~ /Distinct/
+        if o.limit && o.orders.empty? && o.cores.first.groups.empty? && !o.offset && o.cores.first.set_quantifier.class.to_s !~ /Distinct/
           o.cores.last.wheres.push Nodes::LessThanOrEqual.new(
             Nodes::SqlLiteral.new('ROWNUM'), o.limit.expr
           )

data/lib/arel/visitors/reduce.rb

@@ -10,14 +10,14 @@ module Arel
       private
 
       def visit object, collector
-        send dispatch[object.class], object, collector
+        send dispatch[object.class.name], object, collector
       rescue NoMethodError => e
-        raise e if respond_to?(dispatch[object.class], true)
+        raise e if respond_to?(dispatch[object.class.name], true)
         superklass = object.class.ancestors.find { |klass|
-          respond_to?(dispatch[klass], true)
+          respond_to?(dispatch[klass.name], true)
         }
         raise(TypeError, "Cannot visit #{object.class}") unless superklass
-        dispatch[object.class] = dispatch[superklass]
+        dispatch[object.class.name] = dispatch[superklass.name]
         retry
       end
     end

data/lib/arel/visitors/to_sql.rb

@@ -59,10 +59,8 @@ module Arel
       DISTINCT = 'DISTINCT'   # :nodoc:
 
       def initialize connection
+        super()
         @connection     = connection
-        @schema_cache   = connection.schema_cache
-        @quoted_tables  = {}
-        @quoted_columns = {}
       end
 
       def compile node, &block
@@ -71,6 +69,10 @@ module Arel
 
       private
 
+      def schema_cache
+        @connection.schema_cache
+      end
+
       def visit_Arel_Nodes_DeleteStatement o, collector
         collector << "DELETE FROM "
         collector = visit o.relation, collector
@@ -162,7 +164,7 @@ module Arel
       end
 
       def table_exists? name
-        @schema_cache.table_exists? name
+        schema_cache.table_exists? name
       end
 
       def column_for attr
@@ -176,7 +178,7 @@ module Arel
       end
 
       def column_cache(table)
-        @schema_cache.columns_hash(table)
+        schema_cache.columns_hash(table)
       end
 
       def visit_Arel_Nodes_Values o, collector
@@ -227,15 +229,9 @@ module Arel
       def visit_Arel_Nodes_SelectCore o, collector
         collector << "SELECT"
 
-        if o.top
-          collector << " "
-          collector = visit o.top, collector
-        end
+        collector = maybe_visit o.top, collector
 
-        if o.set_quantifier
-          collector << " "
-          collector = visit o.set_quantifier, collector
-        end
+        collector = maybe_visit o.set_quantifier, collector
 
         unless o.projections.empty?
           collector << SPACE
@@ -269,10 +265,7 @@ module Arel
           end
         end
 
-        if o.having
-          collector << " "
-          collector = visit(o.having, collector)
-        end
+        collector = maybe_visit o.having, collector
 
         unless o.windows.empty?
           collector << WINDOW
@@ -436,8 +429,12 @@ module Arel
       end
 
       def visit_Arel_Nodes_Grouping o, collector
-        collector << "("
-        visit(o.expr, collector) << ")"
+        if o.expr.is_a? Nodes::Grouping
+          visit(o.expr, collector)
+        else
+          collector << "("
+          visit(o.expr, collector) << ")"
+        end
       end
 
       def visit_Arel_SelectManager o, collector
@@ -471,14 +468,7 @@ module Arel
 
       def visit_Arel_Nodes_Extract o, collector
         collector << "EXTRACT(#{o.field.to_s.upcase} FROM "
-        collector = visit o.expr, collector
-        collector << ")"
-        if o.alias
-          collector << " AS "
-          visit o.alias, collector
-        else
-          collector
-        end
+        visit(o.expr, collector) << ")"
       end
 
       def visit_Arel_Nodes_Count o, collector
@@ -540,13 +530,25 @@ module Arel
       def visit_Arel_Nodes_Matches o, collector
         collector = visit o.left, collector
         collector << " LIKE "
-        visit o.right, collector
+        collector = visit o.right, collector
+        if o.escape
+          collector << ' ESCAPE '
+          visit o.escape, collector
+        else
+          collector
+        end
       end
 
       def visit_Arel_Nodes_DoesNotMatch o, collector
         collector = visit o.left, collector
         collector << " NOT LIKE "
-        visit o.right, collector
+        collector = visit o.right, collector
+        if o.escape
+          collector << ' ESCAPE '
+          visit o.escape, collector
+        else
+          collector
+        end
       end
 
       def visit_Arel_Nodes_JoinSource o, collector
@@ -755,6 +757,7 @@ module Arel
       def visit_Array o, collector
         inject_join o, collector, ", "
       end
+      alias :visit_Set :visit_Array
 
       def quote value, column = nil
         return value if Arel::Nodes::SqlLiteral === value
@@ -763,11 +766,12 @@ module Arel
 
       def quote_table_name name
         return name if Arel::Nodes::SqlLiteral === name
-        @quoted_tables[name] ||= @connection.quote_table_name(name)
+        @connection.quote_table_name(name)
       end
 
       def quote_column_name name
-        @quoted_columns[name] ||= Arel::Nodes::SqlLiteral === name ? name : @connection.quote_column_name(name)
+        return name if Arel::Nodes::SqlLiteral === name
+        @connection.quote_column_name(name)
       end
 
       def maybe_visit thing, collector

data/lib/arel/visitors/visitor.rb

@@ -1,32 +1,39 @@
 module Arel
   module Visitors
     class Visitor
+      def initialize
+        @dispatch = Hash.new do |hash, class_name|
+          raise if class_name == 'Arel::Nodes::Union'
+           hash[class_name] = "visit_#{(class_name || '').gsub('::', '_')}"
+        end
+
+        # pre-populate cache. FIXME: this should be passed in to each
+        # instance, but we can do that later.
+        self.class.private_instance_methods.sort.each do |name|
+          next unless name =~ /^visit_(.*)$/
+          @dispatch[$1.gsub('_', '::')] = name
+        end
+      end
+
       def accept object
         visit object
       end
 
       private
 
-      DISPATCH = Hash.new do |hash, visitor_class|
-        hash[visitor_class] =
-          Hash.new do |method_hash, node_class|
-            method_hash[node_class] = "visit_#{(node_class.name || '').gsub('::', '_')}"
-          end
-      end
-
       def dispatch
-        DISPATCH[self.class]
+        @dispatch
       end
 
       def visit object
-        send dispatch[object.class], object
+        send dispatch[object.class.name], object
       rescue NoMethodError => e
-        raise e if respond_to?(dispatch[object.class], true)
+        raise e if respond_to?(dispatch[object.class.name], true)
         superklass = object.class.ancestors.find { |klass|
-          respond_to?(dispatch[klass], true)
+          respond_to?(dispatch[klass.name], true)
         }
         raise(TypeError, "Cannot visit #{object.class}") unless superklass
-        dispatch[object.class] = dispatch[superklass]
+        dispatch[object.class.name] = dispatch[superklass.name]
         retry
       end
     end

data/lib/arel/visitors/where_sql.rb

@@ -1,6 +1,8 @@
 module Arel
   module Visitors
     class WhereSql < Arel::Visitors::ToSql
+      private
+
       def visit_Arel_Nodes_SelectCore o, collector
         collector << "WHERE "
         inject_join o.wheres, collector, ' AND '

data/test/attributes/test_attribute.rb

@@ -66,7 +66,7 @@ module Arel
           relation[:id].gt(10).must_be_kind_of Nodes::GreaterThan
         end
 
-        it 'should generate >= in sql' do
+        it 'should generate > in sql' do
           relation = Table.new(:users)
           mgr = relation.project relation[:id]
           mgr.where relation[:id].gt(10)
@@ -85,6 +85,17 @@ module Arel
             SELECT * FROM "users" WHERE "users"."karma" > (SELECT AVG("users"."karma") AS avg_id FROM "users")
           }
         end
+
+        it 'should accept various data types.' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:name].gt('fake_name')
+          mgr.to_sql.must_match %{"users"."name" > 'fake_name'}
+
+          current_time = ::Time.now
+          mgr.where relation[:created_at].gt(current_time)
+          mgr.to_sql.must_match %{"users"."created_at" > '#{current_time}'}
+        end
       end
 
       describe '#gt_any' do
@@ -133,6 +144,17 @@ module Arel
             SELECT "users"."id" FROM "users" WHERE "users"."id" >= 10
           }
         end
+
+        it 'should accept various data types.' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:name].gteq('fake_name')
+          mgr.to_sql.must_match %{"users"."name" >= 'fake_name'}
+
+          current_time = ::Time.now
+          mgr.where relation[:created_at].gteq(current_time)
+          mgr.to_sql.must_match %{"users"."created_at" >= '#{current_time}'}
+        end
       end
 
       describe '#gteq_any' do
@@ -181,6 +203,17 @@ module Arel
             SELECT "users"."id" FROM "users" WHERE "users"."id" < 10
           }
         end
+
+        it 'should accept various data types.' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:name].lt('fake_name')
+          mgr.to_sql.must_match %{"users"."name" < 'fake_name'}
+
+          current_time = ::Time.now
+          mgr.where relation[:created_at].lt(current_time)
+          mgr.to_sql.must_match %{"users"."created_at" < '#{current_time}'}
+        end
       end
 
       describe '#lt_any' do
@@ -229,6 +262,17 @@ module Arel
             SELECT "users"."id" FROM "users" WHERE "users"."id" <= 10
           }
         end
+
+        it 'should accept various data types.' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:name].lteq('fake_name')
+          mgr.to_sql.must_match %{"users"."name" <= 'fake_name'}
+
+          current_time = ::Time.now
+          mgr.where relation[:created_at].lteq(current_time)
+          mgr.to_sql.must_match %{"users"."created_at" <= '#{current_time}'}
+        end
       end
 
       describe '#lteq_any' do
@@ -507,15 +551,109 @@ module Arel
         end
       end
 
+      describe 'with a range' do
+        it 'can be constructed with a standard range' do
+          attribute = Attribute.new nil, nil
+          node = attribute.between(1..3)
+
+          node.must_equal Nodes::Between.new(
+            attribute,
+            Nodes::And.new([
+              Nodes::Casted.new(1, attribute),
+              Nodes::Casted.new(3, attribute)
+            ])
+          )
+        end
+
+        it 'can be constructed with a range starting from -Infinity' do
+          attribute = Attribute.new nil, nil
+          node = attribute.between(-::Float::INFINITY..3)
+
+          node.must_equal Nodes::LessThanOrEqual.new(
+            attribute,
+            Nodes::Casted.new(3, attribute)
+          )
+        end
+
+        it 'can be constructed with an exclusive range starting from -Infinity' do
+          attribute = Attribute.new nil, nil
+          node = attribute.between(-::Float::INFINITY...3)
+
+          node.must_equal Nodes::LessThan.new(
+            attribute,
+            Nodes::Casted.new(3, attribute)
+          )
+        end
+
+        it 'can be constructed with an infinite range' do
+          attribute = Attribute.new nil, nil
+          node = attribute.between(-::Float::INFINITY..::Float::INFINITY)
+
+          node.must_equal Nodes::NotIn.new(attribute, [])
+        end
+
+        it 'can be constructed with a range ending at Infinity' do
+          attribute = Attribute.new nil, nil
+          node = attribute.between(0..::Float::INFINITY)
+
+          node.must_equal Nodes::GreaterThanOrEqual.new(
+            attribute,
+            Nodes::Casted.new(0, attribute)
+          )
+        end
+
+        it 'can be constructed with an exclusive range' do
+          attribute = Attribute.new nil, nil
+          node = attribute.between(0...3)
+
+          node.must_equal Nodes::And.new([
+            Nodes::GreaterThanOrEqual.new(
+              attribute,
+              Nodes::Casted.new(0, attribute)
+            ),
+            Nodes::LessThan.new(
+              attribute,
+              Nodes::Casted.new(3, attribute)
+            )
+          ])
+        end
+      end
+
       describe '#in' do
+        it 'can be constructed with a subquery' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:name].does_not_match_all(['%chunky%','%bacon%'])
+          attribute = Attribute.new nil, nil
+
+          node = attribute.in(mgr)
+
+          node.must_equal Nodes::In.new(attribute, mgr.ast)
+        end
+
         it 'can be constructed with a list' do
+          attribute = Attribute.new nil, nil
+          node = attribute.in([1, 2, 3])
+
+          node.must_equal Nodes::In.new(
+            attribute,
+            [
+              Nodes::Casted.new(1, attribute),
+              Nodes::Casted.new(2, attribute),
+              Nodes::Casted.new(3, attribute),
+            ]
+          )
         end
 
-        it 'should return an in node' do
+        it 'can be constructed with a random object' do
           attribute = Attribute.new nil, nil
-          node = Nodes::In.new attribute, [1,2,3]
-          node.left.must_equal attribute
-          node.right.must_equal [1, 2, 3]
+          random_object = Object.new
+          node = attribute.in(random_object)
+
+          node.must_equal Nodes::In.new(
+            attribute,
+            Nodes::Casted.new(random_object, attribute)
+          )
         end
 
         it 'should generate IN in sql' do
@@ -560,13 +698,112 @@ module Arel
         end
       end
 
+      describe 'with a range' do
+        it 'can be constructed with a standard range' do
+          attribute = Attribute.new nil, nil
+          node = attribute.not_between(1..3)
+
+          node.must_equal Nodes::Grouping.new(Nodes::Or.new(
+            Nodes::LessThan.new(
+              attribute,
+              Nodes::Casted.new(1, attribute)
+            ),
+            Nodes::GreaterThan.new(
+              attribute,
+              Nodes::Casted.new(3, attribute)
+            )
+          ))
+        end
+
+        it 'can be constructed with a range starting from -Infinity' do
+          attribute = Attribute.new nil, nil
+          node = attribute.not_between(-::Float::INFINITY..3)
+
+          node.must_equal Nodes::GreaterThan.new(
+            attribute,
+            Nodes::Casted.new(3, attribute)
+          )
+        end
+
+        it 'can be constructed with an exclusive range starting from -Infinity' do
+          attribute = Attribute.new nil, nil
+          node = attribute.not_between(-::Float::INFINITY...3)
+
+          node.must_equal Nodes::GreaterThanOrEqual.new(
+            attribute,
+            Nodes::Casted.new(3, attribute)
+          )
+        end
+
+        it 'can be constructed with an infinite range' do
+          attribute = Attribute.new nil, nil
+          node = attribute.not_between(-::Float::INFINITY..::Float::INFINITY)
+
+          node.must_equal Nodes::In.new(attribute, [])
+        end
+
+        it 'can be constructed with a range ending at Infinity' do
+          attribute = Attribute.new nil, nil
+          node = attribute.not_between(0..::Float::INFINITY)
+
+          node.must_equal Nodes::LessThan.new(
+            attribute,
+            Nodes::Casted.new(0, attribute)
+          )
+        end
+
+        it 'can be constructed with an exclusive range' do
+          attribute = Attribute.new nil, nil
+          node = attribute.not_between(0...3)
+
+          node.must_equal Nodes::Grouping.new(Nodes::Or.new(
+            Nodes::LessThan.new(
+              attribute,
+              Nodes::Casted.new(0, attribute)
+            ),
+            Nodes::GreaterThanOrEqual.new(
+              attribute,
+              Nodes::Casted.new(3, attribute)
+            )
+          ))
+        end
+      end
+
       describe '#not_in' do
+        it 'can be constructed with a subquery' do
+          relation = Table.new(:users)
+          mgr = relation.project relation[:id]
+          mgr.where relation[:name].does_not_match_all(['%chunky%','%bacon%'])
+          attribute = Attribute.new nil, nil
+
+          node = attribute.not_in(mgr)
 
-        it 'should return a NotIn node' do
+          node.must_equal Nodes::NotIn.new(attribute, mgr.ast)
+        end
+
+        it 'can be constructed with a list' do
           attribute = Attribute.new nil, nil
-          node = Nodes::NotIn.new attribute, [1,2,3]
-          node.left.must_equal attribute
-          node.right.must_equal [1, 2, 3]
+          node = attribute.not_in([1, 2, 3])
+
+          node.must_equal Nodes::NotIn.new(
+            attribute,
+            [
+              Nodes::Casted.new(1, attribute),
+              Nodes::Casted.new(2, attribute),
+              Nodes::Casted.new(3, attribute),
+            ]
+          )
+        end
+
+        it 'can be constructed with a random object' do
+          attribute = Attribute.new nil, nil
+          random_object = Object.new
+          node = attribute.not_in(random_object)
+
+          node.must_equal Nodes::NotIn.new(
+            attribute,
+            Nodes::Casted.new(random_object, attribute)
+          )
         end
 
         it 'should generate NOT IN in sql' do