activerecord-jdbc-adapter 5.0.pre1 → 50.0

data/lib/arjdbc/abstract/database_statements.rb

@@ -0,0 +1,46 @@
+module ArJdbc
+  module Abstract
+
+    # This provides the basic interface for interacting with the
+    # database for JDBC based adapters
+    module DatabaseStatements
+
+      # It appears that at this point (AR 5.0) "prepare" should only ever be true
+      # if prepared statements are enabled
+      def exec_query(sql, name = nil, binds = [], prepare: false)
+        if without_prepared_statement?(binds)
+          execute(sql, name)
+        else
+          binds = convert_legacy_binds_to_attributes(binds) if binds.first.is_a?(Array)
+          log(sql, name, binds) do
+            # It seems that #supports_statement_cache? is defined but isn't checked before setting "prepare" (AR 5.0)
+            cached_statement = fetch_cached_statement(sql) if prepare && supports_statement_cache?
+            @connection.execute_prepared(sql, binds, cached_statement)
+          end
+        end
+      end
+
+      def exec_update(sql, name = nil, binds = [])
+        if without_prepared_statement?(binds)
+          log(sql, name) { @connection.execute_update(sql, nil) }
+        else
+          log(sql, name, binds) { @connection.execute_prepared_update(sql, binds) }
+        end
+      end
+      alias :exec_delete :exec_update
+
+      def execute(sql, name = nil)
+        log(sql, name) { @connection.execute(sql) }
+      end
+
+      private
+
+      def convert_legacy_binds_to_attributes(binds)
+        binds.map do |column, value|
+          ActiveRecord::Relation::QueryAttribute.new(nil, type_cast(value, column), ActiveModel::Type::Value.new)
+        end
+      end
+
+    end
+  end
+end

data/lib/arjdbc/abstract/statement_cache.rb

@@ -0,0 +1,58 @@
+require 'active_record/connection_adapters/statement_pool'
+
+module ArJdbc
+  module Abstract
+    module StatementCache
+
+      # This works a little differently than the AR implementation in that
+      # we are storing an actual PreparedStatement object instead of just
+      # the name of the prepared statement
+      class StatementPool < ActiveRecord::ConnectionAdapters::StatementPool
+
+        private
+
+        def dealloc(statement)
+          statement.close
+        end
+
+      end
+
+      def initialize(connection, logger, config)
+        super
+
+        # Only say we support the statement cache if we are using prepared statements
+        # and have a max number of statements defined
+        statement_limit = self.class.type_cast_config_to_integer(config[:statement_limit])
+        @jdbc_statement_cache_enabled = config[:prepared_statements] && (statement_limit.nil? || statement_limit > 0)
+
+        @statements = StatementPool.new(statement_limit) # AR (5.0) expects this to be stored as @statements
+      end
+
+      # Clears the prepared statements cache.
+      def clear_cache!
+        @statements.clear
+      end
+
+      def delete_cached_statement(sql)
+        @statements.delete(cached_statement_key(sql))
+      end
+
+      def fetch_cached_statement(sql)
+        @statements[cached_statement_key(sql)] ||= @connection.connection.prepare_statement(sql)
+      end
+
+      def supports_statement_cache?
+        @jdbc_statement_cache_enabled
+      end
+
+      private
+
+      # This should be overridden by the adapter if the sql itself
+      # is not enough to make the key unique
+      def cached_statement_key(sql)
+        sql
+      end
+
+    end
+  end
+end

data/lib/arjdbc/abstract/transaction_support.rb

@@ -0,0 +1,86 @@
+module ArJdbc
+  module Abstract
+
+    # Provides the basic interface needed to support transactions for JDBC based adapters
+    module TransactionSupport
+
+      ########################## Support Checks #################################
+
+      # Does our database (+ its JDBC driver) support save-points?
+      # @since 1.3.0
+      # @override
+      def supports_savepoints?
+        @connection.supports_savepoints?
+      end
+
+      # Does this adapter support setting the isolation level for a transaction?
+      # Unlike 'plain' `ActiveRecord` we allow checking for concrete transaction
+      # isolation level support by the database.
+      # @param level optional to check if we support a specific isolation level
+      # @since 1.3.0
+      # @extension added optional level parameter
+      def supports_transaction_isolation?(level = nil)
+        return false unless level
+        @connection.supports_transaction_isolation?(level)
+      end
+
+      ########################## Transaction Interface ##########################
+
+      # Starts a database transaction.
+      # @override
+      def begin_db_transaction
+        log('BEGIN TRANSACTION'.freeze, nil) { @connection.begin }
+      end
+
+      # Starts a database transaction.
+      # @param isolation the transaction isolation to use
+      def begin_isolated_db_transaction(isolation)
+        log("BEGIN ISOLATED TRANSACTION - #{isolation}", nil) { @connection.begin(isolation) }
+      end
+
+      # Commits the current database transaction.
+      # @override
+      def commit_db_transaction
+        log('COMMIT TRANSACTION'.freeze, nil) { @connection.commit }
+      end
+
+      # Rolls back the current database transaction.
+      # Called from 'rollback_db_transaction' in the AbstractAdapter
+      # @override
+      def exec_rollback_db_transaction
+        log('ROLLBACK TRANSACTION'.freeze, nil) { @connection.rollback }
+      end
+
+      ########################## Savepoint Interface ############################
+
+      # Creates a (transactional) save-point one can rollback to.
+      # Unlike 'plain' `ActiveRecord` it is allowed to pass a save-point name.
+      # @param name the save-point name
+      # @return save-point name (even if nil passed will be generated)
+      # @since 1.3.0
+      # @extension added optional name parameter
+      def create_savepoint(name = current_savepoint_name)
+        log("SAVEPOINT #{name}", 'Savepoint') { @connection.create_savepoint(name) }
+      end
+
+      # Transaction rollback to a given (previously created) save-point.
+      # If no save-point name given rollback to the last created one.
+      # Called from 'rollback_to_savepoint' in AbstractAdapter
+      # @param name the save-point name
+      # @extension added optional name parameter
+      def exec_rollback_to_savepoint(name = current_savepoint_name)
+        log("ROLLBACK TO SAVEPOINT #{name}", 'Savepoint') { @connection.rollback_savepoint(name) }
+      end
+
+      # Release a previously created save-point.
+      # @note Save-points are auto-released with the transaction they're created
+      # in (on transaction commit or roll-back).
+      # @param name the save-point name
+      # @extension added optional name parameter
+      def release_savepoint(name = current_savepoint_name)
+        log("RELEASE SAVEPOINT #{name}", 'Savepoint') { @connection.release_savepoint(name) }
+      end
+
+    end
+  end
+end

data/lib/arjdbc/derby/adapter.rb

@@ -175,10 +175,15 @@ module ArJdbc
       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 @connection.marked_savepoint_names.include?(name)
+      release_savepoint(name) if existing_savepoint_name?(name)
       super(name)
     end
 

data/lib/arjdbc/discover.rb

@@ -75,13 +75,6 @@ module ArJdbc
     end
   end
 
-  extension :Oracle do |name|
-    if name =~ /oracle/i
-      require 'arjdbc/oracle'
-      true
-    end
-  end
-  
   # NOTE: following ones are likely getting deprecated :
   
   extension :FireBird do |name|

data/lib/arjdbc/firebird/adapter.rb

@@ -413,7 +413,7 @@ module ActiveRecord::ConnectionAdapters
     #   ActiveRecord::ConnectionAdapters::FirebirdAdapter.emulate_booleans = false
     #
     def self.emulate_booleans?; ::ArJdbc::Firebird.emulate_booleans?; end
-    def self.emulate_booleans;  ::ArJdbc::Firebird.emulate_booleans?; end # oracle-enhanced
+    def self.emulate_booleans;  ::ArJdbc::Firebird.emulate_booleans?; end
     def self.emulate_booleans=(emulate); ::ArJdbc::Firebird.emulate_booleans = emulate; end
 
     def initialize(*args)
@@ -431,4 +431,4 @@ module ActiveRecord::ConnectionAdapters
     include ::ArJdbc::Firebird::Column
   end
 
-end
+end

data/lib/arjdbc/jdbc.rb

@@ -31,7 +31,7 @@ module ArJdbc
     end
 
     def deprecate(message, once = nil) # adds a "DEPRECATION WARNING: " prefix
-      ::ActiveSupport::Deprecation.warn(message, caller) || true if warn?(message, once)
+      ::ActiveSupport::Deprecation.warn(message, caller_locations) || true if warn?(message, once)
     end
 
     private
@@ -56,4 +56,4 @@ module ArJdbc
   else
     require 'arjdbc/discover'
   end
-end
+end

data/lib/arjdbc/jdbc/adapter.rb

@@ -11,6 +11,10 @@ require 'arjdbc/jdbc/connection'
 require 'arjdbc/jdbc/callbacks'
 require 'arjdbc/jdbc/extension'
 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
@@ -34,7 +38,12 @@ module ActiveRecord
     class JdbcAdapter < AbstractAdapter
       include Jdbc::ConnectionPoolCallbacks
 
-      attr_reader :config, :prepared_statements
+      include ArJdbc::Abstract::Core
+      include ArJdbc::Abstract::ConnectionManagement
+      include ArJdbc::Abstract::DatabaseStatements
+      include ArJdbc::Abstract::TransactionSupport
+
+      attr_reader :prepared_statements
 
       def self.new(connection, logger = nil, pool = nil)
         adapter = super
@@ -67,17 +76,11 @@ module ActiveRecord
         @config[:adapter_spec] = adapter_spec(@config) unless @config.key?(:adapter_spec)
         spec = @config[:adapter_spec]
 
-        # NOTE: adapter spec's init_connection only called if instantiated here :
-        connection ||= jdbc_connection_class(spec).new(@config, self)
-
         super(connection, logger, @config)
 
         # kind of like `extend ArJdbc::MyDB if self.class == JdbcAdapter` :
         klass = @config[:adapter_class]
         extend spec if spec && ( ! klass || klass == JdbcAdapter)
-
-        # NOTE: should not be necessary for JNDI due reconnect! on checkout :
-        configure_connection if respond_to?(:configure_connection)
       end
 
       # Returns the (JDBC) connection class to be used for this adapter.
@@ -96,30 +99,6 @@ module ActiveRecord
         ::ActiveRecord::ConnectionAdapters::JdbcColumn
       end
 
-      # Retrieve the raw `java.sql.Connection` object.
-      # The unwrap parameter is useful if an attempt to unwrap a pooled (JNDI)
-      # connection should be made - to really return the 'native' JDBC object.
-      # @param unwrap [true, false] whether to unwrap the connection object
-      # @return [Java::JavaSql::Connection] the JDBC connection
-      def jdbc_connection(unwrap = nil)
-        java_connection = raw_connection.connection
-        return java_connection unless unwrap
-        connection_class = java.sql.Connection.java_class
-        begin
-          if java_connection.wrapper_for?(connection_class)
-            return java_connection.unwrap(connection_class) # java.sql.Wrapper.unwrap
-          end
-        rescue Java::JavaLang::AbstractMethodError => e
-          ArJdbc.warn("driver/pool connection impl does not support unwrapping (#{e})")
-        end
-        if java_connection.respond_to?(:connection)
-          # e.g. org.apache.tomcat.jdbc.pool.PooledConnection
-          java_connection.connection # getConnection
-        else
-          java_connection
-        end
-      end
-
       # 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).
@@ -282,202 +261,15 @@ module ActiveRecord
         return nil, nil
       end
 
-      # @override
-      def active?
-        @connection.active?
-      end
-
-      # @override
-      def reconnect!
-        @connection.reconnect! # handles adapter.configure_connection
-        @connection
-      end
-
-      # @override
-      def disconnect!
-        @connection.disconnect!
-      end
-
-      # @note Used on AR 2.3 and 3.0
-      # @override
-      def insert_sql(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil)
-        id = execute(sql, name)
-        id_value || id
-      end
-
       def columns(table_name, name = nil)
         @connection.columns(table_name.to_s)
       end
 
-      # Starts a database transaction.
-      # @override
-      def begin_db_transaction
-        @connection.begin
-      end
-
-      # Commits the current database transaction.
-      # @override
-      def commit_db_transaction
-        @connection.commit
-      end
-
-      # Rolls back the current database transaction.
-      # @override
-      def rollback_db_transaction
-        @connection.rollback
-      end
-
-      # Starts a database transaction.
-      # @param isolation the transaction isolation to use
-      # @since 1.3.0
-      # @override on **AR-4.0**
-      def begin_isolated_db_transaction(isolation)
-        @connection.begin(isolation)
-      end
-
-      # Does this adapter support setting the isolation level for a transaction?
-      # Unlike 'plain' `ActiveRecord` we allow checking for concrete transaction
-      # isolation level support by the database.
-      # @param level optional to check if we support a specific isolation level
-      # @since 1.3.0
-      # @extension added optional level parameter
-      def supports_transaction_isolation?(level = nil)
-        @connection.supports_transaction_isolation?(level)
-      end
-
-      # Does our database (+ its JDBC driver) support save-points?
-      # @since 1.3.0
-      # @override
-      def supports_savepoints?
-        @connection.supports_savepoints?
-      end
-
-      # Creates a (transactional) save-point one can rollback to.
-      # Unlike 'plain' `ActiveRecord` it is allowed to pass a save-point name.
-      # @param name the save-point name
-      # @return save-point name (even if nil passed will be generated)
-      # @since 1.3.0
-      # @extension added optional name parameter
-      def create_savepoint(name = current_savepoint_name(true))
-        @connection.create_savepoint(name)
-      end
-
-      # Transaction rollback to a given (previously created) save-point.
-      # If no save-point name given rollback to the last created one.
-      # @param name the save-point name
-      # @since 1.3.0
-      # @extension added optional name parameter
-      def rollback_to_savepoint(name = current_savepoint_name(true))
-        @connection.rollback_savepoint(name)
-      end
-
-      # Release a previously created save-point.
-      # @note Save-points are auto-released with the transaction they're created
-      # in (on transaction commit or roll-back).
-      # @param name the save-point name
-      # @since 1.3.0
-      # @extension added optional name parameter
-      def release_savepoint(name = current_savepoint_name(false))
-        @connection.release_savepoint(name)
-      end
-
-      # Due tracking of save-points created in a LIFO manner, always returns
-      # the correct name if any (last) save-point has been marked and not released.
-      # Otherwise when creating a save-point same naming convention as
-      # `ActiveRecord` uses ("active_record_" prefix) will be returned.
-      # @return [String] the current save-point name
-      # @since 1.3.0
-      # @override
-      def current_savepoint_name(compat = true)
-        open_tx = open_transactions
-        return "active_record_#{open_tx}" if compat # by default behave like AR
-
-        sp_names = @connection.marked_savepoint_names
-        sp_names.last || "active_record_#{open_tx}"
-        # should (open_tx- 1) here but we play by AR's rules as it might fail
-      end unless ArJdbc::AR42
-
-      # @note Same as AR 4.2 but we're allowing an unused parameter.
-      # @private
-      def current_savepoint_name(compat = nil)
-        current_transaction.savepoint_name # unlike AR 3.2-4.1 might be nil
-      end if ArJdbc::AR42
-
       # @override
       def supports_views?
         @connection.supports_views?
       end
 
-      # Executes a SQL query in the context of this connection using the bind
-      # substitutes.
-      # @param sql the query string (or AREL object)
-      # @param name logging marker for the executed SQL statement log entry
-      # @param binds the bind parameters
-      # @return [ActiveRecord::Result] or [Array] on **AR-2.3**
-      # @override available since **AR-3.1**
-      def exec_query(sql, name = 'SQL', binds = [])
-        if sql.respond_to?(:to_sql)
-          sql = to_sql(sql, binds); to_sql = true
-        end
-        if prepared_statements?
-          log(sql, name, binds) { @connection.execute_query(sql, binds) }
-        else
-          sql = suble_binds(sql, binds) unless to_sql # deprecated behavior
-          log(sql, name) { @connection.execute_query(sql) }
-        end
-      end
-
-      # Executes an insert statement in the context of this connection.
-      # @param sql the query string (or AREL object)
-      # @param name logging marker for the executed SQL statement log entry
-      # @param binds the bind parameters
-      # @override available since **AR-3.1**
-      def exec_insert(sql, name, binds, pk = nil, sequence_name = nil)
-        if sql.respond_to?(:to_sql)
-          sql = to_sql(sql, binds); to_sql = true
-        end
-        if prepared_statements?
-          log(sql, name || 'SQL', binds) { @connection.execute_insert(sql, binds) }
-        else
-          sql = suble_binds(sql, binds) unless to_sql # deprecated behavior
-          log(sql, name || 'SQL') { @connection.execute_insert(sql) }
-        end
-      end
-
-      # Executes a delete statement in the context of this connection.
-      # @param sql the query string (or AREL object)
-      # @param name logging marker for the executed SQL statement log entry
-      # @param binds the bind parameters
-      # @override available since **AR-3.1**
-      def exec_delete(sql, name, binds)
-        if sql.respond_to?(:to_sql)
-          sql = to_sql(sql, binds); to_sql = true
-        end
-        if prepared_statements?
-          log(sql, name || 'SQL', binds) { @connection.execute_delete(sql, binds) }
-        else
-          sql = suble_binds(sql, binds) unless to_sql # deprecated behavior
-          log(sql, name || 'SQL') { @connection.execute_delete(sql) }
-        end
-      end
-
-      # # Executes an update statement in the context of this connection.
-      # @param sql the query string (or AREL object)
-      # @param name logging marker for the executed SQL statement log entry
-      # @param binds the bind parameters
-      # @override available since **AR-3.1**
-      def exec_update(sql, name, binds)
-        if sql.respond_to?(:to_sql)
-          sql = to_sql(sql, binds); to_sql = true
-        end
-        if prepared_statements?
-          log(sql, name || 'SQL', binds) { @connection.execute_update(sql, binds) }
-        else
-          sql = suble_binds(sql, binds) unless to_sql # deprecated behavior
-          log(sql, name || 'SQL') { @connection.execute_update(sql) }
-        end
-      end
-
       # 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}.
@@ -506,22 +298,6 @@ module ActiveRecord
         exec_query_raw(sql, name, binds).map!(&:values)
       end
 
-      if ActiveRecord::VERSION::MAJOR > 3 # expects AR::Result e.g. from select_all
-
-      # @private
-      def select(sql, name = nil, binds = [])
-        exec_query(to_sql(sql, binds), name, binds)
-      end
-
-      else
-
-      # @private
-      def select(sql, name = nil, binds = []) # NOTE: only (sql, name) on AR < 3.1
-        exec_query_raw(to_sql(sql, binds), name, binds)
-      end
-
-      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
@@ -595,11 +371,6 @@ module ActiveRecord
         ( key = primary_key(table) ) ? [ key, nil ] : nil
       end
 
-      # @override
-      def primary_key(table)
-        primary_keys(table).first
-      end
-
       # @override
       def primary_keys(table)
         @connection.primary_keys(table)
@@ -662,19 +433,6 @@ module ActiveRecord
       end if ActiveRecord::VERSION::MAJOR < 3 ||
         ( ActiveRecord::VERSION::MAJOR == 3 && ActiveRecord::VERSION::MINOR < 1 )
 
-      def translate_exception(e, message)
-        # we shall not translate native "Java" exceptions as they might
-        # swallow an ArJdbc / driver bug into a AR::StatementInvalid ...
-        return e if e.is_a?(NativeException) # JRuby 1.6
-        return e if e.is_a?(Java::JavaLang::Throwable)
-
-        case e
-        when SystemExit, SignalException, NoMemoryError then e
-        # NOTE: wraps AR::JDBCError into AR::StatementInvalid, desired ?!
-        else super
-        end
-      end
-
       # Take an id from the result of an INSERT query.
       # @return [Integer, NilClass]
       def last_inserted_id(result)