neo-activerecord-jdbc-adapter 5.0.pre2

data/lib/arjdbc.rb

@@ -0,0 +1,19 @@
+if defined?(JRUBY_VERSION)
+  begin
+    require 'active_record/version'
+    require 'active_record'
+  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-adapter is for use with JRuby only"
+end
+
+require 'arjdbc/version'

data/lib/arjdbc/abstract/database_statements.rb

@@ -0,0 +1,92 @@
+module ArJdbc
+  module Abstract
+
+    # This provides the basic interface for interacting with the
+    # database for JDBC based adapters
+    module DatabaseStatements
+
+      # Executes a delete statement in the context of this connection.
+      # @param sql the query string (or AREL object)
+      # @param name logging marker for the executed SQL statement log entry
+      # @param binds the bind parameters
+      # @override available since **AR-3.1**
+      def exec_delete(sql, name, binds)
+        if prepared_statements?
+          log(sql, name || 'SQL', binds) { @connection.execute_delete(sql, binds) }
+        else
+          sql = to_sql(sql, binds) if sql.respond_to?(:to_sql)
+          log(sql, name || 'SQL') { @connection.execute_delete(sql) }
+        end
+      end
+
+      # Executes an insert statement in the context of this connection.
+      # @param sql the query string (or AREL object)
+      # @param name logging marker for the executed SQL statement log entry
+      # @param binds the bind parameters
+      # @override available since **AR-3.1**
+      def exec_insert(sql, name, binds, pk = nil, sequence_name = nil)
+        if prepared_statements?
+          log(sql, name || 'SQL', binds) { @connection.execute_insert(sql, binds) }
+        else
+          sql = to_sql(sql, binds) if sql.respond_to?(:to_sql)
+          log(sql, name || 'SQL') { @connection.execute_insert(sql) }
+        end
+      end
+
+      # Executes a SQL query in the context of this connection using the bind
+      # substitutes.
+      # @param sql the query string (or AREL object)
+      # @param name logging marker for the executed SQL statement log entry
+      # @param binds the bind parameters
+      # @return [ActiveRecord::Result] or [Array] on **AR-2.3**
+      # @override available since **AR-3.1**
+      def exec_query(sql, name = 'SQL', binds = [])
+        if prepared_statements?
+          log(sql, name, binds) { @connection.execute_query(sql, binds) }
+        else
+          sql = to_sql(sql, binds) if sql.respond_to?(:to_sql)
+          log(sql, name) { @connection.execute_query(sql) }
+        end
+      end
+
+      # # Executes an update statement in the context of this connection.
+      # @param sql the query string (or AREL object)
+      # @param name logging marker for the executed SQL statement log entry
+      # @param binds the bind parameters
+      # @override available since **AR-3.1**
+      def exec_update(sql, name, binds)
+        if prepared_statements?
+          log(sql, name || 'SQL', binds) { @connection.execute_update(sql, binds) }
+        else
+          sql = to_sql(sql, binds) if sql.respond_to?(:to_sql)
+          log(sql, name || 'SQL') { @connection.execute_update(sql) }
+        end
+      end
+
+      def execute(sql, name = nil)
+        log(sql, name) { @connection.execute(sql) }
+      end
+
+      # Take an id from the result of an INSERT query.
+      # @return [Integer, NilClass]
+      def last_inserted_id(result)
+        if result.is_a?(Hash) || result.is_a?(ActiveRecord::Result)
+          result.first.first[1] # .first = { "id"=>1 } .first = [ "id", 1 ]
+        else
+          result
+        end
+      end
+
+      # @return whether `:prepared_statements` are to be used
+      def prepared_statements?
+        return @prepared_statements unless (@prepared_statements ||= nil).nil?
+        @prepared_statements = if config.key?(:prepared_statements)
+                                 self.class.type_cast_config_to_boolean(config.fetch(:prepared_statements))
+                               else
+                                 false
+                               end
+      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', 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', nil) { @connection.begin(isolation) }
+      end
+
+      # Commits the current database transaction.
+      # @override
+      def commit_db_transaction
+        log('COMMIT TRANSACTION', 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', 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/common_jdbc_methods.rb

@@ -0,0 +1,13 @@
+module ArJdbc
+  # This is minimum amount of code neede from base JDBC Adapter class to make common adapters
+  # work.  This replaces using jdbc/adapter as a base class for all adapters.
+  module CommonJdbcMethods
+    def initialize(connection, logger = nil, config = {})
+      config[:adapter_spec] = adapter_spec(config) unless config.key?(:adapter_spec)
+
+      connection ||= jdbc_connection_class(config[:adapter_spec]).new(config, self)
+
+      super(connection, logger, config)
+    end
+  end
+end

data/lib/arjdbc/db2.rb

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,789 @@
+# 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
+
+    # @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
+          ActiveRecord::Type::Decimal.new(:precision => precision, :scale => scale)
+        end
+      end
+
+      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
+          ActiveRecord::Type::Integer.new(:limit => 1)
+        end
+      end
+
+      m.register_type %r(xml)i, XmlType.new
+    end if AR42
+
+    # @private
+    class XmlType < ActiveRecord::Type::String
+      def type; :xml end
+
+      def type_cast_for_database(value)
+        return unless value
+        Data.new(super)
+      end
+
+      class Data
+        def initialize(value)
+          @value = value
+        end
+        def to_s; @value end
+      end
+    end if AR42
+
+    # @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
+
+      # 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)
+      end
+
+      def graphic(*args)
+        options = args.extract_options!
+        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(".")
+      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 next_sequence_value(sequence_name)
+      select_value("SELECT NEXT VALUE FOR #{sequence_name} FROM sysibm.sysdummy1")
+    end
+
+    def create_table(name, options = {}, &block)
+      if zos?
+        zos_create_table(name, options, &block)
+      else
+        super
+      end
+    end
+
+    def zos_create_table(name, options = {})
+      table_definition = new_table_definition TableDefinition, name, options[:temporary], options[:options], options[:as]
+
+      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
+      end
+
+      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.
+      keys = super(table.upcase)
+      if keys && keys[0]
+        # In ActiveRecord side, only downcase names of table and column are handled.
+        keys[0] = keys[0].downcase
+      end
+      keys
+    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)
+
+      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 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
+
+    # @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
+
+    # @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 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
+
+    # @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
+
+    # @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
+
+    # @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:
+      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
+        sql = "ALTER TABLE #{table_name} ALTER COLUMN #{column_name} DROP NOT NULL"
+      else
+        sql = "ALTER TABLE #{table_name} ALTER COLUMN #{column_name} SET NOT NULL"
+      end
+      execute_table_change(sql, table_name, 'Change Column')
+    end
+
+    def change_column_default(table_name, column_name, default)
+      if default.nil?
+        sql = "ALTER TABLE #{table_name} ALTER COLUMN #{column_name} DROP DEFAULT"
+      else
+        sql = "ALTER TABLE #{table_name} ALTER COLUMN #{column_name} SET WITH DEFAULT #{quote(default)}"
+      end
+      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}"
+      execute_table_change(sql, table_name, 'Change Column')
+
+      if options.include?(:default) and options.include?(:null)
+        # which to run first?
+        if options[:null] or options[:default].nil?
+          change_column_null(table_name, column_name, options[:null])
+          change_column_default(table_name, column_name, options[:default])
+        else
+          change_column_default(table_name, column_name, options[:default])
+          change_column_null(table_name, column_name, options[:null])
+        end
+      elsif options.include?(:default)
+        change_column_default(table_name, column_name, options[:default])
+      elsif options.include?(:null)
+        change_column_null(table_name, column_name, options[:null])
+      end
+    end
+
+    if ActiveRecord::VERSION::MAJOR >= 4
+
+    def remove_column(table_name, column_name, type = nil, options = {})
+      db2_remove_column(table_name, column_name)
+    end
+
+    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, 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_PRECISION = %w(DECIMAL NUMERIC)
+    HAVE_SCALE = %w(DECIMAL NUMERIC)
+
+    def columns(table_name, name = nil)
+      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 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
+
+      columns
+    end
+
+    def indexes(table_name, name = nil)
+      @connection.indexes(table_name, name, schema)
+    end
+
+    def recreate_database(name = nil, options = {})
+      drop_database(name)
+    end
+
+    def drop_database(name = nil)
+      tables.each { |table| drop_table("#{table}") }
+    end
+
+    def truncate(table_name, name = nil)
+      execute "TRUNCATE TABLE #{quote_table_name(table_name)} IMMEDIATE", name
+    end
+
+    # @override
+    def supports_views?; true 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
+      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 =
+        if url = config[:url]
+          !!( url =~ /^jdbc:db2j:net:/ && config[:driver] == DRIVER_NAME )
+        else
+          nil
+        end
+    end
+
+    # @private
+    # @deprecated no longer used
+    def 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
+      @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] || ENV['USER']
+        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