activerecord-jdbc-alt-adapter 72.1.0-java → 80.0.0.rc1-java

data/Rakefile

@@ -5,6 +5,21 @@
 #
 # Environment variables used by this Rakefile:
 #
+# DBS
+#   Limits the command performed to only work for one of the database
+#   types listed in this env var. You can set to a combination of mysql, 
+#   postgres, or sqlite, separated by commas. For example:
+#
+#    mysql,postgres,sqlite
+#
+#    You may use pg or postgres as aliases for postgresql
+#    You may use sqlite3 as an alias for sqlite
+#    You may use all to mean all three
+#
+#    NOTE: if you ever want to add a new type of database to be released,
+#          just fix up this documentation, the error string in invalid_dbs,
+#          and add it to the ALL_DBS array. Everything else should just work!
+#
 # INCLUDE_JAR_IN_GEM [default task - false, other taks - true]:
 #   Note: This is something you should not normally have to set.
 #   For local development we always will end up including the jar file
@@ -85,6 +100,12 @@ end
 
 desc "Releasing AR-JDBC gems (use NOOP=true to disable gem pushing)"
 task 'release:do' do
+  unless ENV["DBS"]
+    puts "you must explicitly provide a DBS env var when calling release:do. An empty one will not default to 'all' " \
+           "for this command\n\n"
+    invalid_dbs!
+  end
+
   Rake::Task['build'].invoke
   # Rake::Task['build:adapters'].invoke
 
@@ -107,8 +128,41 @@ task 'release:push' do
   sh "for gem in `ls pkg/*-#{current_version.call}-java.gem`; do gem push $gem; done"
 end
 
-ADAPTERS = %w[mysql postgresql sqlite3].map { |a| "activerecord-jdbc#{a}-adapter" }
-DRIVERS  = %w[mysql postgres sqlite3].map { |a| "jdbc-#{a}" }
+ALL_DBS = ["mysql", "postgresql", "sqlite3"]  #NOTE: if we add a new database type to be released, just add it here!
+DB_ALIASES = ALL_DBS.map {|db| [db, db]}.to_h.merge({
+  "pg" => "postgresql",
+  "postgres" => "postgresql",
+  "sqlite" => "sqlite3"
+})
+
+def invalid_dbs!
+  raise ArgumentError, "Invalid DBS env var\nThe DBS env var must be set to a combination of mysql, postgres, or " \
+                       "sqlite, separated by commas. For example:\n\nmysql,postgres,sqlite\n\nYou may use pg or " \
+                       "postgres as aliases for postgresql\nYou may use sqlite3 as an alias for sqlite\n" \
+                       "You may use all as a shortcut to listing them all out"
+end
+
+def make_db_list
+  env_dbs = ENV["DBS"]
+  return ALL_DBS if !env_dbs || env_dbs == "all"
+  requested = env_dbs.split(",").map(&:strip).reject(&:empty?).map(&:downcase)
+  invalid_dbs! unless requested.size > 0 && requested == requested.uniq
+
+  canonical = requested.map do |name|
+    DB_ALIASES.fetch(name) { invalid_dbs! }
+  end
+
+  invalid_dbs! unless canonical == canonical.uniq
+
+  canonical
+end
+
+db_list = make_db_list
+ADAPTERS = db_list.map { |db| "activerecord-jdbc#{db}-adapter" }
+
+db_list.map! {|db| db == 'postgresql' ? 'postgres' : db  }  #naming convention for DRIVERS
+DRIVERS  = db_list.map { |a| "jdbc-#{a}" }
+
 TARGETS = ( ADAPTERS + DRIVERS )
 
 ADAPTERS.each do |target|
@@ -185,7 +239,7 @@ if defined? JRUBY_VERSION
   #directory classes = 'pkg/classes'; CLEAN << classes
 
   file jar_file => FileList[ 'src/java/**/*.java' ] do
-    source = target = '1.8'; debug = true
+    source = target = '21'; debug = true
 
     get_driver_jars_local = lambda do |*args|
       driver_deps = args.empty? ? [ :Postgres, :MySQL ] : args
@@ -230,7 +284,7 @@ if defined? JRUBY_VERSION
           if match = requirement.match(/^jar\s+([\w\-\.]+):([\w\-]+),\s+?([\w\.\-]+)?/)
             matched_jar = Jars.send :to_jar, match[1], match[2], match[3], nil
             matched_jar = File.join( Jars.home, matched_jar )
-            matched_jars << matched_jar if File.exists?( matched_jar )
+            matched_jars << matched_jar if File.exist?( matched_jar )
           end
         end
         matched_jars
@@ -262,18 +316,12 @@ if defined? JRUBY_VERSION
     end
 
     classpath = []
-    [ 'java.class.path', 'sun.boot.class.path' ].map { |key| ENV_JAVA[key] }.each do |v|
-      classpath += v.split(File::PATH_SEPARATOR).find_all { |jar| jar =~ /jruby/i } if v
-    end
-    # Using Java 9+.  Let's try and infer jruby.jar location from rbconfig
-    if classpath.empty?; require 'rbconfig'
-      libdir = RbConfig::CONFIG['libdir']
-      if libdir.start_with? 'classpath:'
-        error "Cannot build activerecord-jdbc with jruby-complete"
-      end
-      classpath << File.join(libdir, 'jruby.jar')
+    require 'rbconfig'
+    libdir = RbConfig::CONFIG['libdir']
+    if libdir.start_with? 'classpath:'
+      error "Cannot build activerecord-jdbc with jruby-complete"
     end
-    
+    classpath << File.join(libdir, 'jruby.jar')
     classpath += driver_jars
     classpath = classpath.compact.join(File::PATH_SEPARATOR)
 

data/activerecord-jdbc-adapter.gemspec

@@ -10,7 +10,7 @@ Gem::Specification.new do |gem|
   gem.homepage = 'https://github.com/jruby/activerecord-jdbc-adapter'
   gem.license = 'BSD-2-Clause'
   gem.summary = 'JDBC adapter for ActiveRecord, for use within JRuby on Rails.'
-  gem.description = "" <<
+  gem.description = +"" <<
     "AR-JDBC is a database adapter for Rails' ActiveRecord component " <<
     "designed to be used with JRuby built upon Java's JDBC API for " <<
     "database access. Provides (ActiveRecord) built-in adapters: MySQL,  " <<
@@ -41,7 +41,7 @@ Gem::Specification.new do |gem|
   gem.executables = gem.files.grep(%r{^bin/}).map { |f| File.basename(f) }
   gem.test_files = gem.files.grep(%r{^test/})
 
-  gem.add_dependency "activerecord", "~> 7.2.2"
+  gem.add_dependency "activerecord", "~> 8.0"
 
   #gem.add_development_dependency 'test-unit', '2.5.4'
   #gem.add_development_dependency 'test-unit-context', '>= 0.3.0'

data/activerecord-jdbc-alt-adapter.gemspec

@@ -43,7 +43,7 @@ Gem::Specification.new do |gem|
   gem.executables = gem.files.grep(%r{^bin/}).map { |f| File.basename(f) }
   gem.test_files = gem.files.grep(%r{^test/})
 
-  gem.add_dependency "activerecord", "~> 7.2.2"
+  gem.add_dependency "activerecord", "~> 8.0.0"
 
   #gem.add_development_dependency 'test-unit', '2.5.4'
   #gem.add_development_dependency 'test-unit-context', '>= 0.3.0'

data/lib/arjdbc/abstract/core.rb

@@ -56,23 +56,6 @@ module ArJdbc
           else super
         end
       end
-
-      # this version of log() automatically fills type_casted_binds from binds if necessary
-      def log(sql, name = "SQL", binds = [], type_casted_binds = [], statement_name = nil, async: false)
-        if binds.any? && (type_casted_binds.nil? || type_casted_binds.empty?)
-          type_casted_binds = lambda {
-            # extract_raw_bind_values
-            binds.map do |bind|
-              if bind.respond_to?(:value_for_database)
-                bind.value_for_database
-              else
-                bind
-              end
-            end
-          }
-        end
-        super
-      end
     end
   end
 

data/lib/arjdbc/abstract/database_statements.rb

@@ -10,8 +10,6 @@ module ArJdbc
       NO_BINDS = [].freeze
 
       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
@@ -20,11 +18,15 @@ module ArJdbc
 
         binds = convert_legacy_binds_to_attributes(binds) if binds.first.is_a?(Array)
 
+        type_casted_binds = type_casted_binds(binds)
+
         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
+            log(sql, name, binds, type_casted_binds) do
+              # TODO: the ideas is to pass type casted binds but dozens of tests fail
+              # conn.execute_insert_pk(sql, type_casted_binds, pk)
               conn.execute_insert_pk(sql, binds, pk)
             end
           end
@@ -34,8 +36,6 @@ module ArJdbc
       # It appears that at this point (AR 5.0) "prepare" should only ever be true
       # if prepared statements are enabled
       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
@@ -55,15 +55,13 @@ module ArJdbc
             log(sql, name, type_casted_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, type_casted_binds, cached_statement)
+              conn.execute_prepared_query(sql, binds, cached_statement)
             end
           end
         end
       end
 
       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
@@ -72,11 +70,17 @@ module ArJdbc
 
         binds = convert_legacy_binds_to_attributes(binds) if binds.first.is_a?(Array)
 
+        type_casted_binds = type_casted_binds(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) }
+            log(sql, name, binds, type_casted_binds) do
+              # TODO: the ideas is to pass type casted binds but some tests fail
+              # conn.execute_prepared_update(sql, type_casted_binds)
+              conn.execute_prepared_update(sql, binds)
+            end
           end
         end
       end
@@ -90,22 +94,21 @@ module ArJdbc
 
       private
 
+      def without_prepared_statement?(binds)
+        !prepared_statements || binds.empty?
+      end
+
       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
 
-      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|
-            result = conn.execute(sql)
-            verified!
-            result
-          end
-        end
+      def preprocess_query(sql)
+        check_if_write_query(sql) if respond_to?(:check_if_write_query, true)
+        mark_transaction_written_if_write(sql) if respond_to?(:mark_transaction_written_if_write, true)
+        sql
       end
-
     end
   end
 end

data/lib/arjdbc/mssql/adapter.rb

@@ -479,31 +479,31 @@ module ActiveRecord
       def translate_exception(exception, message:, sql:, binds:)
         case message
         when /no connection available/i
-          ConnectionNotEstablished.new(exception)
+          ConnectionNotEstablished.new(message, connection_pool: @pool)
         when /(cannot insert duplicate key .* with unique index) | (violation of unique key constraint)/i
-          RecordNotUnique.new(message, sql: sql, binds: binds)
+          RecordNotUnique.new(message, sql: sql, binds: binds, connection_pool: @pool)
         when /Violation of PRIMARY KEY constraint .* Cannot insert duplicate key in object .* The duplicate key value is/i
-          RecordNotUnique.new(message, sql: sql, binds: binds)
+          RecordNotUnique.new(message, sql: sql, binds: binds, connection_pool: @pool)
         when /Lock request time out period exceeded/i
           LockTimeout.new(message, sql: sql, binds: binds)
         when /The .* statement conflicted with the FOREIGN KEY constraint/
-          InvalidForeignKey.new(message, sql: sql, binds: binds)
+          InvalidForeignKey.new(message, sql: sql, binds: binds, connection_pool: @pool)
         when /Could not drop object .* because it is referenced by a FOREIGN KEY constraint/
-          StatementInvalid.new(message, sql: sql, binds: binds)
+          StatementInvalid.new(message, sql: sql, binds: binds, connection_pool: @pool)
         when /The .* statement conflicted with the REFERENCE constraint/
-          InvalidForeignKey.new(message, sql: sql, binds: binds)
+          InvalidForeignKey.new(message, sql: sql, binds: binds, connection_pool: @pool)
         when /(String or binary data would be truncated)/i
-          ValueTooLong.new(message, sql: sql, binds: binds)
+          ValueTooLong.new(message, sql: sql, binds: binds, connection_pool: @pool)
         when /Cannot insert the value NULL into column .* does not allow nulls/
-          NotNullViolation.new(message, sql: sql, binds: binds)
+          NotNullViolation.new(message, sql: sql, binds: binds, connection_pool: @pool)
         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)
+          StatementInvalid.new(message, sql: sql, binds: binds, connection_pool: @pool)
         when /Incorrect syntax near the keyword .*/
-          StatementInvalid.new(message, sql: sql, binds: binds)
+          StatementInvalid.new(message, sql: sql, binds: binds, connection_pool: @pool)
         when /Could not find stored procedure .*/
-          StatementInvalid.new(message, sql: sql, binds: binds)
+          StatementInvalid.new(message, sql: sql, binds: binds, connection_pool: @pool)
         else
           super
         end

data/lib/arjdbc/mssql/database_statements.rb

@@ -93,11 +93,7 @@ module ActiveRecord
         end
 
         def internal_exec_query(sql, name = 'SQL', binds = [], prepare: false, async: false, allow_retry: false)
-          sql = transform_query(sql)
-
-          check_if_write_query(sql)
-
-          mark_transaction_written_if_write(sql)
+          sql = preprocess_query(sql)
 
           # binds = convert_legacy_binds_to_attributes(binds) if binds.first.is_a?(Array)
 
@@ -105,7 +101,7 @@ module ActiveRecord
           type_casted_binds = type_casted_binds(binds)
           # puts "[2]internal----->sql: #{type_casted_binds.size}, binds: #{type_casted_binds}"
 
-          if without_prepared_statement?(binds)
+          if binds.nil? || binds.empty?
             log(sql, name) do
               with_raw_connection do |conn|
                 result = conditional_indentity_insert(sql) do
@@ -132,14 +128,12 @@ module ActiveRecord
         end
 
         def exec_update(sql, name = nil, binds = [])
-          sql = transform_query(sql)
+          sql = preprocess_query(sql)
 
-          check_if_write_query(sql)
-
-          mark_transaction_written_if_write(sql)
+          type_casted_binds = type_casted_binds(binds)
 
           # puts "exec_update----->sql: #{sql}, binds: #{binds}"
-          if without_prepared_statement?(binds)
+          if binds.nil? || binds.empty?
             log(sql, name) do
               with_raw_connection do |conn|
                 result = conn.execute_update(sql)
@@ -148,9 +142,9 @@ module ActiveRecord
               end
             end
           else
-            log(sql, name, binds) do
+            log(sql, name, binds, type_casted_binds) do
               with_raw_connection do |conn|
-                result = conn.execute_prepared_update(sql, binds)
+                result = conn.execute_prepared_update(sql, type_casted_binds)
                 verified!
                 result
               end
@@ -160,14 +154,12 @@ module ActiveRecord
         alias :exec_delete :exec_update
 
         def exec_insert(sql, name = nil, binds = [], pk = nil, sequence_name = nil, returning: nil)
-          sql = transform_query(sql)
+          sql = preprocess_query(sql)
 
-          check_if_write_query(sql)
-
-          mark_transaction_written_if_write(sql)
+          type_casted_binds = type_casted_binds(binds)
 
           # puts "exec_insert----->sql: #{sql}, binds: #{binds}"
-          if without_prepared_statement?(binds)
+          if binds.nil? || binds.empty?
             log(sql, name) do
               with_raw_connection do |conn|
                 result = conditional_indentity_insert(sql) do
@@ -178,12 +170,14 @@ module ActiveRecord
               end
             end
           else
-            log(sql, name, binds) do
+            log(sql, name, binds, type_casted_binds) do
               with_raw_connection do |conn|
                 result = conditional_indentity_insert(sql) do
                   # DEPRECATION WARNING: to_time will always preserve the timezone offset of the receiver in Rails 8.0.
                   # To opt in to the new behavior, set `ActiveSupport.to_time_preserves_timezone = true`.
                   # (called from block in execute_insert_pk
+                  # TODO: the ideas is to pass type casted binds but causes strange test failures
+                  # conn.execute_insert_pk(sql, type_casted_binds, pk)
                   conn.execute_insert_pk(sql, binds, pk)
                 end
                 verified!
@@ -195,15 +189,23 @@ module ActiveRecord
 
         private
 
-        def raw_execute(sql, name, async: false, allow_retry: false, materialize_transactions: true)
-          # puts "raw_execute----->sql: #{sql}"
-          log(sql, name, async: async) do
-            with_raw_connection(allow_retry: allow_retry, materialize_transactions: materialize_transactions) do |conn|
-              result = conditional_indentity_insert(sql) { conn.execute(sql) }
-              verified!
-              result
-            end
-          end
+        def cast_result(raw_result)
+          return ActiveRecord::Result.empty if raw_result.nil?
+
+          # nothing to cast here. the java part returns an AR Result
+          raw_result
+        end
+
+
+        def perform_query(raw_connection, sql, binds, type_casted_binds, prepare:, notification_payload:, batch:)
+          result = conditional_indentity_insert(sql) { raw_connection.execute(sql) }
+
+          count = 0
+          count = result.count if result.respond_to?(:count)
+
+          verified!
+          notification_payload[:row_count] = count
+          result
         end
 
         def sql_for_insert(sql, pk, binds, returning) # :nodoc:

data/lib/arjdbc/mssql/explain_support.rb

@@ -50,7 +50,12 @@ module ActiveRecord
                 end
 
           binds.each do |bind|
-            value = quote(bind.value_for_database)
+            value = if bind.is_a?(::ActiveModel::Attribute)
+                      quote(bind.value_for_database)
+                    else
+                      quote(bind)
+                    end
+
             sql = sql.sub('?', value)
           end
 

data/lib/arjdbc/mssql.rb

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

data/lib/arjdbc/postgresql/adapter.rb

@@ -219,6 +219,10 @@ module ArJdbc
       true
     end
 
+    def supports_native_partitioning?
+      database_version >= 100_000
+    end
+
     def supports_insert_returning?
       true
     end
@@ -953,7 +957,6 @@ module ActiveRecord::ConnectionAdapters
     FEATURE_NOT_SUPPORTED = "0A000" # :nodoc:
 
     def execute_and_clear(sql, name, binds, prepare: false, async: false)
-      sql = transform_query(sql)
       check_if_write_query(sql)
 
       if !prepare || without_prepared_statement?(binds)

data/lib/arjdbc/postgresql/database_statements.rb

@@ -15,6 +15,51 @@ module ArJdbc
 
         "EXPLAIN (#{options.join(", ").upcase})"
       end
+
+      private
+
+      def internal_exec_query(sql, name = nil, binds = [], prepare: false, async: false, allow_retry: false, materialize_transactions: true)
+          sql = preprocess_query(sql)
+
+        # puts "[1]internal----->sql: #{sql}, binds: #{binds}"
+        type_casted_binds = type_casted_binds(binds)
+        # puts "[2]internal----->sql: #{type_casted_binds.size}, binds: #{type_casted_binds}"
+
+        with_raw_connection do |conn|
+          if without_prepared_statement?(binds)
+            log(sql, name, async: async) { conn.execute_query(sql) }
+          else
+            log(sql, name, type_casted_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, type_casted_binds, cached_statement)
+            end
+          end
+        end
+      end
+
+      def perform_query(raw_connection, sql, binds, type_casted_binds, prepare:, notification_payload:, batch:)
+        result = raw_connection.execute(sql)
+
+        count = 0
+        count = result.count if result.respond_to?(:count)
+
+        verified!
+        notification_payload[:row_count] = count
+        result
+      end
+
+      def cast_result(raw_result)
+        return ActiveRecord::Result.empty if raw_result.nil?
+
+        fields = raw_result.fields
+
+        if fields.empty?
+          ActiveRecord::Result.empty
+        else
+          ActiveRecord::Result.new(fields, raw_result.values)
+        end
+      end
     end
   end
 end

data/lib/arjdbc/postgresql/schema_statements.rb

@@ -6,6 +6,23 @@ module ArJdbc
       ForeignKeyDefinition = ActiveRecord::ConnectionAdapters::ForeignKeyDefinition
       Utils = ActiveRecord::ConnectionAdapters::PostgreSQL::Utils
 
+      def decode_string_array(value)
+        return value if value.is_a?(Array)
+        _arjdbc_array_parser.parse_pg_array(value)
+      end
+
+      private
+
+      def _arjdbc_array_parser
+        @_arjdbc_array_parser ||= begin
+          obj = Object.new
+          obj.extend(ActiveRecord::ConnectionAdapters::PostgreSQL::ArrayParser)
+          obj
+        end
+      end
+
+      public
+
       def foreign_keys(table_name)
         scope = quoted_scope(table_name)
         fk_info = internal_exec_query(<<~SQL, "SCHEMA", allow_retry: true, materialize_transactions: false)

data/lib/arjdbc/sqlite3/adapter.rb

@@ -22,6 +22,8 @@ require "arjdbc/sqlite3/pragmas"
 
 require "arjdbc/abstract/relation_query_attribute_monkey_patch"
 
+require "arjdbc/sqlite3/database_statements"
+
 module SQLite3
   module Constants
     module Open
@@ -223,17 +225,29 @@ module ArJdbc
 
     # REFERENTIAL INTEGRITY ====================================
 
+    def execute_batch(statements, name = nil, **kwargs)
+      if statements.is_a?(Array)
+        # SQLite JDBC doesn't support multiple statements in one execute
+        # Execute each statement separately
+        statements.each do |sql|
+          raw_execute(sql, name, **kwargs.merge(batch: true))
+        end
+      else
+        raw_execute(statements, name, batch: true, **kwargs)
+      end
+    end
+
     def disable_referential_integrity # :nodoc:
       old_foreign_keys = query_value("PRAGMA foreign_keys")
       old_defer_foreign_keys = query_value("PRAGMA defer_foreign_keys")
 
       begin
-        execute("PRAGMA defer_foreign_keys = ON")
-        execute("PRAGMA foreign_keys = OFF")
+        execute("PRAGMA defer_foreign_keys = ON", "SCHEMA")
+        execute("PRAGMA foreign_keys = OFF", "SCHEMA")
         yield
       ensure
-        execute("PRAGMA defer_foreign_keys = #{old_defer_foreign_keys}")
-        execute("PRAGMA foreign_keys = #{old_foreign_keys}")
+        execute("PRAGMA defer_foreign_keys = #{old_defer_foreign_keys}", "SCHEMA")
+        execute("PRAGMA foreign_keys = #{old_foreign_keys}", "SCHEMA")
       end
     end
 
@@ -388,6 +402,24 @@ module ArJdbc
       end
     end
 
+    # Returns a list of defined virtual tables (for Rails 8 compatibility)
+    VIRTUAL_TABLE_REGEX = /USING\s+(\w+)(?:\s*\((.*)\))?/im
+    def virtual_tables
+      query = <<~SQL
+        SELECT name, sql FROM sqlite_master
+        WHERE type = 'table' AND sql LIKE 'CREATE VIRTUAL TABLE%';
+      SQL
+
+      exec_query(query, "SCHEMA").cast_values.each_with_object({}) do |(name, sql), memo|
+        match = sql.match(VIRTUAL_TABLE_REGEX)
+        next unless match
+
+        module_name = match[1]
+        arguments = match[2] || ""
+        memo[name] = [module_name, arguments.strip]
+      end.to_a
+    end
+
     def build_insert_sql(insert) # :nodoc:
       sql = +"INSERT #{insert.into} #{insert.values_list}"
 
@@ -791,7 +823,17 @@ module ArJdbc
       DEFAULT_PRAGMAS.merge(pragmas).each do |pragma, value|
         if ::SQLite3::Pragmas.respond_to?(pragma)
           stmt = ::SQLite3::Pragmas.public_send(pragma, value)
-          raw_execute(stmt, "SCHEMA")
+          # Skip pragma execution if we're inside a transaction and it's not allowed
+          begin
+            raw_connection.execute(stmt)
+          rescue => e
+            if e.message.include?("Safety level may not be changed inside a transaction")
+              # Log warning and skip this pragma
+              warn "Cannot set pragma '#{pragma}' inside a transaction, skipping"
+            else
+              raise
+            end
+          end
         else
           warn "Unknown SQLite pragma: #{pragma}"
         end
@@ -845,8 +887,9 @@ module ActiveRecord::ConnectionAdapters
     include ArJdbc::Abstract::ConnectionManagement
     include ArJdbc::Abstract::DatabaseStatements
     include ArJdbc::Abstract::StatementCache
-    include ArJdbc::Abstract::TransactionSupport
+    # Don't include TransactionSupport - use Rails' SQLite3::DatabaseStatements instead
 
+    include ::ArJdbc::SQLite3::DatabaseStatements
 
     ##
     # :singleton-method:
@@ -954,7 +997,8 @@ module ActiveRecord::ConnectionAdapters
 
     # because the JDBC driver doesn't like multiple SQL statements in one JDBC statement
     def combine_multi_statements(total_sql)
-      total_sql
+      # For Rails 8 compatibility - join multiple statements with semicolon
+      total_sql.is_a?(Array) ? total_sql.join(";\n") : total_sql
     end
 
     def type_map