neo-activerecord-jdbc-adapter 5.0.pre2

data/lib/arjdbc/db2/as400.rb

@@ -0,0 +1,130 @@
+require 'arjdbc/db2/adapter'
+
+module ArJdbc
+  module AS400
+    include DB2
+
+    # @private
+    def self.extended(adapter); DB2.extended(adapter); end
+
+    # @private
+    def self.initialize!; DB2.initialize!; end
+
+    # @see ActiveRecord::ConnectionAdapters::JdbcAdapter#jdbc_connection_class
+    def self.jdbc_connection_class; DB2.jdbc_connection_class; end
+
+    def self.column_selector
+      [ /as400/i, lambda { |config, column| column.extend(Column) } ]
+    end
+
+    # Boolean emulation can be disabled using :
+    #
+    #   ArJdbc::AS400.emulate_booleans = false
+    #
+    def self.emulate_booleans; DB2.emulate_booleans; end
+    def self.emulate_booleans=(emulate); DB2.emulate_booleans = emulate; end
+
+    ADAPTER_NAME = 'AS400'.freeze
+
+    def adapter_name
+      ADAPTER_NAME
+    end
+
+    # @override
+    def prefetch_primary_key?(table_name = nil)
+      # TRUE if the table has no identity column
+      names = table_name.upcase.split(".")
+      sql = "SELECT 1 FROM SYSIBM.SQLPRIMARYKEYS WHERE "
+      sql << "TABLE_SCHEM = '#{names.first}' AND " if names.size == 2
+      sql << "TABLE_NAME = '#{names.last}'"
+      select_one(sql).nil?
+    end
+
+    # @override
+    def rename_column(table_name, column_name, new_column_name)
+      raise NotImplementedError, "rename_column is not supported on IBM iSeries"
+    end
+
+    # @override
+    def execute_table_change(sql, table_name, name = nil)
+      execute_and_auto_confirm(sql, name)
+    end
+
+    # holy moly batman! all this to tell AS400 "yes i am sure"
+    def execute_and_auto_confirm(sql, name = nil)
+
+      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.inspect}"
+      end
+
+      begin
+        result = execute(sql, name)
+      rescue Exception
+        raise
+      else
+        # Return if all work fine
+        result
+      ensure
+
+        # Ensure default configuration restoration
+        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.inspect}"
+        end
+
+      end
+    end
+    private :execute_and_auto_confirm
+
+    # disable all schemas browsing when default schema is specified
+    def table_exists?(name)
+      return false unless name
+      schema ? @connection.table_exists?(name, schema) : @connection.table_exists?(name)
+    end
+
+    DRIVER_NAME = 'com.ibm.as400.access.AS400JDBCDriver'.freeze
+
+    # @private
+    # @deprecated no longer used
+    def as400?
+      true
+    end
+
+    private
+
+    # @override
+    def db2_schema
+      @db2_schema = false unless defined? @db2_schema
+      return @db2_schema if @db2_schema != false
+      @db2_schema =
+        if config[:schema].present?
+          config[:schema]
+        elsif config[:jndi].present?
+          # Only found method to set db2_schema from jndi
+          result = select_one("SELECT CURRENT_SCHEMA FROM SYSIBM.SYSDUMMY1")
+          schema = result['00001']
+          # If the connection uses the library list schema name will be nil
+          if schema == '*LIBL'
+            schema = nil
+          end
+          schema
+        else
+          # AS400 implementation takes schema from library name (last part of URL)
+          # jdbc:as400://localhost/schema;naming=system;libraries=lib1,lib2
+          schema = nil
+          split = config[:url].split('/')
+          # Return nil if schema isn't defined
+          schema = split.last.split(';').first.strip if split.size == 4
+          schema
+        end
+    end
+
+  end
+end

data/lib/arjdbc/db2/column.rb

@@ -0,0 +1,167 @@
+module ArJdbc
+  module DB2
+
+    # @see ActiveRecord::ConnectionAdapters::JdbcColumn#column_types
+    def self.column_selector
+      [ /(db2|zos)/i, lambda { |config, column| column.extend(Column) } ]
+    end
+
+    # @see ActiveRecord::ConnectionAdapters::JdbcColumn
+    module Column
+
+      # @private
+      def self.included(base)
+        # NOTE: assumes a standalone DB2Column class
+        class << base; include Cast; end
+      end
+
+      # @deprecated use `self.class.string_to_time`
+      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
+
+      # @deprecated use `self.class.string_to_time` or `self.class.string_to_dummy_time`
+      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
+        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
+
+      # @deprecated
+      # @private
+      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
+
+      # @override
+      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 :date      then self.class.string_to_date(value)
+        when :datetime  then self.class.string_to_time(value)
+        when :timestamp then self.class.string_to_time(value)
+        when :time      then self.class.string_to_dummy_time(value)
+        # TODO AS400 stores binary strings in EBCDIC (CCSID 65535), need to convert back to ASCII
+        else
+          super
+        end
+      end
+
+      # @override
+      def type_cast_code(var_name)
+        case type
+        when :date      then "#{self.class.name}.string_to_date(#{var_name})"
+        when :datetime  then "#{self.class.name}.string_to_time(#{var_name})"
+        when :timestamp then "#{self.class.name}.string_to_time(#{var_name})"
+        when :time      then "#{self.class.name}.string_to_dummy_time(#{var_name})"
+        else
+          super
+        end
+      end
+
+      private
+
+      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
+        # DB2 provides three data types to store these data objects as strings of up to 2 GB in size:
+        #  Character large objects (CLOBs)
+        #    Use the CLOB data type to store SBCS or mixed data, such as documents that contain
+        #    single character set. Use this data type if your data is larger (or might grow larger)
+        #    than the VARCHAR data type permits.
+        #  Double-byte character large objects (DBCLOBs)
+        #    Use the DBCLOB data type to store large amounts of DBCS data, such as documents that
+        #    use a DBCS character set.
+        #  Binary large objects (BLOBs)
+        #    Use the BLOB data type to store large amounts of noncharacter data, such as pictures,
+        #    voice, and mixed media.
+        when /clob|text/i        then :text # handles DBCLOB
+        when /^long varchar/i    then :text # :limit => 32700
+        when /blob|binary/i      then :binary
+        # varchar () for bit data, char () for bit data, long varchar for bit data
+        when /for bit data/i     then :binary
+        when /xml/i              then :xml
+        when /graphic/i          then :graphic # vargraphic, long vargraphic
+        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
+
+      module Cast
+
+        # @override
+        def string_to_date(value)
+          return nil unless value = current_date_time_parse(value)
+
+          super
+        end
+
+        # @override
+        def string_to_time(value)
+          return nil unless value = current_date_time_parse(value)
+
+          super
+        end
+
+        # @override
+        def string_to_dummy_time(value)
+          return nil unless value = current_date_time_parse(value)
+
+          super
+        end
+
+        private
+
+        def current_date_time_parse(value)
+          return value unless value.is_a?(String)
+          return nil if value.empty?
+          return Time.now if value.index('CURRENT') == 0
+
+          return value
+        end
+
+      end
+
+    end
+  end
+end

data/lib/arjdbc/db2/connection_methods.rb

@@ -0,0 +1,44 @@
+ArJdbc::ConnectionMethods.module_eval do
+  # @note Assumes DB2 driver (*db2jcc.jar*) is on class-path.
+  def db2_connection(config)
+    config[:adapter_spec] ||= ::ArJdbc::DB2
+
+    return jndi_connection(config) if jndi_config?(config)
+
+    config[:url] ||= begin
+      if config[:host] # Type 4 URL: jdbc:db2://server:port/database
+        config[:port] ||= 50000
+        "jdbc:db2://#{config[:host]}:#{config[:port]}/#{config[:database]}"
+      else # Type 2 URL: jdbc:db2:database
+        "jdbc:db2:#{config[:database]}"
+      end
+    end
+    config[:driver] ||= ::ArJdbc::DB2::DRIVER_NAME
+    config[:connection_alive_sql] ||= 'SELECT 1 FROM syscat.tables FETCH FIRST 1 ROWS ONLY'
+    jdbc_connection(config)
+  end
+  alias_method :jdbcdb2_connection, :db2_connection
+
+  # @note Assumes AS400 driver (*jt400.jar*) is on class-path.
+  def as400_connection(config)
+    config[:adapter_spec] ||= ::ArJdbc::AS400
+
+    return jndi_connection(config) if config[:jndi]
+
+    config[:url] ||= begin
+      # jdbc:as400://[host]
+      url = 'jdbc:as400://'
+      url << config[:host] if config[:host]
+      # jdbc:as400://myiSeries;database name=IASP1
+      url << ";database name=#{config[:database]}" if config[:database]
+      # jdbc:as400://[host];proxy server=HODServerName:proxyServerPort
+      url << ";proxy server=#{config[:proxy]}" if config[:proxy]
+      url
+    end
+    require 'arjdbc/db2/as400'
+    config[:driver] ||= ::ArJdbc::AS400::DRIVER_NAME
+    config[:connection_alive_sql] ||= 'SELECT 1 FROM sysibm.tables FETCH FIRST 1 ROWS ONLY'
+    jdbc_connection(config)
+  end
+  alias_method :jdbcas400_connection, :as400_connection
+end

data/lib/arjdbc/derby.rb

@@ -0,0 +1,3 @@
+require 'arjdbc'
+require 'arjdbc/derby/connection_methods'
+require 'arjdbc/derby/adapter'

data/lib/arjdbc/derby/active_record_patch.rb

@@ -0,0 +1,13 @@
+# Needed because Rails is broken wrt to quoting of some values.
+# Most databases are nice about it, but not Derby.
+# The real issue is that you can't compare a CHAR value to a NUMBER column.
+ActiveRecord::Associations::ClassMethods.module_eval do
+  private
+  def select_limited_ids_list(options, join_dependency)
+    return super unless connection.is_a?(ArJdbc::Derby)
+    connection.select_all(
+      construct_finder_sql_for_association_limiting(options, join_dependency),
+      "#{name} Load IDs For Limited Eager Loading"
+    ).collect { |row| connection.quote(row[primary_key], columns_hash[primary_key]) }.join(", ")
+  end
+end

data/lib/arjdbc/derby/adapter.rb

@@ -0,0 +1,556 @@
+ArJdbc.load_java_part :Derby
+
+require 'arjdbc/util/table_copier'
+require 'arjdbc/derby/schema_creation' # AR 4.x
+require 'arel/visitors/derby'
+
+module ArJdbc
+  module Derby
+    include Util::TableCopier
+
+    def self.extended(adapter)
+      require 'arjdbc/derby/active_record_patch'
+    end
+
+    def self.included(base)
+      require 'arjdbc/derby/active_record_patch'
+    end
+
+    # @see ActiveRecord::ConnectionAdapters::JdbcAdapter#jdbc_connection_class
+    def self.jdbc_connection_class
+      ::ActiveRecord::ConnectionAdapters::DerbyJdbcConnection
+    end
+
+    # @see ActiveRecord::ConnectionAdapters::JdbcColumn#column_types
+    def self.column_selector
+      [ /derby/i, lambda { |config, column| column.extend(Column) } ]
+    end
+
+ 	# @private
+    @@emulate_booleans = true
+
+    # Boolean emulation can be disabled using :
+    #
+    #   ArJdbc::Derby.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
+
+    # @note Part of this module is implemented in "native" Java.
+    # @see ActiveRecord::ConnectionAdapters::JdbcColumn
+    module Column
+
+      private
+
+      def extract_limit(sql_type)
+        case @sql_type = sql_type.downcase
+        when /^smallint/i    then @sql_type = 'smallint'; limit = 2
+        when /^bigint/i      then @sql_type = 'bigint'; limit = 8
+        when /^double/i      then @sql_type = 'double'; limit = 8 # DOUBLE PRECISION
+        when /^real/i        then @sql_type = 'real'; limit = 4
+        when /^integer/i     then @sql_type = 'integer'; limit = 4
+        when /^datetime/i    then @sql_type = 'datetime'; limit = nil
+        when /^timestamp/i   then @sql_type = 'timestamp'; limit = nil
+        when /^time/i        then @sql_type = 'time'; limit = nil
+        when /^date/i        then @sql_type = 'date'; limit = nil
+        when /^xml/i         then @sql_type = 'xml'; limit = nil
+        else
+          limit = super
+          # handle maximum length for a VARCHAR string :
+          limit = 32672 if ! limit && @sql_type.index('varchar') == 0
+        end
+        limit
+      end
+
+      def simplified_type(field_type)
+        case field_type
+        when /^smallint/i    then Derby.emulate_booleans? ? :boolean : :integer
+        when /^bigint|int/i  then :integer
+        when /^real|double/i then :float
+        when /^dec/i         then # DEC is a DECIMAL alias
+          extract_scale(field_type) == 0 ? :integer : :decimal
+        when /^timestamp/i   then :datetime
+        when /^xml/i         then :xml
+        when 'long varchar'  then :text
+        when /for bit data/i then :binary
+        # :name=>"long varchar for bit data", :limit=>32700
+        # :name=>"varchar() for bit data", :limit=>32672
+        # :name=>"char() for bit data", :limit=>254}
+        else
+          super
+        end
+      end
+
+      # Post process default value from JDBC into a Rails-friendly format (columns{-internal})
+      def default_value(value)
+        # JDBC returns column default strings with actual single quotes around the value.
+        return $1 if value =~ /^'(.*)'$/
+        return nil if value == "GENERATED_BY_DEFAULT"
+        value
+      end
+
+    end
+
+    ADAPTER_NAME = 'Derby'.freeze
+
+    def adapter_name
+      ADAPTER_NAME
+    end
+
+    # @private
+    def init_connection(jdbc_connection)
+      md = jdbc_connection.meta_data
+      major_version = md.database_major_version; minor_version = md.database_minor_version
+      if major_version < 10 || (major_version == 10 && minor_version < 5)
+        raise ::ActiveRecord::ConnectionNotEstablished, "Derby adapter requires Derby >= 10.5"
+      end
+      if major_version == 10 && minor_version < 8 # 10.8 ~ supports JDBC 4.1
+        config[:connection_alive_sql] ||=
+          'SELECT 1 FROM SYS.SYSSCHEMAS FETCH FIRST 1 ROWS ONLY' # FROM clause mandatory
+      else
+        # NOTE: since the loaded Java driver class can't change :
+        Derby.send(:remove_method, :init_connection) rescue nil
+      end
+    end
+
+    def configure_connection
+      # must be done or SELECT...FOR UPDATE won't work how we expect :
+      tx_isolation = config[:transaction_isolation] # set false to leave as is
+      tx_isolation = :serializable if tx_isolation.nil?
+      @connection.transaction_isolation = tx_isolation if tx_isolation
+      # if a user name was specified upon connection, the user's name is the
+      # default schema for the connection, if a schema with that name exists
+      set_schema(config[:schema]) if config.key?(:schema)
+    end
+
+    def index_name_length
+      128
+    end
+
+    NATIVE_DATABASE_TYPES = {
+      :primary_key => "int GENERATED BY DEFAULT AS identity NOT NULL PRIMARY KEY",
+      :string => { :name => "varchar", :limit => 255 }, # 32672
+      :text => { :name => "clob" }, # 2,147,483,647
+      :char => { :name => "char", :limit => 254 }, # JDBC :limit => 254
+      :binary => { :name => "blob" }, # 2,147,483,647
+      :float => { :name => "float", :limit => 8 }, # DOUBLE PRECISION
+      :real => { :name => "real", :limit => 4 }, # JDBC :limit => 23
+      :double => { :name => "double", :limit => 8 }, # JDBC :limit => 52
+      :decimal => { :name => "decimal", :precision => 5, :scale => 0 }, # JDBC :limit => 31
+      :numeric => { :name => "decimal", :precision => 5, :scale => 0 }, # JDBC :limit => 31
+      :integer => { :name => "integer", :limit => 4 }, # JDBC :limit => 10
+      :smallint => { :name => "smallint", :limit => 2 }, # JDBC :limit => 5
+      :bigint => { :name => "bigint", :limit => 8 }, # JDBC :limit => 19
+      :date => { :name => "date" },
+      :time => { :name => "time" },
+      :datetime => { :name => "timestamp" },
+      :timestamp => { :name => "timestamp" },
+      :xml => { :name => "xml" },
+      :boolean => { :name => "smallint", :limit => 1 }, # TODO boolean (since 10.7)
+      :object => { :name => "object" },
+    }
+
+    # @private
+    def initialize_type_map(m)
+      super
+      m.register_type(%r(smallint)i) do |sql_type|
+        if Derby.emulate_booleans?
+          ActiveRecord::Type::Boolean.new
+        else
+          ActiveRecord::Type::Integer.new(:limit => 1)
+        end
+      end
+      m.alias_type %r(real)i, 'float'
+    end if AR42
+
+    def reset_column_information
+      initialize_type_map(type_map)
+    end if AR42
+
+    # @override
+    def native_database_types
+      NATIVE_DATABASE_TYPES
+    end
+
+    # UNTESTED
+    def existing_savepoint_name?(name)
+      (@connection.instance_variable_get('@savepoints') || {}).key? name
+    end
+
+    # Ensure the savepoint name is unused before creating it.
+    # @override
+    def create_savepoint(name = current_savepoint_name(true))
+      release_savepoint(name) if existing_savepoint_name?(name)
+      super(name)
+    end
+
+    # @override
+    def quote(value, column = nil)
+      return super if column && ArJdbc::AR42 && column.cast_type.is_a?(ActiveRecord::Type::Serialized)
+      return value.quoted_id if value.respond_to?(:quoted_id)
+      return value if sql_literal?(value)
+      return 'NULL' if value.nil?
+
+      column_type = column && column.type
+      if column_type == :string || column_type == :text
+        # Derby is not permissive
+        # e.g. sending an Integer to a VARCHAR column will fail
+        case value
+        when BigDecimal then value = value.to_s('F')
+        when Numeric then value = value.to_s
+        when true, false then value = value.to_s
+        when Date, Time then value = quoted_date(value)
+        else # on 2.3 attribute serialization needs to_yaml here
+          value = value.to_s if ActiveRecord::VERSION::MAJOR >= 3
+        end
+      end
+
+      case value
+      when String, ActiveSupport::Multibyte::Chars
+        if column_type == :text
+          "CAST('#{quote_string(value)}' AS CLOB)"
+        elsif column_type == :binary
+          "CAST(X'#{quote_binary(value)}' AS BLOB)"
+        elsif column_type == :xml
+          "XMLPARSE(DOCUMENT '#{quote_string(value)}' PRESERVE WHITESPACE)"
+        elsif column_type == :integer
+          value.to_i
+        elsif column_type == :float
+          value.to_f
+        else
+          "'#{quote_string(value)}'"
+        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
+
+    # @private In Derby, these cannot specify a limit.
+    NO_LIMIT_TYPES = [ :integer, :boolean, :timestamp, :datetime, :date, :time ]
+
+    # Convert the specified column type to a SQL string.
+    # @override
+    def type_to_sql(type, limit = nil, precision = nil, scale = nil)
+      return super unless NO_LIMIT_TYPES.include?(t = type.to_s.downcase.to_sym)
+
+      native_type = NATIVE_DATABASE_TYPES[t]
+      native_type.is_a?(Hash) ? native_type[:name] : native_type
+    end
+
+    # @private
+    class TableDefinition < ActiveRecord::ConnectionAdapters::TableDefinition
+
+      def xml(*args)
+        options = args.extract_options!
+        column(args[0], 'xml', options)
+      end
+
+    end
+
+    def table_definition(*args)
+      new_table_definition(TableDefinition, *args)
+    end
+
+    # @override
+    def empty_insert_statement_value
+      ::Arel::Visitors::Derby::VALUES_DEFAULT # Derby needs to know the columns
+    end
+
+    # Set the sequence to the max value of the table's column.
+    # @override
+    def reset_sequence!(table, column, sequence = nil)
+      mpk = select_value("SELECT MAX(#{quote_column_name(column)}) FROM #{quote_table_name(table)}")
+      execute("ALTER TABLE #{quote_table_name(table)} ALTER COLUMN #{quote_column_name(column)} RESTART WITH #{mpk.to_i + 1}")
+    end
+
+    def reset_pk_sequence!(table, pk = nil, sequence = nil)
+      klasses = classes_for_table_name(table)
+      klass   = klasses.nil? ? nil : klasses.first
+      pk      = klass.primary_key unless klass.nil?
+      if pk && klass.columns_hash[pk].type == :integer
+        reset_sequence!(klass.table_name, pk)
+      end
+    end
+
+    def classes_for_table_name(table)
+      ActiveRecord::Base.send(:subclasses).select { |klass| klass.table_name == table }
+    end
+    private :classes_for_table_name
+
+    # @override
+    def remove_index(table_name, options)
+      execute "DROP INDEX #{index_name(table_name, options)}"
+    end
+
+    # @override
+    def rename_table(name, new_name)
+      execute "RENAME TABLE #{quote_table_name(name)} TO #{quote_table_name(new_name)}"
+    end
+
+    def add_column(table_name, column_name, type, options = {})
+      add_column_sql = "ALTER TABLE #{quote_table_name(table_name)} ADD #{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 unless const_defined? :SchemaCreation
+
+    # @override fix case where AR passes `:default => nil, :null => true`
+    def add_column_options!(sql, options)
+      options.delete(:default) if options.has_key?(:default) && options[:default].nil?
+      sql << " DEFAULT #{quote(options.delete(:default))}" if options.has_key?(:default)
+      super
+    end unless const_defined? :SchemaCreation
+
+    if ActiveRecord::VERSION::MAJOR >= 4
+
+    # @override
+    def remove_column(table_name, column_name, type = nil, options = {})
+      do_remove_column(table_name, column_name)
+    end
+
+    else
+
+    # @override
+    def remove_column(table_name, *column_names)
+      for column_name in column_names.flatten
+        do_remove_column(table_name, column_name)
+      end
+    end
+    alias remove_columns remove_column
+
+    end
+
+    def do_remove_column(table_name, column_name)
+      execute "ALTER TABLE #{quote_table_name(table_name)} DROP COLUMN #{quote_column_name(column_name)} RESTRICT"
+    end
+    private :do_remove_column
+
+    # @override
+    def change_column(table_name, column_name, type, options = {})
+      # TODO this needs a review since now we're likely to be on >= 10.8
+
+      # Notes about changing in Derby:
+      #    http://db.apache.org/derby/docs/10.2/ref/rrefsqlj81859.html#rrefsqlj81859__rrefsqlj37860)
+      #
+      # We support changing columns using the strategy outlined in:
+      #    https://issues.apache.org/jira/browse/DERBY-1515
+      #
+      # This feature has not made it into a formal release and is not in Java 6.
+      # We will need to conditionally support this (supposed to arrive for 10.3.0.0).
+
+      # null/not nulling is easy, handle that separately
+      if options.include?(:null)
+        # This seems to only work with 10.2 of Derby
+        if options.delete(:null) == false
+          execute "ALTER TABLE #{quote_table_name(table_name)} ALTER COLUMN #{quote_column_name(column_name)} NOT NULL"
+        else
+          execute "ALTER TABLE #{quote_table_name(table_name)} ALTER COLUMN #{quote_column_name(column_name)} NULL"
+        end
+      end
+
+      # anything left to do?
+      unless options.empty?
+        begin
+          execute "ALTER TABLE #{quote_table_name(table_name)} ALTER COLUMN " <<
+                  " #{quote_column_name(column_name)} SET DATA TYPE #{type_to_sql(type, options[:limit])}"
+        rescue
+          transaction do
+            temp_new_column_name = "#{column_name}_newtype"
+            # 1) ALTER TABLE t ADD COLUMN c1_newtype NEWTYPE;
+            add_column table_name, temp_new_column_name, type, options
+            # 2) UPDATE t SET c1_newtype = c1;
+            execute "UPDATE #{quote_table_name(table_name)} SET " <<
+                    " #{quote_column_name(temp_new_column_name)} = " <<
+                    " CAST(#{quote_column_name(column_name)} AS #{type_to_sql(type, options[:limit])})"
+            # 3) ALTER TABLE t DROP COLUMN c1;
+            remove_column table_name, column_name
+            # 4) ALTER TABLE t RENAME COLUMN c1_newtype to c1;
+            rename_column table_name, temp_new_column_name, column_name
+          end
+        end
+      end
+    end
+
+    # @override
+    def rename_column(table_name, column_name, new_column_name)
+      execute "RENAME COLUMN #{quote_table_name(table_name)}.#{quote_column_name(column_name)} " <<
+              " TO #{quote_column_name(new_column_name)}"
+    end
+
+    # SELECT DISTINCT clause for a given set of columns and a given ORDER BY clause.
+    #
+    # Derby requires the ORDER BY columns in the select list for distinct queries, and
+    # requires that the ORDER BY include the distinct column.
+    # ```
+    #   distinct("posts.id", "posts.created_at desc")
+    # ```
+    # @note This is based on distinct method for the PostgreSQL Adapter.
+    # @override
+    def distinct(columns, order_by)
+      "DISTINCT #{columns_for_distinct(columns, order_by)}"
+    end
+
+    # @override Since AR 4.0 (on 4.1 {#distinct} is gone and won't be called).
+    def columns_for_distinct(columns, orders)
+      return columns if orders.blank?
+
+      # construct a clean list of column names from the ORDER BY clause,
+      # removing any ASC/DESC modifiers
+      order_columns = [ orders ]; order_columns.flatten! # AR 3.x vs 4.x
+      order_columns.map! do |column|
+        column = column.to_sql unless column.is_a?(String) # handle AREL node
+        column.split(',').collect! { |s| s.split.first }
+      end.flatten!
+      order_columns.reject!(&:blank?)
+      order_columns = order_columns.zip (0...order_columns.size).to_a
+      order_columns = order_columns.map { |s, i| "#{s} AS alias_#{i}" }
+
+      columns = [ columns ]; columns.flatten!
+      columns.push( *order_columns ).join(', ')
+      # return a DISTINCT clause that's distinct on the columns we want but
+      # includes all the required columns for the ORDER BY to work properly
+    end
+
+    # @override
+    def primary_keys(table_name)
+      @connection.primary_keys table_name.to_s.upcase
+    end
+
+    # @override
+    def tables(name = nil)
+      @connection.tables(nil, current_schema)
+    end
+
+    # @override
+    def supports_ddl_transactions?; true end
+ 
+    # @override
+    def supports_foreign_keys?; true end
+
+    def truncate(table_name, name = nil)
+      execute "TRUNCATE TABLE #{quote_table_name(table_name)}", name
+    end
+
+    # @return [String] the current schema name
+    def current_schema
+      @current_schema ||=
+        select_value "SELECT CURRENT SCHEMA FROM SYS.SYSSCHEMAS FETCH FIRST 1 ROWS ONLY", 'SCHEMA'
+    end
+
+    # Change the current (implicit) Derby schema to be used for this connection.
+    def set_schema(schema)
+      @current_schema = nil
+      execute "SET SCHEMA #{schema}", 'SCHEMA'
+    end
+    alias_method :current_schema=, :set_schema
+
+    # Creates a new Derby schema.
+    # @see #set_schema
+    def create_schema(schema)
+      execute "CREATE SCHEMA #{schema}", 'Create Schema'
+    end
+
+    # Drops an existing schema, needs to be empty (no DB objects).
+    def drop_schema(schema)
+      execute "DROP SCHEMA #{schema} RESTRICT", 'Drop Schema'
+    end
+
+    # @private
+    def recreate_database(name = nil, options = {})
+      drop_database(name)
+      create_database(name, options)
+    end
+
+    # @private
+    def create_database(name = nil, options = {}); end
+
+    # @private
+    def drop_database(name = nil)
+      tables.each { |table| drop_table(table) }
+    end
+
+    # @override
+    def quote_column_name(name)
+      %Q{"#{name.to_s.upcase.gsub('"', '""')}"}
+    end
+
+    # @override
+    def quote_table_name_for_assignment(table, attr)
+      quote_column_name(attr)
+    end if ::ActiveRecord::VERSION::MAJOR > 3
+
+    # @note Only used with (non-AREL) ActiveRecord **2.3**.
+    # @see Arel::Visitors::Derby
+    def add_limit_offset!(sql, options)
+      sql << " OFFSET #{options[:offset]} ROWS" if options[:offset]
+      # ROWS/ROW and FIRST/NEXT mean the same
+      sql << " FETCH FIRST #{options[:limit]} ROWS ONLY" if options[:limit]
+    end if ::ActiveRecord::VERSION::MAJOR < 3
+
+    # @override
+    def execute(sql, name = nil, binds = [])
+      sql = to_sql(sql, binds)
+      insert = self.class.insert?(sql)
+      update = ! insert && ! self.class.select?(sql)
+      sql = correct_is_null(sql, insert || update)
+      super(sql, name, binds)
+    end
+
+    # 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
+
+    private
+
+    def correct_is_null(sql, insert_or_update = false)
+      if insert_or_update
+        if ( i = sql =~ /\sWHERE\s/im )
+          where_part = sql[i..-1]; sql = sql.dup
+          where_part.gsub!(/!=\s*NULL/i, 'IS NOT NULL')
+          where_part.gsub!(/=\sNULL/i, 'IS NULL')
+          sql[i..-1] = where_part
+        end
+        sql
+      else
+        sql.gsub(/=\sNULL/i, 'IS NULL')
+      end
+    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.insert?(sql)
+        @connection.execute_insert(sql)
+      elsif self.class.select?(sql)
+        @connection.execute_query_raw(sql)
+      else
+        @connection.execute_update(sql)
+      end
+    end
+
+    end
+
+  end
+end