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

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

@@ -1,7 +1,3 @@
-require 'arjdbc/jdbc'
-jdbc_require_driver 'jdbc/derby'
+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

@@ -1,106 +1,261 @@
-require 'arjdbc/jdbc/missing_functionality_helper'
+ArJdbc.load_java_part :Derby
 
-module ::ArJdbc
+require 'arjdbc/util/table_copier'
+require 'arjdbc/derby/schema_creation' # AR 4.x
+require 'arel/visitors/derby'
+
+module ArJdbc
   module Derby
-    def self.column_selector
-      [/derby/i, lambda {|cfg,col| col.extend(::ArJdbc::Derby::Column)}]
-    end
-
-    def self.monkey_rails
-      unless @already_monkeyd
-        # 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)
-            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
+    include Util::TableCopier
 
-        @already_monkeyd = true
-      end
+    def self.extended(adapter)
+      require 'arjdbc/derby/active_record_patch'
     end
 
-    def self.extended(*args)
-      monkey_rails
+    def self.included(base)
+      require 'arjdbc/derby/active_record_patch'
     end
 
-    def self.included(*args)
-      monkey_rails
+    # @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)
-        return :boolean if field_type =~ /smallint/i
-        return :float if field_type =~ /real/i
-        super
+        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.
+        # 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
 
-    def adapter_name #:nodoc:
-      'Derby'
     end
 
-    def arel2_visitors
-      require 'arel/visitors/derby'
-      {'derby' => ::Arel::Visitors::Derby, 'jdbcderby' => ::Arel::Visitors::Derby}
+    ADAPTER_NAME = 'Derby'.freeze
+
+    def adapter_name
+      ADAPTER_NAME
     end
 
-    include ArJdbc::MissingFunctionalityHelper
+    def configure_connection
+      # must be done or SELECT...FOR UPDATE won't work how we expect :
+      if tx_isolation = config[:transaction_isolation]
+        @connection.transaction_isolation = tx_isolation
+      end
+      # 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[: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.
-    # In Derby, the following cannot specify a limit:
-    # - integer
-    # - boolean (smallint)
-    # - timestamp
-    # - date
-    def type_to_sql(type, limit = nil, precision = nil, scale = nil) #:nodoc:
-      return super unless [:integer, :boolean, :timestamp, :date].include? type
+    # @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 = native_database_types[type.to_s.downcase.to_sym]
-      native.is_a?(Hash) ? native[:name] : native
+      native_type = NATIVE_DATABASE_TYPES[t]
+      native_type.is_a?(Hash) ? native_type[:name] : native_type
     end
 
-    def modify_types(tp)
-      tp[:primary_key] = "int generated by default as identity NOT NULL PRIMARY KEY"
-      tp[:string][:limit] = 256
-      tp[:integer][:limit] = nil
-      tp[:boolean] = {:name => "smallint"}
-      tp[:timestamp][:limit] = nil
-      tp[:date][:limit] = nil
-      tp
+    # @private
+    class TableDefinition < ActiveRecord::ConnectionAdapters::TableDefinition
+
+      def xml(*args)
+        options = args.extract_options!
+        column(args[0], 'xml', options)
+      end
+
     end
 
-    # Override default -- fix case where ActiveRecord 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
+    def table_definition(*args)
+      new_table_definition(TableDefinition, *args)
     end
 
-    def classes_for_table_name(table)
-      ActiveRecord::Base.send(:subclasses).select {|klass| klass.table_name == table}
+    # @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}")
@@ -115,150 +270,71 @@ module ::ArJdbc
       end
     end
 
-    def remove_index(table_name, options) #:nodoc:
+    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
 
-    AUTO_INC_STMT2 = "SELECT AUTOINCREMENTSTART, AUTOINCREMENTINC, COLUMNNAME, REFERENCEID, COLUMNDEFAULT FROM SYS.SYSCOLUMNS WHERE REFERENCEID = (SELECT T.TABLEID FROM SYS.SYSTABLES T WHERE T.TABLENAME = '%s') AND COLUMNNAME = '%s'"
-
-    def add_quotes(name)
-      return name unless name
-      %Q{"#{name}"}
-    end
-
-    def strip_quotes(str)
-      return str unless str
-      return str unless /^(["']).*\1$/ =~ str
-      str[1..-2]
-    end
-
-    def expand_double_quotes(name)
-      return name unless name && name['"']
-      name.gsub(/"/,'""')
-    end
-
-    def auto_increment_stmt(tname, cname)
-      stmt = AUTO_INC_STMT2 % [tname, strip_quotes(cname)]
-      data = execute(stmt).first
-      if data
-        start = data['autoincrementstart']
-        if start
-          coldef = ""
-          coldef << " GENERATED " << (data['columndefault'].nil? ? "ALWAYS" : "BY DEFAULT ")
-          coldef << "AS IDENTITY (START WITH "
-          coldef << start
-          coldef << ", INCREMENT BY "
-          coldef << data['autoincrementinc']
-          coldef << ")"
-          return coldef
-        end
-      end
-      ""
-    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
+    end unless const_defined? :SchemaCreation
 
-    def execute(sql, name = nil)
-      if sql =~ /\A\s*(UPDATE|INSERT)/i
-        i = sql =~ /\swhere\s/im
-        if i
-          sql[i..-1] = sql[i..-1].gsub(/!=\s*NULL/, 'IS NOT NULL').gsub(/=\sNULL/i, 'IS NULL')
-        end
-      else
-        sql.gsub!(/= NULL/i, 'IS NULL')
-      end
+    # @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
+    end unless const_defined? :SchemaCreation
 
-    # 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")
-    #
-    # Based on distinct method for PostgreSQL Adapter
-    def distinct(columns, order_by)
-      return "DISTINCT #{columns}" if order_by.blank?
-
-      # construct a clean list of column names from the ORDER BY clause, removing
-      # any asc/desc modifiers
-      order_columns = order_by.split(',').collect { |s| s.split.first }
-      order_columns.delete_if(&:blank?)
-      order_columns = order_columns.zip((0...order_columns.size).to_a).map { |s,i| "#{s} AS alias_#{i}" }
-
-      # 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
-      sql = "DISTINCT #{columns}, #{order_columns * ', '}"
-      sql
-    end
-
-    SIZEABLE = %w(VARCHAR CLOB BLOB)
-
-    def structure_dump #:nodoc:
-      definition=""
-      rs = @connection.connection.meta_data.getTables(nil,nil,nil,["TABLE"].to_java(:string))
-      while rs.next
-        tname = rs.getString(3)
-        definition << "CREATE TABLE #{tname} (\n"
-        rs2 = @connection.connection.meta_data.getColumns(nil,nil,tname,nil)
-        first_col = true
-        while rs2.next
-          col_name = add_quotes(rs2.getString(4));
-          default = ""
-          d1 = rs2.getString(13)
-          if d1 =~ /^GENERATED_/
-            default = auto_increment_stmt(tname, col_name)
-          elsif d1
-            default = " DEFAULT #{d1}"
-          end
+    if ActiveRecord::VERSION::MAJOR >= 4
 
-          type = rs2.getString(6)
-          col_size = rs2.getString(7)
-          nulling = (rs2.getString(18) == 'NO' ? " NOT NULL" : "")
-          create_col_string = add_quotes(expand_double_quotes(strip_quotes(col_name))) +
-            " " +
-            type +
-            (SIZEABLE.include?(type) ? "(#{col_size})" : "") +
-            nulling +
-            default
-          if !first_col
-            create_col_string = ",\n #{create_col_string}"
-          else
-            create_col_string = " #{create_col_string}"
-          end
+    # @override
+    def remove_column(table_name, column_name, type = nil, options = {})
+      do_remove_column(table_name, column_name)
+    end
 
-          definition << create_col_string
+    else
 
-          first_col = false
-        end
-        definition << ");\n\n"
+    # @override
+    def remove_column(table_name, *column_names)
+      for column_name in column_names.flatten
+        do_remove_column(table_name, column_name)
       end
-      definition
+    end
+    alias remove_columns remove_column
+
     end
 
-    def remove_column(table_name, column_name)
+    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
 
-    # 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 somehow (supposed to arrive for 10.3.0.0)
+    # @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
@@ -272,14 +348,17 @@ module ::ArJdbc
       # 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])}"
+          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])})"
+            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;
@@ -289,60 +368,173 @@ module ::ArJdbc
       end
     end
 
-    def rename_column(table_name, column_name, new_column_name) #:nodoc:
-      execute "RENAME COLUMN #{quote_table_name(table_name)}.#{quote_column_name(column_name)} TO #{quote_column_name(new_column_name)}"
+    # @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
 
-    def columns(table_name, name=nil)
-      @connection.columns_internal(table_name.to_s, name, derby_schema)
+    # @override
+    def tables(name = nil)
+      @connection.tables(nil, current_schema)
     end
 
-    def tables
-      @connection.tables(nil, derby_schema)
+    # @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
 
-    def recreate_database(db_name)
-      tables.each do |t|
-        drop_table t
-      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
 
-    def quote_column_name(name) #:nodoc:
-      %Q{"#{name.to_s.upcase.gsub(/"/, '""')}"}
+    # 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
 
-    def quoted_true
-      '1'
+    # Creates a new Derby schema.
+    # @see #set_schema
+    def create_schema(schema)
+      execute "CREATE SCHEMA #{schema}", 'Create Schema'
     end
 
-    def quoted_false
-      '0'
+    # Drops an existing schema, needs to be empty (no DB objects).
+    def drop_schema(schema)
+      execute "DROP SCHEMA #{schema} RESTRICT", 'Drop Schema'
     end
 
-    def add_limit_offset!(sql, options) #:nodoc:
-      if options[:offset]
-        sql << " OFFSET #{options[:offset]} ROWS"
-      end
-      if options[:limit]
-        #ROWS/ROW and FIRST/NEXT mean the same
-        sql << " FETCH FIRST #{options[:limit]} ROWS ONLY"
-      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
-    # Derby appears to define schemas using the username
-    def derby_schema
-      if @config.has_key?(:schema)
-        config[:schema]
+
+    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
-        (@config[:username] && @config[:username].to_s) || ''
+        sql.gsub(/=\sNULL/i, 'IS NULL')
       end
     end
-  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