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

data/lib/arjdbc/db2/as400.rb

@@ -3,23 +3,35 @@ require 'arjdbc/db2/adapter'
 module ArJdbc
   module AS400
     include DB2
-    
-    def self.extended(base); DB2.extended(base); end
-    
-    def self.column_selector
-      [ /as400/i, lambda { |cfg, column| column.extend(::ArJdbc::AS400::Column) } ]
-    end
 
+    # @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.arel2_visitors(config)
-      visitors = DB2.arel2_visitors(config).dup
-      visitors['as400'] = ::Arel::Visitors::DB2
-      visitors
+    # @see ActiveRecord::ConnectionAdapters::Jdbc::ArelSupport
+    def self.arel_visitor_type(config = nil); DB2.arel_visitor_type(config); end
+
+    def self.column_selector
+      [ /as400/i, lambda { |config, column| column.extend(Column) } ]
     end
 
+    # @private
+    Column = DB2::Column
+
+    # 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
@@ -35,7 +47,7 @@ module ArJdbc
     end
 
     # @override
-    def rename_column(table_name, column_name, new_column_name) # :nodoc:
+    def rename_column(table_name, column_name, new_column_name)
       raise NotImplementedError, "rename_column is not supported on IBM iSeries"
     end
 
@@ -43,7 +55,7 @@ module ArJdbc
     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)
 
@@ -83,21 +95,22 @@ module ArJdbc
         @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 = 
+      @db2_schema =
         if config[:schema].present?
           config[:schema]
         elsif config[:jndi].present?
@@ -119,6 +132,6 @@ module ArJdbc
           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

@@ -1,4 +1,5 @@
 ArJdbc::ConnectionMethods.module_eval do
+  # @note Assumes DB2 driver (*db2jcc.jar*) is on class-path.
   def db2_connection(config)
     config[:url] ||= begin
       if config[:host] # Type 4 URL: jdbc:db2://server:port/database
@@ -15,6 +16,7 @@ ArJdbc::ConnectionMethods.module_eval do
   end
   alias_method :jdbcdb2_connection, :db2_connection
 
+  # @note Assumes AS400 driver (*jt400.jar*) is on class-path.
   def as400_connection(config)
     config[:url] ||= begin
       # jdbc:as400://[host]

data/lib/arjdbc/derby/adapter.rb

@@ -1,8 +1,10 @@
 ArJdbc.load_java_part :Derby
-require 'arjdbc/jdbc/missing_functionality_helper'
+
+require 'arjdbc/util/table_copier'
 
 module ArJdbc
   module Derby
+    include Util::TableCopier
 
     def self.extended(adapter)
       require 'arjdbc/derby/active_record_patch'
@@ -12,21 +14,20 @@ module ArJdbc
       require 'arjdbc/derby/active_record_patch'
     end
 
-    def self.column_selector
-      [ /derby/i, lambda { |cfg, column| column.extend(::ArJdbc::Derby::Column) } ]
-    end
-
+    # @see ActiveRecord::ConnectionAdapters::JdbcAdapter#jdbc_connection_class
     def self.jdbc_connection_class
       ::ActiveRecord::ConnectionAdapters::DerbyJdbcConnection
     end
-    
-    def configure_connection
-      execute("SET ISOLATION = SERIALIZABLE")
-      # must be done or SELECT...FOR UPDATE won't work how we expect
+
+    # @see ActiveRecord::ConnectionAdapters::JdbcColumn#column_types
+    def self.column_selector
+      [ /derby/i, lambda { |config, column| column.extend(Column) } ]
     end
 
+    # @note Part of this module is implemented in "native" Java.
+    # @see ActiveRecord::ConnectionAdapters::JdbcColumn
     module Column
-      
+
       private
 
       def extract_limit(sql_type)
@@ -48,7 +49,7 @@ module ArJdbc
         end
         limit
       end
-      
+
       def simplified_type(field_type)
         case field_type
         when /^smallint/i    then :boolean
@@ -58,6 +59,11 @@ module ArJdbc
           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
@@ -70,24 +76,43 @@ module ArJdbc
         return nil if value == "GENERATED_BY_DEFAULT"
         value
       end
-      
+
+    end
+
+    # @see ActiveRecord::ConnectionAdapters::Jdbc::ArelSupport
+    def self.arel_visitor_type(config = nil)
+      require 'arel/visitors/derby'; ::Arel::Visitors::Derby
     end
 
-    ADAPTER_NAME = 'Derby'
-    
-    def adapter_name # :nodoc:
+    ADAPTER_NAME = 'Derby'.freeze
+
+    def adapter_name
       ADAPTER_NAME
     end
 
-    def self.arel2_visitors(config)
-      require 'arel/visitors/derby'
-      {
-        'derby' => ::Arel::Visitors::Derby,
-        'jdbcderby' => ::Arel::Visitors::Derby,
-      }
+    # @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::ConnectionFailed, "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
 
-    include ArJdbc::MissingFunctionalityHelper
+    def configure_connection
+      # must be done or SELECT...FOR UPDATE won't work how we expect :
+      execute("SET ISOLATION = SERIALIZABLE")
+      # 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
@@ -95,76 +120,83 @@ module ArJdbc
 
     NATIVE_DATABASE_TYPES = {
       :primary_key => "int GENERATED BY DEFAULT AS identity NOT NULL PRIMARY KEY",
-      :string => { :name => "varchar", :limit => 255 },
+      :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
-      :decimal => { :name => "decimal", :precision => 5, :scale => 0 }, # defaults
-      :numeric => { :name => "decimal", :precision => 5, :scale => 0 }, # defaults
-      :integer => { :name => "integer", :limit => 4 },
-      :smallint => { :name => "smallint", :limit => 2 },
-      :bigint => { :name => "bigint", :limit => 8 },
-      :real => { :name => "real", :limit => 4 },
-      :double => { :name => "double", :limit => 8 },
+      :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" },
+      :boolean => { :name => "smallint", :limit => 1 }, # TODO boolean (since 10.7)
+      :object => { :name => "object" },
     }
-    
+
+    # @override
     def native_database_types
-      super.merge NATIVE_DATABASE_TYPES
-    end
-    
-    def modify_types(types)
-      super(types)
-      types[:primary_key] = NATIVE_DATABASE_TYPES[:primary_key]
-      [ :string, :float, :decimal, :numeric, :integer, 
-        :smallint, :bigint, :real, :double, :xml ].each do |type|
-        types[type] = NATIVE_DATABASE_TYPES[type].dup
-      end
-      types[:boolean] = NATIVE_DATABASE_TYPES[:boolean].dup
-      types
+      NATIVE_DATABASE_TYPES
     end
-    
-    # in Derby, the following cannot specify a limit :
-    NO_LIMIT_TYPES = [ :integer, :boolean, :timestamp, :datetime, :date, :time ] # :nodoc:
-    
+
+    # @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.
-    def type_to_sql(type, limit = nil, precision = nil, scale = nil) # :nodoc:
+    # @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
 
-    class TableDefinition < ActiveRecord::ConnectionAdapters::TableDefinition # :nodoc:
-      
+    # @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 default -- fix case where ActiveRecord passes :default => nil, :null => true
+
+    # @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
 
+    # @override
     def empty_insert_statement_value
       'VALUES ( DEFAULT )' # won't work as Derby does need to know the columns count
     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}")
@@ -183,11 +215,13 @@ module ArJdbc
       ActiveRecord::Base.send(:subclasses).select { |klass| klass.table_name == table }
     end
     private :classes_for_table_name
-    
-    def remove_index(table_name, options) #:nodoc:
+
+    # @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
@@ -198,29 +232,15 @@ module ArJdbc
       execute(add_column_sql)
     end
 
-    def execute(sql, name = nil, binds = [])
-      sql = to_sql(sql, binds)
-      if sql =~ /\A\s*(UPDATE|INSERT)/i
-        if ( i = sql =~ /\sWHERE\s/im )
-          where_part = sql[i..-1]; sql = sql.dup
-          where_part.gsub!(/!=\s*NULL/, 'IS NOT NULL')
-          where_part.gsub!(/=\sNULL/i, 'IS NULL')
-          sql[i..-1] = where_part
-        end
-      else
-        sql = sql.gsub(/=\sNULL/i, 'IS NULL')
-      end
-      super(sql, name, binds)
-    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")
-    #
-    # Based on distinct method for PostgreSQL Adapter
+    # ```
+    # @note This is based on distinct method for the PostgreSQL Adapter.
+    # @override
     def distinct(columns, order_by)
       return "DISTINCT #{columns}" if order_by.blank?
 
@@ -234,22 +254,27 @@ module ArJdbc
       sql = "DISTINCT #{columns}, #{order_columns * ', '}"
       sql
     end
-    
-    def remove_column(table_name, *column_names) # :nodoc:
+
+    # @override
+    def remove_column(table_name, *column_names)
       for column_name in column_names.flatten
         execute "ALTER TABLE #{quote_table_name(table_name)} DROP COLUMN #{quote_column_name(column_name)} RESTRICT"
       end
     end
 
-    # 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).
+    # @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
@@ -263,14 +288,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;
@@ -280,53 +308,124 @@ 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
 
+    # @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, nil, derby_schema)
+    # @override
+    def tables(name = nil)
+      @connection.tables(nil, current_schema)
+    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
 
-    def tables
-      @connection.tables(nil, derby_schema)
+    # Creates a new Derby schema.
+    # @see #set_schema
+    def create_schema(schema)
+      execute "CREATE SCHEMA #{schema}", 'Create Schema'
     end
-    
-    def recreate_database(name = nil, options = {}) # :nodoc:
+
+    # 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
-    
-    def create_database(name = nil, options = {}); end # :nodoc:
 
-    def drop_database(name = nil) # :nodoc:
+    # @private
+    def create_database(name = nil, options = {}); end
+
+    # @private
+    def drop_database(name = nil)
       tables.each { |table| drop_table(table) }
     end
 
-    def quote_column_name(name) # :nodoc:
+    # @override
+    def quote_column_name(name)
       %Q{"#{name.to_s.upcase.gsub('"', '""')}"}
     end
 
-    def add_limit_offset!(sql, options) # :nodoc:
+    # @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
-    
+
+    # 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