activerecord-jdbc-alt-adapter 72.0.0.alpha1-java → 72.0.0.rc1-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9368e28d99e49de4164150e2e006ce8991be7d7aab58e6773936866f86dbbdd0
-  data.tar.gz: '03983c9218db6dd3a9ab278b0364ded1d9f5c315853b7ed6b543a05cca8c6c6c'
+  metadata.gz: 0f7f249466042cd80343c394b99718ff78c5754a2105f06eaf87672f25d2d54e
+  data.tar.gz: cc61ff60b8f74d3fa100156f59c4cdd198865e87d9be401bf833a2e0ed623291
 SHA512:
-  metadata.gz: 450ddae41c05f2519c53ff0ad17de0bfd3cfefa1a471775a9d27946843f2d685301ff12cbbcdd4f434f275ee4f067798fc500ff49a2f2ec79f2339dfede6fc8c
-  data.tar.gz: aa9aa18ad21ead09d7bab3180032c8fa71ffee37fbb43dbba6a52ac3b436da34010e229e10cf1d6eec9edb2a803addcd0585a0b8ac78bdba05281f77dc7f5924
+  metadata.gz: 25c0368cbbeecad8536caa0ffadff34c28aacb0ff4a66f2085016224322645add68206976dbcef42475bdc39c1ffd47da761eacd919292ae15e6711c44935317
+  data.tar.gz: 9beed2af43699a9349a9284c252fd97db3c0110510892ac6937b5ace94df6be02269fb7360caa653fb864a4326d6582e958bea1afe4c69d8adaabec96af2a671

data/README.md

@@ -175,7 +175,7 @@ adapters are available:
 
 ```yml
 development:
-  adapter: mysql2 # or mysql
+  adapter: mysql2
   database: blog_development
   username: blog
   password: 1234
@@ -199,7 +199,7 @@ or preferably using the *properties:* syntax:
 
 ```yml
 production:
-  adapter: mysql
+  adapter: mysql2
   username: blog
   password: blog
   url: "jdbc:mysql://localhost:3306/blog?profileSQL=true"

data/lib/arjdbc/abstract/core.rb

@@ -60,7 +60,16 @@ module ArJdbc
       # 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 = ->{ binds.map(&:value_for_database) } # extract_raw_bind_values
+          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

data/lib/arjdbc/abstract/transaction_support.rb

@@ -26,7 +26,9 @@ module ArJdbc
       def begin_db_transaction
         log('BEGIN', 'TRANSACTION') do
           with_raw_connection(allow_retry: true, materialize_transactions: false) do |conn|
-            conn.begin
+            result = conn.begin
+            verified!
+            result
           end
         end
       end

data/lib/arjdbc/jdbc/adapter.rb

@@ -5,7 +5,6 @@ require 'active_record/connection_adapters/abstract_adapter'
 
 require 'arjdbc/version'
 require 'arjdbc/jdbc/java'
-require 'arjdbc/jdbc/base_ext'
 require 'arjdbc/jdbc/error'
 require 'arjdbc/jdbc/connection_methods'
 require 'arjdbc/jdbc/column'

data/lib/arjdbc/mssql/adapter.rb

@@ -54,6 +54,7 @@ module ActiveRecord
       include MSSQL::ExplainSupport
       include MSSQL::DatabaseLimits
 
+      # Latin1-General, case-sensitive, accent-sensitive, kanatype-insensitive, width-sensitive
       @cs_equality_operator = 'COLLATE Latin1_General_CS_AS_WS'
 
       class << self
@@ -265,29 +266,25 @@ module ActiveRecord
 
       alias_method :current_schema=, :default_schema=
 
-      # FIXME: This needs to be fixed when we implement the collation per
-      # column basis. At the moment we only use the global database collation
-      def default_uniqueness_comparison(attribute, value) # :nodoc:
+      # FIXME: This needs to be fixed when we implement the collation per column
+      def case_sensitive_comparison(attribute, value)
         column = column_for_attribute(attribute)
 
-        if [:string, :text].include?(column.type) && collation && !collation.match(/_CS/) && !value.nil?
-          # NOTE: there is a deprecation warning here in the mysql adapter
-          # no sure if it's required.
+        case_sensitive = collation && collation.match(/_CS/)
+
+        if %i[string text].include?(column.type) && !case_sensitive && !value.nil?
           attribute.eq(Arel::Nodes::Bin.new(value))
         else
           super
         end
       end
 
-      def case_sensitive_comparison(attribute, value)
-        column = column_for_attribute(attribute)
+      def can_perform_case_insensitive_comparison_for?(column)
+        case_sensitive = collation && collation.match(/_CS/)
 
-        if [:string, :text].include?(column.type) && collation && !collation.match(/_CS/) && !value.nil?
-          attribute.eq(Arel::Nodes::Bin.new(value))
-        else
-          super
-        end
+        %i[string text].include?(column.type) && !case_sensitive
       end
+      private :can_perform_case_insensitive_comparison_for?
 
       def configure_connection
         # Here goes initial settings per connection
@@ -485,6 +482,8 @@ module ActiveRecord
           ConnectionNotEstablished.new(exception)
         when /(cannot insert duplicate key .* with unique index) | (violation of unique key constraint)/i
           RecordNotUnique.new(message, sql: sql, binds: binds)
+        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)
         when /Lock request time out period exceeded/i
           LockTimeout.new(message, sql: sql, binds: binds)
         when /The .* statement conflicted with the FOREIGN KEY constraint/

data/lib/arjdbc/mssql/column.rb

@@ -9,17 +9,26 @@ module ActiveRecord
       def initialize(name, raw_default, sql_type_metadata = nil, null = true, table_name = nil, default_function = nil, collation = nil, comment: nil)
         @table_name = table_name
 
-        default = extract_default(raw_default)
+        default_val, default_fun = extract_default(raw_default)
 
-        super(name, default, sql_type_metadata, null, default_function, collation: collation, comment: comment)
+        super(name, default_val, sql_type_metadata, null, default_fun, collation: collation, comment: comment)
       end
 
       def extract_default(value)
-        # return nil if default does not match the patterns to avoid
-        # any unexpected errors.
-        return unless value =~ /^\(N?'(.*)'\)$/m || value =~ /^\(\(?(.*?)\)?\)$/
-
-        unquote_string(Regexp.last_match[1])
+        return [nil, nil] unless value
+
+        case value
+        when /\A\(N?'(.*)'\)\Z/m
+          [unquote_string(Regexp.last_match[1]), nil]
+        when /\A\(\((.*)\)\)\Z/
+          [unquote_string(Regexp.last_match[1]), nil]
+        when /\A\((\w+\(\))\)\Z/
+          [nil, unquote_string(Regexp.last_match[1])]
+        else
+          # return nil if default does not match the patterns to avoid
+          # any unexpected errors.
+          [nil, nil]
+        end
       end
 
       def unquote_string(string)

data/lib/arjdbc/mssql/database_statements.rb

@@ -31,6 +31,8 @@ module ActiveRecord
 
         def write_query?(sql) # :nodoc:
           !READ_QUERY.match?(sql)
+        rescue ArgumentError # Invalid encoding
+          !READ_QUERY.match?(sql.b)
         end
 
         # Internal method to test different isolation levels supported by this
@@ -176,6 +178,9 @@ module ActiveRecord
             log(sql, name, 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
                   conn.execute_insert_pk(sql, binds, pk)
                 end
                 verified!

data/lib/arjdbc/mssql/schema_creation.rb

@@ -38,6 +38,22 @@ module ActiveRecord
           end
         end
 
+        def visit_CreateIndexDefinition(o)
+          index = o.index
+
+          sql = []
+          sql << "IF NOT EXISTS (SELECT name FROM sysindexes WHERE name = '#{o.index.name}')" if o.if_not_exists
+          sql << "CREATE"
+          sql << "UNIQUE" if index.unique
+          sql << index.type.upcase if index.type
+          sql << "INDEX"
+          sql << "#{quote_column_name(index.name)} ON #{quote_table_name(index.table)}"
+          sql << "(#{quoted_columns(index)})"
+          sql << "WHERE #{index.where}" if index.where
+
+          sql.join(" ")
+        end
+
         def add_column_options!(sql, options)
           sql << " DEFAULT #{quote_default_expression(options[:default], options[:column])}" if options_include_default?(options)
 

data/lib/arjdbc/mssql/schema_statements.rb

@@ -80,8 +80,50 @@ module ActiveRecord
           valid_raw_connection.primary_keys(table_name)
         end
 
+        def build_change_column_definition(table_name, column_name, type, **options) # :nodoc:
+          td = create_table_definition(table_name)
+          cd = td.new_column_definition(column_name, type, **options)
+          ChangeColumnDefinition.new(cd, column_name)
+        end
+
+        def build_change_column_default_definition(table_name, column_name, default_or_changes) # :nodoc:
+          column = column_for(table_name, column_name)
+          return unless column
+
+          default = extract_new_default_value(default_or_changes)
+          ChangeColumnDefaultDefinition.new(column, default)
+        end
+
         def foreign_keys(table_name)
-          valid_raw_connection.foreign_keys(table_name)
+          # valid_raw_connection.foreign_keys(table_name)
+          fk_info = execute_procedure(:sp_fkeys, nil, nil, nil, table_name, nil)
+
+          grouped_fk = fk_info.group_by { |row| row["FK_NAME"] }.values.each { |group| group.sort_by! { |row| row["KEY_SEQ"] } }
+          grouped_fk.map do |group|
+            row = group.first
+            options = {
+              name: row["FK_NAME"],
+              on_update: extract_foreign_key_action("update", row["FK_NAME"]),
+              on_delete: extract_foreign_key_action("delete", row["FK_NAME"])
+            }
+
+            if group.one?
+              options[:column] = row["FKCOLUMN_NAME"]
+              options[:primary_key] = row["PKCOLUMN_NAME"]
+            else
+              options[:column] = group.map { |row| row["FKCOLUMN_NAME"] }
+              options[:primary_key] = group.map { |row| row["PKCOLUMN_NAME"] }
+            end
+
+            ForeignKeyDefinition.new(table_name, row["PKTABLE_NAME"], options)
+          end
+        end
+
+        def extract_foreign_key_action(action, fk_name)
+          case select_value("SELECT #{action}_referential_action_desc FROM sys.foreign_keys WHERE name = '#{fk_name}'")
+          when "CASCADE" then :cascade
+          when "SET_NULL" then :nullify
+          end
         end
 
         def charset

data/lib/arjdbc/mysql/adapter.rb

@@ -84,15 +84,6 @@ module ActiveRecord
         @connection_parameters = conn_params
       end
 
-      def self.database_exists?(config)
-        conn = ActiveRecord::Base.mysql2_connection(config)
-        conn && conn.really_valid?
-      rescue ActiveRecord::NoDatabaseError
-        false
-      ensure
-        conn.disconnect! if conn
-      end
-
       def supports_json?
         !mariadb? && database_version >= '5.7.8'
       end
@@ -250,7 +241,7 @@ module ActiveRecord
 
       # e.g. "5.7.20-0ubuntu0.16.04.1"
       def full_version
-        schema_cache.database_version.full_version_string
+        database_version.full_version_string
       end
 
       def get_full_version

data/lib/arjdbc/mysql/adapter_hash_config.rb

@@ -7,7 +7,9 @@ module ArJdbc
 
       load_jdbc_driver
 
-      config[:driver] ||= database_driver_name
+      # don't set driver if it's explicitly set to false
+      # allow Java's service discovery mechanism (with connector/j 8.0)
+      config[:driver] ||= database_driver_name if config[:driver] != false
 
       host = (config[:host] ||= "localhost")
       port = (config[:port] ||= 3306)
@@ -40,7 +42,7 @@ module ArJdbc
     def build_properties(config)
       properties = config[:properties] || {}
 
-      properties["zeroDateTimeBehavior"] ||= "CONVERT_TO_NULL"
+      properties["zeroDateTimeBehavior"] ||= default_zero_date_time_behavior(config[:driver])
 
       properties["jdbcCompliantTruncation"] ||= false
 
@@ -88,6 +90,14 @@ module ArJdbc
       properties
     end
 
+    def default_zero_date_time_behavior(driver)
+      return "CONVERT_TO_NULL" if driver == false
+
+      return "CONVERT_TO_NULL" if driver.start_with?("com.mysql.cj.")
+
+      "convertToNull"
+    end
+
     # See https://dev.mysql.com/doc/connector-j/5.1/en/connector-j-reference-charsets.html
     # to charset-name (characterEncoding=...)
     def convert_mysql_encoding(config)

data/lib/arjdbc/postgresql/adapter.rb

@@ -345,7 +345,7 @@ module ArJdbc
           type.typname AS name,
           type.OID AS oid,
           n.nspname AS schema,
-          string_agg(enum.enumlabel, ',' ORDER BY enum.enumsortorder) AS value
+          array_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
@@ -842,6 +842,15 @@ module ActiveRecord::ConnectionAdapters
     # setting, you should immediately run <tt>bin/rails db:migrate</tt> to update the types in your schema.rb.
     class_attribute :datetime_type, default: :timestamp
 
+    ##
+    # :singleton-method:
+    # Toggles automatic decoding of date columns.
+    #
+    #   ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.select_value("select '2024-01-01'::date").class #=> String
+    #   ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.decode_dates = true
+    #   ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.select_value("select '2024-01-01'::date").class #=> Date
+    class_attribute :decode_dates, default: false
+
     # Try to use as much of the built in postgres logic as possible
     # maybe someday we can extend the actual adapter
     include ActiveRecord::ConnectionAdapters::PostgreSQL::ReferentialIntegrity
@@ -855,9 +864,12 @@ module ActiveRecord::ConnectionAdapters
     include ArJdbc::Abstract::DatabaseStatements
     include ArJdbc::Abstract::StatementCache
     include ArJdbc::Abstract::TransactionSupport
-    include ArJdbc::PostgreSQL
     include ArJdbc::PostgreSQLConfig
 
+    # NOTE: after AR refactor quote_column_name became class and instance method
+    include ArJdbc::PostgreSQL
+    extend ArJdbc::PostgreSQL
+
     require 'arjdbc/postgresql/oid_types'
     include ::ArJdbc::PostgreSQL::OIDTypes
     include ::ArJdbc::PostgreSQL::DatabaseStatements

data/lib/arjdbc/sqlite3/adapter.rb

@@ -18,6 +18,7 @@ require "active_record/connection_adapters/sqlite3/schema_statements"
 require "active_support/core_ext/class/attribute"
 require "arjdbc/sqlite3/column"
 require "arjdbc/sqlite3/adapter_hash_config"
+require "arjdbc/sqlite3/pragmas"
 
 require "arjdbc/abstract/relation_query_attribute_monkey_patch"
 
@@ -59,6 +60,7 @@ module ArJdbc
     # DIFFERENCE: Some common constant names to reduce differences in rest of this module from AR5 version
     ConnectionAdapters = ::ActiveRecord::ConnectionAdapters
     IndexDefinition = ::ActiveRecord::ConnectionAdapters::IndexDefinition
+    ForeignKeyDefinition = ::ActiveRecord::ConnectionAdapters::ForeignKeyDefinition
     Quoting = ::ActiveRecord::ConnectionAdapters::SQLite3::Quoting
     RecordNotUnique = ::ActiveRecord::RecordNotUnique
     SchemaCreation = ConnectionAdapters::SQLite3::SchemaCreation
@@ -79,6 +81,15 @@ module ArJdbc
         json:         { name: "json" },
     }
 
+    DEFAULT_PRAGMAS = {
+      "foreign_keys"        => true,
+      "journal_mode"        => :wal,
+      "synchronous"         => :normal,
+      "mmap_size"           => 134217728, # 128 megabytes
+      "journal_size_limit"  => 67108864, # 64 megabytes
+      "cache_size"          => 2000
+    }
+
     class StatementPool < ConnectionAdapters::StatementPool # :nodoc:
       private
       def dealloc(stmt)
@@ -154,8 +165,23 @@ module ArJdbc
       !@memory_database
     end
 
+    def supports_virtual_columns?
+      database_version >= "3.31.0"
+    end
+
+    def connected?
+      !(@raw_connection.nil? || @raw_connection.closed?)
+    end
+
     def active?
-      @raw_connection && !@raw_connection.closed?
+      if connected?
+        @lock.synchronize do
+          if @raw_connection&.active?
+            verified!
+            true
+          end
+        end
+      end || false
     end
 
     def return_value_after_insert?(column) # :nodoc:
@@ -167,10 +193,11 @@ module ArJdbc
     # Disconnects from the database if already connected. Otherwise, this
     # method does nothing.
     def disconnect!
-      super
-
-      @raw_connection&.close rescue nil
-      @raw_connection = nil
+      @lock.synchronize do
+        super
+        @raw_connection&.close rescue nil
+        @raw_connection = nil
+      end
     end
 
     def supports_index_sort_order?
@@ -235,7 +262,6 @@ module ArJdbc
       internal_exec_query "DROP INDEX #{quote_column_name(index_name)}"
     end
 
-    
     # Renames a table.
     #
     # Example:
@@ -324,15 +350,31 @@ module ArJdbc
     end
     alias :add_belongs_to :add_reference
 
+    FK_REGEX = /.*FOREIGN KEY\s+\("([^"]+)"\)\s+REFERENCES\s+"(\w+)"\s+\("(\w+)"\)/
+    DEFERRABLE_REGEX = /DEFERRABLE INITIALLY (\w+)/
     def foreign_keys(table_name)
       # SQLite returns 1 row for each column of composite foreign keys.
       fk_info = internal_exec_query("PRAGMA foreign_key_list(#{quote(table_name)})", "SCHEMA")
+      # Deferred or immediate foreign keys can only be seen in the CREATE TABLE sql
+      fk_defs = table_structure_sql(table_name)
+                  .select do |column_string|
+                    column_string.start_with?("CONSTRAINT") &&
+                    column_string.include?("FOREIGN KEY")
+                  end
+                  .to_h do |fk_string|
+                    _, from, table, to = fk_string.match(FK_REGEX).to_a
+                    _, mode = fk_string.match(DEFERRABLE_REGEX).to_a
+                    deferred = mode&.downcase&.to_sym || false
+                    [[table, from, to], deferred]
+                  end
+
       grouped_fk = fk_info.group_by { |row| row["id"] }.values.each { |group| group.sort_by! { |row| row["seq"] } }
       grouped_fk.map do |group|
         row = group.first
         options = {
           on_delete: extract_foreign_key_action(row["on_delete"]),
-          on_update: extract_foreign_key_action(row["on_update"])
+          on_update: extract_foreign_key_action(row["on_update"]),
+          deferrable: fk_defs[[row["table"], row["from"], row["to"]]]
         }
 
         if group.one?
@@ -342,8 +384,7 @@ module ArJdbc
           options[:column] = group.map { |row| row["from"] }
           options[:primary_key] = group.map { |row| row["to"] }
         end
-        # DIFFERENCE: FQN
-        ::ActiveRecord::ConnectionAdapters::ForeignKeyDefinition.new(table_name, row["table"], options)
+        ForeignKeyDefinition.new(table_name, row["table"], options)
       end
     end
 
@@ -390,7 +431,14 @@ module ArJdbc
 
       type_metadata = fetch_type_metadata(field["type"])
       default_value = extract_value_from_default(default)
-      default_function = extract_default_function(default_value, default)
+      generated_type = extract_generated_type(field)
+
+      if generated_type.present?
+        default_function = default
+      else
+        default_function = extract_default_function(default_value, default)
+      end
+
       rowid = is_column_the_rowid?(field, definitions)
 
       ActiveRecord::ConnectionAdapters::SQLite3Column.new(
@@ -401,7 +449,8 @@ module ArJdbc
         default_function,
         collation: field["collation"],
         auto_increment: field["auto_increment"],
-        rowid: rowid
+        rowid: rowid,
+        generated_type: generated_type
       )
     end
 
@@ -413,7 +462,12 @@ module ArJdbc
     end
 
     def table_structure(table_name)
-      structure = internal_exec_query("PRAGMA table_info(#{quote_table_name(table_name)})", "SCHEMA")
+      structure = if supports_virtual_columns?
+        internal_exec_query("PRAGMA table_xinfo(#{quote_table_name(table_name)})", "SCHEMA")
+      else
+        internal_exec_query("PRAGMA table_info(#{quote_table_name(table_name)})", "SCHEMA")
+      end
+
       raise(ActiveRecord::StatementInvalid, "Could not find table '#{table_name}'") if structure.empty?
       table_structure_with_collation(table_name, structure)
     end
@@ -453,8 +507,9 @@ module ArJdbc
     # See: https://www.sqlite.org/lang_altertable.html
     # SQLite has an additional restriction on the ALTER TABLE statement
     def invalid_alter_table_type?(type, options)
-      type.to_sym == :primary_key || options[:primary_key] ||
-        options[:null] == false && options[:default].nil?
+      type == :primary_key || options[:primary_key] ||
+        options[:null] == false && options[:default].nil? ||
+        (type == :virtual && options[:stored])
     end
 
     def alter_table(
@@ -510,12 +565,6 @@ module ArJdbc
              options[:rename][column.name.to_sym] ||
              column.name) : column.name
 
-          if column.has_default?
-            type = lookup_cast_type_from_column(column)
-            default = type.deserialize(column.default)
-            default = -> { column.default_function } if default.nil?
-          end
-
           column_options = {
             limit: column.limit,
             precision: column.precision,
@@ -525,19 +574,31 @@ module ArJdbc
             primary_key: column_name == from_primary_key
           }
 
-          unless column.auto_increment?
-            column_options[:default] = default
+          if column.virtual?
+            column_options[:as] = column.default_function
+            column_options[:stored] = column.virtual_stored?
+            column_options[:type] = column.type
+          elsif column.has_default?
+            type = lookup_cast_type_from_column(column)
+            default = type.deserialize(column.default)
+            default = -> { column.default_function } if default.nil?
+
+            unless column.auto_increment?
+              column_options[:default] = default
+            end
           end
 
-          column_type = column.bigint? ? :bigint : column.type
+          column_type = column.virtual? ? :virtual : (column.bigint? ? :bigint : column.type)
           @definition.column(column_name, column_type, **column_options)
         end
 
         yield @definition if block_given?
       end
       copy_table_indexes(from, to, options[:rename] || {})
+
+      columns_to_copy = @definition.columns.reject { |col| col.options.key?(:as) }.map(&:name)
       copy_table_contents(from, to,
-        @definition.columns.map(&:name),
+        columns_to_copy,
         options[:rename] || {})
     end
 
@@ -611,32 +672,22 @@ module ArJdbc
 
     COLLATE_REGEX = /.*\"(\w+)\".*collate\s+\"(\w+)\".*/i.freeze
     PRIMARY_KEY_AUTOINCREMENT_REGEX = /.*\"(\w+)\".+PRIMARY KEY AUTOINCREMENT/i
+    GENERATED_ALWAYS_AS_REGEX = /.*"(\w+)".+GENERATED ALWAYS AS \((.+)\) (?:STORED|VIRTUAL)/i
 
     def table_structure_with_collation(table_name, basic_structure)
       collation_hash = {}
       auto_increments = {}
-      sql = <<~SQL
-        SELECT sql FROM
-          (SELECT * FROM sqlite_master UNION ALL
-           SELECT * FROM sqlite_temp_master)
-        WHERE type = 'table' AND name = #{quote(table_name)}
-      SQL
-
-      # Result will have following sample string
-      # CREATE TABLE "users" ("id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
-      #                       "password_digest" varchar COLLATE "NOCASE");
-      result = query_value(sql, "SCHEMA")
+      generated_columns = {}
 
-      if result
-        # Splitting with left parentheses and discarding the first part will return all
-        # columns separated with comma(,).
-        columns_string = result.split("(", 2).last
+      column_strings = table_structure_sql(table_name, basic_structure.map { |column| column["name"] })
 
-        columns_string.split(",").each do |column_string|
+      if column_strings.any?
+        column_strings.each do |column_string|
           # This regex will match the column name and collation type and will save
           # the value in $1 and $2 respectively.
           collation_hash[$1] = $2 if COLLATE_REGEX =~ column_string
           auto_increments[$1] = true if PRIMARY_KEY_AUTOINCREMENT_REGEX =~ column_string
+          generated_columns[$1] = $2 if GENERATED_ALWAYS_AS_REGEX =~ column_string
         end
 
         basic_structure.map do |column|
@@ -650,6 +701,10 @@ module ArJdbc
             column["auto_increment"] = true
           end
 
+          if generated_columns.has_key?(column_name)
+            column["dflt_value"] = generated_columns[column_name]
+          end
+
           column
         end
       else
@@ -657,6 +712,50 @@ module ArJdbc
       end
     end
 
+    UNQUOTED_OPEN_PARENS_REGEX = /\((?![^'"]*['"][^'"]*$)/
+    FINAL_CLOSE_PARENS_REGEX = /\);*\z/
+
+    def table_structure_sql(table_name, column_names = nil)
+      unless column_names
+        column_info = table_info(table_name)
+        column_names = column_info.map { |column| column["name"] }
+      end
+
+      sql = <<~SQL
+        SELECT sql FROM
+          (SELECT * FROM sqlite_master UNION ALL
+           SELECT * FROM sqlite_temp_master)
+        WHERE type = 'table' AND name = #{quote(table_name)}
+      SQL
+
+      # Result will have following sample string
+      # CREATE TABLE "users" ("id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+      #                       "password_digest" varchar COLLATE "NOCASE",
+      #                       "o_id" integer,
+      #                       CONSTRAINT "fk_rails_78146ddd2e" FOREIGN KEY ("o_id") REFERENCES "os" ("id"));
+      result = query_value(sql, "SCHEMA")
+
+      return [] unless result
+
+      # Splitting with left parentheses and discarding the first part will return all
+      # columns separated with comma(,).
+      result.partition(UNQUOTED_OPEN_PARENS_REGEX)
+            .last
+            .sub(FINAL_CLOSE_PARENS_REGEX, "")
+            # column definitions can have a comma in them, so split on commas followed
+            # by a space and a column name in quotes or followed by the keyword CONSTRAINT
+            .split(/,(?=\s(?:CONSTRAINT|"(?:#{Regexp.union(column_names).source})"))/i)
+            .map(&:strip)
+    end
+
+    def table_info(table_name)
+      if supports_virtual_columns?
+        internal_exec_query("PRAGMA table_xinfo(#{quote_table_name(table_name)})", "SCHEMA")
+      else
+        internal_exec_query("PRAGMA table_info(#{quote_table_name(table_name)})", "SCHEMA")
+      end
+    end
+
     def arel_visitor
       Arel::Visitors::SQLite.new(self)
     end
@@ -686,29 +785,17 @@ module ArJdbc
         end
       end
 
-      # Enforce foreign key constraints
-      # https://www.sqlite.org/pragma.html#pragma_foreign_keys
-      # https://www.sqlite.org/foreignkeys.html
-      raw_execute("PRAGMA foreign_keys = ON", "SCHEMA")
-      unless @memory_database
-        # Journal mode WAL allows for greater concurrency (many readers + one writer)
-        # https://www.sqlite.org/pragma.html#pragma_journal_mode
-        raw_execute("PRAGMA journal_mode = WAL", "SCHEMA")
-        # Set more relaxed level of database durability
-        # 2 = "FULL" (sync on every write), 1 = "NORMAL" (sync every 1000 written pages) and 0 = "NONE"
-        # https://www.sqlite.org/pragma.html#pragma_synchronous
-        raw_execute("PRAGMA synchronous = NORMAL", "SCHEMA")
-        # Set the global memory map so all processes can share some data
-        # https://www.sqlite.org/pragma.html#pragma_mmap_size
-        # https://www.sqlite.org/mmap.html
-        raw_execute("PRAGMA mmap_size = #{128.megabytes}", "SCHEMA")
-      end
-      # Impose a limit on the WAL file to prevent unlimited growth
-      # https://www.sqlite.org/pragma.html#pragma_journal_size_limit
-      raw_execute("PRAGMA journal_size_limit = #{64.megabytes}", "SCHEMA")
-      # Set the local connection cache to 2000 pages
-      # https://www.sqlite.org/pragma.html#pragma_cache_size
-      raw_execute("PRAGMA cache_size = 2000", "SCHEMA")
+      super
+
+      pragmas = @config.fetch(:pragmas, {}).stringify_keys
+      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")
+        else
+          warn "Unknown SQLite pragma: #{pragma}"
+        end
+      end
     end
   end
   # DIFFERENCE: A registration here is moved down to concrete class so we are not registering part of an adapter.
@@ -745,6 +832,12 @@ module ActiveRecord::ConnectionAdapters
       end
     end
 
+    # NOTE: include these modules before all then override some methods with the
+    # ones defined in ArJdbc::SQLite3 java part and ArJdbc::Abstract
+    include ::ActiveRecord::ConnectionAdapters::SQLite3::Quoting
+    include ::ActiveRecord::ConnectionAdapters::SQLite3::SchemaStatements
+    include ::ActiveRecord::ConnectionAdapters::SQLite3::DatabaseStatements
+
     include ArJdbc::Abstract::Core
     include ArJdbc::SQLite3
     include ArJdbc::SQLite3Config
@@ -754,9 +847,6 @@ module ActiveRecord::ConnectionAdapters
     include ArJdbc::Abstract::StatementCache
     include ArJdbc::Abstract::TransactionSupport
 
-    include ::ActiveRecord::ConnectionAdapters::SQLite3::Quoting
-    include ::ActiveRecord::ConnectionAdapters::SQLite3::SchemaStatements
-    include ::ActiveRecord::ConnectionAdapters::SQLite3::DatabaseStatements
 
     ##
     # :singleton-method:
@@ -771,6 +861,14 @@ module ActiveRecord::ConnectionAdapters
     def initialize(...)
       super
 
+      @memory_database = false
+      case @config[:database].to_s
+      when ""
+        raise ArgumentError, "No database file specified. Missing argument: database"
+      when ":memory:"
+        @memory_database = true
+      end
+
       # assign arjdbc extra connection params
       conn_params = build_connection_config(@config.compact)
 

data/lib/arjdbc/sqlite3/column.rb

@@ -4,12 +4,14 @@ module ActiveRecord::ConnectionAdapters
   class SQLite3Column < JdbcColumn
 
     attr_reader :rowid
-    
-    def initialize(name, default, sql_type_metadata = nil, null = true, default_function = nil, collation: nil, comment: nil, auto_increment: nil, rowid: false, **)
+
+    def initialize(*, auto_increment: nil, rowid: false, generated_type: nil, **)
       super
+
       @auto_increment = auto_increment
       @default = nil if default =~ /NULL/
       @rowid = rowid
+      @generated_type = generated_type
     end
 
     def self.string_to_binary(value)
@@ -39,6 +41,18 @@ module ActiveRecord::ConnectionAdapters
       auto_increment? || rowid
     end
 
+    def virtual?
+      !@generated_type.nil?
+    end
+
+    def virtual_stored?
+      virtual? && @generated_type == :stored
+    end
+
+    def has_default?
+      super && !virtual?
+    end
+
     def init_with(coder)
       @auto_increment = coder["auto_increment"]
       super
@@ -100,4 +114,4 @@ module ActiveRecord::ConnectionAdapters
       end
     end
   end
-end
+end

data/lib/arjdbc/sqlite3/pragmas.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module SQLite3
+  # defines methods to de generate pragma statements
+  module Pragmas
+    class << self
+      # The enumeration of valid synchronous modes.
+      SYNCHRONOUS_MODES = [["full", 2], ["normal", 1], ["off", 0]].freeze
+
+      # The enumeration of valid temp store modes.
+      TEMP_STORE_MODES = [["default", 0], ["file", 1], ["memory", 2]].freeze
+
+      # The enumeration of valid auto vacuum modes.
+      AUTO_VACUUM_MODES = [["none", 0], ["full", 1], ["incremental", 2]].freeze
+
+      # The list of valid journaling modes.
+      JOURNAL_MODES = [["delete"], ["truncate"], ["persist"], ["memory"], ["wal"], ["off"]].freeze
+
+      # The list of valid locking modes.
+      LOCKING_MODES = [["normal"], ["exclusive"]].freeze
+
+      # The list of valid encodings.
+      ENCODINGS = [["utf-8"], ["utf-16"], ["utf-16le"], ["utf-16be"]].freeze
+
+      # The list of valid WAL checkpoints.
+      WAL_CHECKPOINTS = [["passive"], ["full"], ["restart"], ["truncate"]].freeze
+
+      # Enforce foreign key constraints
+      # https://www.sqlite.org/pragma.html#pragma_foreign_keys
+      # https://www.sqlite.org/foreignkeys.html
+      def foreign_keys(value)
+        gen_boolean_pragma(:foreign_keys, value)
+      end
+
+      # Journal mode WAL allows for greater concurrency (many readers + one writer)
+      # https://www.sqlite.org/pragma.html#pragma_journal_mode
+      def journal_mode(value)
+        gen_enum_pragma(:journal_mode, value, JOURNAL_MODES)
+      end
+
+      # Set more relaxed level of database durability
+      # 2 = "FULL" (sync on every write), 1 = "NORMAL" (sync every 1000 written pages) and 0 = "NONE"
+      # https://www.sqlite.org/pragma.html#pragma_synchronous
+      def synchronous(value)
+        gen_enum_pragma(:synchronous, value, SYNCHRONOUS_MODES)
+      end
+
+      def temp_store(value)
+        gen_enum_pragma(:temp_store, value, TEMP_STORE_MODES)
+      end
+
+      # Set the global memory map so all processes can share some data
+      # https://www.sqlite.org/pragma.html#pragma_mmap_size
+      # https://www.sqlite.org/mmap.html
+      def mmap_size(value)
+        "PRAGMA mmap_size = #{value.to_i}"
+      end
+
+      # Impose a limit on the WAL file to prevent unlimited growth
+      # https://www.sqlite.org/pragma.html#pragma_journal_size_limit
+      def journal_size_limit(value)
+        "PRAGMA journal_size_limit = #{value.to_i}"
+      end
+
+      # Set the local connection cache to 2000 pages
+      # https://www.sqlite.org/pragma.html#pragma_cache_size
+      def cache_size(value)
+        "PRAGMA cache_size = #{value.to_i}"
+      end
+
+      private
+
+      def gen_boolean_pragma(name, mode)
+        case mode
+        when String
+          case mode.downcase
+          when "on", "yes", "true", "y", "t" then mode = "'ON'"
+          when "off", "no", "false", "n", "f" then mode = "'OFF'"
+          else
+            raise ActiveRecord::JDBCError, "unrecognized pragma parameter #{mode.inspect}"
+          end
+        when true, 1
+          mode = "ON"
+        when false, 0, nil
+          mode = "OFF"
+        else
+          raise ActiveRecord::JDBCError, "unrecognized pragma parameter #{mode.inspect}"
+        end
+
+        "PRAGMA #{name} = #{mode}"
+      end
+
+      def gen_enum_pragma(name, mode, enums)
+        match = enums.find { |p| p.find { |i| i.to_s.downcase == mode.to_s.downcase } }
+
+        unless match
+          # Unknown pragma value
+          raise ActiveRecord::JDBCError, "unrecognized #{name} #{mode.inspect}"
+        end
+
+        "PRAGMA #{name} = '#{match.first.upcase}'"
+      end
+    end
+  end
+end

data/lib/arjdbc/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ArJdbc
-  VERSION = "72.0.0.alpha1"
+  VERSION = "72.0.0.rc1"
 end

data/lib/arjdbc.rb

@@ -17,6 +17,15 @@ if defined?(JRUBY_VERSION)
     ActiveRecord::ConnectionAdapters.register(
       "sqlserver", "ActiveRecord::ConnectionAdapters::MSSQLAdapter", "active_record/connection_adapters/mssql_adapter"
     )
+    ActiveRecord::ConnectionAdapters.register(
+      "sqlite3", "ActiveRecord::ConnectionAdapters::SQLite3Adapter", "arjdbc/sqlite3/adapter"
+    )
+    ActiveRecord::ConnectionAdapters.register(
+      "postgresql", "ActiveRecord::ConnectionAdapters::PostgreSQLAdapter", "arjdbc/postgresql/adapter"
+    )
+    ActiveRecord::ConnectionAdapters.register(
+      "mysql2", "ActiveRecord::ConnectionAdapters::Mysql2Adapter", "arjdbc/mysql/adapter"
+    )
   end
 else
   warn "activerecord-jdbc-adapter is for use with JRuby only"

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

@@ -126,6 +126,7 @@ public class RubyJdbcConnection extends RubyObject {
     private IRubyObject adapter; // the AbstractAdapter instance we belong to
     private volatile boolean connected = true;
     private RubyClass attributeClass;
+    private RubyClass timeZoneClass;
 
     private boolean lazy = false; // final once set on initialize
     private boolean jndi; // final once set on initialize
@@ -135,6 +136,7 @@ public class RubyJdbcConnection extends RubyObject {
     protected RubyJdbcConnection(Ruby runtime, RubyClass metaClass) {
         super(runtime, metaClass);
         attributeClass = runtime.getModule("ActiveModel").getClass("Attribute");
+        timeZoneClass = runtime.getModule("ActiveSupport").getClass("TimeWithZone");
     }
 
     private static final ObjectAllocator ALLOCATOR = new ObjectAllocator() {
@@ -2441,6 +2443,9 @@ public class RubyJdbcConnection extends RubyObject {
         if (attributeClass.isInstance(attribute)) {
             type = jdbcTypeForAttribute(context, attribute);
             value = valueForDatabase(context, attribute);
+        } else if (timeZoneClass.isInstance(attribute)) {
+            type = jdbcTypeFor("timestamp");
+            value = attribute;
         } else {
             type = jdbcTypeForPrimitiveAttribute(context, attribute);
             value = attribute;

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

@@ -473,7 +473,10 @@ public class SQLite3RubyJdbcConnection extends RubyJdbcConnection {
         // Assume we will only call this with an array.
         final RubyArray statements = (RubyArray) statementsArg;
         return withConnection(context, connection -> {
+            final Ruby runtime = context.runtime;
+
             Statement statement = null;
+
             try {
                 statement = createStatement(context, connection);
 
@@ -481,8 +484,15 @@ public class SQLite3RubyJdbcConnection extends RubyJdbcConnection {
                 for (int i = 0; i < length; i++) {
                     statement.addBatch(sqlString(statements.eltOk(i)));
                 }
-                statement.executeBatch();
-                return context.nil;
+
+                int[] rows = statement.executeBatch();
+
+                RubyArray rowsAffected = runtime.newArray();
+
+                for (int i = 0; i < rows.length; i++) {
+                    rowsAffected.append(runtime.newFixnum(rows[i]));
+                }
+                return rowsAffected;
             } catch (final SQLException e) {
                 // Generate list semicolon list of statements which should match AR error formatting more.
                 debugErrorSQL(context, sqlString(statements.join(context, context.runtime.newString(";\n"))));

metadata

@@ -1,22 +1,22 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-jdbc-alt-adapter
 version: !ruby/object:Gem::Version
-  version: 72.0.0.alpha1
+  version: 72.0.0.rc1
 platform: java
 authors:
 - Nick Sieger, Ola Bini, Karol Bucek, Jesse Chavez, and JRuby contributors
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-01-28 00:00:00.000000000 Z
+date: 2025-02-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
+  name: activerecord
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 7.2.2
-  name: activerecord
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -95,7 +95,6 @@ files:
 - lib/arjdbc/jdbc/adapter.rb
 - lib/arjdbc/jdbc/adapter_java.jar
 - lib/arjdbc/jdbc/adapter_require.rb
-- lib/arjdbc/jdbc/base_ext.rb
 - lib/arjdbc/jdbc/callbacks.rb
 - lib/arjdbc/jdbc/column.rb
 - lib/arjdbc/jdbc/connection.rb
@@ -157,6 +156,7 @@ files:
 - lib/arjdbc/sqlite3/adapter_hash_config.rb
 - lib/arjdbc/sqlite3/column.rb
 - lib/arjdbc/sqlite3/connection_methods.rb
+- lib/arjdbc/sqlite3/pragmas.rb
 - lib/arjdbc/tasks.rb
 - lib/arjdbc/tasks/database_tasks.rb
 - lib/arjdbc/tasks/databases.rake

data/lib/arjdbc/jdbc/base_ext.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveRecord
-  class << Base
-    m = Module.new do
-      # Allow adapters to provide their own {#reset_column_information} method.
-      # @note This only affects the current thread's connection.
-      def reset_column_information # :nodoc:
-        # invoke the adapter-specific reset_column_information method
-        connection.reset_column_information if connection.respond_to?(:reset_column_information)
-        super
-      end
-    end
-
-    self.prepend(m)
-  end
-end