arel 3.0.0 → 3.0.3

data/lib/arel/visitors/bind_visitor.rb

@@ -0,0 +1,24 @@
+module Arel
+  module Visitors
+    module BindVisitor
+      def initialize target
+        @block = nil
+        super
+      end
+
+      def accept node, &block
+        @block = block if block_given?
+        super
+      end
+
+      private
+      def visit_Arel_Nodes_BindParam o
+        if @block
+          @block.call
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/arel/visitors/depth_first.rb

@@ -70,6 +70,7 @@ module Arel
       alias :visit_Arel_Nodes_GreaterThan        :binary
       alias :visit_Arel_Nodes_GreaterThanOrEqual :binary
       alias :visit_Arel_Nodes_In                 :binary
+      alias :visit_Arel_Nodes_InfixOperation     :binary
       alias :visit_Arel_Nodes_JoinSource         :binary
       alias :visit_Arel_Nodes_InnerJoin          :binary
       alias :visit_Arel_Nodes_LessThan           :binary
@@ -109,6 +110,8 @@ module Arel
       alias :visit_Arel_Nodes_Lock               :terminal
       alias :visit_Arel_Nodes_Node               :terminal
       alias :visit_Arel_Nodes_SqlLiteral         :terminal
+      alias :visit_Arel_Nodes_BindParam          :terminal
+      alias :visit_Arel_Nodes_Window             :terminal
       alias :visit_Arel_SqlLiteral               :terminal
       alias :visit_BigDecimal                    :terminal
       alias :visit_Bignum                        :terminal
@@ -135,6 +138,7 @@ module Arel
         visit o.source
         visit o.wheres
         visit o.groups
+        visit o.windows
         visit o.having
       end
 

data/lib/arel/visitors/dot.rb

@@ -65,6 +65,7 @@ module Arel
         visit_edge o, "expr"
       end
       alias :visit_Arel_Nodes_Group             :unary
+      alias :visit_Arel_Nodes_BindParam         :unary
       alias :visit_Arel_Nodes_Grouping          :unary
       alias :visit_Arel_Nodes_Having            :unary
       alias :visit_Arel_Nodes_Limit             :unary
@@ -73,6 +74,23 @@ module Arel
       alias :visit_Arel_Nodes_On                :unary
       alias :visit_Arel_Nodes_Top               :unary
       alias :visit_Arel_Nodes_UnqualifiedColumn :unary
+      alias :visit_Arel_Nodes_Preceding         :unary
+      alias :visit_Arel_Nodes_Following         :unary
+      alias :visit_Arel_Nodes_Rows              :unary
+      alias :visit_Arel_Nodes_Range             :unary
+
+      def window o
+        visit_edge o, "orders"
+        visit_edge o, "framing"
+      end
+      alias :visit_Arel_Nodes_Window            :window
+
+      def named_window o
+        visit_edge o, "orders"
+        visit_edge o, "framing"
+        visit_edge o, "name"        
+      end
+      alias :visit_Arel_Nodes_NamedWindow       :named_window
 
       def function o
         visit_edge o, "expressions"
@@ -85,6 +103,12 @@ module Arel
       alias :visit_Arel_Nodes_Avg    :function
       alias :visit_Arel_Nodes_Sum    :function
 
+      def extract o
+        visit_edge o, "expressions"
+        visit_edge o, "alias"
+      end
+      alias :visit_Arel_Nodes_Extract :extract
+
       def visit_Arel_Nodes_NamedFunction o
         visit_edge o, "name"
         visit_edge o, "expressions"
@@ -102,6 +126,7 @@ module Arel
         visit_edge o, "source"
         visit_edge o, "projections"
         visit_edge o, "wheres"
+        visit_edge o, "windows"
       end
 
       def visit_Arel_Nodes_SelectStatement o
@@ -158,6 +183,7 @@ module Arel
       alias :visit_Arel_Nodes_NotEqual           :binary
       alias :visit_Arel_Nodes_NotIn              :binary
       alias :visit_Arel_Nodes_Or                 :binary
+      alias :visit_Arel_Nodes_Over               :binary
 
       def visit_String o
         @node_stack.last.fields << o

data/lib/arel/visitors/informix.rb

@@ -15,7 +15,7 @@ module Arel
       def visit_Arel_Nodes_SelectCore o
         [
           "#{o.projections.map { |x| visit x }.join ', '}",
-          ("FROM #{visit o.froms}" if o.froms),
+          ("FROM #{visit(o.source)}" if o.source && !o.source.empty?),
           ("WHERE #{o.wheres.map { |x| visit x }.join ' AND ' }" unless o.wheres.empty?),
           ("GROUP BY #{o.groups.map { |x| visit x }.join ', ' }" unless o.groups.empty?),
           (visit(o.having) if o.having),

data/lib/arel/visitors/to_sql.rb

@@ -108,7 +108,7 @@ key on UpdateManager using UpdateManager#key=
       def visit_Arel_Nodes_Values o
         "VALUES (#{o.expressions.zip(o.columns).map { |value, attr|
           if Nodes::SqlLiteral === value
-            visit_Arel_Nodes_SqlLiteral value
+            visit value
           else
             quote(value, attr && column_for(attr))
           end
@@ -133,9 +133,10 @@ key on UpdateManager using UpdateManager#key=
           (visit(o.set_quantifier) if o.set_quantifier),
           ("#{o.projections.map { |x| visit x }.join ', '}" unless o.projections.empty?),
           ("FROM #{visit(o.source)}" if o.source && !o.source.empty?),
-          ("WHERE #{o.wheres.map { |x| accept x }.join ' AND ' }" unless o.wheres.empty?),
+          ("WHERE #{o.wheres.map { |x| visit x }.join ' AND ' }" unless o.wheres.empty?),
           ("GROUP BY #{o.groups.map { |x| visit x }.join ', ' }" unless o.groups.empty?),
           (visit(o.having) if o.having),
+          ("WINDOW #{o.windows.map { |x| visit x }.join ', ' }" unless o.windows.empty?)
         ].compact.join ' '
       end
 
@@ -175,6 +176,59 @@ key on UpdateManager using UpdateManager#key=
         "( #{visit o.left} EXCEPT #{visit o.right} )"
       end
 
+      def visit_Arel_Nodes_NamedWindow o
+        "#{quote_column_name o.name} AS #{visit_Arel_Nodes_Window o}"
+      end
+
+      def visit_Arel_Nodes_Window o
+        s = [
+          ("ORDER BY #{o.orders.map { |x| visit(x) }.join(', ')}" unless o.orders.empty?),
+          (visit o.framing if o.framing)
+        ].compact.join ' '
+        "(#{s})"
+      end
+
+      def visit_Arel_Nodes_Rows o
+        if o.expr
+          "ROWS #{visit o.expr}"
+        else
+          "ROWS"
+        end
+      end
+
+      def visit_Arel_Nodes_Range o
+        if o.expr
+          "RANGE #{visit o.expr}"
+        else
+          "RANGE"
+        end
+      end
+
+      def visit_Arel_Nodes_Preceding o
+        "#{o.expr ? visit(o.expr) : 'UNBOUNDED'} PRECEDING"
+      end
+
+      def visit_Arel_Nodes_Following o
+        "#{o.expr ? visit(o.expr) : 'UNBOUNDED'} FOLLOWING"
+      end
+
+      def visit_Arel_Nodes_CurrentRow o
+        "CURRENT ROW"
+      end
+
+      def visit_Arel_Nodes_Over o
+        case o.right
+          when nil
+            "#{visit o.left} OVER ()"
+          when Arel::Nodes::SqlLiteral
+            "#{visit o.left} OVER #{visit o.right}"
+          when String, Symbol
+            "#{visit o.left} OVER #{quote_column_name o.right.to_s}"
+          else
+            "#{visit o.left} OVER #{visit o.right}"
+        end
+      end
+
       def visit_Arel_Nodes_Having o
         "HAVING #{visit o.expr}"
       end
@@ -218,6 +272,10 @@ key on UpdateManager using UpdateManager#key=
         }.join(', ')})#{o.alias ? " AS #{visit o.alias}" : ''}"
       end
 
+      def visit_Arel_Nodes_Extract o
+        "EXTRACT(#{o.field.to_s.upcase} FROM #{visit o.expr})#{o.alias ? " AS #{visit o.alias}" : ''}"
+      end
+
       def visit_Arel_Nodes_Count o
         "COUNT(#{o.distinct ? 'DISTINCT ' : ''}#{o.expressions.map { |x|
           visit x
@@ -312,11 +370,19 @@ key on UpdateManager using UpdateManager#key=
       end
 
       def visit_Arel_Nodes_In o
-        "#{visit o.left} IN (#{visit o.right})"
+        if Array === o.right && o.right.empty?
+          '1=0'
+        else
+          "#{visit o.left} IN (#{visit o.right})"
+        end
       end
 
       def visit_Arel_Nodes_NotIn o
-        "#{visit o.left} NOT IN (#{visit o.right})"
+        if Array === o.right && o.right.empty?
+          '1=1'
+        else
+          "#{visit o.left} NOT IN (#{visit o.right})"
+        end
       end
 
       def visit_Arel_Nodes_And o
@@ -374,6 +440,7 @@ key on UpdateManager using UpdateManager#key=
 
       def literal o; o end
 
+      alias :visit_Arel_Nodes_BindParam  :literal
       alias :visit_Arel_Nodes_SqlLiteral :literal
       alias :visit_Arel_SqlLiteral       :literal # This is deprecated
       alias :visit_Bignum                :literal

data/lib/arel/window_predications.rb

@@ -0,0 +1,9 @@
+module Arel
+  module WindowPredications
+
+    def over(expr = nil)
+      Nodes::Over.new(self, expr)
+    end
+
+  end
+end

data/test/nodes/test_extract.rb

@@ -0,0 +1,19 @@
+require 'helper'
+
+describe Arel::Nodes::Extract do
+  it "should extract field" do
+    table = Arel::Table.new :users
+    table[:timestamp].extract('date').to_sql.must_be_like %{
+      EXTRACT(DATE FROM "users"."timestamp")
+    }
+  end
+
+  describe "as" do
+    it 'should alias the extract' do
+      table = Arel::Table.new :users
+      table[:timestamp].extract('date').as('foo').to_sql.must_be_like %{
+        EXTRACT(DATE FROM "users"."timestamp") AS foo
+      }
+    end
+  end
+end

data/test/nodes/test_node.rb

@@ -11,6 +11,7 @@ module Arel
         Nodes.const_get(k)
       }.grep(Class).each do |klass|
         next if Nodes::SqlLiteral == klass
+        next if Nodes::BindParam == klass
         next if klass.name =~ /^Arel::Nodes::Test/
         assert klass.ancestors.include?(Nodes::Node), klass.name
       end

data/test/nodes/test_over.rb

@@ -0,0 +1,49 @@
+require 'helper'
+
+describe Arel::Nodes::Over do
+  describe 'as' do
+    it 'should alias the expression' do
+      table = Arel::Table.new :users
+      table[:id].count.over.as('foo').to_sql.must_be_like %{
+        COUNT("users"."id") OVER () AS foo
+      }
+    end
+  end
+
+  describe 'with literal' do
+    it 'should reference the window definition by name' do
+      table = Arel::Table.new :users
+      table[:id].count.over('foo').to_sql.must_be_like %{
+        COUNT("users"."id") OVER "foo"
+      }
+    end
+  end
+
+  describe 'with SQL literal' do
+    it 'should reference the window definition by name' do
+      table = Arel::Table.new :users
+      table[:id].count.over(Arel.sql('foo')).to_sql.must_be_like %{
+        COUNT("users"."id") OVER foo
+      }
+    end
+  end
+
+  describe 'with no expression' do
+    it 'should use empty definition' do
+      table = Arel::Table.new :users
+      table[:id].count.over.to_sql.must_be_like %{
+        COUNT("users"."id") OVER ()
+      }
+    end
+  end
+
+  describe 'with expression' do
+    it 'should use definition in sub-expression' do
+      table = Arel::Table.new :users
+      window = Arel::Nodes::Window.new.order(table['foo'])
+      table[:id].count.over(window).to_sql.must_be_like %{
+        COUNT("users"."id") OVER (ORDER BY \"users\".\"foo\")
+      }
+    end
+  end
+end

data/test/test_select_manager.rb

@@ -731,6 +731,162 @@ module Arel
       end
     end
 
+    describe 'window definition' do
+      it 'can be empty' do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new Table.engine
+        manager.from table
+        manager.window('a_window')
+        manager.to_sql.must_be_like %{
+          SELECT FROM "users" WINDOW "a_window" AS ()
+        }
+      end
+
+      it 'takes an order' do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new Table.engine
+        manager.from table
+        manager.window('a_window').order(table['foo'].asc)
+        manager.to_sql.must_be_like %{
+          SELECT FROM "users" WINDOW "a_window" AS (ORDER BY "users"."foo" ASC)
+        }
+      end
+
+      it 'takes a rows frame, unbounded preceding' do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new Table.engine
+        manager.from table
+        manager.window('a_window').rows(Arel::Nodes::Preceding.new)
+        manager.to_sql.must_be_like %{
+          SELECT FROM "users" WINDOW "a_window" AS (ROWS UNBOUNDED PRECEDING)
+        }
+      end
+
+      it 'takes a rows frame, bounded preceding' do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new Table.engine
+        manager.from table
+        manager.window('a_window').rows(Arel::Nodes::Preceding.new(5))
+        manager.to_sql.must_be_like %{
+          SELECT FROM "users" WINDOW "a_window" AS (ROWS 5 PRECEDING)
+        }
+      end
+
+      it 'takes a rows frame, unbounded following' do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new Table.engine
+        manager.from table
+        manager.window('a_window').rows(Arel::Nodes::Following.new)
+        manager.to_sql.must_be_like %{
+          SELECT FROM "users" WINDOW "a_window" AS (ROWS UNBOUNDED FOLLOWING)
+        }
+      end
+
+      it 'takes a rows frame, bounded following' do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new Table.engine
+        manager.from table
+        manager.window('a_window').rows(Arel::Nodes::Following.new(5))
+        manager.to_sql.must_be_like %{
+          SELECT FROM "users" WINDOW "a_window" AS (ROWS 5 FOLLOWING)
+        }
+      end
+
+      it 'takes a rows frame, current row' do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new Table.engine
+        manager.from table
+        manager.window('a_window').rows(Arel::Nodes::CurrentRow.new)
+        manager.to_sql.must_be_like %{
+          SELECT FROM "users" WINDOW "a_window" AS (ROWS CURRENT ROW)
+        }
+      end
+
+      it 'takes a rows frame, between two delimiters' do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new Table.engine
+        manager.from table
+        window = manager.window('a_window')
+        window.frame(
+          Arel::Nodes::Between.new(
+            window.rows,
+            Nodes::And.new([
+              Arel::Nodes::Preceding.new,
+              Arel::Nodes::CurrentRow.new
+            ])))
+        manager.to_sql.must_be_like %{
+          SELECT FROM "users" WINDOW "a_window" AS (ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
+        }
+      end
+
+      it 'takes a range frame, unbounded preceding' do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new Table.engine
+        manager.from table
+        manager.window('a_window').range(Arel::Nodes::Preceding.new)
+        manager.to_sql.must_be_like %{
+          SELECT FROM "users" WINDOW "a_window" AS (RANGE UNBOUNDED PRECEDING)
+        }
+      end
+
+      it 'takes a range frame, bounded preceding' do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new Table.engine
+        manager.from table
+        manager.window('a_window').range(Arel::Nodes::Preceding.new(5))
+        manager.to_sql.must_be_like %{
+          SELECT FROM "users" WINDOW "a_window" AS (RANGE 5 PRECEDING)
+        }
+      end
+
+      it 'takes a range frame, unbounded following' do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new Table.engine
+        manager.from table
+        manager.window('a_window').range(Arel::Nodes::Following.new)
+        manager.to_sql.must_be_like %{
+          SELECT FROM "users" WINDOW "a_window" AS (RANGE UNBOUNDED FOLLOWING)
+        }
+      end
+
+      it 'takes a range frame, bounded following' do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new Table.engine
+        manager.from table
+        manager.window('a_window').range(Arel::Nodes::Following.new(5))
+        manager.to_sql.must_be_like %{
+          SELECT FROM "users" WINDOW "a_window" AS (RANGE 5 FOLLOWING)
+        }
+      end
+
+      it 'takes a range frame, current row' do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new Table.engine
+        manager.from table
+        manager.window('a_window').range(Arel::Nodes::CurrentRow.new)
+        manager.to_sql.must_be_like %{
+          SELECT FROM "users" WINDOW "a_window" AS (RANGE CURRENT ROW)
+        }
+      end
+
+      it 'takes a range frame, between two delimiters' do
+        table   = Table.new :users
+        manager = Arel::SelectManager.new Table.engine
+        manager.from table
+        window = manager.window('a_window')
+        window.frame(
+          Arel::Nodes::Between.new(
+            window.range,
+            Nodes::And.new([
+              Arel::Nodes::Preceding.new,
+              Arel::Nodes::CurrentRow.new
+            ])))
+        manager.to_sql.must_be_like %{
+          SELECT FROM "users" WINDOW "a_window" AS (RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
+        }
+      end
+    end
+
     describe 'delete' do
       it "copies from" do
         engine  = EngineProxy.new Table.engine