activerecord-jdbc-adapter 70.0.pre-java → 70.1-java

data/lib/arjdbc/postgresql/adapter.rb

@@ -21,6 +21,7 @@ require 'arjdbc/abstract/transaction_support'
 require 'arjdbc/postgresql/base/array_decoder'
 require 'arjdbc/postgresql/base/array_encoder'
 require 'arjdbc/postgresql/name'
+require 'active_model'
 
 module ArJdbc
   # Strives to provide Rails built-in PostgreSQL adapter (API) compatibility.
@@ -320,6 +321,38 @@ module ArJdbc
       exec_query("SELECT extname FROM pg_extension", "SCHEMA").cast_values
     end
 
+    # Returns a list of defined enum types, and their values.
+    def enum_types
+      query = <<~SQL
+          SELECT
+            type.typname AS name,
+            string_agg(enum.enumlabel, ',' ORDER BY enum.enumsortorder) AS value
+          FROM pg_enum AS enum
+          JOIN pg_type AS type
+            ON (type.oid = enum.enumtypid)
+          GROUP BY type.typname;
+      SQL
+      exec_query(query, "SCHEMA").cast_values
+    end
+
+    # Given a name and an array of values, creates an enum type.
+    def create_enum(name, values)
+      sql_values = values.map { |s| "'#{s}'" }.join(", ")
+      query = <<~SQL
+          DO $$
+          BEGIN
+              IF NOT EXISTS (
+                SELECT 1 FROM pg_type t
+                WHERE t.typname = '#{name}'
+              ) THEN
+                  CREATE TYPE \"#{name}\" AS ENUM (#{sql_values});
+              END IF;
+          END
+          $$;
+      SQL
+      exec_query(query)
+    end
+
     # Returns the configured supported identifier length supported by PostgreSQL
     def max_identifier_length
       @max_identifier_length ||= query_value("SHOW max_identifier_length", "SCHEMA").to_i
@@ -672,6 +705,37 @@ module ActiveRecord::ConnectionAdapters
   class PostgreSQLAdapter < AbstractAdapter
     class_attribute :create_unlogged_tables, default: false
 
+    ##
+    # :singleton-method:
+    # PostgreSQL allows the creation of "unlogged" tables, which do not record
+    # data in the PostgreSQL Write-Ahead Log. This can make the tables faster,
+    # but significantly increases the risk of data loss if the database
+    # crashes. As a result, this should not be used in production
+    # environments. If you would like all created tables to be unlogged in
+    # the test environment you can add the following line to your test.rb
+    # file:
+    #
+    #   ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.create_unlogged_tables = true
+    class_attribute :create_unlogged_tables, default: false
+
+    ##
+    # :singleton-method:
+    # PostgreSQL supports multiple types for DateTimes. By default, if you use +datetime+
+    # in migrations, Rails will translate this to a PostgreSQL "timestamp without time zone".
+    # Change this in an initializer to use another NATIVE_DATABASE_TYPES. For example, to
+    # store DateTimes as "timestamp with time zone":
+    #
+    #   ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.datetime_type = :timestamptz
+    #
+    # Or if you are adding a custom type:
+    #
+    #   ActiveRecord::ConnectionAdapters::PostgreSQLAdapter::NATIVE_DATABASE_TYPES[:my_custom_type] = { name: "my_custom_type_name" }
+    #   ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.datetime_type = :my_custom_type
+    #
+    # If you're using +:ruby+ as your +config.active_record.schema_format+ and you change this
+    # 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
+
     # 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
@@ -735,11 +799,96 @@ module ActiveRecord::ConnectionAdapters
 
     private
 
-    # Prepared statements aren't schema aware so we need to make sure we
-    # store different PreparedStatement objects for different schemas
+    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)
+        result = exec_no_cache(sql, name, binds, async: async)
+      else
+        result = exec_cache(sql, name, binds, async: async)
+      end
+      begin
+        ret = yield result
+      ensure
+        # Is this really result in AR PG?
+#        result.clear
+      end
+      ret
+    end
+
+    def exec_no_cache(sql, name, binds, async: false)
+      materialize_transactions
+      mark_transaction_written_if_write(sql)
+
+      # make sure we carry over any changes to ActiveRecord.default_timezone that have been
+      # made since we established the connection
+      update_typemap_for_default_timezone
+
+      type_casted_binds = type_casted_binds(binds)
+      log(sql, name, binds, type_casted_binds, async: async) do
+        ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
+          @connection.exec_params(sql, type_casted_binds)
+        end
+      end
+    end
+
+    def exec_cache(sql, name, binds, async: false)
+      materialize_transactions
+      mark_transaction_written_if_write(sql)
+      update_typemap_for_default_timezone
+
+      stmt_key = prepare_statement(sql, binds)
+      type_casted_binds = type_casted_binds(binds)
+
+      log(sql, name, binds, type_casted_binds, stmt_key, async: async) do
+        ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
+          @connection.exec_prepared(stmt_key, type_casted_binds)
+        end
+      end
+    rescue ActiveRecord::StatementInvalid => e
+      raise unless is_cached_plan_failure?(e)
+
+      # Nothing we can do if we are in a transaction because all commands
+      # will raise InFailedSQLTransaction
+      if in_transaction?
+        raise ActiveRecord::PreparedStatementCacheExpired.new(e.cause.message)
+      else
+        @lock.synchronize do
+          # outside of transactions we can simply flush this query and retry
+          @statements.delete sql_key(sql)
+        end
+        retry
+      end
+    end
+
+    # Annoyingly, the code for prepared statements whose return value may
+    # have changed is FEATURE_NOT_SUPPORTED.
+    #
+    # This covers various different error types so we need to do additional
+    # work to classify the exception definitively as a
+    # ActiveRecord::PreparedStatementCacheExpired
+    #
+    # Check here for more details:
+    # https://git.postgresql.org/gitweb/?p=postgresql.git;a=blob;f=src/backend/utils/cache/plancache.c#l573
+    def is_cached_plan_failure?(e)
+      pgerror = e.cause
+      pgerror.result.result_error_field(PG::PG_DIAG_SQLSTATE) == FEATURE_NOT_SUPPORTED &&
+        pgerror.result.result_error_field(PG::PG_DIAG_SOURCE_FUNCTION) == "RevalidateCachedQuery"
+    rescue
+      false
+    end
+
+    def in_transaction?
+      open_transactions > 0
+    end
+
+    # Returns the statement identifier for the client side cache
+    # of statements
     def sql_key(sql)
       "#{schema_search_path}-#{sql}"
     end
-
   end
 end

data/lib/arjdbc/postgresql/oid_types.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-
 require 'thread'
 
 module ArJdbc
@@ -91,8 +90,23 @@ module ArJdbc
       end
 
       def get_oid_type(oid, fmod, column_name, sql_type = '') # :nodoc:
-        if !type_map.key?(oid)
-          load_additional_types(type_map, oid)
+        # Note: type_map is storing a bunch of oid type prefixed with a namespace even
+        # if they are not namespaced (e.g. ""."oidvector").  builtin types which are
+        # common seem to not be prefixed (e.g. "varchar").  OID numbers are also keys
+        # but JDBC never returns those.  So the current scheme is to check with
+        # what we got and that covers number and plain strings and otherwise we will
+        # wrap with the namespace form.
+        found = type_map.key?(oid)
+
+        if !found
+          key = oid.kind_of?(String) && oid != "oid" ? "\"\".\"#{oid}\"" : oid
+          found = type_map.key?(key)
+
+          if !found
+            load_additional_types([oid])
+          else
+            oid = key
+          end
         end
 
         type_map.fetch(oid, fmod, sql_type) {
@@ -103,132 +117,165 @@ module ArJdbc
         }
       end
 
+      def reload_type_map
+          type_map.clear
+          initialize_type_map
+      end
+
+        def initialize_type_map_inner(m)
+          m.register_type "int2", Type::Integer.new(limit: 2)
+          m.register_type "int4", Type::Integer.new(limit: 4)
+          m.register_type "int8", Type::Integer.new(limit: 8)
+          m.register_type "oid", OID::Oid.new
+          m.register_type "float4", Type::Float.new
+          m.alias_type "float8", "float4"
+          m.register_type "text", Type::Text.new
+          register_class_with_limit m, "varchar", Type::String
+          m.alias_type "char", "varchar"
+          m.alias_type "name", "varchar"
+          m.alias_type "bpchar", "varchar"
+          m.register_type "bool", Type::Boolean.new
+          register_class_with_limit m, "bit", OID::Bit
+          register_class_with_limit m, "varbit", OID::BitVarying
+          m.register_type "date", OID::Date.new
+
+          m.register_type "money", OID::Money.new
+          m.register_type "bytea", OID::Bytea.new
+          m.register_type "point", OID::Point.new
+          m.register_type "hstore", OID::Hstore.new
+          m.register_type "json", Type::Json.new
+          m.register_type "jsonb", OID::Jsonb.new
+          m.register_type "cidr", OID::Cidr.new
+          m.register_type "inet", OID::Inet.new
+          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::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)
+          m.register_type "lseg", OID::SpecializedString.new(:lseg)
+          m.register_type "box", OID::SpecializedString.new(:box)
+          m.register_type "path", OID::SpecializedString.new(:path)
+          m.register_type "polygon", OID::SpecializedString.new(:polygon)
+          m.register_type "circle", OID::SpecializedString.new(:circle)
+          m.register_type "regproc", OID::Enum.new
+          # FIXME: adding this vector type leads to quoting not handlign Array data in quoting.
+          #m.register_type "_int4", OID::Vector.new(",", m.lookup("int4"))
+          register_class_with_precision m, "time", Type::Time
+          register_class_with_precision m, "timestamp", OID::Timestamp
+          register_class_with_precision m, "timestamptz", OID::TimestampWithTimeZone
+
+          m.register_type "numeric" do |_, fmod, sql_type|
+            precision = extract_precision(sql_type)
+            scale = extract_scale(sql_type)
+
+            # The type for the numeric depends on the width of the field,
+            # so we'll do something special here.
+            #
+            # When dealing with decimal columns:
+            #
+            # places after decimal  = fmod - 4 & 0xffff
+            # places before decimal = (fmod - 4) >> 16 & 0xffff
+            if fmod && (fmod - 4 & 0xffff).zero?
+              # FIXME: Remove this class, and the second argument to
+              # lookups on PG
+              Type::DecimalWithoutScale.new(precision: precision)
+            else
+              OID::Decimal.new(precision: precision, scale: scale)
+            end
+          end
+
+          m.register_type "interval" do |*args, sql_type|
+            precision = extract_precision(sql_type)
+            OID::Interval.new(precision: precision)
+          end
+
+          # pgjdbc returns these if the column is auto-incrmenting
+          m.alias_type 'serial', 'int4'
+          m.alias_type 'bigserial', 'int8'
+        end
+
+
+      # We differ from AR here because we will initialize type_map when adapter initializes
       def type_map
         @type_map
       end
 
-      def reload_type_map
-        if ( @type_map ||= nil )
-          @type_map.clear
-          initialize_type_map(@type_map)
-        end
+      def initialize_type_map(m = type_map)
+        initialize_type_map_inner(m)
+        load_additional_types
       end
 
       private
 
-      def initialize_type_map(m = type_map)
-        register_class_with_limit m, 'int2', Type::Integer
-        register_class_with_limit m, 'int4', Type::Integer
-        register_class_with_limit m, 'int8', Type::Integer
-        m.register_type 'oid', OID::Oid.new
-        m.register_type 'float4', Type::Float.new
-        m.alias_type 'float8', 'float4'
-        m.register_type 'text', Type::Text.new
-        register_class_with_limit m, 'varchar', Type::String
-        m.alias_type 'char', 'varchar'
-        m.alias_type 'name', 'varchar'
-        m.alias_type 'bpchar', 'varchar'
-        m.register_type 'bool', Type::Boolean.new
-        register_class_with_limit m, 'bit', OID::Bit
-        register_class_with_limit m, 'varbit', OID::BitVarying
-        m.alias_type 'timestamptz', 'timestamp'
-        m.register_type 'date', OID::Date.new
-
-        m.register_type 'money', OID::Money.new
-        m.register_type 'bytea', OID::Bytea.new
-        m.register_type 'point', OID::Point.new
-        m.register_type 'hstore', OID::Hstore.new
-        m.register_type 'json', Type::Json.new
-        m.register_type 'jsonb', OID::Jsonb.new
-        m.register_type 'cidr', OID::Cidr.new
-        m.register_type 'inet', OID::Inet.new
-        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::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)
-        m.register_type 'lseg', OID::SpecializedString.new(:lseg)
-        m.register_type 'box', OID::SpecializedString.new(:box)
-        m.register_type 'path', OID::SpecializedString.new(:path)
-        m.register_type 'polygon', OID::SpecializedString.new(:polygon)
-        m.register_type 'circle', OID::SpecializedString.new(:circle)
-
-        m.register_type 'interval' do |*args, sql_type|
-          precision = extract_precision(sql_type)
-          OID::Interval.new(precision: precision)
+      def register_class_with_limit(...)
+        ::ActiveRecord::ConnectionAdapters::AbstractAdapter.send(:register_class_with_limit, ...)
+      end
+
+      def register_class_with_precision(...)
+        ::ActiveRecord::ConnectionAdapters::AbstractAdapter.send(:register_class_with_precision, ...)
+      end
+
+      def load_additional_types(oids = nil) # :nodoc:
+        initializer = ArjdbcTypeMapInitializer.new(type_map)
+        load_types_queries(initializer, oids) do |query|
+          execute_and_clear(query, "SCHEMA", []) do |records|
+            initializer.run(records)
+          end
         end
+      end
 
-        register_class_with_precision m, 'time', Type::Time
-        register_class_with_precision m, 'timestamp', OID::DateTime
-
-        m.register_type 'numeric' do |_, fmod, sql_type|
-          precision = extract_precision(sql_type)
-          scale = extract_scale(sql_type)
-
-          # The type for the numeric depends on the width of the field,
-          # so we'll do something special here.
-          #
-          # When dealing with decimal columns:
-          #
-          # places after decimal  = fmod - 4 & 0xffff
-          # places before decimal = (fmod - 4) >> 16 & 0xffff
-          if fmod && (fmod - 4 & 0xffff).zero?
-            # FIXME: Remove this class, and the second argument to
-            # lookups on PG
-            Type::DecimalWithoutScale.new(precision: precision)
+      def load_types_queries(initializer, oids)
+        query = <<~SQL
+            SELECT t.oid, t.typname, t.typelem, t.typdelim, t.typinput, r.rngsubtype, t.typtype, t.typbasetype
+            FROM pg_type as t
+            LEFT JOIN pg_range as r ON oid = rngtypid
+        SQL
+        if oids
+          if oids.all? { |e| e.kind_of? Numeric }
+            yield query + "WHERE t.oid IN (%s)" % oids.join(", ")
           else
-            OID::Decimal.new(precision: precision, scale: scale)
+            in_list = oids.map { |e| %Q{'#{e}'} }.join(", ")
+            yield query + "WHERE t.typname IN (%s)" % in_list
           end
+        else
+          yield query + initializer.query_conditions_for_known_type_names
+          yield query + initializer.query_conditions_for_known_type_types
+          yield query + initializer.query_conditions_for_array_types
         end
-
-        load_additional_types(m)
-
-        # pgjdbc returns these if the column is auto-incrmenting
-        m.alias_type 'serial', 'int4'
-        m.alias_type 'bigserial', 'int8'
       end
 
-      def load_additional_types(type_map, oid = nil) # :nodoc:
-        initializer = ArjdbcTypeMapInitializer.new(type_map)
+      def update_typemap_for_default_timezone
+        if @default_timezone != ActiveRecord.default_timezone && @timestamp_decoder
+          decoder_class = ActiveRecord.default_timezone == :utc ?
+                            PG::TextDecoder::TimestampUtc :
+                            PG::TextDecoder::TimestampWithoutTimeZone
 
-        if supports_ranges?
-          query = <<-SQL
-              SELECT t.oid, t.typname, t.typelem, t.typdelim, t.typinput, r.rngsubtype, t.typtype, t.typbasetype,
-                ns.nspname, ns.nspname = ANY(current_schemas(true)) in_ns
-              FROM pg_type as t
-              LEFT JOIN pg_range as r ON oid = rngtypid
-              JOIN pg_namespace AS ns ON t.typnamespace = ns.oid
-          SQL
-        else
-          query = <<-SQL
-              SELECT t.oid, t.typname, t.typelem, t.typdelim, t.typinput, t.typtype, t.typbasetype,
-                ns.nspname, ns.nspname = ANY(current_schemas(true)) in_ns
-              FROM pg_type as t
-              JOIN pg_namespace AS ns ON t.typnamespace = ns.oid
-          SQL
-        end
+          @timestamp_decoder = decoder_class.new(@timestamp_decoder.to_h)
+          @connection.type_map_for_results.add_coder(@timestamp_decoder)
 
-        if oid
-          if oid.is_a? Numeric || oid.match(/^\d+$/)
-            # numeric OID
-            query += "WHERE t.oid = %s" % oid
+          @default_timezone = ActiveRecord.default_timezone
 
-          elsif m = oid.match(/"?(\w+)"?\."?(\w+)"?/)
-            # namespace and type name
-            query += "WHERE ns.nspname = '%s' AND t.typname = '%s'" % [m[1], m[2]]
+          # if default timezone has changed, we need to reconfigure the connection
+          # (specifically, the session time zone)
+          configure_connection
+        end
+      end
 
-          else
-            # only type name
-            query += "WHERE t.typname = '%s' AND ns.nspname = ANY(current_schemas(true))" % oid
-          end
-        else
-          query += initializer.query_conditions_for_initial_load
+      def extract_scale(sql_type)
+        case sql_type
+        when /\((\d+)\)/ then 0
+        when /\((\d+)(,(\d+))\)/ then $3.to_i
         end
+      end
+
+      def extract_precision(sql_type)
+        $1.to_i if sql_type =~ /\((\d+)(,\d+)?\)/
+      end
 
-        records = execute(query, 'SCHEMA')
-        initializer.run(records)
+      def extract_limit(sql_type)
+        $1.to_i if sql_type =~ /\((.*)\)/
       end
 
       # Support arrays/ranges for defining attributes that don't exist in the db

data/lib/arjdbc/sqlite3/adapter.rb

@@ -262,9 +262,7 @@ module ArJdbc
     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
+        definition.foreign_keys.delete_if { |fk| fk.column == column_name.to_s }
       end
     end
 
@@ -298,8 +296,8 @@ module ArJdbc
     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.options.merge!(options)
+          self.type = aliased_types(type.to_s, type)
+          self.options.merge!(options)
         end
       end
     end
@@ -336,8 +334,12 @@ module ArJdbc
         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(",")
+        if insert.raw_update_sql?
+          sql << insert.raw_update_sql
+        else
+          sql << insert.touch_model_timestamps_unless { |column| "#{column} IS excluded.#{column}" }
+          sql << insert.updatable_columns.map { |column| "#{column}=excluded.#{column}" }.join(",")
+        end
       end
 
       sql
@@ -348,7 +350,7 @@ module ArJdbc
     end
 
     def get_database_version # :nodoc:
-      SQLite3Adapter::Version.new(query_value("SELECT sqlite_version(*)"))
+      SQLite3Adapter::Version.new(query_value("SELECT sqlite_version(*)", "SCHEMA"))
     end
 
     def check_version
@@ -459,8 +461,13 @@ 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)
+          end
+
           @definition.column(column_name, column.type,
-            limit: column.limit, default: column.default,
+            limit: column.limit, default: default,
             precision: column.precision, scale: column.scale,
             null: column.null, collation: column.collation,
             primary_key: column_name == from_primary_key
@@ -478,9 +485,6 @@ module ArJdbc
     def copy_table_indexes(from, to, rename = {})
       indexes(from).each do |index|
         name = index.name
-        # indexes sqlite creates for internal use start with `sqlite_` and
-        # don't need to be copied
-        next if name.start_with?("sqlite_")
         if to == "a#{from}"
           name = "t#{name}"
         elsif from == "a#{to}"
@@ -520,20 +524,22 @@ module ArJdbc
     end
 
     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: .*/
+      if exception.message.match?(/(column(s)? .* (is|are) not unique|UNIQUE constraint failed: .*)/i)
         # DIFFERENCE: FQN
         ::ActiveRecord::RecordNotUnique.new(message, sql: sql, binds: binds)
-      when /.* may not be NULL/, /NOT NULL constraint failed: .*/
+      elsif exception.message.match?(/(.* may not be NULL|NOT NULL constraint failed: .*)/i)
         # DIFFERENCE: FQN
         ::ActiveRecord::NotNullViolation.new(message, sql: sql, binds: binds)
-      when /FOREIGN KEY constraint failed/i
+      elsif exception.message.match?(/FOREIGN KEY constraint failed/i)
         # DIFFERENCE: FQN
         ::ActiveRecord::InvalidForeignKey.new(message, sql: sql, binds: binds)
+      elsif exception.message.match?(/called on a closed database/i)
+        # DIFFERENCE: FQN
+        ::ActiveRecord::ConnectionNotEstablished.new(exception)
       else
         super
       end
@@ -553,12 +559,12 @@ module ArJdbc
       # Result will have following sample string
       # CREATE TABLE "users" ("id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
       #                       "password_digest" varchar COLLATE "NOCASE");
-      result = exec_query(sql, "SCHEMA").first
+      result = query_value(sql, "SCHEMA")
 
       if result
         # Splitting with left parentheses and discarding the first part will return all
         # columns separated with comma(,).
-        columns_string = result["sql"].split("(", 2).last
+        columns_string = result.split("(", 2).last
 
         columns_string.split(",").each do |column_string|
           # This regex will match the column name and collation type and will save
@@ -596,6 +602,9 @@ module ArJdbc
     end
 
     def configure_connection
+      # FIXME: missing from adapter
+#      @connection.busy_timeout(self.class.type_cast_config_to_integer(@config[:timeout])) if @config[:timeout]
+
       execute("PRAGMA foreign_keys = ON", "SCHEMA")
     end
 
@@ -747,6 +756,29 @@ 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)
 
+    # 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)
+
+    class << self
+      private
+        def initialize_type_map(m)
+          super
+          register_class_with_limit m, %r(int)i, SQLite3Integer
+        end
+    end
+
+    TYPE_MAP = ActiveRecord::Type::TypeMap.new.tap { |m| initialize_type_map(m) }
+
     private
 
     # because the JDBC driver doesn't like multiple SQL statements in one JDBC statement
@@ -754,6 +786,10 @@ module ActiveRecord::ConnectionAdapters
       total_sql
     end
 
+    def type_map
+      TYPE_MAP
+    end
+
     # combine
     def write_query?(sql) # :nodoc:
       return sql.any? { |stmt| super(stmt) } if sql.kind_of? Array
@@ -761,23 +797,5 @@ module ActiveRecord::ConnectionAdapters
     rescue ArgumentError # Invalid encoding
       !READ_QUERY.match?(sql.b)
     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