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

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6590c4d705c35e5a4849e4ef0bb076efba93509b8bcd8b4c2db49a4bc84b0f31
-  data.tar.gz: cb87d9f9f2763b178f990359efecb6b1199cbe15866460bb837232fcdd8b75e1
+  metadata.gz: 973f3cfa750c3424b5de9105f177584edea8ebe705d50b20e4b9f6d989a4919f
+  data.tar.gz: e7f86bfeb49f90f2767e3bdcc3e0101a58149e97421e8d7b96da8f59fc469959
 SHA512:
-  metadata.gz: 511e55410d149724a0765b5494a15ca4fe493bbd36b969a587d7bab23458cb32a45d34c01f79ca8b170b7f1e86fdf58e81bc4ba3ea15d464fe954a8266c41743
-  data.tar.gz: 9fdfe69ab63373f8e31cd2d60f5ae88fd3f4499250010aab4ffbeabb9c9345f017bb012932598a84297bd63d8b28f5bc38d18213f95b19b3307a93f38ecfc775
+  metadata.gz: f276911281e38f162526b603959f5798fa5d09c73284a79078376126b5fade87add2e4a4345242029a4b4e39097b5a6964651483576f51ed8bee3ac7b6e586a3
+  data.tar.gz: 8e5d458add630631bfaa82605f20d28c80310e25787c9db2c94c1b8cc677ac8ff6e0730c97b6271a333cbfe919da8a35ad8deb7911aeedc89c3021629e0c5370

data/.github/workflows/ruby.yml

@@ -27,7 +27,7 @@ jobs:
         ruby-version: ['jruby-head']
         db: ['mysql2']
         test_targets: ["rails:test_mysql2"]
-        ar_version: ["7-1-stable"]
+        ar_version: ["7-2-stable"]
         prepared_statements: ['false', 'true']
         driver: ['MySQL']
 
@@ -42,7 +42,7 @@ jobs:
       AR_VERSION: ${{ matrix.ar_version }}
       PREPARED_STATEMENTS: ${{ matrix.prepared_statements }}
       DRIVER: ${{ matrix.driver }}
-      JRUBY_OPTS: "-J-Xms64M -J-Xmx1024M"
+      JRUBY_OPTS: "-J-Xms64M -J-Xmx1024M --dev"
 
     steps:
       - uses: actions/checkout@v4
@@ -79,7 +79,7 @@ jobs:
         ruby-version: [ 'jruby-head' ]
         db: [ 'postgresql' ]
         test_targets: [ "rails:test_postgresql" ]
-        ar_version: ["7-1-stable"]
+        ar_version: ["7-2-stable"]
         prepared_statements: [ 'false', 'true' ]
 
     services:
@@ -95,7 +95,7 @@ jobs:
     env:
       DB: ${{ matrix.db }}
       AR_VERSION: ${{ matrix.ar_version }}
-      JRUBY_OPTS: "-J-Xms64M -J-Xmx1024M"
+      JRUBY_OPTS: "-J-Xms64M -J-Xmx1024M --dev"
       PREPARED_STATEMENTS: ${{ matrix.prepared_statements }}
       PGHOST: localhost
       PGPORT: 5432
@@ -129,12 +129,12 @@ jobs:
         ruby-version: ['jruby-head']
         db: ['sqlite3']
         test_targets: ["rails:test_sqlite3"]
-        ar_version: ["7-1-stable", "main"]
+        ar_version: ["7-2-stable"]
 
     env:
       DB: ${{ matrix.db }}
       AR_VERSION: ${{ matrix.ar_version }}
-      JRUBY_OPTS: "-J-Xms64M -J-Xmx1024M"
+      JRUBY_OPTS: "-J-Xms64M -J-Xmx1024M --dev"
 
     steps:
       - uses: actions/checkout@v4
@@ -149,7 +149,7 @@ jobs:
           rake jar # compiles ext generates: lib/arjdbc/jdbc/adapter_java.jar
       - name: Run tests
         run: |
-          bundle exec rake ${{ matrix.test_targets }}
+          bundle exec rake ${{ matrix.test_targets }} --trace
 
   test-arjdbc-mysql:
 
@@ -173,7 +173,7 @@ jobs:
     env:
       DB: ${{ matrix.db }}
       DRIVER: ${{ matrix.driver }}
-      JRUBY_OPTS: "-J-Xms64M -J-Xmx1024M"
+      JRUBY_OPTS: "-J-Xms64M -J-Xmx1024M --dev"
       MY_USER: root
       MY_PASSWORD: root
       PREPARED_STATEMENTS: ${{ matrix.prepared_statements }}
@@ -222,7 +222,7 @@ jobs:
     env:
       DB: ${{ matrix.db }}
       DRIVER: ${{ matrix.driver }}
-      JRUBY_OPTS: "-J-Xms64M -J-Xmx1024M"
+      JRUBY_OPTS: "-J-Xms64M -J-Xmx1024M --dev"
       PREPARED_STATEMENTS: ${{ matrix.prepared_statements }}
       INSERT_RETURNING: ${{ matrix.insert_returning }}
       PGHOST: localhost

data/Gemfile

@@ -62,13 +62,13 @@ group :test do
   gem 'mocha', '~> 1.2', require: false # Rails has '~> 0.14'
 
   gem 'bcrypt', '~> 3.1.11', require: false
-  gem 'jdbc-mssql', '~> 12.2', require: nil
+  gem 'jdbc-mssql', '~> 12.6', require: nil
   # gem 'pry-debugger-jruby', platform: :jruby
 end
 
 group :rails do
   group :test do
-    gem 'minitest', require: nil
+    gem 'minitest', '~> 5.24.0', require: nil
     gem 'minitest-excludes', require: nil
     gem 'minitest-rg', require: nil
 

data/README.md

@@ -145,9 +145,10 @@ Versions are targeted at certain versions of Rails and live on their own branche
 | 60.x        | 6.0.x         | 60-stable | 9.2.7     | 8        |
 | 61.x        | 6.1.x         | 61-stable | 9.2.7     | 8        |
 | 70.x        | 7.0.x         | 70-stable | 9.3.0     | 8        |
-| 71.x        | 7.1.x         | master    | 9.4.3     | 8        |
+| 71.x        | 7.1.x         | 71-stable | 9.4.3     | 8        |
+| 72.x        | 7.2.x         | master    | 9.4.3     | 8        |
 
-Note: 71.x is still under development and not supported yet.
+Note: 72.x is still under development and not supported yet.
 
 Note that JRuby 9.1.x and JRuby 9.2.x are at end-of-life. We recommend Java 8
 at a minimum for all versions.

data/lib/arel/visitors/sqlserver.rb

@@ -241,8 +241,21 @@ module Arel
 
         # column_name = schema_cache.primary_keys(t.name) || column_cache(t.name).first.try(:second).try(:name)
         # NOTE: for table name aliases columns_hash('table_alias')  requires to return an empty hash.
-        column_name = @connection.schema_cache.primary_keys(t.name) ||
-          @connection.schema_cache.columns_hash(t.name).first.try(:second).try(:name)
+        primary_keys = @connection.schema_cache.primary_keys(t.name)
+        column_name = nil
+
+        case primary_keys
+        when NilClass
+          column_name = @connection.schema_cache.columns_hash(t.name).first.try(:second).try(:name)
+        when String
+          column_name = primary_keys
+        when Array
+          candidate_columns = @connection.schema_cache.columns_hash(t.name).slice(*primary_keys).values
+          candidate_column = candidate_columns.find(&:identity?)
+          candidate_column ||= candidate_columns.first
+          column_name = candidate_column.try(:name)
+        end
+
         column_name ? t[column_name] : nil
       end
 

data/lib/arjdbc/abstract/connection_management.rb

@@ -46,13 +46,12 @@ module ArJdbc
       end
 
       def reconnect
-        if active?
-          @raw_connection.rollback rescue nil
-        else
-          connect
-        end
-      end
+        @raw_connection&.close
+
+        @raw_connection = nil
 
+        connect
+      end
     end
   end
 end

data/lib/arjdbc/abstract/database_statements.rb

@@ -78,18 +78,6 @@ module ArJdbc
       end
       alias :exec_delete :exec_update
 
-      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
-
-        mark_transaction_written_if_write(sql)
-
-        raw_execute(sql, name, async: async, allow_retry: allow_retry, materialize_transactions: materialize_transactions)
-      end
-
       # overridden to support legacy binds
       def select_all(arel, name = nil, binds = NO_BINDS, preparable: nil, async: false)
         binds = convert_legacy_binds_to_attributes(binds) if binds.first.is_a?(Array)
@@ -107,7 +95,9 @@ module ArJdbc
       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)
+            result = conn.execute(sql)
+            verified!
+            result
           end
         end
       end

data/lib/arjdbc/abstract/relation_query_attribute_monkey_patch.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "active_model/attribute"
+
+module ActiveRecord
+  # NOTE: improved implementation for hash methods that is used to
+  # compare objects. AR and arel commonly use `[a, b] - [b]` operations and
+  # JRuby internally uses the hash method to implement that operation,
+  # on the other hand, CRuby does not use the hash method
+  # for small arrays (length <= 16).
+  class Relation
+    # monkey patch
+    module RelationQueryAttributeMonkeyPatch
+      def hash
+        # [self.class, name, value_for_database, type].hash
+        [self.class, name, value_before_type_cast, type].hash
+      end
+    end
+
+    class QueryAttribute
+      prepend RelationQueryAttributeMonkeyPatch
+    end
+  end
+end

data/lib/arjdbc/mssql/adapter.rb

@@ -30,6 +30,8 @@ require 'arjdbc/mssql/errors'
 require 'arjdbc/mssql/schema_creation'
 require 'arjdbc/mssql/database_limits'
 
+require "arjdbc/abstract/relation_query_attribute_monkey_patch"
+
 module ActiveRecord
   module ConnectionAdapters
     # MSSQL (SQLServer) adapter class definition

data/lib/arjdbc/mssql.rb

@@ -6,4 +6,4 @@ module ArJdbc
   MsSQL = MSSQL # compatibility with 1.2
 end
 
-ArJdbc.warn_unsupported_adapter 'mssql', [7, 0] # warns on AR >= 4.2
+ArJdbc.warn_unsupported_adapter 'mssql', [7, 1] # warns on AR >= 4.2

data/lib/arjdbc/mysql/adapter.rb

@@ -11,6 +11,8 @@ require 'arjdbc/abstract/database_statements'
 require 'arjdbc/abstract/statement_cache'
 require 'arjdbc/abstract/transaction_support'
 
+require "arjdbc/abstract/relation_query_attribute_monkey_patch"
+
 module ActiveRecord
   module ConnectionAdapters
     AbstractMysqlAdapter.class_eval do

data/lib/arjdbc/postgresql/adapter.rb

@@ -22,10 +22,13 @@ require 'arjdbc/abstract/transaction_support'
 require 'arjdbc/postgresql/base/array_decoder'
 require 'arjdbc/postgresql/base/array_encoder'
 require 'arjdbc/postgresql/name'
+require 'arjdbc/postgresql/database_statements'
 require 'arjdbc/postgresql/schema_statements'
 
 require 'active_model'
 
+require "arjdbc/abstract/relation_query_attribute_monkey_patch"
+
 module ArJdbc
   # Strives to provide Rails built-in PostgreSQL adapter (API) compatibility.
   module PostgreSQL
@@ -120,7 +123,8 @@ module ArJdbc
       citext:       { name: 'citext' },
       date:         { name: 'date' },
       daterange:    { name: 'daterange' },
-      datetime:     { name: 'timestamp' },
+      datetime:     {}, # set dynamically based on datetime_type
+      timestamptz:  { name: 'timestamptz' },
       decimal:      { name: 'decimal' }, # :limit => 1000
       float:        { name: 'float' },
       hstore:       { name: 'hstore' },
@@ -150,17 +154,10 @@ module ArJdbc
       tstzrange:    { name: 'tstzrange' },
       tsvector:     { name: 'tsvector' },
       uuid:         { name: 'uuid' },
-      xml:          { name: 'xml' }
+      xml:          { name: 'xml' },
+      enum:         {} # special type https://www.postgresql.org/docs/current/datatype-enum.html
     }
 
-    def native_database_types
-      NATIVE_DATABASE_TYPES
-    end
-
-    def valid_type?(type)
-      !native_database_types[type].nil?
-    end
-
     def set_standard_conforming_strings
       execute("SET standard_conforming_strings = on", "SCHEMA")
     end
@@ -232,10 +229,18 @@ module ArJdbc
     alias supports_insert_on_duplicate_update? supports_insert_on_conflict?
     alias supports_insert_conflict_target? supports_insert_on_conflict?
 
+    def supports_virtual_columns?
+      database_version >= 12_00_00 # >= 12.0
+    end
+
     def supports_identity_columns? # :nodoc:
       database_version >= 10_00_00 # >= 10.0
     end
 
+    def supports_nulls_not_distinct?
+      database_version >= 15_00_00 # >= 15.0
+    end
+
     def index_algorithms
       { concurrently: 'CONCURRENTLY' }
     end
@@ -335,33 +340,100 @@ module ArJdbc
     # Returns a list of defined enum types, and their values.
     def enum_types
       query = <<~SQL
-          SELECT
-            type.typname AS name,
-            string_agg(enum.enumlabel, ',' ORDER BY enum.enumsortorder) AS value
-          FROM pg_enum AS enum
-          JOIN pg_type AS type
-            ON (type.oid = enum.enumtypid)
-          GROUP BY type.typname;
+        SELECT
+          type.typname AS name,
+          type.OID AS oid,
+          n.nspname AS schema,
+          string_agg(enum.enumlabel, ',' ORDER BY enum.enumsortorder) AS value
+        FROM pg_enum AS enum
+        JOIN pg_type AS type ON (type.oid = enum.enumtypid)
+        JOIN pg_namespace n ON type.typnamespace = n.oid
+        WHERE n.nspname = ANY (current_schemas(false))
+        GROUP BY type.OID, n.nspname, type.typname;
       SQL
-      exec_query(query, "SCHEMA").cast_values
+
+      internal_exec_query(query, "SCHEMA", allow_retry: true, materialize_transactions: false).cast_values.each_with_object({}) do |row, memo|
+        name, schema = row[0], row[2]
+        schema = nil if schema == current_schema
+        full_name = [schema, name].compact.join(".")
+        memo[full_name] = row.last
+      end.to_a
     end
 
     # Given a name and an array of values, creates an enum type.
-    def create_enum(name, values)
-      sql_values = values.map { |s| "'#{s}'" }.join(", ")
+    def create_enum(name, values, **options)
+      sql_values = values.map { |s| quote(s) }.join(", ")
+      scope = quoted_scope(name)
       query = <<~SQL
-          DO $$
-          BEGIN
-              IF NOT EXISTS (
-                SELECT 1 FROM pg_type t
-                WHERE t.typname = '#{name}'
-              ) THEN
-                  CREATE TYPE \"#{name}\" AS ENUM (#{sql_values});
-              END IF;
-          END
-          $$;
+        DO $$
+        BEGIN
+            IF NOT EXISTS (
+              SELECT 1
+              FROM pg_type t
+              JOIN pg_namespace n ON t.typnamespace = n.oid
+              WHERE t.typname = #{scope[:name]}
+                AND n.nspname = #{scope[:schema]}
+            ) THEN
+                CREATE TYPE #{quote_table_name(name)} AS ENUM (#{sql_values});
+            END IF;
+        END
+        $$;
       SQL
-      exec_query(query)
+
+      internal_exec_query(query).tap { reload_type_map }
+    end
+
+    # Drops an enum type.
+    #
+    # If the <tt>if_exists: true</tt> option is provided, the enum is dropped
+    # only if it exists. Otherwise, if the enum doesn't exist, an error is
+    # raised.
+    #
+    # The +values+ parameter will be ignored if present. It can be helpful
+    # to provide this in a migration's +change+ method so it can be reverted.
+    # In that case, +values+ will be used by #create_enum.
+    def drop_enum(name, values = nil, **options)
+      query = <<~SQL
+        DROP TYPE#{' IF EXISTS' if options[:if_exists]} #{quote_table_name(name)};
+      SQL
+      internal_exec_query(query).tap { reload_type_map }
+    end
+
+    # Rename an existing enum type to something else.
+    def rename_enum(name, options = {})
+      to = options.fetch(:to) { raise ArgumentError, ":to is required" }
+
+      exec_query("ALTER TYPE #{quote_table_name(name)} RENAME TO #{to}").tap { reload_type_map }
+    end
+
+    # Add enum value to an existing enum type.
+    def add_enum_value(type_name, value, options = {})
+      before, after = options.values_at(:before, :after)
+      sql = +"ALTER TYPE #{quote_table_name(type_name)} ADD VALUE '#{value}'"
+
+      if before && after
+        raise ArgumentError, "Cannot have both :before and :after at the same time"
+      elsif before
+        sql << " BEFORE '#{before}'"
+      elsif after
+        sql << " AFTER '#{after}'"
+      end
+
+      execute(sql).tap { reload_type_map }
+    end
+
+    # Rename enum value on an existing enum type.
+    def rename_enum_value(type_name, options = {})
+      unless database_version >= 10_00_00 # >= 10.0
+        raise ArgumentError, "Renaming enum values is only supported in PostgreSQL 10 or later"
+      end
+
+      from = options.fetch(:from) { raise ArgumentError, ":from is required" }
+      to = options.fetch(:to) { raise ArgumentError, ":to is required" }
+
+      execute("ALTER TYPE #{quote_table_name(type_name)} RENAME VALUE '#{from}' TO '#{to}'").tap {
+        reload_type_map
+      }
     end
 
     # Returns the configured supported identifier length supported by PostgreSQL
@@ -455,11 +527,6 @@ module ArJdbc
       execute(combine_multi_statements(statements), name)
     end
 
-    def explain(arel, binds = [])
-      sql, binds = to_sql_and_binds(arel, binds)
-      ActiveRecord::ConnectionAdapters::PostgreSQL::ExplainPrettyPrinter.new.pp(exec_query("EXPLAIN #{sql}", 'EXPLAIN', binds))
-    end
-
     # from ActiveRecord::ConnectionAdapters::PostgreSQL::DatabaseStatements
     READ_QUERY = ActiveRecord::ConnectionAdapters::AbstractAdapter.build_read_query_regexp(
       :close, :declare, :fetch, :move, :set, :show
@@ -493,6 +560,16 @@ module ArJdbc
       end
     end
 
+    # Disconnects from the database if already connected. Otherwise, this
+    # method does nothing.
+    def disconnect!
+      @lock.synchronize do
+        super
+        @raw_connection&.close
+        @raw_connection = nil
+      end
+    end
+
     def default_sequence_name(table_name, pk = "id") #:nodoc:
       serial_sequence(table_name, pk)
     rescue ActiveRecord::StatementInvalid
@@ -608,17 +685,19 @@ module ArJdbc
     #  - format_type includes the column size constraint, e.g. varchar(50)
     #  - ::regclass is a function that gives the id for a table name
     def column_definitions(table_name)
-      select_rows(<<~SQL, 'SCHEMA')
-        SELECT a.attname, format_type(a.atttypid, a.atttypmod),
-               pg_get_expr(d.adbin, d.adrelid), a.attnotnull, a.atttypid, a.atttypmod,
-               c.collname, col_description(a.attrelid, a.attnum) AS comment
-          FROM pg_attribute a
-          LEFT JOIN pg_attrdef d ON a.attrelid = d.adrelid AND a.attnum = d.adnum
-          LEFT JOIN pg_type t ON a.atttypid = t.oid
-          LEFT JOIN pg_collation c ON a.attcollation = c.oid AND a.attcollation <> t.typcollation
-         WHERE a.attrelid = #{quote(quote_table_name(table_name))}::regclass
-           AND a.attnum > 0 AND NOT a.attisdropped
-         ORDER BY a.attnum
+      query(<<~SQL, "SCHEMA")
+          SELECT a.attname, format_type(a.atttypid, a.atttypmod),
+                 pg_get_expr(d.adbin, d.adrelid), a.attnotnull, a.atttypid, a.atttypmod,
+                 c.collname, col_description(a.attrelid, a.attnum) AS comment,
+                 #{supports_identity_columns? ? 'attidentity' : quote('')} AS identity,
+                 #{supports_virtual_columns? ? 'attgenerated' : quote('')} as attgenerated
+            FROM pg_attribute a
+            LEFT JOIN pg_attrdef d ON a.attrelid = d.adrelid AND a.attnum = d.adnum
+            LEFT JOIN pg_type t ON a.atttypid = t.oid
+            LEFT JOIN pg_collation c ON a.attcollation = c.oid AND a.attcollation <> t.typcollation
+           WHERE a.attrelid = #{quote(quote_table_name(table_name))}::regclass
+             AND a.attnum > 0 AND NOT a.attisdropped
+           ORDER BY a.attnum
       SQL
     end
 
@@ -633,22 +712,27 @@ module ArJdbc
 
     # Pulled from ActiveRecord's Postgres adapter and modified to use execute
     def can_perform_case_insensitive_comparison_for?(column)
-      @case_insensitive_cache ||= {}
-      @case_insensitive_cache[column.sql_type] ||= begin
-        sql = <<~SQL
-          SELECT exists(
-            SELECT * FROM pg_proc
-            WHERE proname = 'lower'
-              AND proargtypes = ARRAY[#{quote column.sql_type}::regtype]::oidvector
-          ) OR exists(
-            SELECT * FROM pg_proc
-            INNER JOIN pg_cast
-              ON ARRAY[casttarget]::oidvector = proargtypes
-            WHERE proname = 'lower'
-              AND castsource = #{quote column.sql_type}::regtype
-          )
-        SQL
-        select_value(sql, 'SCHEMA')
+      # NOTE: citext is an exception. It is possible to perform a
+      #       case-insensitive comparison using `LOWER()`, but it is
+      #       unnecessary, as `citext` is case-insensitive by definition.
+      @case_insensitive_cache ||= { "citext" => false }
+      @case_insensitive_cache.fetch(column.sql_type) do
+        @case_insensitive_cache[column.sql_type] = begin
+          sql = <<~SQL
+            SELECT exists(
+              SELECT * FROM pg_proc
+              WHERE proname = 'lower'
+                AND proargtypes = ARRAY[#{quote column.sql_type}::regtype]::oidvector
+            ) OR exists(
+              SELECT * FROM pg_proc
+              INNER JOIN pg_cast
+                ON ARRAY[casttarget]::oidvector = proargtypes
+              WHERE proname = 'lower'
+                AND castsource = #{quote column.sql_type}::regtype
+            )
+          SQL
+          select_value(sql, 'SCHEMA')
+        end
       end
     end
 
@@ -657,6 +741,8 @@ module ArJdbc
 
       # TODO: Can we base these on an error code of some kind?
       case exception.message
+      when /could not create unique index/
+        ::ActiveRecord::RecordNotUnique.new(message, sql: sql, binds: binds, connection_pool: @pool)
       when /duplicate key value violates unique constraint/
         ::ActiveRecord::RecordNotUnique.new(message, sql: sql, binds: binds)
       when /violates not-null constraint/
@@ -675,7 +761,9 @@ module ArJdbc
         ::ActiveRecord::LockWaitTimeout.new(message, sql: sql, binds: binds)
       when /canceling statement/ # This needs to come after lock timeout because the lock timeout message also contains "canceling statement"
         ::ActiveRecord::QueryCanceled.new(message, sql: sql, binds: binds)
-      when /relation "animals" does not exist/i
+      when /relation .* does not exist/i
+        ::ActiveRecord::StatementInvalid.new(message, sql: sql, binds: binds, connection_pool: @pool)
+      when /syntax error at or near/i
         ::ActiveRecord::StatementInvalid.new(message, sql: sql, binds: binds, connection_pool: @pool)
       else
         super
@@ -770,6 +858,7 @@ module ActiveRecord::ConnectionAdapters
 
     require 'arjdbc/postgresql/oid_types'
     include ::ArJdbc::PostgreSQL::OIDTypes
+    include ::ArJdbc::PostgreSQL::DatabaseStatements
     include ::ArJdbc::PostgreSQL::SchemaStatements
 
     include ::ArJdbc::PostgreSQL::ColumnHelpers
@@ -787,6 +876,25 @@ module ActiveRecord::ConnectionAdapters
       def new_client(conn_params, adapter_instance)
         jdbc_connection_class.new(conn_params, adapter_instance)
       end
+
+      def dbconsole(config, options = {})
+        pg_config = config.configuration_hash
+
+        ENV["PGUSER"]         = pg_config[:username] if pg_config[:username]
+        ENV["PGHOST"]         = pg_config[:host] if pg_config[:host]
+        ENV["PGPORT"]         = pg_config[:port].to_s if pg_config[:port]
+        ENV["PGPASSWORD"]     = pg_config[:password].to_s if pg_config[:password] && options[:include_password]
+        ENV["PGSSLMODE"]      = pg_config[:sslmode].to_s if pg_config[:sslmode]
+        ENV["PGSSLCERT"]      = pg_config[:sslcert].to_s if pg_config[:sslcert]
+        ENV["PGSSLKEY"]       = pg_config[:sslkey].to_s if pg_config[:sslkey]
+        ENV["PGSSLROOTCERT"]  = pg_config[:sslrootcert].to_s if pg_config[:sslrootcert]
+        if pg_config[:variables]
+          ENV["PGOPTIONS"] = pg_config[:variables].filter_map do |name, value|
+            "-c #{name}=#{value.to_s.gsub(/[ \\]/, '\\\\\0')}" unless value == ":default" || value == :default
+          end.join(" ")
+        end
+        find_cmd_and_exec("psql", config.database)
+      end
     end
 
     def initialize(...)
@@ -822,6 +930,18 @@ module ActiveRecord::ConnectionAdapters
     public :sql_for_insert
     alias :postgresql_version :database_version
 
+    def native_database_types # :nodoc:
+      self.class.native_database_types
+    end
+
+    def self.native_database_types # :nodoc:
+      @native_database_types ||= begin
+        types = NATIVE_DATABASE_TYPES.dup
+        types[:datetime] = types[datetime_type]
+        types
+      end
+    end
+
     private
 
     FEATURE_NOT_SUPPORTED = "0A000" # :nodoc:

data/lib/arjdbc/postgresql/database_statements.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module ArJdbc
+  module PostgreSQL
+    module DatabaseStatements
+      def explain(arel, binds = [], options = [])
+        sql    = build_explain_clause(options) + " " + to_sql(arel, binds)
+
+        result = internal_exec_query(sql, "EXPLAIN", binds)
+        ActiveRecord::ConnectionAdapters::PostgreSQL::ExplainPrettyPrinter.new.pp(result)
+      end
+
+      def build_explain_clause(options = [])
+        return "EXPLAIN" if options.empty?
+
+        "EXPLAIN (#{options.join(", ").upcase})"
+      end
+    end
+  end
+end

data/lib/arjdbc/sqlite3/adapter.rb

@@ -18,6 +18,8 @@ require "active_record/connection_adapters/sqlite3/schema_statements"
 require "active_support/core_ext/class/attribute"
 require "arjdbc/sqlite3/column"
 
+require "arjdbc/abstract/relation_query_attribute_monkey_patch"
+
 module SQLite3
   module Constants
     module Open
@@ -669,6 +671,14 @@ module ArJdbc
       StatementPool.new(self.class.type_cast_config_to_integer(@config[:statement_limit]))
     end
 
+    def reconnect
+      if active?
+        @raw_connection.rollback rescue nil
+      else
+        connect
+      end
+    end
+
     def configure_connection
       if @config[:timeout] && @config[:retries]
         raise ArgumentError, "Cannot specify both timeout and retries arguments"

data/lib/arjdbc/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-jdbc-alt-adapter
 version: !ruby/object:Gem::Version
-  version: 71.0.0.alpha2
+  version: 71.0.0
 platform: java
 authors:
 - Nick Sieger, Ola Bini, Karol Bucek, Jesse Chavez, and JRuby contributors
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-08-06 00:00:00.000000000 Z
+date: 2025-01-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
@@ -78,6 +78,7 @@ files:
 - lib/arjdbc/abstract/connection_management.rb
 - lib/arjdbc/abstract/core.rb
 - lib/arjdbc/abstract/database_statements.rb
+- lib/arjdbc/abstract/relation_query_attribute_monkey_patch.rb
 - lib/arjdbc/abstract/statement_cache.rb
 - lib/arjdbc/abstract/transaction_support.rb
 - lib/arjdbc/discover.rb
@@ -143,6 +144,7 @@ files:
 - lib/arjdbc/postgresql/base/pgconn.rb
 - lib/arjdbc/postgresql/column.rb
 - lib/arjdbc/postgresql/connection_methods.rb
+- lib/arjdbc/postgresql/database_statements.rb
 - lib/arjdbc/postgresql/name.rb
 - lib/arjdbc/postgresql/oid_types.rb
 - lib/arjdbc/postgresql/schema_statements.rb
@@ -229,9 +231,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubygems_version: 3.3.26
 signing_key: