activerecord-jdbc-alt-adapter 52.4.0-java → 61.0.0-java

data/lib/arjdbc/postgresql/base/array_decoder.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # This implements a basic decoder to work around ActiveRecord's dependence on the pg gem
 module ActiveRecord::ConnectionAdapters::PostgreSQL::OID
   class Array < ActiveModel::Type::Value

data/lib/arjdbc/postgresql/base/array_encoder.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # This implements a basic encoder to work around ActiveRecord's dependence on the pg gem
 module ActiveRecord::ConnectionAdapters::PostgreSQL::OID
   class Array < ActiveModel::Type::Value
@@ -6,10 +8,10 @@ module ActiveRecord::ConnectionAdapters::PostgreSQL::OID
         class Array
 
           def initialize(name:, delimiter:)
-            @type = if name == 'string[]'.freeze
+            @type = if name == 'string[]'
                       'text'.freeze
                     else
-                      base_type = name.chomp('[]'.freeze).to_sym
+                      base_type = name.chomp('[]').to_sym
                       ActiveRecord::Base.connection.native_database_types[base_type][:name]
                     end
           end

data/lib/arjdbc/postgresql/base/array_parser.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # based on active_record/connection_adapters/postgresql/array_parser.rb
 # until it's some day shareable with Rails ... this is not public API !
 module ActiveRecord
@@ -33,7 +35,7 @@ module ActiveRecord
             is_escaping  = false
             is_quoted    = false
             was_quoted   = false
-            current_item = ''
+            current_item = ''.dup
 
             local_index = index
             while local_index
@@ -58,7 +60,7 @@ module ActiveRecord
                     is_escaping = true
                   when COMMA
                     add_item_to_array(array, current_item, was_quoted)
-                    current_item = ''
+                    current_item = ''.dup
                     was_quoted = false
                   when DOUBLE_QUOTE
                     is_quoted = true

data/lib/arjdbc/postgresql/base/pgconn.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord::ConnectionAdapters::PostgreSQL::OID
   class Bytea < ActiveModel::Type::Binary
     module PG

data/lib/arjdbc/postgresql/column.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ArJdbc
   module PostgreSQL
 
@@ -20,13 +22,13 @@ module ArJdbc
           # Quoted types
           when /\A[\(B]?'(.*)'.*::"?([\w. ]+)"?(?:\[\])?\z/m
             # The default 'now'::date is CURRENT_DATE
-            if $1 == "now".freeze && $2 == "date".freeze
+            if $1 == "now" && $2 == "date"
               nil
             else
-              $1.gsub("''".freeze, "'".freeze)
+              $1.gsub("''", "'")
             end
           # Boolean types
-          when 'true'.freeze, 'false'.freeze
+          when 'true', 'false'
             default
           # Numeric types
           when /\A\(?(-?\d+(\.\d*)?)\)?(::bigint)?\z/
@@ -46,7 +48,7 @@ module ArJdbc
       end
 
       def has_default_function?(default_value, default)
-        !default_value && %r{\w+\(.*\)|\(.*\)::\w+|CURRENT_DATE|CURRENT_TIMESTAMP} === default
+        !default_value && default && %r{\w+\(.*\)|\(.*\)::\w+|CURRENT_DATE|CURRENT_TIMESTAMP}.match?(default)
       end
     end
 

data/lib/arjdbc/postgresql/connection_methods.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 ArJdbc::ConnectionMethods.module_eval do
   def postgresql_connection(config)
+    config = config.deep_dup
     # NOTE: this isn't "really" necessary but Rails (in tests) assumes being able to :
     #   ActiveRecord::Base.postgresql_connection ActiveRecord::Base.configurations['arunit'].merge(:insert_returning => false)
     # ... while using symbols by default but than configurations returning string keys ;(

data/lib/arjdbc/postgresql/name.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # This patches the Name class so that it doesn't use pg gem specific quoting
 module ActiveRecord
   module ConnectionAdapters

data/lib/arjdbc/postgresql/oid_types.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'thread'
 
 module ArJdbc
@@ -143,7 +145,7 @@ module ArJdbc
         m.register_type 'uuid', OID::Uuid.new
         m.register_type 'xml', OID::Xml.new
         m.register_type 'tsvector', OID::SpecializedString.new(:tsvector)
-        m.register_type 'macaddr', OID::SpecializedString.new(:macaddr)
+        m.register_type 'macaddr', OID::Macaddr.new
         m.register_type 'citext', OID::SpecializedString.new(:citext)
         m.register_type 'ltree', OID::SpecializedString.new(:ltree)
         m.register_type 'line', OID::SpecializedString.new(:line)
@@ -153,9 +155,9 @@ module ArJdbc
         m.register_type 'polygon', OID::SpecializedString.new(:polygon)
         m.register_type 'circle', OID::SpecializedString.new(:circle)
 
-        m.register_type 'interval' do |_, _, sql_type|
+        m.register_type 'interval' do |*args, sql_type|
           precision = extract_precision(sql_type)
-          OID::SpecializedString.new(:interval, precision: precision)
+          OID::Interval.new(precision: precision)
         end
 
         register_class_with_precision m, 'time', Type::Time
@@ -211,7 +213,7 @@ module ArJdbc
         if oid
           if oid.is_a? Numeric || oid.match(/^\d+$/)
             # numeric OID
-            query += "WHERE t.oid::integer = %s" % oid
+            query += "WHERE t.oid = %s" % oid
 
           elsif m = oid.match(/"?(\w+)"?\."?(\w+)"?/)
             # namespace and type name
@@ -242,6 +244,7 @@ module ArJdbc
       ActiveRecord::Type.register(:enum, OID::Enum, adapter: :postgresql)
       ActiveRecord::Type.register(:hstore, OID::Hstore, adapter: :postgresql)
       ActiveRecord::Type.register(:inet, OID::Inet, adapter: :postgresql)
+      ActiveRecord::Type.register(:interval, OID::Interval, adapter: :postgresql)
       ActiveRecord::Type.register(:json, Type::Json, adapter: :postgresql)
       ActiveRecord::Type.register(:jsonb, OID::Jsonb, adapter: :postgresql)
       ActiveRecord::Type.register(:money, OID::Money, adapter: :postgresql)

data/lib/arjdbc/sqlite3/adapter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 ArJdbc.load_java_part :SQLite3
 
 require "arjdbc/abstract/core"
@@ -14,6 +16,33 @@ require "active_record/connection_adapters/sqlite3/schema_dumper"
 require "active_record/connection_adapters/sqlite3/schema_statements"
 require "active_support/core_ext/class/attribute"
 
+module SQLite3
+  module Constants
+    module Open
+      READONLY       = 0x00000001
+      READWRITE      = 0x00000002
+      CREATE         = 0x00000004
+      DELETEONCLOSE  = 0x00000008
+      EXCLUSIVE      = 0x00000010
+      AUTOPROXY      = 0x00000020
+      URI            = 0x00000040
+      MEMORY         = 0x00000080
+      MAIN_DB        = 0x00000100
+      TEMP_DB        = 0x00000200
+      TRANSIENT_DB   = 0x00000400
+      MAIN_JOURNAL   = 0x00000800
+      TEMP_JOURNAL   = 0x00001000
+      SUBJOURNAL     = 0x00002000
+      MASTER_JOURNAL = 0x00004000
+      NOMUTEX        = 0x00008000
+      FULLMUTEX      = 0x00010000
+      SHAREDCACHE    = 0x00020000
+      PRIVATECACHE   = 0x00040000
+      WAL            = 0x00080000
+    end
+  end
+end
+
 module ArJdbc
   # All the code in this module is a copy of ConnectionAdapters::SQLite3Adapter from active_record 5.
   # The constants at the front of this file are to allow the rest of the file to remain with no modifications
@@ -30,7 +59,7 @@ module ArJdbc
     SchemaCreation = ConnectionAdapters::SQLite3::SchemaCreation
     SQLite3Adapter = ConnectionAdapters::AbstractAdapter
 
-    ADAPTER_NAME = 'SQLite'.freeze
+    ADAPTER_NAME = 'SQLite'
 
     # DIFFERENCE: FQN
     include ::ActiveRecord::ConnectionAdapters::SQLite3::Quoting
@@ -54,20 +83,8 @@ module ArJdbc
     # DIFFERENCE: class_attribute in original adapter is moved down to our section which is a class
     #  since we cannot define it here in the module (original source this is a class).
 
-    class StatementPool < ConnectionAdapters::StatementPool
-      private
-
-      def dealloc(stmt)
-        stmt[:stmt].close unless stmt[:stmt].closed?
-      end
-    end
-
     def initialize(connection, logger, connection_options, config)
       super(connection, logger, config)
-
-      @active     = true
-      @statements = StatementPool.new(self.class.type_cast_config_to_integer(config[:statement_limit]))
-
       configure_connection
     end
 
@@ -79,16 +96,28 @@ module ArJdbc
       true
     end
 
+    def supports_transaction_isolation?
+      true
+    end
+
     def supports_partial_index?
-      sqlite_version >= "3.8.0"
+      database_version >= "3.9.0"
+    end
+
+    def supports_expression_index?
+      database_version >= "3.9.0"
     end
 
     def requires_reloading?
       true
     end
 
-    def supports_foreign_keys_in_create?
-      sqlite_version >= "3.6.19"
+    def supports_foreign_keys?
+      true
+    end
+
+    def supports_check_constraints?
+      true
     end
 
     def supports_views?
@@ -99,38 +128,27 @@ module ArJdbc
       true
     end
 
-    def supports_multi_insert?
-      sqlite_version >= "3.7.11"
+    def supports_json?
+      true
     end
 
-    def active?
-      @active
+    def supports_common_table_expressions?
+      database_version >= "3.8.3"
     end
 
-    # Disconnects from the database if already connected. Otherwise, this
-    # method does nothing.
-    def disconnect!
-      super
-      @active = false
-      @connection.close rescue nil
+    def supports_insert_on_conflict?
+      database_version >= "3.24.0"
     end
+    alias supports_insert_on_duplicate_skip? supports_insert_on_conflict?
+    alias supports_insert_on_duplicate_update? supports_insert_on_conflict?
+    alias supports_insert_conflict_target? supports_insert_on_conflict?
 
-    # Clears the prepared statements cache.
-    def clear_cache!
-      @statements.clear
-    end
+    # DIFFERENCE: active?, reconnect!, disconnect! handles by arjdbc core
 
     def supports_index_sort_order?
       true
     end
 
-    # Returns 62. SQLite supports index names up to 64
-    # characters. The rest is used by Rails internally to perform
-    # temporary rename operations
-    def allowed_index_name_length
-      index_name_length - 2
-    end
-
     def native_database_types #:nodoc:
       NATIVE_DATABASE_TYPES
     end
@@ -144,90 +162,68 @@ module ArJdbc
       true
     end
 
+    def supports_lazy_transactions?
+      true
+    end
+
     # REFERENTIAL INTEGRITY ====================================
 
     def disable_referential_integrity # :nodoc:
-      old = query_value("PRAGMA foreign_keys")
+      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")
         yield
       ensure
-        execute("PRAGMA foreign_keys = #{old}")
+        execute("PRAGMA defer_foreign_keys = #{old_defer_foreign_keys}")
+        execute("PRAGMA foreign_keys = #{old_foreign_keys}")
       end
     end
-    
+
     #--
     # DATABASE STATEMENTS ======================================
     #++
 
+    READ_QUERY = ActiveRecord::ConnectionAdapters::AbstractAdapter.build_read_query_regexp(
+      :pragma
+    ) # :nodoc:
+    private_constant :READ_QUERY
+
+    def write_query?(sql) # :nodoc:
+      !READ_QUERY.match?(sql)
+    end
+
     def explain(arel, binds = [])
       sql = "EXPLAIN QUERY PLAN #{to_sql(arel, binds)}"
       # DIFFERENCE: FQN
       ::ActiveRecord::ConnectionAdapters::SQLite3::ExplainPrettyPrinter.new.pp(exec_query(sql, "EXPLAIN", []))
     end
 
-    def exec_query(sql, name = nil, binds = [], prepare: false)
-      type_casted_binds = type_casted_binds(binds)
-
-      log(sql, name, binds, type_casted_binds) do
-        ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
-          # Don't cache statements if they are not prepared
-          unless prepare
-            stmt = @connection.prepare(sql)
-            begin
-              cols = stmt.columns
-              unless without_prepared_statement?(binds)
-                stmt.bind_params(type_casted_binds)
-              end
-              records = stmt.to_a
-            ensure
-              stmt.close
-            end
-          else
-            cache = @statements[sql] ||= {
-                stmt: @connection.prepare(sql)
-            }
-            stmt = cache[:stmt]
-            cols = cache[:cols] ||= stmt.columns
-            stmt.reset!
-            stmt.bind_params(type_casted_binds)
-            records = stmt.to_a
-          end
-
-          ActiveRecord::Result.new(cols, records)
-        end
-      end
-    end
+    # DIFFERENCE: implemented in ArJdbc::Abstract::DatabaseStatements
+    #def exec_query(sql, name = nil, binds = [], prepare: false)
 
-    def exec_delete(sql, name = 'SQL', binds = [])
-      exec_query(sql, name, binds)
-      @connection.changes
-    end
-    alias :exec_update :exec_delete
+    # DIFFERENCE: implemented in ArJdbc::Abstract::DatabaseStatements
+    #def exec_delete(sql, name = "SQL", binds = [])
 
     def last_inserted_id(result)
       @connection.last_insert_row_id
     end
 
-    def execute(sql, name = nil) #:nodoc:
-      log(sql, name) do
-        ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
-          @connection.execute(sql)
-        end
-      end
-    end
+    # DIFFERENCE: implemented in ArJdbc::Abstract::DatabaseStatements
+    #def execute(sql, name = nil) #:nodoc:
 
     def begin_db_transaction #:nodoc:
-      log("begin transaction",nil) { @connection.transaction }
+      log("begin transaction", 'TRANSACTION') { @connection.transaction }
     end
 
     def commit_db_transaction #:nodoc:
-      log("commit transaction",nil) { @connection.commit }
+      log("commit transaction", 'TRANSACTION') { @connection.commit }
     end
 
     def exec_rollback_db_transaction #:nodoc:
-      log("rollback transaction",nil) { @connection.rollback }
+      log("rollback transaction", 'TRANSACTION') { @connection.rollback }
     end
 
     # SCHEMA STATEMENTS ========================================
@@ -237,8 +233,11 @@ module ArJdbc
       pks.sort_by { |f| f["pk"] }.map { |f| f["name"] }
     end
 
-    def remove_index(table_name, options = {}) #:nodoc:
-      index_name = index_name_for_remove(table_name, options)
+      def remove_index(table_name, column_name = nil, **options) # :nodoc:
+        return if options[:if_exists] && !index_exists?(table_name, column_name, **options)
+
+      index_name = index_name_for_remove(table_name, column_name, options)
+
       exec_query "DROP INDEX #{quote_column_name(index_name)}"
     end
 
@@ -247,30 +246,28 @@ module ArJdbc
     # Example:
     #   rename_table('octopuses', 'octopi')
     def rename_table(table_name, new_name)
+      schema_cache.clear_data_source_cache!(table_name.to_s)
+      schema_cache.clear_data_source_cache!(new_name.to_s)
       exec_query "ALTER TABLE #{quote_table_name(table_name)} RENAME TO #{quote_table_name(new_name)}"
       rename_table_indexes(table_name, new_name)
     end
 
-    # DIFFERENCE: deprecated causes a JRuby 9.1 bug where "super" calls itself -> do inline
-    def valid_alter_table_type?(type, options = {})
-      ActiveSupport::Deprecation.deprecation_warning(__method__)
-      !invalid_alter_table_type?(type, options)
-    end
-    #deprecate :valid_alter_table_type?
-
-    def add_column(table_name, column_name, type, options = {}) #:nodoc:
+    def add_column(table_name, column_name, type, **options) #:nodoc:
       if invalid_alter_table_type?(type, options)
         alter_table(table_name) do |definition|
-          definition.column(column_name, type, options)
+          definition.column(column_name, type, **options)
         end
       else
         super
       end
     end
 
-    def remove_column(table_name, column_name, type = nil, options = {}) #:nodoc:
+    def remove_column(table_name, column_name, type = nil, **options) #:nodoc:
       alter_table(table_name) do |definition|
         definition.remove_column column_name
+        definition.foreign_keys.delete_if do |_, fk_options|
+          fk_options[:column] == column_name.to_s
+        end
       end
     end
 
@@ -291,16 +288,11 @@ module ArJdbc
       end
     end
 
-    def change_column(table_name, column_name, type, options = {}) #:nodoc:
+    def change_column(table_name, column_name, type, **options) #:nodoc:
       alter_table(table_name) do |definition|
         definition[column_name].instance_eval do
           self.type    = type
-          self.limit   = options[:limit] if options.include?(:limit)
-          self.default = options[:default] if options.include?(:default)
-          self.null    = options[:null] if options.include?(:null)
-          self.precision = options[:precision] if options.include?(:precision)
-          self.scale   = options[:scale] if options.include?(:scale)
-          self.collation = options[:collation] if options.include?(:collation)
+            self.options.merge!(options)
         end
       end
     end
@@ -330,14 +322,6 @@ module ArJdbc
       end
     end
 
-    def insert_fixtures(rows, table_name)
-      ActiveSupport::Deprecation.warn(<<-MSG.squish)
-          `insert_fixtures` is deprecated and will be removed in the next version of Rails.
-          Consider using `insert_fixtures_set` for performance improvement.
-      MSG
-      insert_fixtures_set(table_name => rows)
-    end
-
     def insert_fixtures_set(fixture_set, tables_to_delete = [])
       disable_referential_integrity do
         transaction(requires_new: true) do
@@ -349,11 +333,44 @@ module ArJdbc
         end
       end
     end
-    
+
+    def build_insert_sql(insert) # :nodoc:
+      sql = +"INSERT #{insert.into} #{insert.values_list}"
+
+      if insert.skip_duplicates?
+        sql << " ON CONFLICT #{insert.conflict_target} DO NOTHING"
+      elsif insert.update_duplicates?
+        sql << " ON CONFLICT #{insert.conflict_target} DO UPDATE SET "
+        sql << insert.touch_model_timestamps_unless { |column| "#{column} IS excluded.#{column}" }
+        sql << insert.updatable_columns.map { |column| "#{column}=excluded.#{column}" }.join(",")
+      end
+
+      sql
+    end
+
+    def shared_cache?
+      config[:properties] && config[:properties][:shared_cache] == true
+    end
+
+    def get_database_version # :nodoc:
+      SQLite3Adapter::Version.new(query_value("SELECT sqlite_version(*)"))
+    end
+
+    def build_truncate_statement(table_name)
+      "DELETE FROM #{quote_table_name(table_name)}"
+    end
+
+    def check_version
+      if database_version < "3.8.0"
+        raise "Your version of SQLite (#{database_version}) is too old. Active Record supports SQLite >= 3.8."
+      end
+    end
+
     private
-    def initialize_type_map(m = type_map)
-      super
-      register_class_with_limit m, %r(int)i, SQLite3Integer
+    # See https://www.sqlite.org/limits.html,
+    # the default value is 999 when not configured.
+    def bind_params_length
+      999
     end
 
     def table_structure(table_name)
@@ -366,17 +383,40 @@ 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]
+      type.to_sym == :primary_key || options[:primary_key] ||
+        options[:null] == false && options[:default].nil?
     end
 
-    def alter_table(table_name, options = {}) #:nodoc:
+    def alter_table(
+      table_name,
+      foreign_keys = foreign_keys(table_name),
+      check_constraints = check_constraints(table_name),
+      **options
+    )
       altered_table_name = "a#{table_name}"
-      caller = lambda { |definition| yield definition if block_given? }
+
+      caller = lambda do |definition|
+        rename = options[:rename] || {}
+        foreign_keys.each do |fk|
+          if column = rename[fk.options[:column]]
+            fk.options[:column] = column
+          end
+          to_table = strip_table_name_prefix_and_suffix(fk.to_table)
+          definition.foreign_key(to_table, **fk.options)
+        end
+
+        check_constraints.each do |chk|
+          definition.check_constraint(chk.expression, **chk.options)
+        end
+
+        yield definition if block_given?
+      end
 
       transaction do
-        move_table(table_name, altered_table_name,
-                   options.merge(temporary: true))
-        move_table(altered_table_name, table_name, &caller)
+        disable_referential_integrity do
+          move_table(table_name, altered_table_name, options.merge(temporary: true))
+          move_table(altered_table_name, table_name, &caller)
+        end
       end
     end
 
@@ -388,30 +428,32 @@ module ArJdbc
     def copy_table(from, to, options = {})
       from_primary_key = primary_key(from)
       options[:id] = false
-      create_table(to, options) do |definition|
+      create_table(to, **options) do |definition|
         @definition = definition
         if from_primary_key.is_a?(Array)
           @definition.primary_keys from_primary_key
         end
+
         columns(from).each do |column|
           column_name = options[:rename] ?
-              (options[:rename][column.name] ||
-                  options[:rename][column.name.to_sym] ||
-                  column.name) : column.name
+            (options[:rename][column.name] ||
+             options[:rename][column.name.to_sym] ||
+             column.name) : column.name
 
           @definition.column(column_name, column.type,
-                             limit: column.limit, default: column.default,
-                             precision: column.precision, scale: column.scale,
-                             null: column.null, collation: column.collation,
-                             primary_key: column_name == from_primary_key
+            limit: column.limit, default: column.default,
+            precision: column.precision, scale: column.scale,
+            null: column.null, collation: column.collation,
+            primary_key: column_name == from_primary_key
           )
         end
+
         yield @definition if block_given?
       end
       copy_table_indexes(from, to, options[:rename] || {})
       copy_table_contents(from, to,
-                          @definition.columns.map(&:name),
-                          options[:rename] || {})
+        @definition.columns.map(&:name),
+        options[:rename] || {})
     end
 
     def copy_table_indexes(from, to, rename = {})
@@ -419,24 +461,27 @@ module ArJdbc
         name = index.name
         # indexes sqlite creates for internal use start with `sqlite_` and
         # don't need to be copied
-        next if name.starts_with?("sqlite_")
+        next if name.start_with?("sqlite_")
         if to == "a#{from}"
           name = "t#{name}"
         elsif from == "a#{to}"
           name = name[1..-1]
         end
 
-        to_column_names = columns(to).map(&:name)
-        columns = index.columns.map { |c| rename[c] || c }.select do |column|
-          to_column_names.include?(column)
+        columns = index.columns
+        if columns.is_a?(Array)
+          to_column_names = columns(to).map(&:name)
+          columns = columns.map { |c| rename[c] || c }.select do |column|
+            to_column_names.include?(column)
+          end
         end
 
         unless columns.empty?
           # index name can't be the same
-          opts = { name: name.gsub(/(^|_)(#{from})_/, "\\1#{to}_"), internal: true }
-          opts[:unique] = true if index.unique
-          opts[:where] = index.where if index.where
-          add_index(to, columns, opts)
+          options = { name: name.gsub(/(^|_)(#{from})_/, "\\1#{to}_"), internal: true }
+          options[:unique] = true if index.unique
+          options[:where] = index.where if index.where
+          add_index(to, columns, **options)
         end
       end
     end
@@ -454,27 +499,23 @@ module ArJdbc
                      SELECT #{quoted_from_columns} FROM #{quote_table_name(from)}")
     end
 
-    def sqlite_version
-      @sqlite_version ||= SQLite3Adapter::Version.new(select_value("select sqlite_version(*)"))
-    end
-
-    def translate_exception(exception, message)
+    def translate_exception(exception, message:, sql:, binds:)
       case exception.message
-        # SQLite 3.8.2 returns a newly formatted error message:
-        #   UNIQUE constraint failed: *table_name*.*column_name*
-        # Older versions of SQLite return:
-        #   column *column_name* is not unique
-        when /column(s)? .* (is|are) not unique/, /UNIQUE constraint failed: .*/
-          # DIFFERENCE: FQN
-          ::ActiveRecord::RecordNotUnique.new(message)
-        when /.* may not be NULL/, /NOT NULL constraint failed: .*/
-          # DIFFERENCE: FQN
-          ::ActiveRecord::NotNullViolation.new(message)
-        when /FOREIGN KEY constraint failed/i
-          # DIFFERENCE: FQN
-          ::ActiveRecord::InvalidForeignKey.new(message)
-        else
-          super
+      # SQLite 3.8.2 returns a newly formatted error message:
+      #   UNIQUE constraint failed: *table_name*.*column_name*
+      # Older versions of SQLite return:
+      #   column *column_name* is not unique
+      when /column(s)? .* (is|are) not unique/, /UNIQUE constraint failed: .*/
+        # DIFFERENCE: FQN
+        ::ActiveRecord::RecordNotUnique.new(message, sql: sql, binds: binds)
+      when /.* may not be NULL/, /NOT NULL constraint failed: .*/
+        # DIFFERENCE: FQN
+        ::ActiveRecord::NotNullViolation.new(message, sql: sql, binds: binds)
+      when /FOREIGN KEY constraint failed/i
+        # DIFFERENCE: FQN
+        ::ActiveRecord::InvalidForeignKey.new(message, sql: sql, binds: binds)
+      else
+        super
       end
     end
 
@@ -482,11 +523,11 @@ module ArJdbc
 
     def table_structure_with_collation(table_name, basic_structure)
       collation_hash = {}
-      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 = <<~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
@@ -495,9 +536,9 @@ module ArJdbc
       result = exec_query(sql, "SCHEMA").first
 
       if result
-        # Splitting with left parentheses and picking up last will return all
+        # Splitting with left parentheses and discarding the first part will return all
         # columns separated with comma(,).
-        columns_string = result["sql"].split("(").last
+        columns_string = result["sql"].split("(", 2).last
 
         columns_string.split(",").each do |column_string|
           # This regex will match the column name and collation type and will save
@@ -505,7 +546,7 @@ module ArJdbc
           collation_hash[$1] = $2 if COLLATE_REGEX =~ column_string
         end
 
-        basic_structure.map! do |column|
+        basic_structure.map do |column|
           column_name = column["name"]
 
           if collation_hash.has_key? column_name
@@ -515,7 +556,7 @@ module ArJdbc
           column
         end
       else
-        basic_structure.to_hash
+        basic_structure.to_a
       end
     end
 
@@ -527,18 +568,6 @@ module ArJdbc
       execute("PRAGMA foreign_keys = ON", "SCHEMA")
     end
 
-    # DIFFERENCE: FQN
-    class SQLite3Integer < ::ActiveRecord::Type::Integer # :nodoc:
-      private
-      def _limit
-        # INTEGER storage class can be stored 8 bytes value.
-        # See https://www.sqlite.org/datatype3.html#storage_classes_and_datatypes
-        limit || 8
-      end
-    end
-
-    # DIFFERENCE: FQN
-    ::ActiveRecord::Type.register(:integer, SQLite3Integer, adapter: :sqlite3)
   end
   # DIFFERENCE: A registration here is moved down to concrete class so we are not registering part of an adapter.
 end
@@ -597,24 +626,6 @@ module ActiveRecord::ConnectionAdapters
 
     private
 
-    # @override {ActiveRecord::ConnectionAdapters::Column#simplified_type}
-    def simplified_type(field_type)
-      case field_type
-        when /boolean/i       then :boolean
-        when /text/i          then :text
-        when /varchar/i       then :string
-        when /int/i           then :integer
-        when /float/i         then :float
-        when /real|decimal/i  then
-          extract_scale(field_type) == 0 ? :integer : :decimal
-        when /datetime/i      then :datetime
-        when /date/i          then :date
-        when /time/i          then :time
-        when /blob/i          then :binary
-        else super
-      end
-    end
-
     # @override {ActiveRecord::ConnectionAdapters::Column#extract_limit}
     def extract_limit(sql_type)
       return nil if sql_type =~ /^(real)\(\d+/i
@@ -646,37 +657,42 @@ module ActiveRecord::ConnectionAdapters
   class SQLite3Adapter < AbstractAdapter
     include ArJdbc::Abstract::Core
     include ArJdbc::SQLite3
+    include ArJdbc::Abstract::ConnectionManagement
     include ArJdbc::Abstract::DatabaseStatements
     include ArJdbc::Abstract::StatementCache
     include ArJdbc::Abstract::TransactionSupport
 
-    # Note: This is part of original AR sqlite3_adapter.rb and not an override by us.  This is to just
-    # work around our copy of Sqlite3Adapter being a module above and not a class.
-    ##
-    # :singleton-method:
-    # Indicates whether boolean values are stored in sqlite3 databases as 1
-    # and 0 or 't' and 'f'. Leaving <tt>ActiveRecord::ConnectionAdapters::SQLite3Adapter.represent_boolean_as_integer</tt>
-    # set to false is deprecated. SQLite databases have used 't' and 'f' to
-    # serialize boolean values and must have old data converted to 1 and 0
-    # (its native boolean serialization) before setting this flag to true.
-    # Conversion can be accomplished by setting up a rake task which runs
-    #
-    #   ExampleModel.where("boolean_column = 't'").update_all(boolean_column: 1)
-    #   ExampleModel.where("boolean_column = 'f'").update_all(boolean_column: 0)
-    # for all models and all boolean columns, after which the flag must be set
-    # to true by adding the following to your <tt>application.rb</tt> file:
-    #
-    #   Rails.application.config.active_record.sqlite3.represent_boolean_as_integer = true
-    class_attribute :represent_boolean_as_integer, default: false
+    def self.represent_boolean_as_integer=(value) # :nodoc:
+      if value == false
+        raise "`.represent_boolean_as_integer=` is now always true, so make sure your application can work with it and remove this settings."
+      end
+
+      ActiveSupport::Deprecation.warn(
+        "`.represent_boolean_as_integer=` is now always true, so setting this is deprecated and will be removed in Rails 6.1."
+      )
+    end
+
+    def self.database_exists?(config)
+      config = config.symbolize_keys
+      if config[:database] == ":memory:"
+        return true
+      else
+        database_file = defined?(Rails.root) ? File.expand_path(config[:database], Rails.root) : config[:database]
+        File.exist?(database_file)
+      end
+    end
+
 
     def supports_transaction_isolation?
       false
     end
 
     def begin_isolated_db_transaction(isolation)
-      raise ActiveRecord::TransactionIsolationError, 'adapter does not support setting transaction isolation'
+      raise ActiveRecord::TransactionIsolationError, "SQLite3 only supports the `read_uncommitted` transaction isolation level" if isolation != :read_uncommitted
+      raise StandardError, "You need to enable the shared-cache mode in SQLite mode before attempting to change the transaction isolation level" unless shared_cache?
+      super
     end
-    
+
     # SQLite driver doesn't support all types of insert statements with executeUpdate so
     # make it act like a regular query and the ids will be returned from #last_inserted_id
     # example: INSERT INTO "aircraft" DEFAULT VALUES
@@ -699,5 +715,34 @@ module ActiveRecord::ConnectionAdapters
 
     # Note: This is not an override of ours but a moved line from AR Sqlite3Adapter to register ours vs our copied module (which would be their class).
 #    ActiveSupport.run_load_hooks(:active_record_sqlite3adapter, SQLite3Adapter)
+
+    private
+
+    # because the JDBC driver doesn't like multiple SQL statements in one JDBC statement
+    def combine_multi_statements(total_sql)
+      if total_sql.length == 1
+        total_sql.first
+      else
+        total_sql
+      end
+    end
+
+    def initialize_type_map(m = type_map)
+      super
+      register_class_with_limit m, %r(int)i, SQLite3Integer
+    end
+
+    # DIFFERENCE: FQN
+    class SQLite3Integer < ::ActiveRecord::Type::Integer # :nodoc:
+      private
+      def _limit
+        # INTEGER storage class can be stored 8 bytes value.
+        # See https://www.sqlite.org/datatype3.html#storage_classes_and_datatypes
+        limit || 8
+      end
+    end
+
+    # DIFFERENCE: FQN
+    ::ActiveRecord::Type.register(:integer, SQLite3Integer, adapter: :sqlite3)
   end
 end