activerecord-jdbc-adapter 1.3.0.beta2 → 1.3.0.rc1

data/lib/active_record/connection_adapters/firebird_adapter.rb

@@ -0,0 +1 @@
+require 'arjdbc/firebird'

data/lib/active_record/connection_adapters/sqlserver_adapter.rb

@@ -0,0 +1 @@
+require 'arjdbc/mssql'

data/lib/arel/visitors/compat.rb

@@ -1,13 +1,32 @@
 module Arel
   module Visitors
     module ArJdbcCompat
+
+      protected
+
+      if ToSql.instance_method('visit').arity == 1
+        def do_visit(x, a); visit(x); end # a = nil
+      else # > AREL 4.0
+        def do_visit(x, a); visit(x, a); end
+      end
+
+      if ToSql.instance_method('visit_Arel_Nodes_SelectCore').arity == 1
+        def do_visit_select_core(x, a) # a = nil
+          visit_Arel_Nodes_SelectCore(x)
+        end
+      else # > AREL 4.0
+        def do_visit_select_core(x, a)
+          visit_Arel_Nodes_SelectCore(x, a)
+        end
+      end
+
+      private
+
       def limit_for(limit_or_node)
         limit_or_node.respond_to?(:expr) ? limit_or_node.expr.to_i : limit_or_node
       end
-    end
 
-    class ToSql
-      include ArJdbcCompat
     end
+    ToSql.send(:include, ArJdbcCompat)
   end
 end

data/lib/arel/visitors/db2.rb

@@ -3,12 +3,15 @@ require 'arel/visitors/compat'
 module Arel
   module Visitors
     class DB2 < Arel::Visitors::ToSql
-      def visit_Arel_Nodes_SelectStatement o
-        add_limit_offset([o.cores.map { |x| visit_Arel_Nodes_SelectCore x }.join,
-         ("ORDER BY #{o.orders.map { |x| visit x }.join(', ')}" unless o.orders.empty?),
-        ].compact.join(' '), o)
+
+      def visit_Arel_Nodes_SelectStatement o, a = nil
+        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?
+        add_limit_offset(sql, o)
       end
 
+      private
+
       def add_limit_offset(sql, o)
         if o.offset && o.offset.value && o.limit && o.limit.value
           @connection.replace_limit_offset_for_arel! o, sql
@@ -16,6 +19,7 @@ module Arel
           @connection.replace_limit_offset! sql, limit_for(o.limit), o.offset && o.offset.value
         end
       end
+
     end
   end
 end

data/lib/arel/visitors/derby.rb

@@ -3,30 +3,31 @@ require 'arel/visitors/compat'
 module Arel
   module Visitors
     class Derby < Arel::Visitors::ToSql
-      def visit_Arel_Nodes_SelectStatement o
-        [
-         o.cores.map { |x| visit(x) }.join,
-         ("ORDER BY #{o.orders.map { |x| visit x }.join(', ')}" unless o.orders.empty?),
-         (visit(o.offset) if o.offset),
-         (visit(o.limit) if o.limit),
-         (visit(o.lock) if o.lock),
-        ].compact.join ' '
+
+      def visit_Arel_Nodes_SelectStatement o, a = nil
+        sql = o.cores.map { |x| do_visit(x, a) }.join
+        sql << " ORDER BY #{o.orders.map { |x| visit x }.join(', ')}" unless o.orders.empty?
+        sql << " #{do_visit o.offset, a}" if o.offset
+        sql << " #{do_visit o.limit, a}" if o.limit
+        sql << " #{do_visit o.lock, a}" if o.lock
+        sql
       end
 
-      def visit_Arel_Nodes_Limit o
+      def visit_Arel_Nodes_Limit o, a = nil
         "FETCH FIRST #{limit_for(o)} ROWS ONLY"
       end
 
-      def visit_Arel_Nodes_Offset o
-        "OFFSET #{visit o.value} ROWS"
+      def visit_Arel_Nodes_Offset o, a = nil
+        "OFFSET #{do_visit o.value, a} ROWS"
       end
 
       # This generates SELECT...FOR UPDATE, but it will only work if the
       # current transaction isolation level is set to SERIALIZABLE.  Otherwise,
       # locks aren't held for the entire transaction.
-      def visit_Arel_Nodes_Lock o
-        visit o.expr
+      def visit_Arel_Nodes_Lock o, a = nil
+        do_visit o.expr, a
       end
+
     end
   end
 end

data/lib/arel/visitors/firebird.rb

@@ -3,15 +3,16 @@ require 'arel/visitors/compat'
 module Arel
   module Visitors
     class Firebird < Arel::Visitors::ToSql
-      def visit_Arel_Nodes_SelectStatement o
+
+      def visit_Arel_Nodes_SelectStatement o, a = nil
         lim_off = [
-          ("FIRST #{visit(o.limit.expr)}" if o.limit),
-          ("SKIP #{visit(o.offset.expr)}" if o.offset)
+          ("FIRST #{do_visit o.limit.expr, a}" if o.limit),
+          ("SKIP #{do_visit o.offset.expr, a}" if o.offset)
         ].compact.join(' ').strip
 
         sql = [
          o.cores.map { |x| visit_Arel_Nodes_SelectCore x }.join,
-         ("ORDER BY #{o.orders.map { |x| visit x }.join(', ')}" unless o.orders.empty?),
+         ("ORDER BY #{o.orders.map { |x| do_visit x, a }.join(', ')}" unless o.orders.empty?),
         ].compact.join ' '
 
         sql.sub!(/\A(\s*SELECT\s)/i, '\&' + lim_off + ' ') unless lim_off.empty?

data/lib/arel/visitors/hsqldb.rb

@@ -3,25 +3,27 @@ require 'arel/visitors/compat'
 module Arel
   module Visitors
     class HSQLDB < Arel::Visitors::ToSql
-      def visit_Arel_Nodes_SelectStatement o
-        [
-          limit_offset(o.cores.map { |x| visit_Arel_Nodes_SelectCore x }.join, o),
-          ("ORDER BY #{o.orders.map { |x| visit x }.join(', ')}" unless o.orders.empty?),
-        ].compact.join ' '
+
+      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
 
+      private
+
       def limit_offset sql, o
         offset = o.offset || 0
-        offset = offset.expr unless(offset.nil? or offset == 0)
-        bef = sql[7..-1]
+        offset = offset.expr unless (offset.nil? || offset == 0)
         if limit = o.limit
-          "SELECT LIMIT #{offset} #{limit_for(limit)} #{bef}"
+          "SELECT LIMIT #{offset} #{limit_for(limit)} #{sql[7..-1]}"
         elsif offset > 0
-          "SELECT LIMIT #{offset} 0 #{bef}"
+          "SELECT LIMIT #{offset} 0 #{sql[7..-1]}" # removes "SELECT "
         else
           sql
         end
       end
+
     end
   end
 end

data/lib/arel/visitors/sql_server.rb

@@ -2,93 +2,121 @@ require 'arel/visitors/compat'
 
 module Arel
   module Visitors
-    class SQLServer < ToSql
+    # @note AREL set's up `Arel::Visitors::MSSQL` but we should not use that one !
+    class SQLServer < const_defined?(:MSSQL) ? MSSQL : ToSql
 
-      # Need to mimic the subquery logic in ARel 1.x for select count with limit
-      # See arel/engines/sql/compilers/mssql_compiler.rb for details
       def visit_Arel_Nodes_SelectStatement(*args) # [o] AR <= 4.0 [o, a] on 4.1
         o, a = args.first, args.last
-        
-        if ! o.limit && o.offset
-          raise ActiveRecord::ActiveRecordError, "You must specify :limit with :offset."
+
+        if ! o.limit && ! o.offset
+          return super
+        elsif ! o.limit && o.offset
+          raise ActiveRecord::ActiveRecordError, "must specify :limit with :offset"
+        end
+
+        unless o.orders.empty?
+          select_order_by = "ORDER BY #{o.orders.map { |x| do_visit x, a }.join(', ')}"
         end
-        
-        order = "ORDER BY #{o.orders.map { |x| visit x }.join(', ')}" unless o.orders.empty?
-        if o.limit
-          if select_count?(o)
-            subquery = true
-            sql = o.cores.map do |x|
-              x = x.dup
-              x.projections = [Arel::Nodes::SqlLiteral.new("*")]
-              do_visit_select_core(x, a)
-            end.join
+
+        select_count = false
+        sql = o.cores.map do |x|
+          x = x.dup
+          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]
+            select_count = true
           else
-            sql = o.cores.map { |x| do_visit_select_core(x, a) }.join
+            # 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)
           end
+          do_visit_select_core x, a
+        end.join
+
+        #sql = "SELECT _t.* FROM (#{sql}) as _t WHERE #{get_offset_limit_clause(o)}"
+        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
 
-          order ||= "ORDER BY #{@connection.determine_order_clause(sql)}"
-          replace_limit_offset!(sql, limit_for(o.limit).to_i, o.offset && o.offset.value.to_i, order)
-          sql = "SELECT COUNT(*) AS count_id FROM (#{sql}) AS subquery" if subquery
-        else
-          sql = super
-        end
         add_lock!(sql, :lock => o.lock && true)
+
         sql
       end
-      
-      # MS-SQL doesn't support "SELECT...FOR UPDATE".  Instead, it needs
-      # WITH(ROWLOCK,UPDLOCK) specified after each table in the FROM clause.
-      #
-      # So, we return nothing here and add the appropriate stuff using add_lock! above.
-      def visit_Arel_Nodes_Lock o
-        # visit o.expr
-      end
-      
-      def visit_Arel_Nodes_UpdateStatement o
+
+      def visit_Arel_Nodes_UpdateStatement(*args) # [o] AR <= 4.0 [o, a] on 4.1
+        o = args.first
         if o.orders.any? && o.limit.nil?
           o.limit = Nodes::Limit.new(9223372036854775807)
         end
         super
       end
-      
-      def visit_Arel_Nodes_Limit(o)
-        "TOP (#{visit o.expr})"
+
+      def visit_Arel_Nodes_Lock o, a = nil
+        # MS-SQL doesn't support "SELECT...FOR UPDATE".  Instead, it needs
+        # WITH(ROWLOCK,UPDLOCK) specified after each table in the FROM clause.
+        #
+        # we return nothing here and add the appropriate stuff with #add_lock!
+        #do_visit o.expr, a
       end
-      
-      def visit_Arel_Nodes_Ordering(o)
+
+      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 ..."
+        ""
+      end
+
+      def visit_Arel_Nodes_Limit o, a = nil
+        "TOP (#{do_visit o.expr, a})"
+      end
+
+      def visit_Arel_Nodes_Ordering o, a = nil
+        expr = do_visit o.expr, a
         if o.respond_to?(:direction)
-          "#{visit o.expr} #{o.ascending? ? 'ASC' : 'DESC'}"
+          "#{expr} #{o.ascending? ? 'ASC' : 'DESC'}"
         else
-          visit o.expr
+          expr
         end
       end
-      
-      def visit_Arel_Nodes_Bin(o)
-        "#{visit o.expr} COLLATE Latin1_General_CS_AS_WS"
+
+      def visit_Arel_Nodes_Bin o, a = nil
+        "#{do_visit o.expr, a} COLLATE Latin1_General_CS_AS_WS"
       end
-      
+
       private
-      
-      def select_count? o
-        sel = o.cores.length == 1 && o.cores.first
-        projections = sel && sel.projections.length == 1 && sel.projections
-        projections && Arel::Nodes::Count === projections.first
+
+      def select_count? x
+        x.projections.length == 1 && Arel::Nodes::Count === x.projections.first
       end
-      
-      if instance_method('visit_Arel_Nodes_SelectCore').arity == 1
-        def do_visit_select_core(x, a) # a = nil
-          visit_Arel_Nodes_SelectCore(x)
+
+      def determine_order_by x, a
+        unless x.groups.empty?
+          "ORDER BY #{x.groups.map { |g| do_visit g, a }.join(', ')}"
+        else
+          table_pk = find_left_table_pk(x.froms, a)
+          table_pk == 'NULL' ? nil : "ORDER BY #{table_pk}"
         end
-      else # > AREL 4.0
-        def do_visit_select_core(x, a)
-          visit_Arel_Nodes_SelectCore(x, a)
-        end        
       end
-      
-      include ArJdbc::MSSQL::LockHelpers::SqlServerAddLock
-      
+
+      def row_num_literal order_by
+        Arel::Nodes::SqlLiteral.new("ROW_NUMBER() OVER (#{order_by}) as _row_num")
+      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
+      end
+
+      include ArJdbc::MSSQL::LockMethods
+
       include ArJdbc::MSSQL::LimitHelpers::SqlServerReplaceLimitOffset
-      
+
     end
 
     class SQLServer2000 < SQLServer

data/lib/arjdbc.rb

@@ -11,7 +11,7 @@ if defined?(JRUBY_VERSION)
       require 'active_record'
     end
   rescue LoadError => e
-    warn "activerecord-jdbc-adapter requires ActiveRecord at runtime"
+    warn "activerecord-jdbc-adapter requires the activerecord gem at runtime"
     raise e
   end
   require 'arjdbc/jdbc'

data/lib/arjdbc/db2/adapter.rb

@@ -1,18 +1,21 @@
 ArJdbc.load_java_part :DB2
 
+require 'arjdbc/db2/column'
+
 module ArJdbc
+  # @note This adapter doesn't support explain `config.active_record.auto_explain_threshold_in_seconds` should be commented (Rails < 4.0)
   module DB2
 
-    # This adapter doesn't support explain
-    # config.active_record.auto_explain_threshold_in_seconds should be commented before rails 4.0
-    
+    # @private
     def self.extended(adapter); initialize!; end
-    
+
+    # @private
     @@_initialized = nil
-    
+
+    # @private
     def self.initialize!
       return if @@_initialized; @@_initialized = true
-      
+
       require 'arjdbc/jdbc/serialized_attributes_helper'
       ActiveRecord::Base.class_eval do
         def after_save_with_db2_lob
@@ -21,189 +24,105 @@ module ArJdbc
             value = ::ArJdbc::SerializedAttributesHelper.dump_column_value(self, column)
             next if value.nil? # already set NULL
 
-            self.class.connection.write_large_object(
-              column.type == :binary, column.name, 
-              self.class.table_name, 
-              self.class.primary_key, 
-              self.class.connection.quote(id), value
-            )
+            self.class.connection.update_lob_value(self, column, value)
           end
         end
       end
       ActiveRecord::Base.after_save :after_save_with_db2_lob
     end
-    
-    def self.column_selector
-      [ /(db2|zos)/i, lambda { |cfg, column| column.extend(::ArJdbc::DB2::Column) } ]
-    end
 
+    # @see ActiveRecord::ConnectionAdapters::JdbcAdapter#jdbc_connection_class
     def self.jdbc_connection_class
       ::ActiveRecord::ConnectionAdapters::DB2JdbcConnection
     end
 
+    # @see ActiveRecord::ConnectionAdapters::JdbcAdapter#jdbc_column_class
+    def jdbc_column_class
+      ::ActiveRecord::ConnectionAdapters::DB2Column
+    end
+
+    # @see ActiveRecord::ConnectionAdapters::Jdbc::ArelSupport
+    def self.arel_visitor_type(config = nil)
+      require 'arel/visitors/db2'; ::Arel::Visitors::DB2
+    end
+
+    # @deprecated no longer used
+    # @see ActiveRecord::ConnectionAdapters::JdbcAdapter#arel2_visitors
     def self.arel2_visitors(config)
-      require 'arel/visitors/db2'
-      { 'db2' => ::Arel::Visitors::DB2 }
+      { 'db2' => arel_visitor_type }
     end
-    
+
+    # @private
     def self.handle_lobs?; true; end
-    
+
+    # @private
+    @@emulate_booleans = true
+
+    # Boolean emulation can be disabled using :
+    #
+    #   ArJdbc::DB2.emulate_booleans = false
+    #
+    def self.emulate_booleans; @@emulate_booleans; end
+    def self.emulate_booleans=(emulate); @@emulate_booleans = emulate; end
+
     def configure_connection
       schema = self.schema
       set_schema(schema) if schema && schema != config[:username]
     end
-    
+
     ADAPTER_NAME = 'DB2'.freeze
-    
+
     def adapter_name
       ADAPTER_NAME
     end
-    
+
     NATIVE_DATABASE_TYPES = {
-      :double     => { :name => "double" },
-      :bigint     => { :name => "bigint" },
       :string     => { :name => "varchar", :limit => 255 },
+      :integer    => { :name => "integer" },
+      :float      => { :name => "real" }, # :limit => 24
+      :double     => { :name => "double" }, # :limit => 53
       :text       => { :name => "clob" },
-      :date       => { :name => "date" },
       :binary     => { :name => "blob" },
-      :boolean    => { :name => "smallint" }, # no native boolean type
       :xml        => { :name => "xml" },
-      :decimal    => { :name => "decimal" },
-      :char       => { :name => "char" },
-      :decfloat   => { :name => "decfloat" },
-      :rowid      => { :name => "rowid" }, # rowid is a supported datatype on z/OS and i/5
-      :serial     => { :name => "serial" }, # supported datatype on Informix Dynamic Server
-      :graphic    => { :name => "graphic", :limit => 1 },
-      :vargraphic => { :name => "vargraphic", :limit => 1 },
+      :decimal    => { :name => "decimal" }, # :limit => 31
+      :char       => { :name => "char" }, # :limit => 254
+      :date       => { :name => "date" },
       :datetime   => { :name => "timestamp" },
       :timestamp  => { :name => "timestamp" },
-      :time       => { :name => "time" }
+      :time       => { :name => "time" },
+      :boolean    => { :name => "smallint" }, # no native boolean type
+      #:rowid      => { :name => "rowid" }, # rowid is a supported datatype on z/OS and i/5
+      #:serial     => { :name => "serial" }, # supported datatype on Informix Dynamic Server
+      #:graphic    => { :name => "graphic", :limit => 1 }, # :limit => 127
     }
 
+    # @override
     def native_database_types
-      super.merge(NATIVE_DATABASE_TYPES)
+      # NOTE: currently merging with what JDBC gives us since there's a lot
+      # of DB2-like stuff we could be connecting e.g. "classic", Z/OS etc.
+      # types = super
+      types = super.merge(NATIVE_DATABASE_TYPES)
+      types
     end
 
-    @@emulate_booleans = true
-    
-    # Boolean emulation can be disabled using :
-    # 
-    #   ArJdbc::DB2.emulate_booleans = false
-    # 
-    def self.emulate_booleans; @@emulate_booleans; end
-    def self.emulate_booleans=(emulate); @@emulate_booleans = emulate; end
-    
-    module Column
-      
-      def type_cast(value)
-        return nil if value.nil? || value == 'NULL' || value =~ /^\s*NULL\s*$/i
-        case type
-        when :string    then value
-        when :integer   then value.respond_to?(:to_i) ? value.to_i : (value ? 1 : 0)
-        when :primary_key then value.respond_to?(:to_i) ? value.to_i : (value ? 1 : 0)
-        when :float     then value.to_f
-        when :datetime  then Column.cast_to_date_or_time(value)
-        when :date      then Column.cast_to_date_or_time(value)
-        when :timestamp then Column.cast_to_time(value)
-        when :time      then Column.cast_to_time(value)
-        # TODO AS400 stores binary strings in EBCDIC (CCSID 65535), need to convert back to ASCII
-        else
-          super
-        end
-      end
-
-      def type_cast_code(var_name)
-        case type
-        when :datetime  then "ArJdbc::DB2::Column.cast_to_date_or_time(#{var_name})"
-        when :date      then "ArJdbc::DB2::Column.cast_to_date_or_time(#{var_name})"
-        when :timestamp then "ArJdbc::DB2::Column.cast_to_time(#{var_name})"
-        when :time      then "ArJdbc::DB2::Column.cast_to_time(#{var_name})"
-        else
-          super
-        end
-      end
-
-      def self.cast_to_date_or_time(value)
-        return value if value.is_a? Date
-        return nil if value.blank?
-        # https://github.com/jruby/activerecord-jdbc-adapter/commit/c225126e025df2e98ba3386c67e2a5bc5e5a73e6
-        return Time.now if value =~ /^CURRENT/
-        guess_date_or_time((value.is_a? Time) ? value : cast_to_time(value))
-      rescue
-        value
-      end
-
-      def self.cast_to_time(value)
-        return value if value.is_a? Time
-        # AS400 returns a 2 digit year, LUW returns a 4 digit year, so comp = true to help out AS400
-        time = DateTime.parse(value).to_time rescue nil
-        return nil unless time
-        time_array = [time.year, time.month, time.day, time.hour, time.min, time.sec]
-        time_array[0] ||= 2000; time_array[1] ||= 1; time_array[2] ||= 1;
-        Time.send(ActiveRecord::Base.default_timezone, *time_array) rescue nil
-      end
-
-      def self.guess_date_or_time(value)
-        return value if value.is_a? Date
-        ( value && value.hour == 0 && value.min == 0 && value.sec == 0 ) ? 
-          Date.new(value.year, value.month, value.day) : value
-      end
-
-      private
-      # http://publib.boulder.ibm.com/infocenter/db2luw/v9r7/topic/com.ibm.db2.luw.apdv.java.doc/doc/rjvjdata.html
-      def simplified_type(field_type)
-        case field_type
-        when /^decimal\(1\)$/i   then DB2.emulate_booleans ? :boolean : :integer
-        when /smallint/i         then DB2.emulate_booleans ? :boolean : :integer
-        when /boolean/i          then :boolean
-        when /^real|double/i     then :float
-        when /int|serial/i       then :integer
-        # if a numeric column has no scale, lets treat it as an integer.
-        # The AS400 rpg guys do this ALOT since they have no integer datatype ...
-        when /decimal|numeric|decfloat/i
-          extract_scale(field_type) == 0 ? :integer : :decimal
-        when /timestamp/i        then :timestamp
-        when /datetime/i         then :datetime
-        when /time/i             then :time
-        when /date/i             then :date
-        when /clob|text/i        then :text
-        when /blob|binary/i      then :binary
-        when /for bit data/i     then :binary
-        when /xml/i              then :xml
-        when /^vargraphic/i      then :vargraphic
-        when /^graphic/i         then :graphic
-        when /rowid/i            then :rowid # rowid is a supported datatype on z/OS and i/5
-        else
-          super
-        end
-      end
-
-      # Post process default value from JDBC into a Rails-friendly format (columns{-internal})
-      def default_value(value)
-        # IBM i (AS400) will return an empty string instead of null for no default
-        return nil if value.blank?
-
-        # string defaults are surrounded by single quotes
-        return $1 if value =~ /^'(.*)'$/
-
-        value
-      end
-    end
+    # @private
+    class TableDefinition < ::ActiveRecord::ConnectionAdapters::TableDefinition
 
-    class TableDefinition < ::ActiveRecord::ConnectionAdapters::TableDefinition # :nodoc:
-      
       def xml(*args)
         options = args.extract_options!
         column(args[0], 'xml', options)
       end
-      
+
       # IBM DB adapter (MRI) compatibility :
-      
+
+      # @private
+      # @deprecated
       def double(*args)
         options = args.extract_options!
         column(args[0], 'double', options)
       end
 
+      # @private
       def decfloat(*args)
         options = args.extract_options!
         column(args[0], 'decfloat', options)
@@ -214,28 +133,32 @@ module ArJdbc
         column(args[0], 'graphic', options)
       end
 
+      # @private
+      # @deprecated
       def vargraphic(*args)
         options = args.extract_options!
         column(args[0], 'vargraphic', options)
       end
 
+      # @private
+      # @deprecated
       def bigint(*args)
         options = args.extract_options!
         column(args[0], 'bigint', options)
       end
-      
+
       def char(*args)
         options = args.extract_options!
         column(args[0], 'char', options)
       end
       # alias_method :character, :char
-      
+
     end
 
     def table_definition(*args)
       new_table_definition(TableDefinition, *args)
     end
-    
+
     def prefetch_primary_key?(table_name = nil)
       # TRUE if the table has no identity column
       names = table_name.upcase.split(".")
@@ -248,22 +171,16 @@ module ArJdbc
     def next_sequence_value(sequence_name)
       select_value("SELECT NEXT VALUE FOR #{sequence_name} FROM sysibm.sysdummy1")
     end
-    
-    def last_insert_id(sql)
-      table_name = sql.split(/\s/)[2]
-      result = select(ActiveRecord::Base.send(:sanitize_sql, %[SELECT IDENTITY_VAL_LOCAL() AS last_insert_id FROM #{table_name}], nil))
-      result.last['last_insert_id']
-    end
-    
-    def create_table(name, options = {}) #:nodoc:
+
+    def create_table(name, options = {})
       if zos?
         zos_create_table(name, options)
       else
         super(name, options)
       end
     end
-    
-    def zos_create_table(name, options = {}) # :nodoc:
+
+    def zos_create_table(name, options = {})
       # NOTE: this won't work for 4.0 - need to pass different initialize args :
       table_definition = TableDefinition.new(self)
       unless options[:id] == false
@@ -326,10 +243,12 @@ module ArJdbc
     end
 
     # Properly quotes the various data types.
-    # +value+ contains the data, +column+ is optional and contains info on the field
-    def quote(value, column = nil) # :nodoc:
+    # @param value contains the data
+    # @param column (optional) contains info on the field
+    # @override
+    def quote(value, column = nil)
       return value.quoted_id if value.respond_to?(:quoted_id)
-      
+
       if column
         if column.respond_to?(:primary) && column.primary && column.klass != String
           return value.to_i.to_s
@@ -338,9 +257,9 @@ module ArJdbc
           return value.to_s
         end
       end
-      
+
       column_type = column && column.type.to_sym
-      
+
       case value
       when nil then "NULL"
       when Numeric # IBM_DB doesn't accept quotes on numeric types
@@ -371,8 +290,8 @@ module ArJdbc
       when Symbol then "'#{quote_string(value.to_s)}'"
       when Time
         # AS400 doesn't support date in time column
-        if column && column_type == :time
-          "'#{value.strftime("%H:%M:%S")}'"
+        if column_type == :time
+          quote_time(value)
         else
           super
         end
@@ -380,10 +299,27 @@ module ArJdbc
       end
     end
 
+    # @override
+    def quoted_date(value)
+      if value.acts_like?(:time) && value.respond_to?(:usec)
+        usec = sprintf("%06d", value.usec)
+        value = ::ActiveRecord::Base.default_timezone == :utc ? value.getutc : value.getlocal
+        "#{value.strftime("%Y-%m-%d %H:%M:%S")}.#{usec}"
+      else
+        super
+      end
+    end if ::ActiveRecord::VERSION::MAJOR >= 3
+
+    def quote_time(value)
+      value = ::ActiveRecord::Base.default_timezone == :utc ? value.getutc : value.getlocal
+      # AS400 doesn't support date in time column
+      "'#{value.strftime("%H:%M:%S")}'"
+    end
+
     def quote_column_name(column_name)
       column_name.to_s
     end
-    
+
     def modify_types(types)
       super(types)
       types[:primary_key] = 'int not null generated by default as identity (start with 1) primary key'
@@ -398,12 +334,8 @@ module ArJdbc
       super(type, limit, precision, scale)
     end
 
-    def add_limit_offset!(sql, options)
-      replace_limit_offset!(sql, options[:limit], options[:offset])
-    end
-    
-    def add_column_options!(sql, options) # :nodoc:
-      # handle case of defaults for CLOB columns, 
+    def add_column_options!(sql, options)
+      # handle case of defaults for CLOB columns,
       # which might get incorrect if we write LOBs in the after_save callback
       if options_include_default?(options)
         column = options[:column]
@@ -413,7 +345,7 @@ module ArJdbc
         if column && column.type == :binary
           # quoting required for the default value of a column :
           value = options.delete(:default)
-          # DB2 z/OS only allows NULL or "" (empty) string as DEFAULT value 
+          # DB2 z/OS only allows NULL or "" (empty) string as DEFAULT value
           # for a BLOB column. non-empty string and non-NULL, return error!
           if value.nil?
             sql_value = "NULL"
@@ -425,25 +357,31 @@ module ArJdbc
       end
       super
     end
-   
+
+    # @note Only used with (non-AREL) ActiveRecord **2.3**.
+    # @see Arel::Visitors::DB2
+    def add_limit_offset!(sql, options)
+      replace_limit_offset!(sql, options[:limit], options[:offset])
+    end if ::ActiveRecord::VERSION::MAJOR < 3
+
+    # @private shared with {Arel::Visitors::DB2}
     def replace_limit_offset!(sql, limit, offset)
-      if limit
-        limit = limit.to_i
+      return sql unless limit
 
-        if !offset
-          if limit == 1
-            sql << " FETCH FIRST ROW ONLY"
-          else
-            sql << " FETCH FIRST #{limit} ROWS ONLY"
-          end
+      limit = limit.to_i
+      if offset
+        replace_limit_offset_with_ordering(sql, limit, offset)
+      else
+        if limit == 1
+          sql << " FETCH FIRST ROW ONLY"
         else
-          replace_limit_offset_with_ordering( sql, limit, offset )
+          sql << " FETCH FIRST #{limit} ROWS ONLY"
         end
-        
+        sql
       end
-      sql
     end
 
+    # @private only used from {Arel::Visitors::DB2}
     def replace_limit_offset_for_arel!( query, sql )
       replace_limit_offset_with_ordering sql, query.limit.value, query.offset && query.offset.value, query.orders
     end
@@ -454,12 +392,12 @@ module ArJdbc
       sql
     end
     private :replace_limit_offset_with_ordering
-    
+
     def build_ordering( orders )
       return '' unless orders.size > 0
       # need to remove the library/table names from the orderings because we are not really ordering by them anymore
       # we are actually ordering by the results of a query where the result set has the same column names
-      orders = orders.map do |o| 
+      orders = orders.map do |o|
         # need to keep in mind that the order clause could be wrapped in a function
         matches = /(?:\w+\(|\s)*(\S+)(?:\)|\s)*/.match(o)
         o = o.gsub( matches[1], matches[1].split('.').last ) if matches
@@ -483,13 +421,14 @@ module ArJdbc
         statement << ' UNIQUE ' if options[:unique]
         statement << " INDEX #{ActiveRecord::Base.table_name_prefix}#{options[:name]} "
         statement << " ON #{table_name}(#{column_name})"
-        
+
         execute statement
       end
     end
 
-    def remove_index(table_name, options = { })
-      execute "DROP INDEX #{quote_column_name(index_name(table_name, options))}"
+    # @override
+    def remove_index!(table_name, index_name)
+      execute "DROP INDEX #{quote_column_name(index_name)}"
     end
 
     # http://publib.boulder.ibm.com/infocenter/db2luw/v9r7/topic/com.ibm.db2.luw.admin.dbobj.doc/doc/t0020130.html
@@ -537,9 +476,9 @@ module ArJdbc
         change_column_null(table_name, column_name, options[:null])
       end
     end
-    
-    # http://publib.boulder.ibm.com/infocenter/db2luw/v9r7/topic/com.ibm.db2.luw.admin.dbobj.doc/doc/t0020132.html
-    def remove_column(table_name, *column_names) # :nodoc:
+
+    def remove_column(table_name, *column_names)
+      # http://publib.boulder.ibm.com/infocenter/db2luw/v9r7/topic/com.ibm.db2.luw.admin.dbobj.doc/doc/t0020132.html
       outcome = nil
       column_names = column_names.flatten
       for column_name in column_names
@@ -549,18 +488,19 @@ module ArJdbc
       column_names.size == 1 ? outcome : nil
     end
 
-    # http://publib.boulder.ibm.com/infocenter/db2luw/v9r7/topic/com.ibm.db2.luw.sql.ref.doc/doc/r0000980.html
-    def rename_table(name, new_name) # :nodoc:
+    def rename_table(name, new_name)
+      # http://publib.boulder.ibm.com/infocenter/db2luw/v9r7/topic/com.ibm.db2.luw.sql.ref.doc/doc/r0000980.html
       execute_table_change("RENAME TABLE #{name} TO #{new_name}", new_name, 'Rename Table')
     end
-    
+
     def tables
       @connection.tables(nil, schema)
     end
 
     # only record precision and scale for types that can set them via CREATE TABLE:
     # http://publib.boulder.ibm.com/infocenter/db2luw/v9r7/topic/com.ibm.db2.luw.sql.ref.doc/doc/r0000927.html
-    HAVE_LIMIT = %w(FLOAT DECFLOAT CHAR VARCHAR CLOB BLOB NCHAR NCLOB DBCLOB GRAPHIC VARGRAPHIC) #TIMESTAMP
+
+    HAVE_LIMIT = %w(FLOAT DECFLOAT CHAR VARCHAR CLOB BLOB NCHAR NCLOB DBCLOB GRAPHIC VARGRAPHIC) # TIMESTAMP
     HAVE_PRECISION = %w(DECIMAL NUMERIC)
     HAVE_SCALE = %w(DECIMAL NUMERIC)
 
@@ -590,49 +530,68 @@ module ArJdbc
     def recreate_database(name = nil, options = {})
       drop_database(name)
     end
-    
+
     def drop_database(name = nil)
       tables.each { |table| drop_table("#{table}") }
     end
-    
+
     def execute_table_change(sql, table_name, name = nil)
       outcome = execute(sql, name)
       reorg_table(table_name, name)
       outcome
     end
     protected :execute_table_change
-    
+
     def reorg_table(table_name, name = nil)
       exec_update "call sysproc.admin_cmd ('REORG TABLE #{table_name}')", name, []
     end
     private :reorg_table
-    
+
     # alias_method :execute_and_auto_confirm, :execute
 
+    # Returns the value of an identity column of the last *INSERT* statement
+    # made over this connection.
+    # @note Check the *IDENTITY_VAL_LOCAL* function for documentation.
+    # @return [Fixnum]
+    def last_insert_id
+      @connection.identity_val_local
+    end
+
+    # NOTE: only setup query analysis on AR <= 3.0 since on 3.1 {#exec_query},
+    # {#exec_insert} will be used for AR generated queries/inserts etc.
+    # Also there's prepared statement support and {#execute} is meant to stay
+    # as a way of running non-prepared SQL statements (returning raw results).
+    if ActiveRecord::VERSION::MAJOR < 3 ||
+      ( ActiveRecord::VERSION::MAJOR == 3 && ActiveRecord::VERSION::MINOR < 1 )
+
     def _execute(sql, name = nil)
       if self.class.select?(sql)
         @connection.execute_query_raw(sql)
       elsif self.class.insert?(sql)
-        (@connection.execute_insert(sql) || last_insert_id(sql)).to_i
+        @connection.execute_insert(sql) || last_insert_id
       else
         @connection.execute_update(sql)
       end
     end
     private :_execute
-    
+
+    end
+
     DRIVER_NAME = 'com.ibm.db2.jcc.DB2Driver'.freeze
-    
+
+    # @private
     def zos?
       @zos = nil unless defined? @zos
       return @zos unless @zos.nil?
-      @zos = 
+      @zos =
         if url = config[:url]
           !!( url =~ /^jdbc:db2j:net:/ && config[:driver] == DRIVER_NAME )
         else
           nil
         end
     end
-    
+
+    # @private
     # @deprecated no longer used
     def as400?
       false
@@ -641,21 +600,21 @@ module ArJdbc
     def schema
       db2_schema
     end
-    
+
     def schema=(schema)
       set_schema(@db2_schema = schema) if db2_schema != schema
     end
-    
+
     private
-    
+
     def set_schema(schema)
       execute("SET SCHEMA #{schema}")
     end
-    
+
     def db2_schema
       @db2_schema = false unless defined? @db2_schema
       return @db2_schema if @db2_schema != false
-      @db2_schema = 
+      @db2_schema =
         if config[:schema].present?
           config[:schema]
         elsif config[:jndi].present?
@@ -665,6 +624,16 @@ module ArJdbc
           config[:username].presence || ENV['USER']
         end
     end
-    
+
   end
 end
+
+module ActiveRecord::ConnectionAdapters
+
+  remove_const(:DB2Column) if const_defined?(:DB2Column)
+
+  class DB2Column < JdbcColumn
+    include ::ArJdbc::DB2::Column
+  end
+
+end