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

data/lib/arjdbc/hsqldb/connection_methods.rb

@@ -1,14 +1,28 @@
-module ActiveRecord
-  class Base
-    class << self
-      def hsqldb_connection(config)
-        require "arjdbc/hsqldb"
-        config[:url] ||= "jdbc:hsqldb:#{config[:database]}"
-        config[:driver] ||= "org.hsqldb.jdbcDriver"
-        embedded_driver(config)
-      end
+ArJdbc::ConnectionMethods.module_eval do
+  def hsqldb_connection(config)
+    config[:adapter_spec] ||= ::ArJdbc::HSQLDB
+    config[:adapter_class] = ActiveRecord::ConnectionAdapters::HsqldbAdapter unless config.key?(:adapter_class)
+
+    return jndi_connection(config) if jndi_config?(config)
+
+    begin
+      require 'jdbc/hsqldb'
+      ::Jdbc::HSQLDB.load_driver(:require) if defined?(::Jdbc::HSQLDB.load_driver)
+    rescue LoadError # assuming driver.jar is on the class-path
+    end
 
-      alias_method :jdbchsqldb_connection, :hsqldb_connection
+    config[:url] ||= begin
+      db = config[:database]
+      if db[0, 4] == 'mem:' || db[0, 5] == 'file:' || db[0, 5] == 'hsql:'
+        "jdbc:hsqldb:#{db}"
+      else
+        "jdbc:hsqldb:file:#{db}"
+      end
     end
+    config[:driver] ||= defined?(::Jdbc::HSQLDB.driver_name) ? ::Jdbc::HSQLDB.driver_name : 'org.hsqldb.jdbcDriver'
+    config[:connection_alive_sql] ||= 'CALL PI()' # does not like 'SELECT 1'
+
+    embedded_driver(config)
   end
+  alias_method :jdbchsqldb_connection, :hsqldb_connection
 end

data/lib/arjdbc/hsqldb/explain_support.rb

@@ -0,0 +1,35 @@
+module ArJdbc
+  module HSQLDB
+    module ExplainSupport
+      def supports_explain?; true; end
+
+      def explain(arel, binds = [])
+        sql = "EXPLAIN PLAN FOR #{to_sql(arel, binds)}"
+        raw_result = exec_query_raw(sql, "EXPLAIN", binds)
+        # HSQLDB's SqlTool just prints it as it comes :
+        #
+        #  sql> EXPLAIN PLAN FOR SELECT * FROM entries JOIN users on ... ;
+        #
+        # isDistinctSelect=[false]
+        # isGrouped=[false]
+        # isAggregated=[false]
+        # columns=[  COLUMN: PUBLIC.ENTRIES.ID
+        #  not nullable  COLUMN: PUBLIC.ENTRIES.TITLE
+        #  nullable  COLUMN: PUBLIC.ENTRIES.UPDATED_ON
+        #  nullable  COLUMN: PUBLIC.ENTRIES.CONTENT
+        #  nullable  COLUMN: PUBLIC.ENTRIES.RATING
+        #  nullable  COLUMN: PUBLIC.ENTRIES.USER_ID
+        #  nullable  COLUMN: PUBLIC.USERS.ID
+        #  not nullable  COLUMN: PUBLIC.USERS.LOGIN
+        #  nullable
+        # ]
+        # ...
+        # PARAMETERS=[]
+        # SUBQUERIES[]
+        #
+        raw_result.map!(&:values)
+        raw_result.join("\n")
+      end
+    end
+  end
+end

data/lib/arjdbc/hsqldb/schema_creation.rb

@@ -0,0 +1,11 @@
+module ArJdbc
+  module HSQLDB
+    # @private
+    SchemaCreation = ::ActiveRecord::ConnectionAdapters::AbstractAdapter::SchemaCreation
+
+    def schema_creation
+      SchemaCreation.new self
+    end
+
+  end
+end if ::ActiveRecord::ConnectionAdapters::AbstractAdapter.const_defined? :SchemaCreation

data/lib/arjdbc/informix.rb

@@ -1,3 +1,5 @@
-require 'arjdbc/jdbc'
-require 'arjdbc/informix/connection_methods'
+require 'arjdbc'
+ArJdbc.load_java_part :Informix
 require 'arjdbc/informix/adapter'
+require 'arjdbc/informix/connection_methods'
+ArJdbc.warn_unsupported_adapter 'informix', [4, 2] # warns on AR >= 4.2

data/lib/arjdbc/informix/adapter.rb

@@ -1,47 +1,53 @@
-module ::ActiveRecord
-  class Base
-    after_save :write_lobs
-
-  private
-    def write_lobs
-      if connection.is_a?(ArJdbc::Informix)
-        self.class.columns.each do |c|
-          if [:text, :binary].include? c.type
-            value = self[c.name]
-            value = value.to_yaml if unserializable_attribute?(c.name, c)
-
-            unless value.nil? || (value == '')
-              connection.write_large_object(c.type == :binary,
-                                            c.name,
-                                            self.class.table_name,
-                                            self.class.primary_key,
-                                            quote_value(id),
-                                            value)
+require 'arjdbc/util/serialized_attributes'
+
+module ArJdbc
+  module Informix
+
+    @@_lob_callback_added = nil
+
+    def self.extended(base)
+      unless @@_lob_callback_added
+        ActiveRecord::Base.class_eval do
+          def after_save_with_informix_lob
+            lob_columns = self.class.columns.select { |c| [:text, :binary].include?(c.type) }
+            lob_columns.each do |column|
+              value = ::ArJdbc::SerializedAttributesHelper.dump_column_value(self, column)
+              next if value.nil? || (value == '')
+
+              connection.write_large_object(
+                column.type == :binary, column.name,
+                self.class.table_name, self.class.primary_key,
+                quote_value(id), value
+              )
             end
           end
         end
-      end
-    end
-  end
-end
 
-module ::ArJdbc
-  module Informix
-    def self.extended(base)
-      @@db_major_version = base.select_one("SELECT dbinfo('version', 'major') version FROM systables WHERE tabid = 1")['version'].to_i
+        ActiveRecord::Base.after_save :after_save_with_informix_lob
+        @@_lob_callback_added = true
+      end
     end
 
+    # @see ActiveRecord::ConnectionAdapters::JdbcColumn#column_types
     def self.column_selector
-      [ /informix/i,
-        lambda { |cfg, column| column.extend(::ArJdbc::Informix::Column) } ]
+      [ /informix/i, lambda { |cfg, column| column.extend(ColumnMethods) } ]
     end
 
+    JdbcConnection = ::ActiveRecord::ConnectionAdapters::InformixJdbcConnection
+
+    # @see ActiveRecord::ConnectionAdapters::JdbcAdapter#jdbc_connection_class
     def self.jdbc_connection_class
       ::ActiveRecord::ConnectionAdapters::InformixJdbcConnection
     end
 
-    module Column
-    private
+    # @see ActiveRecord::ConnectionAdapters::JdbcAdapter#jdbc_column_class
+    def jdbc_column_class
+      ::ActiveRecord::ConnectionAdapters::InformixColumn
+    end
+
+    module ColumnMethods
+
+      private
       # TODO: Test all Informix column types.
       def simplified_type(field_type)
         if field_type =~ /serial/i
@@ -50,21 +56,23 @@ module ::ArJdbc
           super
         end
       end
+
     end
 
-    def modify_types(tp)
-      tp[:primary_key] = "SERIAL PRIMARY KEY"
-      tp[:string]      = { :name => "VARCHAR", :limit => 255 }
-      tp[:integer]     = { :name => "INTEGER" }
-      tp[:float]       = { :name => "FLOAT" }
-      tp[:decimal]     = { :name => "DECIMAL" }
-      tp[:datetime]    = { :name => "DATETIME YEAR TO FRACTION(5)" }
-      tp[:timestamp]   = { :name => "DATETIME YEAR TO FRACTION(5)" }
-      tp[:time]        = { :name => "DATETIME HOUR TO FRACTION(5)" }
-      tp[:date]        = { :name => "DATE" }
-      tp[:binary]      = { :name => "BYTE" }
-      tp[:boolean]     = { :name => "BOOLEAN" }
-      tp
+    def modify_types(types)
+      super(types)
+      types[:primary_key] = "SERIAL PRIMARY KEY"
+      types[:string]      = { :name => "VARCHAR", :limit => 255 }
+      types[:integer]     = { :name => "INTEGER" }
+      types[:float]       = { :name => "FLOAT" }
+      types[:decimal]     = { :name => "DECIMAL" }
+      types[:datetime]    = { :name => "DATETIME YEAR TO FRACTION(5)" }
+      types[:timestamp]   = { :name => "DATETIME YEAR TO FRACTION(5)" }
+      types[:time]        = { :name => "DATETIME HOUR TO FRACTION(5)" }
+      types[:date]        = { :name => "DATE" }
+      types[:binary]      = { :name => "BYTE" }
+      types[:boolean]     = { :name => "BOOLEAN" }
+      types
     end
 
     def prefetch_primary_key?(table_name = nil)
@@ -81,11 +89,9 @@ module ::ArJdbc
 
     def add_limit_offset!(sql, options)
       if options[:limit]
-        limit = "FIRST #{options[:limit]}"
-        # SKIP available only in IDS >= 10
-        offset = (@@db_major_version >= 10 && options[:offset]?
-                  "SKIP #{options[:offset]}" : "")
-        sql.sub!(/^select /i, "SELECT #{offset} #{limit} ")
+        limit = "FIRST #{options[:limit]}" # SKIP available only in IDS >= 10 :
+        offset = (db_major_version >= 10 && options[:offset] ? "SKIP #{options[:offset]}" : "")
+        sql.sub!(/^\s*?select /i, "SELECT #{offset} #{limit} ")
       end
       sql
     end
@@ -100,10 +106,11 @@ module ::ArJdbc
     end
 
     def quote(value, column = nil)
-      if column && [:binary, :text].include?(column.type)
+      column_type = column && column.type
+      if column_type == :binary || column_type == :text
         # LOBs are updated separately by an after_save trigger.
         "NULL"
-      elsif column && column.type == :date
+      elsif column_type == :date
         "'#{value.mon}/#{value.day}/#{value.year}'"
       else
         super
@@ -129,10 +136,27 @@ module ::ArJdbc
       @connection.execute_update("DROP INDEX #{index_name(table_name, options)}")
     end
 
-  private
-    def select(sql, name = nil)
+    def select(sql, *rest)
       # Informix does not like "= NULL", "!= NULL", or "<> NULL".
-      execute(sql.gsub(/(!=|<>)\s*null/i, "IS NOT NULL").gsub(/=\s*null/i, "IS NULL"), name)
+      super(sql.gsub(/(!=|<>)\s*null/i, "IS NOT NULL").gsub(/=\s*null/i, "IS NULL"), *rest)
+    end
+
+    private
+
+    def db_major_version
+      @@db_major_version ||=
+        select_one("SELECT dbinfo('version', 'major') version FROM systables WHERE tabid = 1")['version'].to_i
     end
+
   end # module Informix
 end # module ::ArJdbc
+
+module ActiveRecord::ConnectionAdapters
+  class InformixColumn < JdbcColumn
+    include ::ArJdbc::Informix::ColumnMethods
+  end
+
+  class InformixAdapter < JdbcAdapter
+    include ::ArJdbc::Informix
+  end
+end

data/lib/arjdbc/informix/connection_methods.rb

@@ -1,10 +1,9 @@
-class ActiveRecord::Base
-  class << self
-    def informix_connection(config)
-      config[:port] ||= 9088
-      config[:url] ||= "jdbc:informix-sqli://#{config[:host]}:#{config[:port]}/#{config[:database]}:INFORMIXSERVER=#{config[:servername]}"
-      config[:driver] = 'com.informix.jdbc.IfxDriver'
-      jdbc_connection(config)
-    end
+ArJdbc::ConnectionMethods.module_eval do
+  def informix_connection(config)
+    config[:port] ||= 9088
+    config[:url] ||= "jdbc:informix-sqli://#{config[:host]}:#{config[:port]}/#{config[:database]}:INFORMIXSERVER=#{config[:servername]}"
+    config[:driver] = 'com.informix.jdbc.IfxDriver'
+    config[:adapter_spec] = ::ArJdbc::Informix
+    jdbc_connection(config)
   end
-end
+end

data/lib/arjdbc/jdbc.rb

@@ -1,2 +1,59 @@
-require 'arjdbc/jdbc/adapter'
-require 'arjdbc/jdbc/discover'
+require 'active_support/deprecation'
+
+module ArJdbc
+
+  # @private
+  AR40 = ::ActiveRecord::VERSION::MAJOR > 3
+  # @private
+  AR42 = ::ActiveRecord::VERSION::STRING >= '4.2'
+  # @private
+  AR50 = ::ActiveRecord::VERSION::MAJOR > 4
+
+  class << self
+
+    # @private Internal API
+    def warn_unsupported_adapter(adapter, version = nil)
+      warn_prefix = 'NOTE:'
+      if version # e.g. [4, 2]
+        ar_version = [ ActiveRecord::VERSION::MAJOR, ActiveRecord::VERSION::MINOR, ActiveRecord::VERSION::TINY ]
+        if ( ar_version <=> version ) >= 0 # e.g. 4.2.0 > 4.2
+          warn_prefix = "NOTE: ActiveRecord #{version.join('.')} with"
+        else
+          warn_prefix = nil
+        end
+      end
+      warn "#{warn_prefix} adapter: #{adapter} is not (yet) fully supported by AR-JDBC," <<
+      " please consider helping us out." if warn_prefix
+    end
+
+    def warn(message, once = nil)
+      super(message) || true if warn?(message, once)
+    end
+
+    def deprecate(message, once = nil) # adds a "DEPRECATION WARNING: " prefix
+      ::ActiveSupport::Deprecation.warn(message, caller_locations) || true if warn?(message, once)
+    end
+
+    private
+
+    @@warns = nil
+    @@warns = false if ENV_JAVA['arjdbc.warn'].eql? 'false'
+
+    def warn?(message, once)
+      return nil if @@warns.equal?(false) || ! message
+      warns = @@warns ||= ( require 'set'; Set.new )
+      return false if warns.include?(message)
+      warns << message.dup if once
+      true
+    end
+
+  end
+
+  require 'arjdbc/jdbc/adapter'
+
+  if ENV_JAVA['arjdbc.extensions.discover'].eql? 'true'
+    self.discover_extensions
+  else
+    require 'arjdbc/discover'
+  end
+end

data/lib/arjdbc/jdbc/adapter.rb

@@ -1,285 +1,475 @@
 require 'active_record/version'
 require 'active_record/connection_adapters/abstract_adapter'
+
 require 'arjdbc/version'
-require 'arjdbc/jdbc/require_driver'
-require 'arjdbc/jdbc/connection_methods'
-require 'arjdbc/jdbc/compatibility'
-require 'arjdbc/jdbc/core_ext'
 require 'arjdbc/jdbc/java'
-require 'arjdbc/jdbc/type_converter'
-require 'arjdbc/jdbc/driver'
+require 'arjdbc/jdbc/base_ext'
+require 'arjdbc/jdbc/error'
+require 'arjdbc/jdbc/connection_methods'
 require 'arjdbc/jdbc/column'
 require 'arjdbc/jdbc/connection'
 require 'arjdbc/jdbc/callbacks'
 require 'arjdbc/jdbc/extension'
-require 'bigdecimal'
+require 'arjdbc/jdbc/type_converter'
+require 'arjdbc/abstract/core'
+require 'arjdbc/abstract/connection_management'
+require 'arjdbc/abstract/database_statements'
+require 'arjdbc/abstract/transaction_support'
 
 module ActiveRecord
   module ConnectionAdapters
+    # Built on top of `ActiveRecord::ConnectionAdapters::AbstractAdapter` which
+    # provides the abstract interface for database-specific functionality, this
+    # class serves 2 purposes in AR-JDBC :
+    # - as a base class for sub-classes
+    # - usable standalone (or with a mixed in adapter spec module)
+    #
+    # Historically this class is mostly been used standalone and that's still a
+    # valid use-case esp. since (with it's `arjdbc.jdbc.RubyJdbcConnectionClass`)
+    # JDBC provides a unified interface for all databases in Java it tries to do
+    # it's best implementing all `ActiveRecord` functionality on top of that.
+    # This might no be perfect that's why it checks for a `config[:adapter_spec]`
+    # module (or tries to resolve one from the JDBC driver's meta-data) and if
+    # the database has "extended" AR-JDBC support mixes in the given module for
+    # each adapter instance.
+    # This is sufficient for most database specific specs we support, but for
+    # compatibility with native (MRI) adapters it's perfectly fine to sub-class
+    # the adapter and override some of its API methods.
     class JdbcAdapter < AbstractAdapter
-      extend ShadowCoreMethods
-      include CompatibilityMethods if CompatibilityMethods.needed?(self)
-      include JdbcConnectionPoolCallbacks if JdbcConnectionPoolCallbacks.needed?
-
-      attr_reader :config
-
-      def initialize(connection, logger, config)
-        @config = config
-        spec = adapter_spec config
-        unless connection
-          connection_class = jdbc_connection_class spec
-          connection = connection_class.new config
-        end
-        super(connection, logger)
-        extend spec if spec
-        configure_arel2_visitors(config)
-        connection.adapter = self
-        JndiConnectionPoolCallbacks.prepare(self, connection)
-      end
+      include Jdbc::ConnectionPoolCallbacks
+
+      include ArJdbc::Abstract::Core
+      include ArJdbc::Abstract::ConnectionManagement
+      include ArJdbc::Abstract::DatabaseStatements
+      include ArJdbc::Abstract::TransactionSupport
+
+      attr_reader :prepared_statements
 
+      # Returns the (JDBC) connection class to be used for this adapter.
+      # This is used by (database specific) spec modules to override the class
+      # used assuming some of the available methods have been re-defined.
+      # @see ActiveRecord::ConnectionAdapters::JdbcConnection
       def jdbc_connection_class(spec)
         connection_class = spec.jdbc_connection_class if spec && spec.respond_to?(:jdbc_connection_class)
-        connection_class = ::ActiveRecord::ConnectionAdapters::JdbcConnection unless connection_class
-        connection_class
+        connection_class ? connection_class : ::ActiveRecord::ConnectionAdapters::JdbcConnection
       end
 
+      # Returns the (JDBC) `ActiveRecord` column class for this adapter.
+      # This is used by (database specific) spec modules to override the class.
+      # @see ActiveRecord::ConnectionAdapters::JdbcColumn
       def jdbc_column_class
-        ActiveRecord::ConnectionAdapters::JdbcColumn
+        ::ActiveRecord::ConnectionAdapters::JdbcColumn
       end
 
-      # Retrieve the raw java.sql.Connection object.
-      def jdbc_connection
-        raw_connection.connection
-      end
-
-      # Locate specialized adapter specification if one exists based on config data
+      # Locate the specialized (database specific) adapter specification module
+      # if one exists based on provided configuration data. This module will than
+      # extend an instance of the adapter (unless an `:adapter_class` provided).
+      #
+      # This method is called during {#initialize} unless an explicit
+      # `config[:adapter_spec]` is set.
+      # @param config the configuration to check for `:adapter_spec`
+      # @return [Module] the database specific module
       def adapter_spec(config)
-        2.times do
-          dialect = (config[:dialect] || config[:driver]).to_s
-          ::ArJdbc.constants.map { |name| ::ArJdbc.const_get name }.each do |constant|
-            if constant.respond_to? :adapter_matcher
-              spec = constant.adapter_matcher(dialect, config)
-              return spec if spec
-            end
+        dialect = (config[:dialect] || config[:driver]).to_s
+        ::ArJdbc.modules.each do |constant| # e.g. ArJdbc::MySQL
+          if constant.respond_to?(:adapter_matcher)
+            spec = constant.adapter_matcher(dialect, config)
+            return spec if spec
           end
+        end
 
-          # If nothing matches and we're using jndi, try to automatically detect the database.
-          break unless config[:jndi] and !config[:dialect]
-          begin
-            conn = Java::javax.naming.InitialContext.new.lookup(config[:jndi]).getConnection
-            config[:dialect] = conn.getMetaData.getClass.getName.downcase
-
-            # Derby-specific hack
-            if ::ArJdbc::Derby.adapter_matcher(config[:dialect], config)
-              # Needed to set the correct database schema name
-              config[:username] ||= conn.getMetaData.getUserName
+        unless config.key?(:dialect)
+          begin # does nothing unless config[:jndi] || config[:data_source]
+            dialect = ::ArJdbc.with_meta_data_from_data_source_if_any(config) do
+              |meta_data| config[:dialect] = meta_data.getDatabaseProductName
             end
-          rescue
-            conn.close
+            return adapter_spec(config) if dialect # re-try matching with :dialect
+          rescue => e
+            ::ArJdbc.warn("failed to set :dialect from database meda-data: #{e.inspect}")
+          else
+            return adapter_spec(config) # re-try matching a spec with set config[:dialect]
           end
         end
+
         nil
       end
 
-      def modify_types(tp)
-        tp
+      ADAPTER_NAME = 'JDBC'.freeze
+
+      # @return [String] the 'JDBC' adapter name.
+      def adapter_name
+        ADAPTER_NAME
       end
 
-      def adapter_name #:nodoc:
-        'JDBC'
+      # @override
+      # Will return true even when native adapter classes passed in
+      # e.g. `jdbc_adapter.is_a? ConnectionAdapter::PostgresqlAdapter`
+      #
+      # This is only necessary (for built-in adapters) when
+      # `config[:adapter_class]` is forced to `nil` and the `:adapter_spec`
+      # module is used to extend the `JdbcAdapter`, otherwise we replace the
+      # class constants for built-in adapters (MySQL, PostgreSQL and SQLite3).
+      def is_a?(klass)
+        # This is to fake out current_adapter? conditional logic in AR tests
+        if klass.is_a?(Class) && klass.name =~ /#{adapter_name}Adapter$/i
+          true
+        else
+          super
+        end
       end
 
-      def arel2_visitors
-        {}
+      # @deprecated re-implemented - no longer used
+      # @return [Hash] the AREL visitor to use
+      # If there's a `self.arel2_visitors(config)` method on the adapter
+      # spec than it is preferred and will be used instead of this one.
+      def self.arel2_visitors(config)
+        { 'jdbc' => ::Arel::Visitors::ToSql }
       end
 
-      def configure_arel2_visitors(config)
-        if defined?(::Arel::Visitors::VISITORS)
-          visitors = ::Arel::Visitors::VISITORS
-          visitor = nil
-          arel2_visitors.each do |k,v|
-            visitor = v
-            visitors[k] = v unless visitors.has_key?(k)
-          end
-          if visitor && config[:dialect] && config[:adapter] =~ /^(jdbc|jndi)$/
-            visitors[config[:adapter]] = visitor
-          end
+      # @deprecated re-implemented - no longer used
+      # @see #arel2_visitors
+      def self.configure_arel2_visitors(config)
+        visitors = ::Arel::Visitors::VISITORS
+        klass = config[:adapter_spec]
+        klass = self unless klass.respond_to?(:arel2_visitors)
+        visitor = nil
+        klass.arel2_visitors(config).each do |name, arel|
+          visitors[name] = ( visitor = arel )
+        end
+        if visitor && config[:adapter] =~ /^(jdbc|jndi)$/
+          visitors[ config[:adapter] ] = visitor
+        end
+        visitor
+      end
+
+      # DB specific types are detected but adapter specs (or extenders) are
+      # expected to hand tune these types for concrete databases.
+      # @return [Hash] the native database types
+      # @override
+      def native_database_types
+        @native_database_types ||= begin
+          types = @connection.native_database_types
+          modify_types(types)
+          types
         end
       end
 
-      def is_a?(klass)          # :nodoc:
-        # This is to fake out current_adapter? conditional logic in AR tests
-        if Class === klass && klass.name =~ /#{adapter_name}Adapter$/i
-          true
-        else
-          super
-        end
+      # @override introduced in AR 4.2
+      def valid_type?(type)
+        ! native_database_types[type].nil?
       end
 
-      def supports_migrations?
-        true
+      # Allows for modification of the detected native types.
+      # @param types the resolved native database types
+      # @see #native_database_types
+      def modify_types(types)
+        types
       end
 
-      def native_database_types #:nodoc:
-        @connection.native_database_types
+      # Abstract adapter default implementation does nothing silently.
+      # @override
+      def structure_dump
+        raise NotImplementedError, "structure_dump not supported"
       end
 
-      def database_name #:nodoc:
+      # JDBC adapters support migration.
+      # @return [true]
+      # @override
+      def supports_migrations?
+        true
+      end
+
+      # Returns the underlying database name.
+      # @override
+      def database_name
         @connection.database_name
       end
 
-      def native_sql_to_type(tp)
-        if /^(.*?)\(([0-9]+)\)/ =~ tp
-          tname = $1
-          limit = $2.to_i
-          ntype = native_database_types
-          if ntype[:primary_key] == tp
-            return :primary_key,nil
+      # @private
+      def native_sql_to_type(type)
+        if /^(.*?)\(([0-9]+)\)/ =~ type
+          tname, limit = $1, $2.to_i
+          ntypes = native_database_types
+          if ntypes[:primary_key] == type
+            return :primary_key, nil
           else
-            ntype.each do |name,val|
+            ntypes.each do |name, val|
               if name == :primary_key
                 next
               end
-              if val[:name].downcase == tname.downcase && (val[:limit].nil? || val[:limit].to_i == limit)
-                return name,limit
+              if val[:name].downcase == tname.downcase &&
+                  ( val[:limit].nil? || val[:limit].to_i == limit )
+                return name, limit
               end
             end
           end
-        elsif /^(.*?)/ =~ tp
+        elsif /^(.*?)/ =~ type
           tname = $1
-          ntype = native_database_types
-          if ntype[:primary_key] == tp
-            return :primary_key,nil
+          ntypes = native_database_types
+          if ntypes[:primary_key] == type
+            return :primary_key, nil
           else
-            ntype.each do |name,val|
+            ntypes.each do |name, val|
               if val[:name].downcase == tname.downcase && val[:limit].nil?
-                return name,nil
+                return name, nil
               end
             end
           end
         else
-          return :string,255
+          return :string, 255
         end
-        return nil,nil
+        return nil, nil
       end
 
-      def active?
-        @connection.active?
+      def columns(table_name, name = nil)
+        @connection.columns(table_name.to_s)
       end
 
-      def reconnect!
-        @connection.reconnect!
-        @connection
+      # @override
+      def supports_views?
+        @connection.supports_views?
       end
 
-      def disconnect!
-        @connection.disconnect!
+      # Similar to {#exec_query} except it returns "raw" results in an array
+      # where each rows is a hash with keys as columns (just like Rails used to
+      # do up until 3.0) instead of wrapping them in a {#ActiveRecord::Result}.
+      # @param sql the query string (or AREL object)
+      # @param name logging marker for the executed SQL statement log entry
+      # @param binds the bind parameters
+      # @yield [v1, v2] depending on the row values returned from the query
+      # In case a block is given it will yield each row from the result set
+      # instead of returning mapped query results in an array.
+      # @return [Array] unless a block is given
+      def exec_query_raw(sql, name = 'SQL', binds = [], &block)
+        sql = to_sql(sql, binds) if sql.respond_to?(:to_sql)
+
+        if prepared_statements?
+          log(sql, name, binds) { @connection.execute_query_raw(sql, binds, &block) }
+        else
+          log(sql, name) { @connection.execute_query_raw(sql, &block) }
+        end
       end
 
-      def execute(sql, name = nil)
+      # @private
+      # @override
+      def select_rows(sql, name = nil, binds = [])
+        exec_query_raw(sql, name, binds).map!(&:values)
+      end
+
+      # Executes the SQL statement in the context of this connection.
+      # The return value from this method depends on the SQL type (whether
+      # it's a SELECT, INSERT etc.). For INSERTs a generated id might get
+      # returned while for UPDATE statements the affected row count.
+      # Please note that this method returns "raw" results (in an array) for
+      # statements that return a result set, while {#exec_query} is expected to
+      # return a `ActiveRecord::Result` (since AR 3.1).
+      # @note This method does not use prepared statements.
+      # @note The method does not emulate various "native" `execute` results on MRI.
+      # @see #exec_query
+      # @see #exec_insert
+      # @see #exec_update
+      def execute(sql, name = nil, binds = nil)
+        sql = to_sql(sql, binds) if binds
         if name == :skip_logging
-          _execute(sql)
+          _execute(sql, name)
         else
-          log(sql, name) { _execute(sql) }
+          log(sql, name) { _execute(sql, name) }
         end
       end
 
-      # we need to do it this way, to allow Rails stupid tests to always work
-      # even if we define a new execute method. Instead of mixing in a new
-      # execute, an _execute should be mixed in.
+      # We need to do it this way, to allow Rails stupid tests to always work
+      # even if we define a new `execute` method. Instead of mixing in a new
+      # `execute`, an `_execute` should be mixed in.
+      # @deprecated it was only introduced due tests
+      # @private
       def _execute(sql, name = nil)
         @connection.execute(sql)
       end
+      private :_execute
+
+      # Kind of `execute(sql) rescue nil` but logging failures at debug level only.
+      def execute_quietly(sql, name = 'SQL')
+        log(sql, name) do
+          begin
+            _execute(sql)
+          rescue => e
+            logger.debug("#{e.class}: #{e.message}: #{sql}")
+          end
+        end
+      end
 
-      def jdbc_insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil)
-        insert_sql(sql, name, pk, id_value, sequence_name)
+      # @override
+      def tables(name = nil)
+        @connection.tables
       end
 
-      def jdbc_update(sql, name = nil) #:nodoc:
-        execute(sql, name)
+      # @override
+      def table_exists?(name)
+        return false unless name
+        @connection.table_exists?(name) # schema_name = nil
       end
-      def jdbc_select_all(sql, name = nil)
-        select(sql, name)
+
+      # @override
+      def data_sources
+        tables
       end
 
-      if ActiveRecord::VERSION::MAJOR < 3
-        # Allow query caching to work even when we override alias_method_chain'd methods
-        alias_chained_method :select_all, :query_cache, :jdbc_select_all
-        alias_chained_method :update, :query_dirty, :jdbc_update
-        alias_chained_method :insert, :query_dirty, :jdbc_insert
+      # @override
+      def data_source_exists?(name)
+        table_exists?(name)
+      end
 
-        # Do we need this? Not in AR 3.
-        def select_one(sql, name = nil)
-          select(sql, name).first
-        end
+      # @override
+      def indexes(table_name, name = nil, schema_name = nil)
+        @connection.indexes(table_name, name, schema_name)
       end
 
-      def select_rows(sql, name = nil)
-        rows = []
-        select(sql, name).each {|row| rows << row.values }
-        rows
+      # @override
+      def pk_and_sequence_for(table)
+        ( key = primary_key(table) ) ? [ key, nil ] : nil
       end
 
-      def insert_sql(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil)
-        id = execute(sql, name = nil)
-        id_value || id
+      # @override
+      def primary_keys(table)
+        @connection.primary_keys(table)
       end
 
-      def jdbc_columns(table_name, name = nil)
-        @connection.columns(table_name.to_s)
+      # @override
+      def foreign_keys(table_name)
+        @connection.foreign_keys(table_name)
       end
-      alias_chained_method :columns, :query_cache, :jdbc_columns
 
-      def tables(name = nil)
-        @connection.tables
+      # Does our database (+ its JDBC driver) support foreign-keys?
+      # @since 1.3.18
+      # @override
+      def supports_foreign_keys?
+        @connection.supports_foreign_keys?
       end
 
-      def table_exists?(name)
-        jdbc_columns(name) rescue nil
+      # @deprecated Rather use {#update_lob_value} instead.
+      def write_large_object(*args)
+        @connection.write_large_object(*args)
       end
 
-      def indexes(table_name, name = nil, schema_name = nil)
-        @connection.indexes(table_name, name, schema_name)
+      # @param record the record e.g. `User.find(1)`
+      # @param column the model's column e.g. `User.columns_hash['photo']`
+      # @param value the lob value - string or (IO or Java) stream
+      def update_lob_value(record, column, value)
+        @connection.update_lob_value(record, column, value)
+      end
+
+      protected
+
+      # Take an id from the result of an INSERT query.
+      # @return [Integer, NilClass]
+      def last_inserted_id(result)
+        if result.is_a?(Hash) || result.is_a?(ActiveRecord::Result)
+          result.first.first[1] # .first = { "id"=>1 } .first = [ "id", 1 ]
+        else
+          result
+        end
       end
 
-      def begin_db_transaction
-        @connection.begin
+      # aliasing #create_table_definition as #table_definition :
+      alias table_definition create_table_definition
+
+      # `TableDefinition.new native_database_types, name, temporary, options`
+      # and ActiveRecord 4.1 supports optional `as` argument (which defaults
+      # to nil) to provide the SQL to use to generate the table:
+      # `TableDefinition.new native_database_types, name, temporary, options, as`
+      # @private
+      def create_table_definition(*args)
+        table_definition(*args)
       end
 
-      def commit_db_transaction
-        @connection.commit
+      # @note AR-4x arguments expected: `(name, temporary, options)`
+      # @private documented bellow
+      def new_table_definition(table_definition, *args)
+        table_definition.new(*args)
       end
+      private :new_table_definition
 
-      def rollback_db_transaction
-        @connection.rollback
+      # @private
+      def new_index_definition(table, name, unique, columns, lengths,
+          orders = nil, where = nil, type = nil, using = nil)
+        IndexDefinition.new(table, name, unique, columns, lengths, orders, where, type, using)
       end
+      private :new_index_definition
 
-      def write_large_object(*args)
-        @connection.write_large_object(*args)
+      #
+
+      # Provides backwards-compatibility on ActiveRecord 4.1 for DB adapters
+      # that override this and than call super expecting to work.
+      # @note This method is available in 4.0 but won't be in 4.1
+      # @private
+      def add_column_options!(sql, options)
+        sql << " DEFAULT #{quote(options[:default], options[:column])}" if options_include_default?(options)
+        # must explicitly check for :null to allow change_column to work on migrations
+        sql << " NOT NULL" if options[:null] == false
+        sql << " AUTO_INCREMENT" if options[:auto_increment] == true
       end
+      public :add_column_options!
 
-      def pk_and_sequence_for(table)
-        key = primary_key(table)
-        [key, nil] if key
+      # @return whether `:prepared_statements` are to be used
+      def prepared_statements?
+        return @prepared_statements unless (@prepared_statements ||= nil).nil?
+        @prepared_statements = self.class.prepared_statements?(config)
       end
 
-      def primary_key(table)
-        primary_keys(table).first
+      # Allows changing the prepared statements setting for this connection.
+      # @see #prepared_statements?
+      #def prepared_statements=(statements)
+      #  @prepared_statements = statements
+      #end
+
+      def self.prepared_statements?(config)
+        config.key?(:prepared_statements) ?
+          type_cast_config_to_boolean(config.fetch(:prepared_statements)) :
+            false # off by default - NOTE: on AR 4.x it's on by default !?
       end
 
-      def primary_keys(table)
-        @connection.primary_keys(table)
+      private
+
+      # Helper useful during {#quote} since AREL might pass in it's literals
+      # to be quoted, fixed since AREL 4.0.0.beta1 : http://git.io/7gyTig
+      def sql_literal?(value); ::Arel::Nodes::SqlLiteral === value; end
+
+      # Helper to get local/UTC time (based on `ActiveRecord::Base.default_timezone`).
+      def get_time(value)
+        get = ::ActiveRecord::Base.default_timezone == :utc ? :getutc : :getlocal
+        value.respond_to?(get) ? value.send(get) : value
+      end
+
+      # @return whether the given SQL string is a 'SELECT' like
+      # query (returning a result set)
+      def self.select?(sql)
+        JdbcConnection::select?(sql)
       end
 
-      def select(*args)
-        execute(*args)
+      # @return whether the given SQL string is an 'INSERT' query
+      def self.insert?(sql)
+        JdbcConnection::insert?(sql)
       end
 
-      def translate_exception(e, message)
-        puts e.backtrace if $DEBUG || ENV['DEBUG']
-        super
+      # @return whether the given SQL string is an 'UPDATE' (or 'DELETE') query
+      def self.update?(sql)
+        ! select?(sql) && ! insert?(sql)
       end
-      protected :translate_exception
+
+      unless defined? AbstractAdapter.type_cast_config_to_integer
+
+        # @private
+        def self.type_cast_config_to_integer(config)
+          config =~ /\A\d+\z/ ? config.to_i : config
+        end
+
+      end
+
+      # @private
+      def self.type_cast_config_to_boolean(config)
+        config == 'false' ? false : (config == 'true' ? true : config)
+      end
+
     end
   end
 end