activerecord-jdbc-adapter 1.3.17 → 1.3.18

data/lib/arel/visitors/firebird.rb

@@ -4,19 +4,76 @@ module Arel
   module Visitors
     class Firebird < Arel::Visitors::ToSql
 
-      def visit_Arel_Nodes_SelectStatement o, a = nil
-        lim_off = ''
-        lim_off << "FIRST #{do_visit o.limit.expr, a} " if o.limit
-        lim_off << " SKIP #{do_visit o.offset.expr, a}" if o.offset
-        lim_off.strip!
+      if ArJdbc::AR42
+        def visit_Arel_Nodes_SelectStatement(o, a)
+          a = o.cores.inject(a) { |c, x| visit_Arel_Nodes_SelectCore(x, c) }
 
-        sql = o.cores.map { |x| do_visit_select_core x, a }.join
-        sql << " ORDER BY #{o.orders.map { |x| do_visit x, a }.join(', ')}" unless o.orders.empty?
+          limit, offset = o.limit, o.offset
+          if limit || offset
+            select = a.parts[0]
 
-        sql.sub!(/\A(\s*SELECT\s)/i, '\&' + lim_off + ' ') unless lim_off.empty?
-        sql
+            sql = Arel::Collectors::SQLString.new
+            visit(limit, sql) if limit
+            if offset
+              sql << ' ' if limit
+              visit(offset, sql)
+            end
+
+            a.parts[0] = "#{select} #{sql.value}"
+          end
+
+          unless o.orders.empty?
+            a << ' ORDER BY '
+            last = o.orders.length - 1
+            o.orders.each_with_index do |x, i|
+              visit(x, a);  a << ', ' unless last == i
+            end
+          end
+
+          a
+        end
+
+        def visit_Arel_Nodes_Limit(o, a)
+          a << "FIRST #{limit_for(o)}"
+        end
+
+        def visit_Arel_Nodes_Offset(o, a)
+          a << 'SKIP '; visit(o.value, a)
+        end
+
+      else
+
+        def visit_Arel_Nodes_SelectStatement o, a = nil
+          if o.limit
+            limit = do_visit o.limit.expr, a
+          else
+            limit = nil
+          end
+          if o.offset
+            offset = do_visit o.offset.expr, a
+          else
+            offset = nil
+          end
+
+          sql = o.cores.map { |x| do_visit_select_core x, a }.join
+          @connection.insert_limit_offset!(sql, limit, offset) if limit || offset
+
+          unless o.orders.empty?
+            sql << ' ORDER BY '
+            last = o.orders.length - 1
+            o.orders.each_with_index do |x, i|
+              sql << do_visit(x, a);  sql << ', ' unless last == i
+            end
+          end
+
+          sql
+        end
       end
 
     end
   end
 end
+
+Arel::Collectors::Bind.class_eval do
+  attr_reader :parts
+end if defined? Arel::Collectors::Bind

data/lib/arel/visitors/h2.rb

@@ -4,6 +4,22 @@ require 'arel/visitors/hsqldb'
 module Arel
   module Visitors
     class H2 < Arel::Visitors::HSQLDB
+      def visit_Arel_Nodes_SelectStatement(o, *)
+        o.limit ||= Arel::Nodes::Limit.new(-1) if o.offset
+        super
+      end if ArJdbc::AR42
+
+      def limit_offset sql, o
+        offset = o.offset || 0
+        offset = offset.expr unless (offset.nil? || offset == 0)
+        if limit = o.limit
+          "SELECT LIMIT #{offset} #{limit_for(limit)} #{sql[7..-1]}"
+        elsif offset > 0
+          "SELECT LIMIT #{offset} -1 #{sql[7..-1]}" # removes "SELECT "
+        else
+          sql
+        end
+      end unless ArJdbc::AR42
     end
   end
 end

data/lib/arel/visitors/hsqldb.rb

@@ -3,12 +3,16 @@ require 'arel/visitors/compat'
 module Arel
   module Visitors
     class HSQLDB < Arel::Visitors::ToSql
+      def visit_Arel_Nodes_SelectStatement(o, *)
+        o.limit ||= Arel::Nodes::Limit.new(0) if o.offset
+        super
+      end if ArJdbc::AR42
 
       def visit_Arel_Nodes_SelectStatement o, a = nil
         sql = limit_offset(o.cores.map { |x| do_visit_select_core x, a }.join, o)
         sql << " ORDER BY #{o.orders.map { |x| do_visit x, a }.join(', ')}" unless o.orders.empty?
         sql
-      end
+      end unless ArJdbc::AR42
 
       private
 
@@ -22,8 +26,7 @@ module Arel
         else
           sql
         end
-      end
-
+      end unless ArJdbc::AR42
     end
   end
 end

data/lib/arel/visitors/postgresql_jdbc.rb

@@ -0,0 +1,6 @@
+require 'arel/visitors/compat'
+
+class Arel::Visitors::PostgreSQL
+  # AREL converts bind argument markers "?" to "$n" for PG, but JDBC wants "?".
+  remove_method :visit_Arel_Nodes_BindParam if ArJdbc::AR42
+end

data/lib/arel/visitors/sql_server.rb

@@ -2,34 +2,41 @@ require 'arel/visitors/compat'
 
 module Arel
   module Visitors
-    # @note AREL set's up `Arel::Visitors::MSSQL` but we should not use that one !
+    ToSql.class_eval do
+      alias_method :_visit_Arel_Nodes_SelectStatement, :visit_Arel_Nodes_SelectStatement
+    end
+    # @note AREL set's up `Arel::Visitors::MSSQL` but its not usable as is ...
+    # @private
     class SQLServer < const_defined?(:MSSQL) ? MSSQL : ToSql
 
+      private
+
       def visit_Arel_Nodes_SelectStatement(*args) # [o] AR <= 4.0 [o, a] on 4.1
         o, a = args.first, args.last
 
-        return super if ! o.limit && ! o.offset # NOTE: really?
+        return _visit_Arel_Nodes_SelectStatement(*args) if ! o.limit && ! o.offset
 
         unless o.orders.empty?
-          select_order_by = "ORDER BY #{do_visit_columns(o.orders, a).join(', ')}"
+          select_order_by = do_visit_columns o.orders, a, 'ORDER BY '
         end
 
-        select_count = false
-        sql = o.cores.map do |x|
+        select_count = false; sql = ''
+        o.cores.each do |x|
           x = x.dup
-          order_by = select_order_by || determine_order_by(x, a)
+          core_order_by = select_order_by || determine_order_by(x, a)
           if select_count? x
-            p = order_by ? row_num_literal(order_by) : Arel::Nodes::SqlLiteral.new("*")
-            x.projections = [p]
+            x.projections = [
+              Arel::Nodes::SqlLiteral.new(core_order_by ? over_row_num(core_order_by) : '*')
+            ]
             select_count = true
           else
             # NOTE: this should really be added here and we should built the
             # wrapping SQL but than #replace_limit_offset! assumes it does that
             # ... MS-SQL adapter code seems to be 'hacked' by a lot of people
-            #x.projections << row_num_literal(order_by)
+            #x.projections << Arel::Nodes::SqlLiteral.new over_row_num(order_by)
           end
-          do_visit_select_core x, a
-        end.join
+          sql << do_visit_select_core(x, a)
+        end
 
         #sql = "SELECT _t.* FROM (#{sql}) as _t WHERE #{get_offset_limit_clause(o)}"
         select_order_by ||= "ORDER BY #{@connection.determine_order_clause(sql)}"
@@ -40,7 +47,7 @@ module Arel
         add_lock!(sql, :lock => o.lock && true)
 
         sql
-      end
+      end unless ArJdbc::AR42
 
       # @private
       MAX_LIMIT_VALUE = 9_223_372_036_854_775_807
@@ -59,19 +66,19 @@ module Arel
         #
         # we return nothing here and add the appropriate stuff with #add_lock!
         #do_visit o.expr, a
-      end
+      end unless ArJdbc::AR42
 
       def visit_Arel_Nodes_Top o, a = nil
         # `top` wouldn't really work here:
         #   User.select("distinct first_name").limit(10)
         # would generate "select top 10 distinct first_name from users",
         # which is invalid should be "select distinct top 10 first_name ..."
-        ''
+        a || ''
       end
 
       def visit_Arel_Nodes_Limit o, a = nil
         "TOP (#{do_visit o.expr, a})"
-      end
+      end unless ArJdbc::AR42
 
       def visit_Arel_Nodes_Ordering o, a = nil
         expr = do_visit o.expr, a
@@ -80,55 +87,126 @@ module Arel
         else
           expr
         end
-      end
+      end unless ArJdbc::AR42
 
       def visit_Arel_Nodes_Bin o, a = nil
-        "#{do_visit o.expr, a} COLLATE Latin1_General_CS_AS_WS"
-      end
+        expr = o.expr; sql = do_visit expr, a
+        if expr.respond_to?(:val) && expr.val.is_a?(Numeric)
+          sql
+        else
+          sql << " #{::ArJdbc::MSSQL.cs_equality_operator} "
+          sql
+        end
+      end unless ArJdbc::AR42
 
       private
 
+      def self.possibly_private_method_defined?(name)
+        private_method_defined?(name) || method_defined?(name)
+      end
+
       def select_count? x
         x.projections.length == 1 && Arel::Nodes::Count === x.projections.first
-      end
+      end unless possibly_private_method_defined? :select_count?
 
       def determine_order_by x, a
         unless x.groups.empty?
-          "ORDER BY #{do_visit_columns(x.groups, a).join(', ')}"
+          do_visit_columns x.groups, a, 'ORDER BY '
         else
-          table_pk = find_left_table_pk(x.froms, a)
-          table_pk == 'NULL' ? nil : "ORDER BY #{table_pk}"
+          table_pk = find_left_table_pk(x)
+          table_pk && "ORDER BY #{table_pk}"
         end
       end
 
-      def do_visit_columns(colls, a)
-        colls.map { |x| do_visit x, a }
+      def find_left_table_pk o
+        primary_key_from_table table_from_select_core(o)
       end
 
-      # @private
-      NON_SIMPLE_ORDER_COLUMN = /\sASC|\sDESC|\sCASE|\sCOLLATE|[\.,\[\(]/i # MIN(width)
+      def do_visit_columns(colls, a, sql)
+        last = colls.size - 1
+        colls.each_with_index do |x, i|
+          sql << do_visit(x, a); sql << ', ' unless i == last
+        end
+        sql
+      end
+
+      def do_visit_columns(colls, a, sql)
+        prefix = sql
+        sql = Arel::Collectors::PlainString.new
+        sql << prefix if prefix
 
-      def do_visit_columns(colls, a)
-        colls = colls.map { |x| do_visit x, a }
-        colls.map! do |x|
-          if x !~ NON_SIMPLE_ORDER_COLUMN && x.to_i == 0
-            @connection.quote_column_name(x)
+        last = colls.size - 1
+        colls.each_with_index do |x, i|
+          visit(x, sql); sql << ', ' unless i == last
+        end
+        sql.value
+      end if ArJdbc::AR42
+
+      def do_visit_columns(colls, a, sql)
+        non_simple_order = /\sASC|\sDESC|\sCASE|\sCOLLATE|[\.,\[\(]/i # MIN(width)
+
+        last = colls.size - 1
+        colls.each_with_index do |x, i|
+          coll = do_visit(x, a)
+
+          if coll !~ non_simple_order && coll.to_i == 0
+            sql << @connection.quote_column_name(coll)
           else
-            x
+            sql << coll
           end
+
+          sql << ', ' unless i == last
         end
-        colls
+        sql
       end if Arel::VERSION < '4.0.0'
 
-      def row_num_literal order_by
-        Arel::Nodes::SqlLiteral.new("ROW_NUMBER() OVER (#{order_by}) as _row_num")
+      def over_row_num order_by
+        "ROW_NUMBER() OVER (#{order_by}) as _row_num"
+      end # unless possibly_private_method_defined? :row_num_literal
+
+      def table_from_select_core core
+        if Arel::Table === core.from
+          core.from
+        elsif Arel::Nodes::SqlLiteral === core.from
+          Arel::Table.new(core.from, @engine)
+        elsif Arel::Nodes::JoinSource === core.source
+          Arel::Nodes::SqlLiteral === core.source.left ? Arel::Table.new(core.source.left, @engine) : core.source.left
+        end
       end
 
-      # @fixme raise exception of there is no pk?
-      # @fixme Table.primary_key will be deprecated. What is the replacement?
-      def find_left_table_pk o, a
-        return do_visit o.primary_key, a if o.instance_of? Arel::Table
-        find_left_table_pk o.left, a if o.kind_of? Arel::Nodes::Join
+      def table_from_select_core core
+        table_finder = lambda do |x|
+          case x
+          when Arel::Table
+            x
+          when Arel::Nodes::SqlLiteral
+            Arel::Table.new(x, @engine)
+          when Arel::Nodes::Join
+            table_finder.call(x.left)
+          end
+        end
+        table_finder.call(core.froms)
+      end if ActiveRecord::VERSION::STRING < '3.2'
+
+      def primary_key_from_table t
+        return unless t
+        return t.primary_key if t.primary_key
+
+        engine = t.engine
+        if engine_pk = engine.primary_key
+          pk = engine.arel_table[engine_pk]
+          return pk if pk
+        end
+
+        pk = (@primary_keys ||= {}).fetch(table_name = engine.table_name) do
+          pk_name = @connection.primary_key(table_name)
+          # some tables might be without primary key
+          @primary_keys[table_name] = pk_name && t[pk_name]
+        end
+        return pk if pk
+
+        column_name = engine.columns.first.try(:name)
+        column_name && t[column_name]
       end
 
       include ArJdbc::MSSQL::LockMethods
@@ -140,5 +218,8 @@ module Arel
     class SQLServer2000 < SQLServer
       include ArJdbc::MSSQL::LimitHelpers::SqlServer2000ReplaceLimitOffset
     end
+
+    load 'arel/visitors/sql_server/ng42.rb' if ArJdbc::AR42
+
   end
 end

data/lib/arel/visitors/sql_server/ng42.rb

@@ -0,0 +1,293 @@
+module Arel
+  module Visitors
+    class SQLServerNG < SQLServer # Arel::Visitors::ToSql
+
+      OFFSET = " OFFSET "
+      ROWS = " ROWS"
+      FETCH = " FETCH NEXT "
+      FETCH0 = " FETCH FIRST (SELECT 0) "
+      ROWS_ONLY = " ROWS ONLY"
+
+      private
+
+      # SQLServer ToSql/Visitor (Overides)
+
+      #def visit_Arel_Nodes_BindParam o, collector
+      #  collector.add_bind(o) { |i| "@#{i-1}" }
+      #end
+
+      def visit_Arel_Nodes_Bin o, collector
+        visit o.expr, collector
+        if o.expr.val.is_a? Numeric
+          collector
+        else
+          collector << " #{::ArJdbc::MSSQL.cs_equality_operator} "
+        end
+      end
+
+      def visit_Arel_Nodes_UpdateStatement(o, a)
+        if o.orders.any? && o.limit.nil?
+          o.limit = Nodes::Limit.new(9_223_372_036_854_775_807)
+        end
+        super
+      end
+
+      def visit_Arel_Nodes_Lock o, collector
+        o.expr = Arel.sql('WITH(UPDLOCK)') if o.expr.to_s =~ /FOR UPDATE/
+        collector << SPACE
+        visit o.expr, collector
+      end
+
+      def visit_Arel_Nodes_Offset o, collector
+        collector << OFFSET
+        visit o.expr, collector
+        collector << ROWS
+      end
+
+      def visit_Arel_Nodes_Limit o, collector
+        if node_value(o) == 0
+          collector << FETCH0
+          collector << ROWS_ONLY
+        else
+          collector << FETCH
+          visit o.expr, collector
+          collector << ROWS_ONLY
+        end
+      end
+
+      def visit_Arel_Nodes_SelectStatement o, collector
+        distinct_One_As_One_Is_So_Not_Fetch o
+
+        set_select_statement_lock o.lock
+
+        if o.with
+          collector = visit o.with, collector
+          collector << SPACE
+        end
+
+        return _visit_Arel_Nodes_SelectStatement(o, collector) if ! o.limit && ! o.offset
+
+        # collector = o.cores.inject(collector) { |c,x|
+        #   visit_Arel_Nodes_SelectCore(x, c)
+        # }
+
+        unless o.orders.empty?
+          select_order_by = do_visit_columns o.orders, collector, 'ORDER BY '
+        end
+
+        select_count = false
+        collector = o.cores.inject(collector) do |c, x|
+          unless core_order_by = select_order_by
+            core_order_by = generate_order_by determine_order_by(o, x)
+          end
+
+          if select_count? x
+            x.projections = [ Arel::Nodes::SqlLiteral.new(over_row_num(core_order_by)) ]
+            select_count = true
+          else
+            # NOTE: this should really be added here and we should built the
+            # wrapping SQL but than #replace_limit_offset! assumes it does that
+            # ... MS-SQL adapter code seems to be 'hacked' by a lot of people
+            #x.projections << Arel::Nodes::SqlLiteral.new(over_row_num(select_order_by))
+          end if core_order_by
+          visit_Arel_Nodes_SelectCore(x, c)
+        end
+        # END collector = o.cores.inject(collector) { |c,x|
+
+        # collector = visit_Orders_And_Let_Fetch_Happen o, collector
+        # collector = visit_Make_Fetch_Happen o, collector
+        # collector # __method__ END
+
+        self.class.collector_proxy(collector) do |sql|
+          select_order_by ||= "ORDER BY #{@connection.determine_order_clause(sql)}"
+          replace_limit_offset!(sql, limit_for(o.limit), o.offset && o.offset.value.to_i, select_order_by)
+          sql = "SELECT COUNT(*) AS count_id FROM (#{sql}) AS subquery" if select_count
+          sql
+        end
+
+      ensure
+        set_select_statement_lock nil
+      end
+
+      def visit_Arel_Nodes_JoinSource o, collector
+        if o.left
+          collector = visit o.left, collector
+          collector = visit_Arel_Nodes_SelectStatement_SQLServer_Lock collector
+        end
+        if o.right.any?
+          collector << " " if o.left
+          collector = inject_join o.right, collector, ' '
+        end
+        collector
+      end
+
+      def visit_Arel_Nodes_OuterJoin o, collector
+        collector << "LEFT OUTER JOIN "
+        collector = visit o.left, collector
+        collector = visit_Arel_Nodes_SelectStatement_SQLServer_Lock collector, space: true
+        collector << " "
+        visit o.right, collector
+      end
+
+      # SQLServer ToSql/Visitor (Additions)
+
+      def visit_Arel_Nodes_SelectStatement_SQLServer_Lock collector, options = {}
+        if lock = select_statement_lock
+          collector = visit lock, collector
+          collector << SPACE if options[:space]
+        end
+        collector
+      end
+
+      def visit_Orders_And_Let_Fetch_Happen o, collector
+        make_Fetch_Possible_And_Deterministic o
+        unless o.orders.empty?
+          collector << SPACE
+          collector << ORDER_BY
+          len = o.orders.length - 1
+          o.orders.each_with_index { |x, i|
+            collector = visit(x, collector)
+            collector << COMMA unless len == i
+          }
+        end
+        collector
+      end
+
+      def visit_Make_Fetch_Happen o, collector
+        o.offset = Nodes::Offset.new(0) if o.limit && !o.offset
+        collector = visit o.offset, collector if o.offset
+        collector = visit o.limit, collector if o.limit
+        collector
+      end
+
+      # SQLServer Helpers
+
+      # attr_reader :select_statement_lock
+      def select_statement_lock
+        Thread.current[:'Arel::Visitors::SQLServerNG.select_statement_lock']
+      end
+
+      def set_select_statement_lock(lock) # @select_statement_lock = lock
+        Thread.current[:'Arel::Visitors::SQLServerNG.select_statement_lock'] = lock
+      end
+
+      def make_Fetch_Possible_And_Deterministic o
+        return if o.limit.nil? && o.offset.nil?
+        if o.orders.empty? # ORDER BY mandatory with OFFSET FETCH clause
+          t = table_From_Statement o
+          pk = primary_Key_From_Table t
+          return unless pk
+          # Prefer deterministic vs a simple `(SELECT NULL)` expr.
+          o.orders = [ pk.asc ]
+        end
+      end
+
+      def distinct_One_As_One_Is_So_Not_Fetch o
+        core = o.cores.first
+        distinct = Nodes::Distinct === core.set_quantifier
+        oneasone = core.projections.all? { |x| x == ActiveRecord::FinderMethods::ONE_AS_ONE }
+        limitone = node_value(o.limit) == 1
+        if distinct && oneasone && limitone && !o.offset
+          core.projections = [Arel.sql("TOP(1) 1 AS [one]")]
+          o.limit = nil
+        end
+      end
+
+      def table_From_Statement o
+        core = o.cores.first
+        if Arel::Table === core.from
+          core.from
+        elsif Arel::Nodes::SqlLiteral === core.from
+          Arel::Table.new(core.from)
+        elsif Arel::Nodes::JoinSource === core.source
+          Arel::Nodes::SqlLiteral === core.source.left ? Arel::Table.new(core.source.left, @engine) : core.source.left
+        end
+      end
+
+      def primary_Key_From_Table t
+        return unless t
+        return t.primary_key if t.primary_key
+        if engine_pk = t.engine.primary_key
+          pk = t.engine.arel_table[engine_pk]
+          return pk if pk
+        end
+        pk = t.engine.connection.schema_cache.primary_keys(t.engine.table_name)
+        return pk if pk
+        column_name = t.engine.columns.first.try(:name)
+        column_name ? t[column_name] : nil
+      end
+
+      def determine_order_by o, x
+        if o.orders.any?
+          o.orders
+        elsif x.groups.any?
+          x.groups
+        else
+          pk = find_left_table_pk(x)
+          pk ? [ pk ] : nil # []
+        end
+      end
+
+      def generate_order_by orders
+        do_visit_columns orders, nil, 'ORDER BY '
+      end
+
+      SQLString = ActiveRecord::ConnectionAdapters::AbstractAdapter::SQLString
+      # BindCollector = ActiveRecord::ConnectionAdapters::AbstractAdapter::BindCollector
+
+      def self.collector_proxy(collector, &block)
+        if collector.is_a?(SQLString)
+          return SQLStringProxy.new(collector, block)
+        end
+        BindCollectorProxy.new(collector, block)
+      end
+
+      class BindCollectorProxy < ActiveRecord::ConnectionAdapters::AbstractAdapter::BindCollector
+
+        def initialize(collector, block); @delegate = collector; @block = block end
+
+        def << str; @delegate << str; self end
+
+        def add_bind bind; @delegate.add_bind bind; self end
+
+        def value; @delegate.value; end
+
+        #def substitute_binds bvs; @delegate.substitute_binds(bvs); self end
+
+        def compile(bvs, conn)
+          _yield_str @delegate.compile(bvs, conn)
+        end
+
+        private
+
+        def method_missing(name, *args, &block); @delegate.send(name, args, &block) end
+
+        def _yield_str(str); @block ? @block.call(str) : str end
+
+      end
+
+      class SQLStringProxy < ActiveRecord::ConnectionAdapters::AbstractAdapter::SQLString
+
+        def initialize(collector, block); @delegate = collector; @block = block end
+
+        def << str; @delegate << str; self end
+
+        def add_bind bind; @delegate.add_bind bind; self end
+
+        def compile(bvs, conn)
+          _yield_str @delegate.compile(bvs, conn)
+        end
+
+        private
+
+        def method_missing(name, *args, &block); @delegate.send(name, args, &block) end
+
+        def _yield_str(str); @block ? @block.call(str) : str end
+
+      end
+
+    end
+  end
+end
+
+Arel::Visitors::VISITORS['mssql'] = Arel::Visitors::VISITORS['sqlserver'] = Arel::Visitors::SQLServerNG