activerecord-jdbc-alt-adapter 70.2.0-java → 71.0.0.alpha2-java

data/lib/arjdbc/abstract/database_statements.rb

@@ -9,83 +9,85 @@ module ArJdbc
 
       NO_BINDS = [].freeze
 
-      def exec_insert(sql, name = nil, binds = NO_BINDS, pk = nil, sequence_name = nil)
+      def exec_insert(sql, name = nil, binds = NO_BINDS, pk = nil, sequence_name = nil, returning: nil)
         sql = transform_query(sql)
 
         if preventing_writes?
           raise ActiveRecord::ReadOnlyError, "Write query attempted while in readonly mode: #{sql}"
         end
 
-        materialize_transactions
         mark_transaction_written_if_write(sql)
 
         binds = convert_legacy_binds_to_attributes(binds) if binds.first.is_a?(Array)
 
-        if without_prepared_statement?(binds)
-          log(sql, name) { @connection.execute_insert_pk(sql, pk) }
-        else
-          log(sql, name, binds) do
-            @connection.execute_insert_pk(sql, binds, pk)
+        with_raw_connection do |conn|
+          if without_prepared_statement?(binds)
+            log(sql, name) { conn.execute_insert_pk(sql, pk) }
+          else
+            log(sql, name, binds) do
+              conn.execute_insert_pk(sql, binds, pk)
+            end
           end
         end
       end
 
       # 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 = NO_BINDS, prepare: false, async: false)
+      def internal_exec_query(sql, name = nil, binds = NO_BINDS, prepare: false, async: false, allow_retry: false, materialize_transactions: true)
         sql = transform_query(sql)
 
         if preventing_writes? && write_query?(sql)
           raise ActiveRecord::ReadOnlyError, "Write query attempted while in readonly mode: #{sql}"
         end
 
-        materialize_transactions
         mark_transaction_written_if_write(sql)
 
         binds = convert_legacy_binds_to_attributes(binds) if binds.first.is_a?(Array)
 
-        if without_prepared_statement?(binds)
-          log(sql, name) { @connection.execute_query(sql) }
-        else
-          log(sql, name, binds) do
-            # this is different from normal AR that always caches
-            cached_statement = fetch_cached_statement(sql) if prepare && @jdbc_statement_cache_enabled
-            @connection.execute_prepared_query(sql, binds, cached_statement)
+        with_raw_connection do |conn|
+          if without_prepared_statement?(binds)
+            log(sql, name, async: async) { conn.execute_query(sql) }
+          else
+            log(sql, name, binds, async: async) do
+              # this is different from normal AR that always caches
+              cached_statement = fetch_cached_statement(sql) if prepare && @jdbc_statement_cache_enabled
+              conn.execute_prepared_query(sql, binds, cached_statement)
+            end
           end
         end
       end
 
-      def exec_update(sql, name = nil, binds = NO_BINDS)
+      def exec_update(sql, name = 'SQL', binds = NO_BINDS)
         sql = transform_query(sql)
 
         if preventing_writes?
           raise ActiveRecord::ReadOnlyError, "Write query attempted while in readonly mode: #{sql}"
         end
 
-        materialize_transactions
         mark_transaction_written_if_write(sql)
 
         binds = convert_legacy_binds_to_attributes(binds) if binds.first.is_a?(Array)
 
-        if without_prepared_statement?(binds)
-          log(sql, name) { @connection.execute_update(sql) }
-        else
-          log(sql, name, binds) { @connection.execute_prepared_update(sql, binds) }
+        with_raw_connection do |conn|
+          if without_prepared_statement?(binds)
+            log(sql, name) { conn.execute_update(sql) }
+          else
+            log(sql, name, binds) { conn.execute_prepared_update(sql, binds) }
+          end
         end
       end
       alias :exec_delete :exec_update
 
-      def execute(sql, name = nil, async: false)
+      def execute(sql, name = nil, async: false, allow_retry: false, materialize_transactions: true)
         sql = transform_query(sql)
         
         if preventing_writes? && write_query?(sql)
           raise ActiveRecord::ReadOnlyError, "Write query attempted while in readonly mode: #{sql}"
         end
 
-        materialize_transactions
         mark_transaction_written_if_write(sql)
 
-        log(sql, name, async: async) { @connection.execute(sql) }
+        raw_execute(sql, name, async: async, allow_retry: allow_retry, materialize_transactions: materialize_transactions)
       end
 
       # overridden to support legacy binds
@@ -102,6 +104,14 @@ module ArJdbc
         end
       end
 
+      def raw_execute(sql, name, async: false, allow_retry: false, materialize_transactions: true)
+        log(sql, name, async: async) do
+          with_raw_connection(allow_retry: allow_retry, materialize_transactions: materialize_transactions) do |conn|
+            conn.execute(sql)
+          end
+        end
+      end
+
     end
   end
 end

data/lib/arjdbc/abstract/statement_cache.rb

@@ -24,23 +24,18 @@ module ArJdbc
 
         # 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])
+        statement_limit = self.class.type_cast_config_to_integer(@config[:statement_limit])
         @jdbc_statement_cache_enabled = 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(sql_key(sql))
       end
 
       def fetch_cached_statement(sql)
-        @statements[sql_key(sql)] ||= @connection.prepare_statement(sql)
+        @statements[sql_key(sql)] ||= @raw_connection.prepare_statement(sql)
       end
 
       private

data/lib/arjdbc/abstract/transaction_support.rb

@@ -12,11 +12,11 @@ module ArJdbc
       # @since 1.3.0
       # @override
       def supports_savepoints?
-        @connection.supports_savepoints?
+        @raw_connection.supports_savepoints?
       end
 
       def supports_transaction_isolation?
-        @connection.supports_transaction_isolation?
+        @raw_connection.supports_transaction_isolation?
       end
 
       ########################## Transaction Interface ##########################
@@ -24,26 +24,42 @@ module ArJdbc
       # Starts a database transaction.
       # @override
       def begin_db_transaction
-        log('BEGIN', 'TRANSACTION') { @connection.begin }
+        log('BEGIN', 'TRANSACTION') do
+          with_raw_connection(allow_retry: true, materialize_transactions: false) do |conn|
+            conn.begin
+          end
+        end
       end
 
       # Starts a database transaction.
       # @param isolation the transaction isolation to use
       def begin_isolated_db_transaction(isolation)
-        log("BEGIN ISOLATED - #{isolation}", 'TRANSACTION') { @connection.begin(isolation) }
+        log("BEGIN ISOLATED - #{isolation}", 'TRANSACTION') do
+          with_raw_connection(allow_retry: true, materialize_transactions: false) do |conn|
+            conn.begin(isolation)
+          end
+        end
       end
 
       # Commits the current database transaction.
       # @override
       def commit_db_transaction
-        log('COMMIT', 'TRANSACTION') { @connection.commit }
+        log('COMMIT', 'TRANSACTION') do
+          with_raw_connection(allow_retry: true, materialize_transactions: false) do |conn|
+            conn.commit
+          end
+        end
       end
 
       # Rolls back the current database transaction.
       # Called from 'rollback_db_transaction' in the AbstractAdapter
       # @override
       def exec_rollback_db_transaction
-        log('ROLLBACK', 'TRANSACTION') { @connection.rollback }
+        log('ROLLBACK', 'TRANSACTION') do
+          with_raw_connection(allow_retry: true, materialize_transactions: false) do |conn|
+            conn.rollback
+          end
+        end
       end
 
       ########################## Savepoint Interface ############################
@@ -55,7 +71,11 @@ module ArJdbc
       # @since 1.3.0
       # @extension added optional name parameter
       def create_savepoint(name = current_savepoint_name)
-        log("SAVEPOINT #{name}", 'TRANSACTION') { @connection.create_savepoint(name) }
+        log("SAVEPOINT #{name}", 'TRANSACTION') do
+          with_raw_connection(allow_retry: true, materialize_transactions: false) do |conn|
+            conn.create_savepoint(name)
+          end
+        end
       end
 
       # Transaction rollback to a given (previously created) save-point.
@@ -64,7 +84,11 @@ module ArJdbc
       # @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}", 'TRANSACTION') { @connection.rollback_savepoint(name) }
+        log("ROLLBACK TO SAVEPOINT #{name}", 'TRANSACTION') do
+          with_raw_connection(allow_retry: true, materialize_transactions: false) do |conn|
+            conn.rollback_savepoint(name)
+          end
+        end
       end
 
       # Release a previously created save-point.
@@ -73,22 +97,13 @@ module ArJdbc
       # @param name the save-point name
       # @extension added optional name parameter
       def release_savepoint(name = current_savepoint_name)
-        log("RELEASE SAVEPOINT #{name}", 'TRANSACTION') { @connection.release_savepoint(name) }
+        log("RELEASE SAVEPOINT #{name}", 'TRANSACTION') do
+          with_raw_connection(allow_retry: true, materialize_transactions: false) do |conn|
+            conn.release_savepoint(name)
+          end
+        end
       end
 
     end
   end
 end
-
-# patch to avoid the usage of WeakMap
-require 'active_record/connection_adapters/abstract/transaction'
-module ActiveRecord
-  module ConnectionAdapters
-    class Transaction
-      def add_record(record, ensure_finalize = true)
-        @records ||= []
-        @records << record
-      end
-    end
-  end
-end

data/lib/arjdbc/jdbc/column.rb

@@ -12,45 +12,11 @@ module ActiveRecord
     # specific type.
     # @see JdbcAdapter#jdbc_column_class
     class JdbcColumn < Column
-      # @deprecated attribute writers will be removed in 1.4
-      attr_writer :limit, :precision # unless ArJdbc::AR42
-
-      def initialize(config, name, *args)
-        if self.class == JdbcColumn
-          # NOTE: extending classes do not want this if they do they shall call
-          call_discovered_column_callbacks(config) if config
-          default = args.shift
-        else # for extending classes allow ignoring first argument :
-          if ! config.nil? && ! config.is_a?(Hash)
-            default = name; name = config # initialize(name, default, *args)
-          else
-            default = args.shift
-          end
-        end
-
-        super(name, default, *args)
-        init_column(name, default, *args)
-      end
-
-      # Additional column initialization for sub-classes.
-      def init_column(*args); end
 
       # Similar to `ActiveRecord`'s `extract_value_from_default(default)`.
       # @return default value for a column (possibly extracted from driver value)
       def default_value(value); value; end
 
-      protected
-
-      # @private
-      def call_discovered_column_callbacks(config)
-        dialect = (config[:dialect] || config[:driver]).to_s
-        for matcher, block in self.class.column_types
-          block.call(config, self) if matcher === dialect
-        end
-      end
-
-      public
-
       # Returns the available column types
       # @return [Hash] of (matcher, block) pairs
       def self.column_types

data/lib/arjdbc/jdbc/connection_methods.rb

@@ -7,7 +7,7 @@ module ArJdbc
 
     def jdbc_connection(config)
       adapter_class = config[:adapter_class] || ::ActiveRecord::ConnectionAdapters::JdbcAdapter
-      adapter_class.new(nil, logger, nil, config)
+      adapter_class.new(config)
     end
 
     def jndi_connection(config); jdbc_connection(config) end

data/lib/arjdbc/mssql/adapter.rb

@@ -15,6 +15,8 @@ require 'arjdbc/abstract/database_statements'
 require 'arjdbc/abstract/statement_cache'
 require 'arjdbc/abstract/transaction_support'
 
+require 'arjdbc/mssql/utils'
+require 'arjdbc/mssql/server_version'
 require 'arjdbc/mssql/column'
 require 'arjdbc/mssql/types'
 require 'arjdbc/mssql/quoting'
@@ -34,23 +36,11 @@ module ActiveRecord
     class MSSQLAdapter < AbstractAdapter
       ADAPTER_NAME = 'MSSQL'.freeze
 
-      MSSQL_VERSION_YEAR = {
-        8  => '2000',
-        9  => '2005',
-        10 => '2008',
-        11 => '2012',
-        12 => '2014',
-        13 => '2016',
-        14 => '2017',
-        15 => '2019',
-        16 => '2022'
-      }.freeze
-
-      include Jdbc::ConnectionPoolCallbacks
+      # include Jdbc::ConnectionPoolCallbacks
       include ArJdbc::Abstract::Core
-      include ArJdbc::Abstract::ConnectionManagement
-      include ArJdbc::Abstract::DatabaseStatements
-      include ArJdbc::Abstract::StatementCache
+      # include ArJdbc::Abstract::ConnectionManagement
+      # include ArJdbc::Abstract::DatabaseStatements
+      # include ArJdbc::Abstract::StatementCache
       include ArJdbc::Abstract::TransactionSupport
 
       include MSSQL::Quoting
@@ -63,32 +53,55 @@ module ActiveRecord
 
       class << self
         attr_accessor :cs_equality_operator
+
+        # Returns the (JDBC) connection class to be used for this adapter.
+        # The class is defined in the java part
+        def jdbc_connection_class
+          ::ActiveRecord::ConnectionAdapters::MSSQLJdbcConnection
+        end
+
+        def new_client(conn_params, adapter_instance)
+          jdbc_connection_class.new(conn_params, adapter_instance)
+        rescue ActiveRecord::JDBCError => error
+          if conn_params && conn_params[:database] && error.message.include?(conn_params[:database])
+            raise ActiveRecord::NoDatabaseError.db_error(conn_params[:database])
+          elsif conn_params && conn_params[:username] && error.message.include?(conn_params[:username])
+            raise ActiveRecord::DatabaseConnectionError.username_error(conn_params[:username])
+          elsif conn_params && conn_params[:host] && error.message.include?(conn_params[:host])
+            raise ActiveRecord::DatabaseConnectionError.hostname_error(conn_params[:host])
+          else
+            raise ActiveRecord::ConnectionNotEstablished, error.message
+          end
+        end
       end
 
-      def initialize(connection, logger, _connection_parameters, config = {})
+      def initialize(...)
         # configure_connection happens in super
-        super(connection, logger, config)
+        super
 
-        if database_version < '11'
-          raise "Your #{mssql_product_name} #{mssql_version_year} is too old. This adapter supports #{mssql_product_name} >= 2012."
-        end
+        conn_params = @config.compact
+
+        @raw_connection = nil
+
+        @connection_parameters = conn_params
       end
 
-      def self.database_exists?(config)
-        !!ActiveRecord::Base.sqlserver_connection(config)
-      rescue ActiveRecord::JDBCError => e
-        case e.message
-        when /Cannot open database .* requested by the login/
-          false
-        else
-          raise
+      # @override
+      def active?
+        @lock.synchronize do
+          return false unless @raw_connection
+
+          @raw_connection.active?
         end
       end
 
-      # Returns the (JDBC) connection class to be used for this adapter.
-      # The class is defined in the java part
-      def jdbc_connection_class(_spec)
-        ::ActiveRecord::ConnectionAdapters::MSSQLJdbcConnection
+      # @override
+      def disconnect!
+        @lock.synchronize do
+          super # clear_cache! && reset_transaction
+          @raw_connection&.disconnect!
+          @raw_connection = nil
+        end
       end
 
       # Returns the (JDBC) `ActiveRecord` column class for this adapter.
@@ -177,10 +190,10 @@ module ActiveRecord
         !native_database_types[type].nil?
       end
 
-      def clear_cache!
-        # reload_type_map
-        super
-      end
+      # def clear_cache!
+      #   # reload_type_map
+      #   super
+      # end
 
       def reset!
         # execute 'IF @@TRANCOUNT > 0 ROLLBACK TRANSACTION'
@@ -193,12 +206,12 @@ module ActiveRecord
         tables = tables_with_referential_integrity
 
         tables.each do |table_name|
-          execute "ALTER TABLE #{table_name} NOCHECK CONSTRAINT ALL"
+          internal_execute("ALTER TABLE #{table_name} NOCHECK CONSTRAINT ALL")
         end
         yield
       ensure
         tables.each do |table_name|
-          execute "ALTER TABLE #{table_name} CHECK CONSTRAINT ALL"
+          internal_execute("ALTER TABLE #{table_name} CHECK CONSTRAINT ALL")
         end
       end
 
@@ -222,13 +235,17 @@ module ActiveRecord
 
       # Returns the name of the current security context
       def current_user
-        @current_user ||= select_value('SELECT CURRENT_USER')
+        @current_user ||= internal_execute('SELECT CURRENT_USER').rows.flatten.first
       end
 
       # Returns the default schema (to be used for table resolution)
       # used for the {#current_user}.
       def default_schema
-        @default_schema ||= select_value('SELECT default_schema_name FROM sys.database_principals WHERE name = CURRENT_USER')
+        @default_schema ||= internal_execute(default_schema_query).rows.flatten.first
+      end
+
+      def default_schema_query
+        'SELECT default_schema_name FROM sys.database_principals WHERE name = CURRENT_USER'
       end
 
       alias_method :current_schema, :default_schema
@@ -236,7 +253,7 @@ module ActiveRecord
       # Allows for changing of the default schema.
       # (to be used during unqualified table name resolution).
       def default_schema=(default_schema)
-        execute("ALTER #{current_user} WITH DEFAULT_SCHEMA=#{default_schema}")
+        internal_execute("ALTER #{current_user} WITH DEFAULT_SCHEMA=#{default_schema}")
         @default_schema = nil if defined?(@default_schema)
       end
 
@@ -273,7 +290,7 @@ module ActiveRecord
       end
 
       def set_session_transaction_isolation
-        isolation_level = config[:transaction_isolation]
+        isolation_level = @config[:transaction_isolation]
 
         self.transaction_isolation = isolation_level if isolation_level
       end
@@ -282,35 +299,31 @@ module ActiveRecord
         true
       end
 
-      def mssql_major_version
-        return @mssql_major_version if defined? @mssql_major_version
-
-        @mssql_major_version = @connection.database_major_version
-      end
-
-      def mssql_version_year
-        MSSQL_VERSION_YEAR[mssql_major_version.to_i]
+      def get_database_version # :nodoc:
+        MSSQLAdapter::Version.new(mssql_version.major, mssql_version.complete)
       end
 
-      def mssql_product_version
-        return @mssql_product_version if defined? @mssql_product_version
+      def check_version # :nodoc:
+        return unless database_version.to_s <= mssql_version.min_major
 
-        @mssql_product_version = @connection.database_product_version
+        raise "Your #{mssql_version.product_name} is too old. #{mssql_version.support_message}"
       end
 
-      def mssql_product_name
-        return @mssql_product_name if defined? @mssql_product_name
+      def mssql_version
+        return @mssql_version if defined? @mssql_version
 
-        @mssql_product_name = @connection.database_product_name
-      end
+        result = internal_execute("SELECT #{mssql_version_properties.join(', ')}").rows
 
-      def get_database_version # :nodoc:
-        MSSQLAdapter::Version.new(mssql_product_version)
+        @mssql_version = MSSQL::Version.new(result.flatten)
       end
 
-      def check_version # :nodoc:
-        # NOTE: hitting the database from here causes trouble when adapter
-        # uses JNDI or Data Source setup.
+      def mssql_version_properties
+        [
+          "SERVERPROPERTY('productVersion')",
+          "SERVERPROPERTY('productMajorVersion')",
+          "SERVERPROPERTY('productLevel')",
+          "SERVERPROPERTY('edition')"
+        ]
       end
 
       def tables_with_referential_integrity
@@ -404,6 +417,8 @@ module ActiveRecord
           register_class_with_precision map, %r{\Adatetime2\(\d+\)}i, MSSQL::Type::DateTime2
           # map.register_type 'datetime2(7)',  MSSQL::Type::DateTime2.new
 
+          # map.register_type %r(^json)i, Type::Json.new
+
           # TODO: we should have identity separated from the sql_type
           # let's say in another attribute (this will help to pass more AR tests),
           # also we add collation attribute per column.
@@ -440,6 +455,20 @@ module ActiveRecord
 
       private
 
+      def connect
+        @raw_connection = self.class.new_client(@connection_parameters, self)
+      rescue ConnectionNotEstablished => ex
+        raise ex.set_pool(@pool)
+      end
+
+      def reconnect
+        @raw_connection&.disconnect!
+
+        @raw_connection = nil
+
+        connect
+      end
+
       def type_map
         TYPE_MAP
       end
@@ -454,6 +483,8 @@ module ActiveRecord
           LockTimeout.new(message, sql: sql, binds: binds)
         when /The .* statement conflicted with the FOREIGN KEY constraint/
           InvalidForeignKey.new(message, sql: sql, binds: binds)
+        when /Could not drop object .* because it is referenced by a FOREIGN KEY constraint/
+          StatementInvalid.new(message, sql: sql, binds: binds)
         when /The .* statement conflicted with the REFERENCE constraint/
           InvalidForeignKey.new(message, sql: sql, binds: binds)
         when /(String or binary data would be truncated)/i
@@ -462,6 +493,12 @@ module ActiveRecord
           NotNullViolation.new(message, sql: sql, binds: binds)
         when /Arithmetic overflow error converting expression/
           RangeError.new(message, sql: sql, binds: binds)
+        when /Snapshot isolation transaction aborted due to update conflict. You cannot use snapshot isolation/
+          StatementInvalid.new(message, sql: sql, binds: binds)
+        when /Incorrect syntax near the keyword .*/
+          StatementInvalid.new(message, sql: sql, binds: binds)
+        when /Could not find stored procedure .*/
+          StatementInvalid.new(message, sql: sql, binds: binds)
         else
           super
         end
@@ -472,13 +509,11 @@ module ActiveRecord
       # NOTE: This is ready, all implemented in the java part of adapter,
       # it uses MSSQLColumn, SqlTypeMetadata, etc.
       def column_definitions(table_name)
-       log('JDBC: GETCOLUMNS', 'SCHEMA') { @connection.columns(table_name, nil, default_schema) }
-      rescue => e
+        log('JDBC: GETCOLUMNS', 'SCHEMA') { valid_raw_connection.columns(table_name, nil, default_schema) }
         # raise translate_exception_class(e, nil)
         # FIXME: this breaks one arjdbc test but fixes activerecord tests
         # (table name alias). Also it behaves similarly to the CRuby adapter
         # which returns an empty array too. (postgres throws a exception)
-        []
       end
 
       def arel_visitor # :nodoc:
@@ -491,16 +526,3 @@ module ActiveRecord
     end
   end
 end
-
-# FIXME: this is not used by the adapter anymore, it is here because
-# it is a dependency of old tests that needs to be reviewed
-module ArJdbc
-  module MSSQL
-    require 'arjdbc/mssql/utils'
-    require 'arjdbc/mssql/limit_helpers'
-    require 'arjdbc/mssql/lock_methods'
-
-    include LimitHelpers
-    include Utils
-  end
-end

data/lib/arjdbc/mssql/column.rb

@@ -29,6 +29,7 @@ module ActiveRecord
       def identity?
         sql_type.downcase.include? 'identity'
       end
+      alias_method :auto_incremented_by_db?, :identity?
 
       def ==(other)
         other.is_a?(MSSQLColumn) &&