arel 2.0.10 → 2.1.0

data/test/test_table.rb

@@ -6,6 +6,38 @@ module Arel
       @relation = Table.new(:users)
     end
 
+    it 'should create join nodes' do
+      join = @relation.create_string_join 'foo'
+      assert_kind_of Arel::Nodes::StringJoin, join
+      assert_equal 'foo', join.left
+    end
+
+    it 'should create join nodes' do
+      join = @relation.create_join 'foo', 'bar'
+      assert_kind_of Arel::Nodes::InnerJoin, join
+      assert_equal 'foo', join.left
+      assert_equal 'bar', join.right
+    end
+
+    it 'should create join nodes with a klass' do
+      join = @relation.create_join 'foo', 'bar', Arel::Nodes::OuterJoin
+      assert_kind_of Arel::Nodes::OuterJoin, join
+      assert_equal 'foo', join.left
+      assert_equal 'bar', join.right
+    end
+
+    it 'should return an insert manager' do
+      im = @relation.compile_insert 'VALUES(NULL)'
+      assert_kind_of Arel::InsertManager, im
+      assert_equal 'INSERT INTO NULL VALUES(NULL)', im.to_sql
+    end
+
+    it 'should return IM from insert_manager' do
+      im = @relation.insert_manager
+      assert_kind_of Arel::InsertManager, im
+      assert_equal im.engine, @relation.engine
+    end
+
     describe 'skip' do
       it 'should add an offset' do
         sm = @relation.skip 2
@@ -13,12 +45,6 @@ module Arel
       end
     end
 
-    describe 'primary_key' do
-      it 'should return an attribute' do
-        @relation.primary_key.name.must_equal :id
-      end
-    end
-
     describe 'select_manager' do
       it 'should return an empty select manager' do
         sm = @relation.select_manager
@@ -36,12 +62,6 @@ module Arel
     end
 
     describe 'backwards compat' do
-      describe 'joins' do
-        it 'returns nil' do
-          @relation.joins(nil).must_equal nil
-        end
-      end
-
       describe 'join' do
         it 'noops on nil' do
           mgr = @relation.join nil
@@ -84,13 +104,6 @@ module Arel
     end
 
     describe 'new' do
-      it 'takes :columns' do
-        columns = Table.engine.connection.columns("users")
-        @relation = Table.new(:users, :columns => columns)
-        @relation.columns.first.name.must_equal :id
-        @relation.engine.must_equal Table.engine
-      end
-
       it 'should accept an engine' do
         rel = Table.new :users, 'foo'
         rel.engine.must_equal 'foo'
@@ -147,18 +160,14 @@ module Arel
       end
     end
 
-    describe 'columns' do
-      it 'returns a list of columns' do
-        columns = @relation.columns
-        columns.length.must_equal 4
-        columns.map { |x| x.name.to_s }.sort.must_equal %w{ created_at bool name id }.sort
-      end
-    end
-
     it "should have a name" do
       @relation.name.must_equal 'users'
     end
 
+    it "should have a table name" do
+      @relation.table_name.must_equal 'users'
+    end
+
     it "should have an engine" do
       @relation.engine.must_equal Table.engine
     end
@@ -168,24 +177,6 @@ module Arel
         it "manufactures an attribute if the symbol names an attribute within the relation" do
           column = @relation[:id]
           column.name.must_equal :id
-          column.must_be_kind_of Attributes::Integer
-        end
-      end
-
-      describe 'when table does not exist' do
-        it 'returns nil' do
-          @relation[:foooo].must_be_nil
-        end
-      end
-    end
-  end
-
-  describe Table do
-    describe 'when checking the existence of a table' do
-      it 'should be present in the table cache despite the class of its name' do
-        [ 'users', :users ].each do |name|
-          relation = Table.new name
-          Table.table_cache(relation.engine).key?(relation.name).must_equal true
         end
       end
     end

data/test/visitors/test_depth_first.rb

@@ -29,6 +29,7 @@ module Arel
         Arel::Nodes::Grouping,
         Arel::Nodes::Offset,
         Arel::Nodes::Having,
+        Arel::Nodes::StringJoin,
         Arel::Nodes::UnqualifiedColumn,
         Arel::Nodes::Top,
         Arel::Nodes::Limit,
@@ -49,12 +50,18 @@ module Arel
         Arel::Nodes::Sum,
       ].each do |klass|
         define_method("test_#{klass.name.gsub('::', '_')}") do
-          func = klass.new(:a, :b)
+          func = klass.new(:a, "b")
           @visitor.accept func
-          assert_equal [:a, :b, func], @collector.calls
+          assert_equal [:a, "b", false, func], @collector.calls
         end
       end
 
+      def test_named_function
+        func = Arel::Nodes::NamedFunction.new(:a, :b, "c")
+        @visitor.accept func
+        assert_equal [:a, :b, false, "c", func], @collector.calls
+      end
+
       def test_lock
         lock = Nodes::Lock.new true
         @visitor.accept lock
@@ -62,25 +69,24 @@ module Arel
       end
 
       def test_count
-        count = Nodes::Count.new :a, :b, :c
+        count = Nodes::Count.new :a, :b, "c"
         @visitor.accept count
-        assert_equal [:a, :c, :b, count], @collector.calls
+        assert_equal [:a, "c", :b, count], @collector.calls
       end
 
       def test_inner_join
-        join = Nodes::InnerJoin.new :a, :b, :c
+        join = Nodes::InnerJoin.new :a, :b
         @visitor.accept join
-        assert_equal [:a, :b, :c, join], @collector.calls
+        assert_equal [:a, :b, join], @collector.calls
       end
 
       def test_outer_join
-        join = Nodes::OuterJoin.new :a, :b, :c
+        join = Nodes::OuterJoin.new :a, :b
         @visitor.accept join
-        assert_equal [:a, :b, :c, join], @collector.calls
+        assert_equal [:a, :b, join], @collector.calls
       end
 
       [
-        Arel::Nodes::And,
         Arel::Nodes::Assignment,
         Arel::Nodes::Between,
         Arel::Nodes::DoesNotMatch,
@@ -94,12 +100,12 @@ module Arel
         Arel::Nodes::NotEqual,
         Arel::Nodes::NotIn,
         Arel::Nodes::Or,
-        Arel::Nodes::StringJoin,
         Arel::Nodes::TableAlias,
         Arel::Nodes::Values,
         Arel::Nodes::As,
         Arel::Nodes::DeleteStatement,
         Arel::Nodes::Ordering,
+        Arel::Nodes::JoinSource,
       ].each do |klass|
         define_method("test_#{klass.name.gsub('::', '_')}") do
           binary = klass.new(:a, :b)
@@ -108,6 +114,17 @@ module Arel
         end
       end
 
+      # N-ary
+      [
+        Arel::Nodes::And,
+      ].each do |klass|
+        define_method("test_#{klass.name.gsub('::', '_')}") do
+          binary = klass.new([:a, :b, :c])
+          @visitor.accept binary
+          assert_equal [:a, :b, :c, binary], @collector.calls
+        end
+      end
+
       [
         Arel::Attributes::Integer,
         Arel::Attributes::Float,
@@ -167,7 +184,8 @@ module Arel
         @visitor.accept core
         assert_equal [
           :a, core.projections,
-          :b,
+          :b, [],
+          core.source,
           :c, core.wheres,
           :d, core.groups,
           :e,

data/test/visitors/test_dot.rb

@@ -7,6 +7,25 @@ module Arel
         @visitor = Visitors::Dot.new
       end
 
+      # functions
+      [
+        Nodes::Sum,
+        Nodes::Exists,
+        Nodes::Max,
+        Nodes::Min,
+        Nodes::Avg,
+      ].each do |klass|
+        define_method("test_#{klass.name.gsub('::', '_')}") do
+          op = klass.new(:a, "z")
+          @visitor.accept op
+        end
+      end
+
+      def test_named_function
+        func = Nodes::NamedFunction.new 'omg', 'omg'
+        @visitor.accept func
+      end
+
       # unary ops
       [
         Arel::Nodes::Not,
@@ -24,6 +43,34 @@ module Arel
           @visitor.accept op
         end
       end
+
+      # binary ops
+      [
+        Arel::Nodes::Assignment,
+        Arel::Nodes::Between,
+        Arel::Nodes::DoesNotMatch,
+        Arel::Nodes::Equality,
+        Arel::Nodes::GreaterThan,
+        Arel::Nodes::GreaterThanOrEqual,
+        Arel::Nodes::In,
+        Arel::Nodes::LessThan,
+        Arel::Nodes::LessThanOrEqual,
+        Arel::Nodes::Matches,
+        Arel::Nodes::NotEqual,
+        Arel::Nodes::NotIn,
+        Arel::Nodes::Or,
+        Arel::Nodes::TableAlias,
+        Arel::Nodes::Values,
+        Arel::Nodes::As,
+        Arel::Nodes::DeleteStatement,
+        Arel::Nodes::Ordering,
+        Arel::Nodes::JoinSource,
+      ].each do |klass|
+        define_method("test_#{klass.name.gsub('::', '_')}") do
+          binary = klass.new(:a, :b)
+          @visitor.accept binary
+        end
+      end
     end
   end
 end

data/test/visitors/test_ibm_db.rb

@@ -0,0 +1,27 @@
+require 'helper'
+
+module Arel
+  module Visitors
+    describe 'the ibm_db visitor' do
+      before do
+        @visitor = IBM_DB.new Table.engine
+      end
+
+      it 'uses FETCH FIRST n ROWS to limit results' do
+        stmt = Nodes::SelectStatement.new
+        stmt.limit = Nodes::Limit.new(1)
+        sql = @visitor.accept(stmt)
+        sql.must_be_like "SELECT FETCH FIRST 1 ROWS ONLY"
+      end
+
+      it 'uses FETCH FIRST n ROWS in updates with a limit' do
+        stmt = Nodes::UpdateStatement.new
+        stmt.limit = Nodes::Limit.new(1)
+        stmt.key = 'id'
+        sql = @visitor.accept(stmt)
+        sql.must_be_like "UPDATE NULL WHERE 'id' IN (SELECT 'id' FETCH FIRST 1 ROWS ONLY)"
+      end
+
+    end
+  end
+end

data/test/visitors/test_join_sql.rb

@@ -4,15 +4,21 @@ module Arel
   module Visitors
     describe 'the join_sql visitor' do
       before do
-        @visitor = JoinSql.new Table.engine
+        @visitor = ToSql.new Table.engine
+        @visitor.extend(JoinSql)
+      end
+
+      it 'should visit string join' do
+        sql = @visitor.accept Nodes::StringJoin.new('omg')
+        sql.must_be_like "'omg'"
       end
 
       describe 'inner join' do
         it 'should visit left if left is a join' do
           t    = Table.new :users
-          join = Nodes::InnerJoin.new t, t, Nodes::On.new(t[:id])
-          j2   = Nodes::InnerJoin.new join, t, Nodes::On.new(t[:id])
-          @visitor.accept(j2).must_be_like %{
+          sm   = t.select_manager
+          sm.join(t).on(t[:id]).join(t).on(t[:id])
+          sm.join_sql.must_be_like %{
             INNER JOIN "users" ON "users"."id"
             INNER JOIN "users" ON "users"."id"
           }
@@ -22,9 +28,10 @@ module Arel
       describe 'outer join' do
         it 'should visit left if left is a join' do
           t    = Table.new :users
-          join = Nodes::OuterJoin.new t, t, Nodes::On.new(t[:id])
-          j2   = Nodes::OuterJoin.new join, t, Nodes::On.new(t[:id])
-          @visitor.accept(j2).must_be_like %{
+          sm   = t.select_manager
+          sm.join(t, Nodes::OuterJoin).on(t[:id]).join(
+            t, Nodes::OuterJoin).on(t[:id])
+          sm.join_sql.must_be_like %{
             LEFT OUTER JOIN "users" ON "users"."id"
             LEFT OUTER JOIN "users" ON "users"."id"
           }

data/test/visitors/test_mssql.rb

@@ -13,6 +13,15 @@ module Arel
         sql = @visitor.accept(stmt)
         sql.must_be_like "SELECT TOP 1"
       end
+
+      it 'uses TOP in updates with a limit' do
+        stmt = Nodes::UpdateStatement.new
+        stmt.limit = Nodes::Limit.new(1)
+        stmt.key = 'id'
+        sql = @visitor.accept(stmt)
+        sql.must_be_like "UPDATE NULL WHERE 'id' IN (SELECT TOP 1 'id' )"
+      end
+
     end
   end
 end

data/test/visitors/test_oracle.rb

@@ -101,7 +101,7 @@ module Arel
             sql.must_be_like %{
               SELECT * FROM (
                 SELECT raw_sql_.*, rownum raw_rnum_
-                FROM (SELECT ) raw_sql_
+                FROM (SELECT) raw_sql_
                 WHERE rownum <= 20
               )
               WHERE raw_rnum_ > 10
@@ -126,21 +126,22 @@ module Arel
             sql.must_be_like %{
               SELECT * FROM (
                 SELECT raw_sql_.*, rownum raw_rnum_
-                FROM (SELECT ) raw_sql_
+                FROM (SELECT) raw_sql_
               )
               WHERE raw_rnum_ > 10
             }
           end
         end
 
-        it 'modified except to be minus' do
-          left = Nodes::SqlLiteral.new("SELECT * FROM users WHERE age > 10")
-          right = Nodes::SqlLiteral.new("SELECT * FROM users WHERE age > 20")
-          sql = @visitor.accept Nodes::Except.new(left, right)
-          sql.must_be_like %{
-            ( SELECT * FROM users WHERE age > 10 MINUS SELECT * FROM users WHERE age > 20 )
-          }
-        end
+      end
+
+      it 'modified except to be minus' do
+        left = Nodes::SqlLiteral.new("SELECT * FROM users WHERE age > 10")
+        right = Nodes::SqlLiteral.new("SELECT * FROM users WHERE age > 20")
+        sql = @visitor.accept Nodes::Except.new(left, right)
+        sql.must_be_like %{
+          ( SELECT * FROM users WHERE age > 10 MINUS SELECT * FROM users WHERE age > 20 )
+        }
       end
     end
   end

data/test/visitors/test_postgres.rb

@@ -31,6 +31,18 @@ module Arel
         assert_match(/LIMIT 'omg'/, sql)
         assert_equal 1, sql.scan(/LIMIT/).length, 'should have one limit'
       end
+
+      it 'should support DISTINCT ON' do
+        core = Arel::Nodes::SelectCore.new
+        core.set_quantifier = Arel::Nodes::DistinctOn.new(Arel.sql('aaron'))
+        assert_match 'DISTINCT ON ( aaron )', @visitor.accept(core)
+      end
+
+      it 'should support DISTINCT' do
+        core = Arel::Nodes::SelectCore.new
+        core.set_quantifier = Arel::Nodes::Distinct.new
+        assert_equal 'SELECT DISTINCT', @visitor.accept(core)
+      end
     end
   end
 end

data/test/visitors/test_to_sql.rb

@@ -5,22 +5,30 @@ module Arel
     describe 'the to_sql visitor' do
       before do
         @visitor = ToSql.new Table.engine
-        @attr = Table.new(:users)[:id]
+        @table = Table.new(:users)
+        @attr = @table[:id]
       end
 
-      it "should be thread safe around usage of last_column" do
-        table = Table.new(:users)
+      it 'should not quote sql literals' do
+        node = @table[Arel.star]
+        sql = @visitor.accept node
+        sql.must_be_like '"users".*'
+      end
 
-        visit_integer_column = Thread.new do
-          Thread.stop
-          @visitor.send(:visit_Arel_Attributes_Attribute, @attr)
-        end
+      it 'should visit named functions' do
+        function = Nodes::NamedFunction.new('omg', [Arel.star])
+        assert_equal 'omg(*)', @visitor.accept(function)
+      end
 
-        @visitor.accept(table[:name])
-        assert_equal(:string, @visitor.send(:last_column).type)
-        visit_integer_column.run
-        visit_integer_column.join
-        assert_equal(:string, @visitor.send(:last_column).type)
+      it 'should chain predications on named functions' do
+        function = Nodes::NamedFunction.new('omg', [Arel.star])
+        sql = @visitor.accept(function.eq(2))
+        sql.must_be_like %{ omg(*) = 2 }
+      end
+
+      it 'works with lists' do
+        function = Nodes::NamedFunction.new('omg', [Arel.star, Arel.star])
+        assert_equal 'omg(*, *)', @visitor.accept(function)
       end
 
       describe 'equality' do
@@ -65,7 +73,7 @@ module Arel
       end
 
       it "should apply Not to the whole expression" do
-        node = Nodes::And.new @attr.eq(10), @attr.eq(11)
+        node = Nodes::And.new [@attr.eq(10), @attr.eq(11)]
         sql = @visitor.accept Nodes::Not.new(node)
         sql.must_be_like %{NOT ("users"."id" = 10 AND "users"."id" = 11)}
       end
@@ -97,7 +105,7 @@ module Arel
       end
 
       it "should visit_Arel_Nodes_And" do
-        node = Nodes::And.new @attr.eq(10), @attr.eq(11)
+        node = Nodes::And.new [@attr.eq(10), @attr.eq(11)]
         @visitor.accept(node).must_be_like %{
           "users"."id" = 10 AND "users"."id" = 11
         }
@@ -111,7 +119,7 @@ module Arel
       end
 
       it "should visit visit_Arel_Attributes_Time" do
-        attr = Attributes::Time.new(@attr.relation, @attr.name, @attr.column)
+        attr = Attributes::Time.new(@attr.relation, @attr.name)
         @visitor.accept attr
       end
 
@@ -179,11 +187,44 @@ module Arel
           end
           in_node = Nodes::In.new @attr, %w{ a b c }
           visitor = visitor.new(Table.engine)
-          visitor.expected = @attr.column
+          visitor.expected = Table.engine.connection.columns(:users).find { |x|
+            x.name == 'name'
+          }
           visitor.accept(in_node).must_equal %("users"."name" IN ('a', 'b', 'c'))
         end
       end
 
+      describe "Nodes::InfixOperation" do
+        it "should handle Multiplication" do
+          node = Arel::Attributes::Decimal.new(Table.new(:products), :price) * Arel::Attributes::Decimal.new(Table.new(:currency_rates), :rate)
+          @visitor.accept(node).must_equal %("products"."price" * "currency_rates"."rate")
+        end
+
+        it "should handle Division" do
+          node = Arel::Attributes::Decimal.new(Table.new(:products), :price) / 5
+          @visitor.accept(node).must_equal %("products"."price" / 5)
+        end
+
+        it "should handle Addition" do
+          node = Arel::Attributes::Decimal.new(Table.new(:products), :price) + 6
+          @visitor.accept(node).must_equal %(("products"."price" + 6))
+        end
+
+        it "should handle Subtraction" do
+          node = Arel::Attributes::Decimal.new(Table.new(:products), :price) - 7
+          @visitor.accept(node).must_equal %(("products"."price" - 7))
+        end
+
+        it "should handle arbitrary operators" do
+          node = Arel::Nodes::InfixOperation.new(
+            '||',
+            Arel::Attributes::String.new(Table.new(:products), :name),
+            Arel::Attributes::String.new(Table.new(:products), :name)
+          )
+          @visitor.accept(node).must_equal %("products"."name" || "products"."name")
+        end
+      end
+
       describe "Nodes::NotIn" do
         it "should know how to visit" do
           node = @attr.not_in [1, 2, 3]
@@ -234,7 +275,9 @@ module Arel
           end
           in_node = Nodes::NotIn.new @attr, %w{ a b c }
           visitor = visitor.new(Table.engine)
-          visitor.expected = @attr.column
+          visitor.expected = Table.engine.connection.columns(:users).find { |x|
+            x.name == 'name'
+          }
           visitor.accept(in_node).must_equal %("users"."name" NOT IN ('a', 'b', 'c'))
         end
       end
@@ -247,6 +290,26 @@ module Arel
           }
         end
       end
+
+      describe 'TableAlias' do
+        it "should use the underlying table for checking columns" do
+          test = Table.new(:users).alias('zomgusers')[:id].eq '3'
+          @visitor.accept(test).must_be_like %{
+            "zomgusers"."id" = 3
+          }
+        end
+      end
+
+      describe 'distinct on' do
+        it 'raises not implemented error' do
+          core = Arel::Nodes::SelectCore.new
+          core.set_quantifier = Arel::Nodes::DistinctOn.new(Arel.sql('aaron'))
+
+          assert_raises(NotImplementedError) do
+            @visitor.accept(core)
+          end
+        end
+      end
     end
   end
 end