activerecord-jdbc-alt-adapter 70.1.0-java → 71.0.0.alpha1-java

data/lib/arjdbc/sqlite3/connection_methods.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 ArJdbc::ConnectionMethods.module_eval do
   def sqlite3_connection(config)
+    raise ArgumentError, 'Configuration must not be empty' if config.blank?
+    
     config = config.deep_dup
     config[:adapter_spec] ||= ::ArJdbc::SQLite3
     config[:adapter_class] = ActiveRecord::ConnectionAdapters::SQLite3Adapter unless config.key?(:adapter_class)
@@ -18,7 +20,7 @@ ArJdbc::ConnectionMethods.module_eval do
       parse_sqlite3_config!(config)
     rescue Errno::ENOENT => error
       if error.message.include?('No such file or directory')
-        raise ActiveRecord::NoDatabaseError
+        raise ActiveRecord::NoDatabaseError.new(connection_pool: ActiveRecord::ConnectionAdapters::NullPool.new)
       else
         raise
       end
@@ -50,7 +52,10 @@ ArJdbc::ConnectionMethods.module_eval do
 
     timeout = config[:timeout]
     if timeout && timeout.to_s !~ /\A\d+\Z/
-      raise TypeError.new "Timeout must be nil or a number (got: #{timeout})."
+      raise ActiveRecord::StatementInvalid.new(
+        "TypeError: Timeout must be nil or a number (got: #{timeout}).",
+        connection_pool: ActiveRecord::ConnectionAdapters::NullPool.new
+      )
     end
 
     options = config[:properties]

data/lib/arjdbc/tasks/mssql_database_tasks.rb

@@ -5,10 +5,6 @@ require 'active_record/tasks/database_tasks'
 module ArJdbc
   module Tasks # :nodoc:
     class MSSQLDatabaseTasks # :nodoc:
-      delegate :connection, to: ActiveRecord::Base
-      delegate :establish_connection, to: ActiveRecord::Base
-      delegate :clear_active_connections!, to: ActiveRecord::Base
-
       def self.using_database_configurations?
         true
       end
@@ -45,7 +41,7 @@ module ArJdbc
       end
 
       def purge
-        clear_active_connections!
+        ActiveRecord::Base.connection_handler.clear_active_connections!(:all)
         drop
         create
       end
@@ -70,6 +66,14 @@ module ArJdbc
 
       attr_reader :db_config, :configuration_hash
 
+      def connection
+        ActiveRecord::Base.connection
+      end
+
+      def establish_connection(config = db_config)
+        ActiveRecord::Base.establish_connection(config)
+      end
+
       def creation_options
         {}.tap do |options|
           options[:collation] = configuration_hash[:collation] if configuration_hash.include?(:collation)

data/lib/arjdbc/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ArJdbc
-  VERSION = '70.1.0'
+  VERSION = '71.0.0.alpha1'
 end

data/rakelib/02-test.rake

@@ -40,7 +40,7 @@ def test_task_for(adapter, options = {})
       test_task.libs.push *FileList["activerecord-jdbc#{adapter}*/lib"]
     end
     test_task.libs << 'test'
-    test_task.options = '--use-color=t'
+    test_task.options = '--use-color=t --progress-style=mark'
     test_task.verbose = true if $VERBOSE
     yield(test_task) if block_given?
   end

data/rakelib/rails.rake

@@ -40,6 +40,7 @@ namespace :rails do
           File.join(root_dir, 'lib'),
           File.join(root_dir, driver, 'lib'),
           File.join(root_dir, 'test/rails'),
+          File.join(root_dir, 'jdbc-sqlite3', 'lib'),  # Added for connection management tests which hardcode sqlite3
           ar_test_dir
       ]
 
@@ -57,6 +58,7 @@ namespace :rails do
       ruby_opts_string += " -C \"#{ar_path}\""
       ruby_opts_string += " -rbundler/setup"
       ruby_opts_string += " -rminitest -rminitest/excludes" unless ENV['NO_EXCLUDES'].eql?('true')
+      ruby_opts_string += " -rmonkey_patches"
       file_list = ENV["TEST"] ? FileList[ ENV["TEST"].split(',') ] : test_files_finder.call
       file_list_string = file_list.map { |fn| "\"#{fn}\"" }.join(' ')
       # test_loader_code = "-e \"ARGV.each{|f| require f}\"" # :direct

data/src/java/arjdbc/jdbc/RubyJdbcConnection.java

@@ -793,7 +793,8 @@ public class RubyJdbcConnection extends RubyObject {
                         // Unfortunately the result set gets closed when getMoreResults()
                         // is called, so we have to process the result sets as we get them
                         // this shouldn't be an issue in most cases since we're only getting 1 result set anyways
-                        result = mapExecuteResult(context, connection, resultSet);
+                        //result = mapExecuteResult(context, connection, resultSet);
+                        result = mapToRawResult(context, connection, resultSet, false);
                         resultSet.close();
                     } else {
                         result = context.runtime.newFixnum(updateCount);
@@ -2735,8 +2736,9 @@ public class RubyJdbcConnection extends RubyObject {
             statement.setDouble(index, ((RubyNumeric) value).getDoubleValue());
         }
         else { // e.g. `BigDecimal '42.00000000000000000001'`
+            Ruby runtime = context.runtime;
             statement.setBigDecimal(index,
-                    RubyBigDecimal.newInstance(context, context.runtime.getModule("BigDecimal"), value).getValue());
+                    RubyBigDecimal.newInstance(context, runtime.getModule("BigDecimal"), value, RubyFixnum.zero(runtime)).getValue());
         }
     }
 

data/src/java/arjdbc/sqlite3/SQLite3RubyJdbcConnection.java

@@ -511,7 +511,8 @@ public class SQLite3RubyJdbcConnection extends RubyJdbcConnection {
             statement.setDouble(index, ((RubyNumeric) value).getDoubleValue());
         }
         else { // e.g. `BigDecimal '42.00000000000000000001'`
-            RubyBigDecimal val = RubyBigDecimal.newInstance(context, context.runtime.getModule("BigDecimal"), value);
+            Ruby runtime = context.runtime;
+            RubyBigDecimal val = RubyBigDecimal.newInstance(context, runtime.getModule("BigDecimal"), value, RubyFixnum.zero(runtime));
             statement.setString(index, val.getValue().toString());
         }
     }

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-jdbc-alt-adapter
 version: !ruby/object:Gem::Version
-  version: 70.1.0
+  version: 71.0.0.alpha1
 platform: java
 authors:
 - Nick Sieger, Ola Bini, Karol Bucek, Jesse Chavez, and JRuby contributors
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-08-27 00:00:00.000000000 Z
+date: 2024-07-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 7.0.0
+        version: 7.1.3
   name: activerecord
-  prerelease: false
   type: :runtime
+  prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 7.0.0
+        version: 7.1.3
 description: 'Fork of the ActiveRecord JDBC adapter with support for SQL Server and
   Azure SQL, for more information and help look at the README file in the github repository.
   AR-JDBC is a database adapter for Rails'' ActiveRecord component designed to be
@@ -42,6 +42,7 @@ files:
 - ".github/workflows/ruby.yml"
 - ".gitignore"
 - ".nvimlog"
+- ".solargraph.yml"
 - ".travis.yml"
 - ".yardopts"
 - CONTRIBUTING.md
@@ -72,8 +73,6 @@ files:
 - lib/arel/visitors/h2.rb
 - lib/arel/visitors/hsqldb.rb
 - lib/arel/visitors/postgresql_jdbc.rb
-- lib/arel/visitors/sql_server.rb
-- lib/arel/visitors/sql_server/ng42.rb
 - lib/arel/visitors/sqlserver.rb
 - lib/arjdbc.rb
 - lib/arjdbc/abstract/connection_management.rb
@@ -118,15 +117,12 @@ files:
 - lib/arjdbc/mssql/explain_support.rb
 - lib/arjdbc/mssql/extensions/attribute_methods.rb
 - lib/arjdbc/mssql/extensions/calculations.rb
-- lib/arjdbc/mssql/limit_helpers.rb
-- lib/arjdbc/mssql/lock_methods.rb
-- lib/arjdbc/mssql/old_adapter.rb
-- lib/arjdbc/mssql/old_column.rb
 - lib/arjdbc/mssql/quoting.rb
 - lib/arjdbc/mssql/schema_creation.rb
 - lib/arjdbc/mssql/schema_definitions.rb
 - lib/arjdbc/mssql/schema_dumper.rb
 - lib/arjdbc/mssql/schema_statements.rb
+- lib/arjdbc/mssql/server_version.rb
 - lib/arjdbc/mssql/transaction.rb
 - lib/arjdbc/mssql/types.rb
 - lib/arjdbc/mssql/types/binary_types.rb
@@ -152,6 +148,7 @@ files:
 - lib/arjdbc/railtie.rb
 - lib/arjdbc/sqlite3.rb
 - lib/arjdbc/sqlite3/adapter.rb
+- lib/arjdbc/sqlite3/column.rb
 - lib/arjdbc/sqlite3/connection_methods.rb
 - lib/arjdbc/tasks.rb
 - lib/arjdbc/tasks/database_tasks.rb
@@ -231,11 +228,11 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
-rubygems_version: 3.3.25
+rubygems_version: 3.3.26
 signing_key:
 specification_version: 4
 summary: ActiveRecord JDBC adapter, for use within JRuby on Rails and SQL Server

data/lib/arel/visitors/sql_server/ng42.rb

@@ -1,294 +0,0 @@
-module Arel
-  module Visitors
-    class SQLServerNG < SQLServer # Arel::Visitors::ToSql
-
-      OFFSET = " OFFSET "
-      ROWS = " ROWS"
-      FETCH = " FETCH NEXT "
-      FETCH0 = " FETCH FIRST (SELECT 0) "
-      ROWS_ONLY = " ROWS ONLY"
-
-      private
-
-      # SQLServer ToSql/Visitor (Overides)
-
-      #def visit_Arel_Nodes_BindParam o, collector
-      #  collector.add_bind(o) { |i| "@#{i-1}" }
-      #end
-
-      def visit_Arel_Nodes_Bin o, collector
-        visit o.expr, collector
-        if o.expr.val.is_a? Numeric
-          collector
-        else
-          collector << " #{::ArJdbc::MSSQL.cs_equality_operator} "
-        end
-      end
-
-      def visit_Arel_Nodes_UpdateStatement(o, a)
-        if o.orders.any? && o.limit.nil?
-          o.limit = Nodes::Limit.new(9_223_372_036_854_775_807)
-        end
-        super
-      end
-
-      def visit_Arel_Nodes_Lock o, collector
-        o.expr = Arel.sql('WITH(UPDLOCK)') if o.expr.to_s =~ /FOR UPDATE/
-        collector << SPACE
-        visit o.expr, collector
-      end
-
-      def visit_Arel_Nodes_Offset o, collector
-        collector << OFFSET
-        visit o.expr, collector
-        collector << ROWS
-      end
-
-      def visit_Arel_Nodes_Limit o, collector
-        if node_value(o) == 0
-          collector << FETCH0
-          collector << ROWS_ONLY
-        else
-          collector << FETCH
-          visit o.expr, collector
-          collector << ROWS_ONLY
-        end
-      end
-
-      def visit_Arel_Nodes_SelectStatement o, collector
-        distinct_One_As_One_Is_So_Not_Fetch o
-
-        set_select_statement_lock o.lock
-
-        if o.with
-          collector = visit o.with, collector
-          collector << SPACE
-        end
-
-        return _visit_Arel_Nodes_SelectStatement(o, collector) if ! o.limit && ! o.offset
-
-        # collector = o.cores.inject(collector) { |c,x|
-        #   visit_Arel_Nodes_SelectCore(x, c)
-        # }
-
-        unless o.orders.empty?
-          select_order_by = do_visit_columns o.orders, collector, 'ORDER BY '
-        end
-
-        select_count = false
-        collector = o.cores.inject(collector) do |c, x|
-          unless core_order_by = select_order_by
-            core_order_by = generate_order_by determine_order_by(o, x)
-          end
-
-          if select_count? x
-            x.projections = [ Arel::Nodes::SqlLiteral.new(over_row_num(core_order_by)) ]
-            select_count = true
-          else
-            # NOTE: this should really be added here and we should built the
-            # wrapping SQL but than #replace_limit_offset! assumes it does that
-            # ... MS-SQL adapter code seems to be 'hacked' by a lot of people
-            #x.projections << Arel::Nodes::SqlLiteral.new(over_row_num(select_order_by))
-          end if core_order_by
-          visit_Arel_Nodes_SelectCore(x, c)
-        end
-        # END collector = o.cores.inject(collector) { |c,x|
-
-        # collector = visit_Orders_And_Let_Fetch_Happen o, collector
-        # collector = visit_Make_Fetch_Happen o, collector
-        # collector # __method__ END
-
-        self.class.collector_proxy(collector) do |sql|
-          select_order_by ||= "ORDER BY #{@connection.determine_order_clause(sql)}"
-          replace_limit_offset!(sql, limit_for(o.limit), o.offset && o.offset.value.to_i, select_order_by)
-          sql = "SELECT COUNT(*) AS count_id FROM (#{sql}) AS subquery" if select_count
-          sql
-        end
-
-      ensure
-        set_select_statement_lock nil
-      end
-
-      def visit_Arel_Nodes_JoinSource o, collector
-        if o.left
-          collector = visit o.left, collector
-          collector = visit_Arel_Nodes_SelectStatement_SQLServer_Lock collector
-        end
-        if o.right.any?
-          collector << " " if o.left
-          collector = inject_join o.right, collector, ' '
-        end
-        collector
-      end
-
-      def visit_Arel_Nodes_OuterJoin o, collector
-        collector << "LEFT OUTER JOIN "
-        collector = visit o.left, collector
-        collector = visit_Arel_Nodes_SelectStatement_SQLServer_Lock collector, space: true
-        collector << " "
-        visit o.right, collector
-      end
-
-      # SQLServer ToSql/Visitor (Additions)
-
-      def visit_Arel_Nodes_SelectStatement_SQLServer_Lock collector, options = {}
-        if lock = select_statement_lock
-          collector = visit lock, collector
-          collector << SPACE if options[:space]
-        end
-        collector
-      end
-
-      def visit_Orders_And_Let_Fetch_Happen o, collector
-        make_Fetch_Possible_And_Deterministic o
-        unless o.orders.empty?
-          collector << SPACE
-          collector << ORDER_BY
-          len = o.orders.length - 1
-          o.orders.each_with_index { |x, i|
-            collector = visit(x, collector)
-            collector << COMMA unless len == i
-          }
-        end
-        collector
-      end
-
-      def visit_Make_Fetch_Happen o, collector
-        o.offset = Nodes::Offset.new(0) if o.limit && !o.offset
-        collector = visit o.offset, collector if o.offset
-        collector = visit o.limit, collector if o.limit
-        collector
-      end
-
-      # SQLServer Helpers
-
-      # attr_reader :select_statement_lock
-      def select_statement_lock
-        Thread.current[:'Arel::Visitors::SQLServerNG.select_statement_lock']
-      end
-
-      def set_select_statement_lock(lock) # @select_statement_lock = lock
-        Thread.current[:'Arel::Visitors::SQLServerNG.select_statement_lock'] = lock
-      end
-
-      def make_Fetch_Possible_And_Deterministic o
-        return if o.limit.nil? && o.offset.nil?
-        if o.orders.empty? # ORDER BY mandatory with OFFSET FETCH clause
-          t = table_From_Statement o
-          pk = primary_Key_From_Table t
-          return unless pk
-          # Prefer deterministic vs a simple `(SELECT NULL)` expr.
-          o.orders = [ pk.asc ]
-        end
-      end
-
-      def distinct_One_As_One_Is_So_Not_Fetch o
-        core = o.cores.first
-        distinct = Nodes::Distinct === core.set_quantifier
-        oneasone = core.projections.all? { |x| x == ActiveRecord::FinderMethods::ONE_AS_ONE }
-        limitone = node_value(o.limit) == 1
-        if distinct && oneasone && limitone && !o.offset
-          core.projections = [Arel.sql("TOP(1) 1 AS [one]")]
-          o.limit = nil
-        end
-      end
-
-      def table_From_Statement o
-        core = o.cores.first
-        if Arel::Table === core.from
-          core.from
-        elsif Arel::Nodes::SqlLiteral === core.from
-          Arel::Table.new(core.from)
-        elsif Arel::Nodes::JoinSource === core.source
-          Arel::Nodes::SqlLiteral === core.source.left ? Arel::Table.new(core.source.left, @engine) : core.source.left
-        end
-      end
-
-      def primary_Key_From_Table t
-        return unless t
-        return t.primary_key if t.primary_key
-        if engine_pk = t.engine.primary_key
-          pk = t.engine.arel_table[engine_pk]
-          return pk if pk
-        end
-        pk = t.engine.connection.schema_cache.primary_keys(t.engine.table_name)
-        return pk if pk
-        column_name = t.engine.columns.first.try(:name)
-        column_name ? t[column_name] : nil
-      end
-
-      def determine_order_by o, x
-        if o.orders.any?
-          o.orders
-        elsif x.groups.any?
-          x.groups
-        else
-          pk = find_left_table_pk(x)
-          pk ? [ pk ] : nil # []
-        end
-      end
-
-      def generate_order_by orders
-        do_visit_columns orders, nil, 'ORDER BY '
-      end
-
-      SQLString = ActiveRecord::ConnectionAdapters::AbstractAdapter::SQLString
-      # BindCollector = ActiveRecord::ConnectionAdapters::AbstractAdapter::BindCollector
-
-      def self.collector_proxy(collector, &block)
-        if collector.is_a?(SQLString)
-          return SQLStringProxy.new(collector, block)
-        end
-        BindCollectorProxy.new(collector, block)
-      end
-
-      class BindCollectorProxy < ActiveRecord::ConnectionAdapters::AbstractAdapter::BindCollector
-
-        def initialize(collector, block); @delegate = collector; @block = block end
-
-        def << str; @delegate << str; self end
-
-        def add_bind bind; @delegate.add_bind bind; self end
-
-        def value; @delegate.value; end
-
-        #def substitute_binds bvs; @delegate.substitute_binds(bvs); self end
-
-        def compile(bvs, conn)
-          _yield_str @delegate.compile(bvs, conn)
-        end
-
-        private
-
-        def method_missing(name, *args, &block); @delegate.send(name, args, &block) end
-
-        def _yield_str(str); @block ? @block.call(str) : str end
-
-      end
-
-      class SQLStringProxy < ActiveRecord::ConnectionAdapters::AbstractAdapter::SQLString
-
-        def initialize(collector, block); @delegate = collector; @block = block end
-
-        def << str; @delegate << str; self end
-
-        def add_bind bind; @delegate.add_bind bind; self end
-
-        def compile(bvs, conn)
-          _yield_str @delegate.compile(bvs, conn)
-        end
-
-        private
-
-        def method_missing(name, *args, &block); @delegate.send(name, args, &block) end
-
-        def _yield_str(str); @block ? @block.call(str) : str end
-
-      end
-
-    end
-  end
-end
-
-# FIXME: Arel::Visitors::VISITORS is not defined anymore
-# Arel::Visitors::VISITORS['mssql'] = Arel::Visitors::VISITORS['sqlserver'] = Arel::Visitors::SQLServerNG

data/lib/arel/visitors/sql_server.rb

@@ -1,124 +0,0 @@
-require 'arel/visitors/compat'
-
-module Arel
-  module Visitors
-    ToSql.class_eval do
-      alias_method :_visit_Arel_Nodes_SelectStatement, :visit_Arel_Nodes_SelectStatement
-    end
-    # @note AREL set's up `Arel::Visitors::MSSQL` but its not usable as is ...
-    # @private
-    class SQLServer < const_defined?(:MSSQL) ? MSSQL : ToSql
-
-      private
-
-      # @private
-      MAX_LIMIT_VALUE = 9_223_372_036_854_775_807
-
-      def visit_Arel_Nodes_UpdateStatement(*args) # [o] AR <= 4.0 [o, a] on 4.1
-        o = args.first
-        if o.orders.any? && o.limit.nil?
-          o.limit = Nodes::Limit.new(MAX_LIMIT_VALUE)
-        end
-        super
-      end
-
-      def visit_Arel_Nodes_Top o, a = nil
-        # `top` wouldn't really work here:
-        #   User.select("distinct first_name").limit(10)
-        # would generate "select top 10 distinct first_name from users",
-        # which is invalid should be "select distinct top 10 first_name ..."
-        a || ''
-      end
-
-      private
-
-      def self.possibly_private_method_defined?(name)
-        private_method_defined?(name) || method_defined?(name)
-      end
-
-      def select_count? x
-        x.projections.length == 1 && Arel::Nodes::Count === x.projections.first
-      end unless possibly_private_method_defined? :select_count?
-
-      def determine_order_by x, a
-        unless x.groups.empty?
-          do_visit_columns x.groups, a, 'ORDER BY '
-        else
-          table_pk = find_left_table_pk(x)
-          table_pk && "ORDER BY #{table_pk}"
-        end
-      end
-
-      def find_left_table_pk o
-        primary_key_from_table table_from_select_core(o)
-      end
-
-      def do_visit_columns(colls, a, sql)
-        last = colls.size - 1
-        colls.each_with_index do |x, i|
-          sql << do_visit(x, a); sql << ', ' unless i == last
-        end
-        sql
-      end
-
-      def do_visit_columns(colls, a, sql)
-        prefix = sql
-        sql = Arel::Collectors::PlainString.new
-        sql << prefix if prefix
-
-        last = colls.size - 1
-        colls.each_with_index do |x, i|
-          visit(x, sql); sql << ', ' unless i == last
-        end
-        sql.value
-      end
-
-      def over_row_num order_by
-        "ROW_NUMBER() OVER (#{order_by}) as _row_num"
-      end # unless possibly_private_method_defined? :row_num_literal
-
-      def table_from_select_core core
-        if Arel::Table === core.from
-          core.from
-        elsif Arel::Nodes::SqlLiteral === core.from
-          Arel::Table.new(core.from, @engine)
-        elsif Arel::Nodes::JoinSource === core.source
-          Arel::Nodes::SqlLiteral === core.source.left ? Arel::Table.new(core.source.left, @engine) : core.source.left
-        end
-      end
-
-      def primary_key_from_table t
-        return unless t
-        return t.primary_key if t.primary_key
-
-        engine = t.engine
-        if engine_pk = engine.primary_key
-          pk = engine.arel_table[engine_pk]
-          return pk if pk
-        end
-
-        pk = (@primary_keys ||= {}).fetch(table_name = engine.table_name) do
-          pk_name = @connection.primary_key(table_name)
-          # some tables might be without primary key
-          @primary_keys[table_name] = pk_name && t[pk_name]
-        end
-        return pk if pk
-
-        column_name = engine.columns.first.try(:name)
-        column_name && t[column_name]
-      end
-
-      include ArJdbc::MSSQL::LockMethods
-
-      include ArJdbc::MSSQL::LimitHelpers::SqlServerReplaceLimitOffset
-
-    end
-
-    class SQLServer2000 < SQLServer
-      include ArJdbc::MSSQL::LimitHelpers::SqlServer2000ReplaceLimitOffset
-    end
-
-    load 'arel/visitors/sql_server/ng42.rb'
-
-  end
-end