activerecord-jdbc-adapter 1.0.3-java → 50.1-java

data/lib/arjdbc.rb

@@ -1,29 +1,19 @@
 if defined?(JRUBY_VERSION)
   begin
-    tried_gem ||= false
     require 'active_record/version'
-  rescue LoadError
-    raise if tried_gem
-    require 'rubygems'
-    gem 'activerecord'
-    tried_gem = true
-    retry
-  end
-  if ActiveRecord::VERSION::MAJOR < 2
-    if defined?(RAILS_CONNECTION_ADAPTERS)
-      RAILS_CONNECTION_ADAPTERS << %q(jdbc)
-    else
-      RAILS_CONNECTION_ADAPTERS = %w(jdbc)
-    end
-    if ActiveRecord::VERSION::MAJOR == 1 && ActiveRecord::VERSION::MINOR == 14
-      require 'arjdbc/jdbc'
-    end
-  else
     require 'active_record'
-    require 'arjdbc/jdbc'
+  rescue LoadError => e
+    warn "activerecord-jdbc-adapter requires the activerecord gem at runtime"
+    raise e
   end
+  require 'arjdbc/jdbc'
+  begin
+    require 'arjdbc/railtie'
+  rescue LoadError => e
+    warn "activerecord-jdbc-adapter failed to load railtie: #{e.inspect}"
+  end if defined?(Rails) && ActiveRecord::VERSION::MAJOR >= 3
 else
-  warn "ActiveRecord-JDBC is for use with JRuby only"
+  warn "activerecord-jdbc-adapter is for use with JRuby only"
 end
 
-require 'arjdbc/version'
+require 'arjdbc/version'

data/lib/arjdbc/abstract/connection_management.rb

@@ -0,0 +1,35 @@
+module ArJdbc
+  module Abstract
+    module ConnectionManagement
+
+      # @override
+      def active?
+        return unless @connection
+        @connection.active?
+      end
+
+      # @override
+      def reconnect!
+        super # clear_cache! && reset_transaction
+        @connection.reconnect! # handles adapter.configure_connection
+      end
+
+      # @override
+      def disconnect!
+        super # clear_cache! && reset_transaction
+        return unless @connection
+        @connection.disconnect!
+      end
+
+      # @override
+      # def verify!(*ignored)
+      #  if @connection && @connection.jndi?
+      #    # checkout call-back does #reconnect!
+      #  else
+      #    reconnect! unless active? # super
+      #  end
+      # end
+
+    end
+  end
+end

data/lib/arjdbc/abstract/core.rb

@@ -0,0 +1,64 @@
+module ArJdbc
+  module Abstract
+
+    # This is minimum amount of code needed from base JDBC Adapter class to make common adapters
+    # work.  This replaces using jdbc/adapter as a base class for all adapters.
+    module Core
+
+      attr_reader :config
+
+      def initialize(connection, logger = nil, config = {})
+        @config = config
+
+        if self.class.equal? ActiveRecord::ConnectionAdapters::JdbcAdapter
+          spec = @config.key?(:adapter_spec) ? @config[:adapter_spec] :
+                     ( @config[:adapter_spec] = adapter_spec(@config) ) # due resolving visitor
+          extend spec if spec
+        end
+
+        connection ||= jdbc_connection_class(config[:adapter_spec]).new(config, self)
+
+        super(connection, logger, config) # AbstractAdapter
+
+        connection.configure_connection # will call us (maybe)
+      end
+      
+      # Retrieve the raw `java.sql.Connection` object.
+      # The unwrap parameter is useful if an attempt to unwrap a pooled (JNDI)
+      # connection should be made - to really return the 'native' JDBC object.
+      # @param unwrap [true, false] whether to unwrap the connection object
+      # @return [Java::JavaSql::Connection] the JDBC connection
+      def jdbc_connection(unwrap = nil)
+        raw_connection.jdbc_connection(unwrap)
+      end
+
+      protected
+
+      def translate_exception_class(e, sql)
+        begin
+          message = "#{e.class.name}: #{e.message}: #{sql}"
+        rescue Encoding::CompatibilityError
+          message = "#{e.class.name}: #{e.message.force_encoding sql.encoding}: #{sql}"
+        end
+
+        exception = translate_exception(e, message)
+        exception.set_backtrace e.backtrace unless e.equal?(exception)
+        exception
+      end
+
+      def translate_exception(e, message)
+        # we shall not translate native "Java" exceptions as they might
+        # swallow an ArJdbc / driver bug into an AR::StatementInvalid !
+        return e if e.is_a?(Java::JavaLang::Throwable)
+
+        case e
+          when SystemExit, SignalException, NoMemoryError then e
+          when ActiveModel::RangeError, TypeError, RuntimeError then e
+          else ActiveRecord::StatementInvalid.new(message)
+        end
+      end
+
+
+    end
+  end
+end

data/lib/arjdbc/abstract/database_statements.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module ArJdbc
+  module Abstract
+
+    # This provides the basic interface for interacting with the
+    # database for JDBC based adapters
+    module DatabaseStatements
+
+      NO_BINDS = [].freeze
+
+      def exec_insert(sql, name = nil, binds = NO_BINDS, pk = nil, sequence_name = nil)
+        if without_prepared_statement?(binds)
+          log(sql, name) { @connection.execute_insert(sql) }
+        else
+          log(sql, name, binds) do
+            @connection.execute_insert(sql, binds)
+          end
+        end
+      end
+
+      # It appears that at this point (AR 5.0) "prepare" should only ever be true
+      # if prepared statements are enabled
+      def exec_query(sql, name = nil, binds = NO_BINDS, prepare: false)
+        if without_prepared_statement?(binds)
+          log(sql, name) { @connection.execute_query(sql) }
+        else
+          log(sql, name, binds) do
+            # It seems that #supports_statement_cache? is defined but isn't checked before setting "prepare" (AR 5.0)
+            cached_statement = fetch_cached_statement(sql) if prepare && supports_statement_cache?
+            @connection.execute_prepared_query(sql, binds, cached_statement)
+          end
+        end
+      end
+
+      def exec_update(sql, name = nil, binds = NO_BINDS)
+        if without_prepared_statement?(binds)
+          log(sql, name) { @connection.execute_update(sql) }
+        else
+          log(sql, name, binds) { @connection.execute_prepared_update(sql, binds) }
+        end
+      end
+      alias :exec_delete :exec_update
+
+      def execute(sql, name = nil)
+        log(sql, name) { @connection.execute(sql) }
+      end
+
+      def select_all(arel, name = nil, binds = NO_BINDS, preparable: nil)
+        binds = convert_legacy_binds_to_attributes(binds) if binds.first.is_a?(Array)
+        super
+      end
+
+      private
+
+      def convert_legacy_binds_to_attributes(binds)
+        binds.map do |column, value|
+          ActiveRecord::Relation::QueryAttribute.new(nil, type_cast(value, column), ActiveModel::Type::Value.new)
+        end
+      end
+
+    end
+  end
+end

data/lib/arjdbc/abstract/statement_cache.rb

@@ -0,0 +1,58 @@
+require 'active_record/connection_adapters/statement_pool'
+
+module ArJdbc
+  module Abstract
+    module StatementCache
+
+      # This works a little differently than the AR implementation in that
+      # we are storing an actual PreparedStatement object instead of just
+      # the name of the prepared statement
+      class StatementPool < ActiveRecord::ConnectionAdapters::StatementPool
+
+        private
+
+        def dealloc(statement)
+          statement.close
+        end
+
+      end
+
+      def initialize(*args) # (connection, logger, config)
+        super
+
+        # Only say we support the statement cache if we are using prepared statements
+        # and have a max number of statements defined
+        statement_limit = self.class.type_cast_config_to_integer(config[:statement_limit])
+        @jdbc_statement_cache_enabled = config[:prepared_statements] && (statement_limit.nil? || statement_limit > 0)
+
+        @statements = StatementPool.new(statement_limit) # AR (5.0) expects this to be stored as @statements
+      end
+
+      # Clears the prepared statements cache.
+      def clear_cache!
+        @statements.clear
+      end
+
+      def delete_cached_statement(sql)
+        @statements.delete(cached_statement_key(sql))
+      end
+
+      def fetch_cached_statement(sql)
+        @statements[cached_statement_key(sql)] ||= @connection.connection.prepare_statement(sql)
+      end
+
+      def supports_statement_cache?
+        @jdbc_statement_cache_enabled
+      end
+
+      private
+
+      # This should be overridden by the adapter if the sql itself
+      # is not enough to make the key unique
+      def cached_statement_key(sql)
+        sql
+      end
+
+    end
+  end
+end

data/lib/arjdbc/abstract/transaction_support.rb

@@ -0,0 +1,86 @@
+module ArJdbc
+  module Abstract
+
+    # Provides the basic interface needed to support transactions for JDBC based adapters
+    module TransactionSupport
+
+      ########################## Support Checks #################################
+
+      # Does our database (+ its JDBC driver) support save-points?
+      # @since 1.3.0
+      # @override
+      def supports_savepoints?
+        @connection.supports_savepoints?
+      end
+
+      # Does this adapter support setting the isolation level for a transaction?
+      # Unlike 'plain' `ActiveRecord` we allow checking for concrete transaction
+      # isolation level support by the database.
+      # @param level optional to check if we support a specific isolation level
+      # @since 1.3.0
+      # @extension added optional level parameter
+      def supports_transaction_isolation?(level = nil)
+        return false unless level
+        @connection.supports_transaction_isolation?(level)
+      end
+
+      ########################## Transaction Interface ##########################
+
+      # Starts a database transaction.
+      # @override
+      def begin_db_transaction
+        log('BEGIN TRANSACTION'.freeze, nil) { @connection.begin }
+      end
+
+      # Starts a database transaction.
+      # @param isolation the transaction isolation to use
+      def begin_isolated_db_transaction(isolation)
+        log("BEGIN ISOLATED TRANSACTION - #{isolation}", nil) { @connection.begin(isolation) }
+      end
+
+      # Commits the current database transaction.
+      # @override
+      def commit_db_transaction
+        log('COMMIT TRANSACTION'.freeze, nil) { @connection.commit }
+      end
+
+      # Rolls back the current database transaction.
+      # Called from 'rollback_db_transaction' in the AbstractAdapter
+      # @override
+      def exec_rollback_db_transaction
+        log('ROLLBACK TRANSACTION'.freeze, nil) { @connection.rollback }
+      end
+
+      ########################## Savepoint Interface ############################
+
+      # Creates a (transactional) save-point one can rollback to.
+      # Unlike 'plain' `ActiveRecord` it is allowed to pass a save-point name.
+      # @param name the save-point name
+      # @return save-point name (even if nil passed will be generated)
+      # @since 1.3.0
+      # @extension added optional name parameter
+      def create_savepoint(name = current_savepoint_name)
+        log("SAVEPOINT #{name}", 'Savepoint') { @connection.create_savepoint(name) }
+      end
+
+      # Transaction rollback to a given (previously created) save-point.
+      # If no save-point name given rollback to the last created one.
+      # Called from 'rollback_to_savepoint' in AbstractAdapter
+      # @param name the save-point name
+      # @extension added optional name parameter
+      def exec_rollback_to_savepoint(name = current_savepoint_name)
+        log("ROLLBACK TO SAVEPOINT #{name}", 'Savepoint') { @connection.rollback_savepoint(name) }
+      end
+
+      # Release a previously created save-point.
+      # @note Save-points are auto-released with the transaction they're created
+      # in (on transaction commit or roll-back).
+      # @param name the save-point name
+      # @extension added optional name parameter
+      def release_savepoint(name = current_savepoint_name)
+        log("RELEASE SAVEPOINT #{name}", 'Savepoint') { @connection.release_savepoint(name) }
+      end
+
+    end
+  end
+end

data/lib/arjdbc/db2.rb

@@ -1,2 +1,4 @@
-require 'arjdbc/jdbc'
+require 'arjdbc'
 require 'arjdbc/db2/adapter'
+require 'arjdbc/db2/connection_methods'
+ArJdbc.warn_unsupported_adapter 'db2', [4, 2] # warns on AR >= 4.2

data/lib/arjdbc/db2/adapter.rb

@@ -1,170 +1,334 @@
+# NOTE: file contains code adapted from **ruby-ibmdb** adapter, license follows
+=begin
+Copyright (c) 2006 - 2015 IBM Corporation
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+=end
+
+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
-    def self.column_selector
-      [ /(db2|as400)/i,
-        lambda { |cfg, column| column.extend(::ArJdbc::DB2::Column) } ]
-    end
-
-    module Column
-      def type_cast(value)
-        return nil if value.nil? || value =~ /^\s*null\s*$/i
-        case type
-        when :string    then value
-        when :integer   then defined?(value.to_i) ? value.to_i : (value ? 1 : 0)
-        when :primary_key then defined?(value.to_i) ? value.to_i : (value ? 1 : 0)
-        when :float     then value.to_f
-        when :datetime  then ArJdbc::DB2::Column.cast_to_date_or_time(value)
-        when :date      then ArJdbc::DB2::Column.cast_to_date_or_time(value)
-        when :timestamp then ArJdbc::DB2::Column.cast_to_time(value)
-        when :time      then ArJdbc::DB2::Column.cast_to_time(value)
-        # TODO AS400 stores binary strings in EBCDIC (CCSID 65535), need to convert back to ASCII
+
+    # @private
+    def self.extended(adapter); initialize!; end
+
+    # @private
+    @@_initialized = nil
+
+    # @private
+    def self.initialize!
+      return if @@_initialized; @@_initialized = true
+
+      require 'arjdbc/util/serialized_attributes'
+      Util::SerializedAttributes.setup /blob|clob/i, 'after_save_with_db2_lob'
+    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
+
+    # @private
+    @@emulate_booleans = true
+
+    # Boolean emulation can be disabled using :
+    #
+    #   ArJdbc::DB2.emulate_booleans = false
+    #
+    def self.emulate_booleans?; @@emulate_booleans; end
+    # @deprecated Use {#emulate_booleans?} instead.
+    def self.emulate_booleans; @@emulate_booleans; end
+    # @see #emulate_booleans?
+    def self.emulate_booleans=(emulate); @@emulate_booleans = emulate; end
+
+    # @private
+    @@update_lob_values = true
+
+    # Updating records with LOB values (binary/text columns) in a separate
+    # statement can be disabled using :
+    #
+    #   ArJdbc::DB2.update_lob_values = false
+    #
+    # @note This only applies when prepared statements are not used.
+    def self.update_lob_values?; @@update_lob_values; end
+    # @see #update_lob_values?
+    def self.update_lob_values=(update); @@update_lob_values = update; end
+
+    # @see #update_lob_values?
+    # @see ArJdbc::Util::SerializedAttributes#update_lob_columns
+    def update_lob_value?(value, column = nil)
+      DB2.update_lob_values? && ! prepared_statements? # && value
+    end
+
+    # @see #quote
+    # @private
+    BLOB_VALUE_MARKER = "BLOB('')"
+    # @see #quote
+    # @private
+    CLOB_VALUE_MARKER = "''"
+
+    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 = {
+      :string     => { :name => "varchar", :limit => 255 },
+      :integer    => { :name => "integer" },
+      :bigint     => { :name => 'bigint' },
+      :float      => { :name => "real" }, # :limit => 24
+      :double     => { :name => "double" }, # :limit => 53
+      :text       => { :name => "clob" },
+      :binary     => { :name => "blob" },
+      :xml        => { :name => "xml" },
+      :decimal    => { :name => "decimal" }, # :limit => 31
+      :char       => { :name => "char" }, # :limit => 254
+      :date       => { :name => "date" },
+      :datetime   => { :name => "timestamp" },
+      :timestamp  => { :name => "timestamp" },
+      :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 initialize_type_map(m)
+      register_class_with_limit m, %r(boolean)i,   ActiveRecord::Type::Boolean
+      register_class_with_limit m, %r(char)i,      ActiveRecord::Type::String
+      register_class_with_limit m, %r(binary)i,    ActiveRecord::Type::Binary
+      register_class_with_limit m, %r(text)i,      ActiveRecord::Type::Text
+      register_class_with_limit m, %r(date)i,      ActiveRecord::Type::Date
+      register_class_with_limit m, %r(time)i,      ActiveRecord::Type::Time
+      register_class_with_limit m, %r(datetime)i,  ActiveRecord::Type::DateTime
+      register_class_with_limit m, %r(float)i,     ActiveRecord::Type::Float
+      register_class_with_limit m, %r(int)i,       ActiveRecord::Type::Integer
+
+      m.alias_type %r(blob)i,      'binary'
+      m.alias_type %r(clob)i,      'text'
+      m.alias_type %r(timestamp)i, 'datetime'
+      m.alias_type %r(numeric)i,   'decimal'
+      m.alias_type %r(number)i,    'decimal'
+      m.alias_type %r(double)i,    'float'
+      m.alias_type %r(real)i,      'float'
+
+      m.register_type(%r(decimal)i) do |sql_type|
+        scale = extract_scale(sql_type)
+        precision = extract_precision(sql_type)
+        limit = extract_limit(sql_type)
+        if scale == 0
+          ActiveRecord::Type::BigInteger.new(:precision => precision, :limit => limit)
         else
-          super
+          ActiveRecord::Type::Decimal.new(:precision => precision, :scale => scale)
         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})"
+      m.alias_type %r(for bit data)i,  'binary'
+      m.alias_type %r(smallint)i,      'boolean'
+      m.alias_type %r(serial)i,        'int'
+      m.alias_type %r(decfloat)i,      'decimal'
+      #m.alias_type %r(real)i,          'decimal'
+      m.alias_type %r(graphic)i,       'binary'
+      m.alias_type %r(rowid)i,         'int'
+
+      m.register_type(%r(smallint)i) do
+        if DB2.emulate_booleans?
+          ActiveRecord::Type::Boolean.new
         else
-          super
+          ActiveRecord::Type::Integer.new(:limit => 1)
         end
       end
 
-      def self.cast_to_date_or_time(value)
-        return value if value.is_a? Date
-        return nil if value.blank?
-        guess_date_or_time((value.is_a? Time) ? value : cast_to_time(value))
-      end
+      m.register_type %r(xml)i, XmlType.new
+    end if AR42
 
-      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_array = ParseDate.parsedate(value, true)
-        time_array[0] ||= 2000; time_array[1] ||= 1; time_array[2] ||= 1;
-        Time.send(ActiveRecord::Base.default_timezone, *time_array) rescue nil
-      end
+    # @private
+    class XmlType < ActiveRecord::Type::String
+      def type; :xml end
 
-      def self.guess_date_or_time(value)
-        (value.hour == 0 and value.min == 0 and value.sec == 0) ?
-        Date.new(value.year, value.month, value.day) : value
+      def type_cast_for_database(value)
+        return unless value
+        Data.new(super)
       end
 
-      private
-      # <b>DEPRECATED:</b> SMALLINT is now used for boolean field types. Please
-      # convert your tables using DECIMAL(5) for boolean values to SMALLINT instead.
-      def use_decimal5_for_boolean
-        warn "[DEPRECATION] using DECIMAL(5) for boolean is deprecated. Convert your columns to SMALLINT instead."
-        :boolean
+      class Data
+        def initialize(value)
+          @value = value
+        end
+        def to_s; @value end
       end
+    end if AR42
 
-      # 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
-        # old jdbc_db2.rb used decimal(5,0) as boolean
-        when /^smallint/i           then :boolean
-        when /^decimal\(5\)$/i      then use_decimal5_for_boolean
-        when /^real/i               then :float
-        when /^timestamp/i          then :datetime
-        else
-          super
-        end
+    # @override
+    def reset_column_information
+      initialize_type_map(type_map)
+    end if AR42
+
+    # @override
+    def 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
+
+    # @private
+    class TableDefinition < ::ActiveRecord::ConnectionAdapters::TableDefinition
+
+      def xml(*args)
+        options = args.extract_options!
+        column(args[0], 'xml', options)
       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?
+      # IBM DB adapter (MRI) compatibility :
 
-        # string defaults are surrounded by single quotes
-        return $1 if value =~ /^'(.*)'$/
+      # @private
+      # @deprecated
+      def double(*args)
+        options = args.extract_options!
+        column(args[0], 'double', options)
+      end
 
-        value
+      # @private
+      def decfloat(*args)
+        options = args.extract_options!
+        column(args[0], 'decfloat', options)
       end
-    end
 
-    def _execute(sql, name = nil)
-      if ActiveRecord::ConnectionAdapters::JdbcConnection::select?(sql)
-        @connection.execute_query(sql)
-      elsif ActiveRecord::ConnectionAdapters::JdbcConnection::insert?(sql)
-        (@connection.execute_insert(sql) or last_insert_id(sql)).to_i
-      else
-        @connection.execute_update(sql)
+      def graphic(*args)
+        options = args.extract_options!
+        column(args[0], 'graphic', options)
       end
-    end
 
-    # holy moly batman! all this to tell AS400 "yes i am sure"
-    def execute_and_auto_confirm(sql)
-      begin
-        @connection.execute_update "call qsys.qcmdexc('QSYS/CHGJOB INQMSGRPY(*SYSRPYL)',0000000031.00000)"
-        @connection.execute_update "call qsys.qcmdexc('ADDRPYLE SEQNBR(9876) MSGID(CPA32B2) RPY(''I'')',0000000045.00000)"
-      rescue Exception => e
-        raise "Could not call CHGJOB INQMSGRPY(*SYSRPYL) and ADDRPYLE SEQNBR(9876) MSGID(CPA32B2) RPY('I').\n" +
-          "Do you have authority to do this?\n\n" + e.to_s
+      # @private
+      # @deprecated
+      def vargraphic(*args)
+        options = args.extract_options!
+        column(args[0], 'vargraphic', options)
       end
 
-      r = execute sql
+      # @private
+      # @deprecated
+      def bigint(*args)
+        options = args.extract_options!
+        column(args[0], 'bigint', options)
+      end
 
-      begin
-        @connection.execute_update "call qsys.qcmdexc('QSYS/CHGJOB INQMSGRPY(*DFT)',0000000027.00000)"
-        @connection.execute_update "call qsys.qcmdexc('RMVRPYLE SEQNBR(9876)',0000000021.00000)"
-      rescue Exception => e
-        raise "Could not call CHGJOB INQMSGRPY(*DFT) and RMVRPYLE SEQNBR(9876).\n" +
-          "Do you have authority to do this?\n\n" + e.to_s
+      def char(*args)
+        options = args.extract_options!
+        column(args[0], 'char', options)
       end
-      r
-    end
+      # alias_method :character, :char
 
-    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 modify_types(tp)
-      tp[:primary_key] = 'int not null generated by default as identity (start with 1) primary key'
-      tp[:string][:limit] = 255
-      tp[:integer][:limit] = nil
-      tp[:boolean] = {:name => "smallint"}
-      tp
+    def table_definition(*args)
+      new_table_definition(TableDefinition, *args)
     end
 
-    def type_to_sql(type, limit = nil, precision = nil, scale = nil)
-      limit = nil if type.to_sym == :integer
-      super(type, limit, precision, scale)
+    def prefetch_primary_key?(table_name = nil)
+      # TRUE if the table has no identity column
+      names = table_name.upcase.split(".")
+      sql = "SELECT 1 FROM SYSCAT.COLUMNS WHERE IDENTITY = 'Y' "
+      sql << "AND TABSCHEMA = '#{names.first}' " if names.size == 2
+      sql << "AND TABNAME = '#{names.last}'"
+      select_one(sql).nil?
     end
 
-    def adapter_name
-      'DB2'
+    def next_sequence_value(sequence_name)
+      select_value("SELECT NEXT VALUE FOR #{sequence_name} FROM sysibm.sysdummy1")
     end
 
-    def arel2_visitors
-      require 'arel/visitors/db2'
-      {'db2' => ::Arel::Visitors::DB2, 'as400' => ::Arel::Visitors::DB2}
+    def create_table(name, options = {}, &block)
+      if zos?
+        zos_create_table(name, options, &block)
+      else
+        super
+      end
     end
 
-    def add_limit_offset!(sql, options)
-      replace_limit_offset!(sql, options[:limit], options[:offset])
-    end
+    def zos_create_table(name, options = {})
+      table_definition = new_table_definition TableDefinition, name, options[:temporary], options[:options], options[:as]
 
-    def replace_limit_offset!(sql, limit, offset)
-      if limit && !offset
-        if limit == 1
-          sql << " FETCH FIRST ROW ONLY"
-        else
-          sql << " FETCH FIRST #{sanitize_limit(limit)} ROWS ONLY"
+      unless options[:id] == false
+        table_definition.primary_key(options[:primary_key] || primary_key(name))
+      end
+
+      yield table_definition if block_given?
+
+      # Clobs in DB2 Host have to be created after the Table with an auxiliary Table.
+      clob_columns = []
+      table_definition.columns.delete_if do |column|
+        if column.type && column.type.to_sym == :text
+          clob_columns << column; true
         end
-      elsif limit && offset
-        sql.gsub!(/SELECT/i, 'SELECT B.* FROM (SELECT A.*, row_number() over () AS internal$rownum FROM (SELECT')
-        sql << ") A ) B WHERE B.internal$rownum > #{offset} AND B.internal$rownum <= #{sanitize_limit(limit) + offset}"
       end
-      sql
+
+      drop_table(name, options) if options[:force] && table_exists?(name)
+
+      create_sql = "CREATE#{' TEMPORARY' if options[:temporary]} TABLE "
+      create_sql << "#{quote_table_name(name)} ("
+      create_sql << table_definition.to_sql
+      create_sql << ") #{options[:options]}"
+      if @config[:database] && @config[:tablespace]
+        create_sql << " IN #{@config[:database]}.#{@config[:tablespace]}"
+      end
+
+      execute create_sql
+
+      # Table definition is complete only when a unique index is created on the primary_key column for DB2 V8 on zOS
+      # create index on id column if options[:id] is nil or id ==true
+      # else check if options[:primary_key]is not nil then create an unique index on that column
+      # TODO someone on Z/OS should test this out - also not needed for V9 ?
+      #primary_column = options[:id] == true ? 'id' : options[:primary_key]
+      #add_index(name, (primary_column || 'id').to_s, :unique => true)
+
+      clob_columns.each do |clob_column|
+        column_name = clob_column.name.to_s
+        execute "ALTER TABLE #{name} ADD COLUMN #{column_name} clob"
+        clob_table_name = "#{name}_#{column_name}_CD_"
+        if @config[:database] && @config[:lob_tablespaces]
+          in_lob_table_space = " IN #{@config[:database]}.#{@config[:lob_tablespaces][name.split(".")[1]]}"
+        end
+        execute "CREATE AUXILIARY TABLE #{clob_table_name} #{in_lob_table_space} STORES #{name} COLUMN #{column_name}"
+        execute "CREATE UNIQUE INDEX #{clob_table_name} ON #{clob_table_name};"
+      end
     end
+    private :zos_create_table
 
     def pk_and_sequence_for(table)
       # In JDBC/DB2 side, only upcase names of table and column are handled.
@@ -176,88 +340,255 @@ module ArJdbc
       keys
     end
 
-    def quote_column_name(column_name)
-      column_name
-    end
+    # Properly quotes the various data types.
+    # @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)
+      return value if sql_literal?(value)
 
-    def quote(value, column = nil) # :nodoc:
-      if column && column.respond_to?(:primary) && column.primary && column.klass != String
-        return value.to_i.to_s
-      end
-      if column && (column.type == :decimal || column.type == :integer) && value
-        return value.to_s
+      if column
+        if column.respond_to?(:primary) && column.primary && column.klass != String
+          return value.to_i.to_s
+        end
+        if value && (column.type.to_sym == :decimal || column.type.to_sym == :integer)
+          return value.to_s
+        end
       end
+
+      column_type = column && column.type.to_sym
+
       case value
-      when String
-        if column && column.type == :binary
-          "BLOB('#{quote_string(value)}')"
+      when nil then 'NULL'
+      when Numeric # IBM_DB doesn't accept quotes on numeric types
+        # if the column type is text or string, return the quote value
+        if column_type == :text || column_type == :string
+          "'#{value}'"
+        else
+          value.to_s
+        end
+      when String, ActiveSupport::Multibyte::Chars
+        if column_type == :binary && column.sql_type !~ /for bit data/i
+          if update_lob_value?(value, column)
+            value.nil? ? 'NULL' : BLOB_VALUE_MARKER # '@@@IBMBINARY@@@'"
+          else
+            "BLOB('#{quote_string(value)}')"
+          end
+        elsif column && column.sql_type =~ /clob/ # :text
+          if update_lob_value?(value, column)
+            value.nil? ? 'NULL' : CLOB_VALUE_MARKER # "'@@@IBMTEXT@@@'"
+          else
+            "'#{quote_string(value)}'"
+          end
+        elsif column_type == :xml
+          value.nil? ? 'NULL' : "'#{quote_string(value)}'" # "'<ibm>@@@IBMXML@@@</ibm>'"
         else
           "'#{quote_string(value)}'"
         end
+      when Symbol then "'#{quote_string(value.to_s)}'"
+      when Time
+        # AS400 doesn't support date in time column
+        if column_type == :time
+          quote_time(value)
+        else
+          super
+        end
       else super
       end
     end
 
-    def quote_string(string)
-      string.gsub(/'/, "''") # ' (for ruby-mode)
+    # @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'
+      types[:string][:limit] = 255
+      types[:integer][:limit] = nil
+      types[:boolean] = {:name => "decimal(1)"}
+      types
+    end
+
+    def type_to_sql(type, limit = nil, precision = nil, scale = nil)
+      limit = nil if type.to_sym == :integer
+      super(type, limit, precision, scale)
     end
 
-    def quoted_true
-      '1'
+    # @private
+    VALUES_DEFAULT = 'VALUES ( DEFAULT )' # NOTE: Arel::Visitors::DB2 uses this
+
+    # @override
+    def empty_insert_statement_value
+      VALUES_DEFAULT # won't work as DB2 needs to know the column count
     end
 
-    def quoted_false
-      '0'
+    def add_column(table_name, column_name, type, options = {})
+      # The keyword COLUMN allows to use reserved names for columns (ex: date)
+      add_column_sql = "ALTER TABLE #{quote_table_name(table_name)} ADD COLUMN #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
+      add_column_options!(add_column_sql, options)
+      execute(add_column_sql)
+    end
+
+    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]
+        if column && column.type == :text
+          sql << " DEFAULT #{quote(options.delete(:default))}"
+        end
+        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
+          # for a BLOB column. non-empty string and non-NULL, return error!
+          if value.nil?
+            sql_value = "NULL"
+          else
+            sql_value = zos? ? "#{value}" : "BLOB('#{quote_string(value)}'"
+          end
+          sql << " DEFAULT #{sql_value}"
+        end
+      end
+      super
     end
 
-    def reorg_table(table_name)
-      unless as400?
-        @connection.execute_update "call sysproc.admin_cmd ('REORG TABLE #{table_name}')"
+    # @note Only used with (non-AREL) ActiveRecord **2.3**.
+    # @see Arel::Visitors::DB2
+    def add_limit_offset!(sql, options)
+      limit = options[:limit]
+      replace_limit_offset!(sql, limit, options[:offset]) if limit
+    end if ::ActiveRecord::VERSION::MAJOR < 3
+
+    # @private shared with {Arel::Visitors::DB2}
+    def replace_limit_offset!(sql, limit, offset, orders = nil)
+      limit = limit.to_i
+
+      if offset # && limit
+        over_order_by = nil # NOTE: orders matching got reverted as it was not complete and there were no case covering it ...
+
+        start_sql = "SELECT B.* FROM (SELECT A.*, row_number() OVER (#{over_order_by}) AS internal$rownum FROM (SELECT"
+        end_sql = ") A ) B WHERE B.internal$rownum > #{offset} AND B.internal$rownum <= #{limit + offset.to_i}"
+
+        if sql.is_a?(String)
+          sql.sub!(/SELECT/i, start_sql)
+          sql << end_sql
+        else # AR 4.2 sql.class ... Arel::Collectors::Bind
+          sql.parts[0] = start_sql # sql.sub! /SELECT/i
+          sql.parts[ sql.parts.length ] = end_sql
+        end
+      else
+        limit_sql = limit == 1 ? " FETCH FIRST ROW ONLY" : " FETCH FIRST #{limit} ROWS ONLY"
+        if sql.is_a?(String)
+          sql << limit_sql
+        else # AR 4.2 sql.class ... Arel::Collectors::Bind
+          sql.parts[ sql.parts.length ] = limit_sql
+        end
       end
+      sql
+    end
+
+    # @deprecated seems not sued nor tested ?!
+    def runstats_for_table(tablename, priority = 10)
+      @connection.execute_update "call sysproc.admin_cmd('RUNSTATS ON TABLE #{tablename} WITH DISTRIBUTION AND DETAILED INDEXES ALL UTIL_IMPACT_PRIORITY #{priority}')"
+    end
+
+    if ::ActiveRecord::VERSION::MAJOR >= 4
+
+    def select(sql, name = nil, binds = [])
+      exec_query(to_sql(suble_null_test(sql), binds), name, binds)
+    end
+
+    else
+
+    def select(sql, name = nil, binds = [])
+      exec_query_raw(to_sql(suble_null_test(sql), binds), name, binds)
+    end
+
     end
 
-    def recreate_database(name)
-      tables.each {|table| drop_table("#{db2_schema}.#{table}")}
+    # @private
+    IS_NOT_NULL = /(!=|<>)\s*NULL/i
+    # @private
+    IS_NULL = /=\s*NULL/i
+
+    def suble_null_test(sql)
+      return sql unless sql.is_a?(String)
+      # DB2 does not like "= NULL", "!= NULL", or "<> NULL" :
+      sql = sql.dup
+      sql.gsub! IS_NOT_NULL, 'IS NOT NULL'
+      sql.gsub! IS_NULL, 'IS NULL'
+      sql
+    end
+    private :suble_null_test
+
+    def add_index(table_name, column_name, options = {})
+      if ! zos? || ( table_name.to_s == ActiveRecord::Migrator.schema_migrations_table_name.to_s )
+        column_name = column_name.to_s if column_name.is_a?(Symbol)
+        super
+      else
+        statement = 'CREATE'
+        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
     # ...not supported on IBM i, so we raise in this case
     def rename_column(table_name, column_name, new_column_name) #:nodoc:
-      if as400?
-        raise NotImplementedError, "rename_column is not supported on IBM i"
-      else
-        execute "ALTER TABLE #{table_name} RENAME COLUMN #{column_name} TO #{new_column_name}"
-        reorg_table(table_name)
-      end
+      sql = "ALTER TABLE #{table_name} RENAME COLUMN #{column_name} TO #{new_column_name}"
+      execute_table_change(sql, table_name, 'Rename Column')
     end
 
     def change_column_null(table_name, column_name, null)
       if null
-        execute_and_auto_confirm "ALTER TABLE #{table_name} ALTER COLUMN #{column_name} DROP NOT NULL"
+        sql = "ALTER TABLE #{table_name} ALTER COLUMN #{column_name} DROP NOT NULL"
       else
-        execute_and_auto_confirm "ALTER TABLE #{table_name} ALTER COLUMN #{column_name} SET NOT NULL"
+        sql = "ALTER TABLE #{table_name} ALTER COLUMN #{column_name} SET NOT NULL"
       end
-      reorg_table(table_name)
+      execute_table_change(sql, table_name, 'Change Column')
     end
 
     def change_column_default(table_name, column_name, default)
       if default.nil?
-        execute_and_auto_confirm "ALTER TABLE #{table_name} ALTER COLUMN #{column_name} DROP DEFAULT"
+        sql = "ALTER TABLE #{table_name} ALTER COLUMN #{column_name} DROP DEFAULT"
       else
-        execute_and_auto_confirm "ALTER TABLE #{table_name} ALTER COLUMN #{column_name} SET WITH DEFAULT #{quote(default)}"
+        sql = "ALTER TABLE #{table_name} ALTER COLUMN #{column_name} SET WITH DEFAULT #{quote(default)}"
       end
-      reorg_table(table_name)
+      execute_table_change(sql, table_name, 'Change Column')
     end
 
     def change_column(table_name, column_name, type, options = {})
       data_type = type_to_sql(type, options[:limit], options[:precision], options[:scale])
       sql = "ALTER TABLE #{table_name} ALTER COLUMN #{column_name} SET DATA TYPE #{data_type}"
-      as400? ? execute_and_auto_confirm(sql) : execute(sql)
-      reorg_table(table_name)
+      execute_table_change(sql, table_name, 'Change Column')
 
       if options.include?(:default) and options.include?(:null)
         # which to run first?
@@ -275,135 +606,184 @@ module ArJdbc
       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_name) #:nodoc:
-      sql = "ALTER TABLE #{table_name} DROP COLUMN #{column_name}"
+    if ActiveRecord::VERSION::MAJOR >= 4
 
-      as400? ? execute_and_auto_confirm(sql) : execute(sql)
-      reorg_table(table_name)
+    def remove_column(table_name, column_name, type = nil, options = {})
+      db2_remove_column(table_name, column_name)
     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:
-      execute "RENAME TABLE #{name} TO #{new_name}"
-      reorg_table(new_name)
+    else
+
+    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
+        outcome = db2_remove_column(table_name, column_name)
+      end
+      column_names.size == 1 ? outcome : nil
+    end
+
+    end
+
+    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, db2_schema, nil, ["TABLE"])
+      @connection.tables(nil, schema)
     end
 
-    # only record precision and scale for types that can set
-    # them via CREATE TABLE:
+    # 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)
 
     def columns(table_name, name = nil)
-      cols = @connection.columns(table_name, name, db2_schema)
+      columns = @connection.columns_internal(table_name.to_s, nil, schema) # catalog == nil
 
+      if zos?
+        # Remove the mighty db2_generated_rowid_for_lobs from the list of columns
+        columns = columns.reject { |col| "db2_generated_rowid_for_lobs" == col.name }
+      end
       # scrub out sizing info when CREATE TABLE doesn't support it
       # but JDBC reports it (doh!)
-      for col in cols
-        base_sql_type = col.sql_type.sub(/\(.*/, "").upcase
-        col.limit = nil unless HAVE_LIMIT.include?(base_sql_type)
-        col.precision = nil unless HAVE_PRECISION.include?(base_sql_type)
-        #col.scale = nil unless HAVE_SCALE.include?(base_sql_type)
+      for column in columns
+        base_sql_type = column.sql_type.sub(/\(.*/, "").upcase
+        column.limit = nil unless HAVE_LIMIT.include?(base_sql_type)
+        column.precision = nil unless HAVE_PRECISION.include?(base_sql_type)
+        #column.scale = nil unless HAVE_SCALE.include?(base_sql_type)
       end
 
-      cols
+      columns
     end
 
     def indexes(table_name, name = nil)
-      @connection.indexes(table_name, name, db2_schema)
+      @connection.indexes(table_name, name, schema)
     end
 
-    def add_quotes(name)
-      return name unless name
-      %Q{"#{name}"}
+    def recreate_database(name = nil, options = {})
+      drop_database(name)
     end
 
-    def strip_quotes(str)
-      return str unless str
-      return str unless /^(["']).*\1$/ =~ str
-      str[1..-2]
+    def drop_database(name = nil)
+      tables.each { |table| drop_table("#{table}") }
     end
 
-    def expand_double_quotes(name)
-      return name unless name && name['"']
-      name.gsub(/"/,'""')
+    def truncate(table_name, name = nil)
+      execute "TRUNCATE TABLE #{quote_table_name(table_name)} IMMEDIATE", name
     end
 
-    def structure_dump #:nodoc:
-      definition=""
-      rs = @connection.connection.meta_data.getTables(nil,db2_schema.upcase,nil,["TABLE"].to_java(:string))
-      while rs.next
-        tname = rs.getString(3)
-        definition << "CREATE TABLE #{tname} (\n"
-        rs2 = @connection.connection.meta_data.getColumns(nil,db2_schema.upcase,tname,nil)
-        first_col = true
-        while rs2.next
-          col_name = add_quotes(rs2.getString(4));
-          default = ""
-          d1 = rs2.getString(13)
-          # IBM i (as400 toolbox driver) will return an empty string if there is no default
-          if @config[:url] =~ /^jdbc:as400:/
-            default = !d1.blank? ? " DEFAULT #{d1}" : ""
-          else
-            default = d1 ? " DEFAULT #{d1}" : ""
-          end
+    # @override
+    def supports_views?; true end
 
-          type = rs2.getString(6)
-          col_precision = rs2.getString(7)
-          col_scale = rs2.getString(9)
-          col_size = ""
-          if HAVE_SCALE.include?(type) and col_scale
-            col_size = "(#{col_precision},#{col_scale})"
-          elsif (HAVE_LIMIT + HAVE_PRECISION).include?(type) and col_precision
-            col_size = "(#{col_precision})"
-          end
-          nulling = (rs2.getString(18) == 'NO' ? " NOT NULL" : "")
-          create_col_string = add_quotes(expand_double_quotes(strip_quotes(col_name))) +
-            " " +
-            type +
-            col_size +
-            "" +
-            nulling +
-            default
-          if !first_col
-            create_col_string = ",\n #{create_col_string}"
-          else
-            create_col_string = " #{create_col_string}"
-          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
 
-          definition << create_col_string
+    def reorg_table(table_name, name = nil)
+      exec_update "call sysproc.admin_cmd ('REORG TABLE #{table_name}')", name, []
+    end
+    private :reorg_table
 
-          first_col = false
-        end
-        definition << ");\n\n"
+    # 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
+      else
+        @connection.execute_update(sql)
       end
-      definition
     end
+    private :_execute
 
-    private
+    end
+
+    DRIVER_NAME = 'com.ibm.db2.jcc.DB2Driver'.freeze
+
+    # @private
+    def zos?
+      @zos = nil unless defined? @zos
+      return @zos unless @zos.nil?
+      @zos =
+        if url = config[:url]
+          !!( url =~ /^jdbc:db2j:net:/ && config[:driver] == DRIVER_NAME )
+        else
+          nil
+        end
+    end
+
+    # @private
+    # @deprecated no longer used
     def as400?
-        @config[:url] =~ /^jdbc:as400:/
+      false
+    end
+
+    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
-      if @config[:schema].blank?
-        if as400?
-          # AS400 implementation takes schema from library name (last part of url)
-          schema = @config[:url].split('/').last.strip
-          (schema[-1..-1] == ";") ? schema.chop : schema
+      @db2_schema = false unless defined? @db2_schema
+      return @db2_schema if @db2_schema != false
+      schema = config[:schema]
+      @db2_schema =
+        if schema then schema
+        elsif config[:jndi] || config[:data_source]
+          nil # let JNDI worry about schema
         else
           # LUW implementation uses schema name of username by default
-          @config[:username] or ENV['USER']
+          config[:username] || ENV['USER']
         end
-      else
-        @config[:schema]
-      end
     end
+
+    def db2_remove_column(table_name, column_name)
+      sql = "ALTER TABLE #{quote_table_name(table_name)} DROP COLUMN #{quote_column_name(column_name)}"
+      execute_table_change(sql, table_name, 'Remove Column')
+    end
+
+  end
+end
+
+module ActiveRecord::ConnectionAdapters
+
+  remove_const(:DB2Column) if const_defined?(:DB2Column)
+
+  class DB2Column < JdbcColumn
+    include ::ArJdbc::DB2::Column
   end
+
 end