activerecord-jdbc-adapter 70.1-java → 71.0-java

data/lib/arjdbc/postgresql/adapter.rb

@@ -13,6 +13,7 @@ require 'active_record/connection_adapters/postgresql/schema_dumper'
 require 'active_record/connection_adapters/postgresql/schema_statements'
 require 'active_record/connection_adapters/postgresql/type_metadata'
 require 'active_record/connection_adapters/postgresql/utils'
+
 require 'arjdbc/abstract/core'
 require 'arjdbc/abstract/connection_management'
 require 'arjdbc/abstract/database_statements'
@@ -21,8 +22,13 @@ require 'arjdbc/abstract/transaction_support'
 require 'arjdbc/postgresql/base/array_decoder'
 require 'arjdbc/postgresql/base/array_encoder'
 require 'arjdbc/postgresql/name'
+require 'arjdbc/postgresql/database_statements'
+require 'arjdbc/postgresql/schema_statements'
+
 require 'active_model'
 
+require "arjdbc/abstract/relation_query_attribute_monkey_patch"
+
 module ArJdbc
   # Strives to provide Rails built-in PostgreSQL adapter (API) compatibility.
   module PostgreSQL
@@ -35,11 +41,6 @@ module ArJdbc
     # @private
     Type = ::ActiveRecord::Type
 
-    # @see ActiveRecord::ConnectionAdapters::JdbcAdapter#jdbc_connection_class
-    def self.jdbc_connection_class
-      ::ActiveRecord::ConnectionAdapters::PostgreSQLJdbcConnection
-    end
-
     # @see ActiveRecord::ConnectionAdapters::JdbcAdapter#jdbc_column_class
     def jdbc_column_class; ::ActiveRecord::ConnectionAdapters::PostgreSQLColumn end
 
@@ -52,8 +53,8 @@ module ArJdbc
     def redshift?
       # SELECT version() :
       #  PostgreSQL 8.0.2 on i686-pc-linux-gnu, compiled by GCC gcc (GCC) 3.4.2 20041017 (Red Hat 3.4.2-6.fc3), Redshift 1.0.647
-      if ( redshift = config[:redshift] ).nil?
-        redshift = !! (@connection.database_product || '').index('Redshift')
+      if (redshift = @config[:redshift]).nil?
+        redshift = !! (valid_raw_connection.database_product || '').index('Redshift')
       end
       redshift
     end
@@ -73,8 +74,8 @@ module ArJdbc
         # see http://jdbc.postgresql.org/documentation/91/connect.html
         # self.set_client_encoding(encoding)
       #end
-      self.client_min_messages = config[:min_messages] || 'warning'
-      self.schema_search_path = config[:schema_search_path] || config[:schema_order]
+      self.client_min_messages = @config[:min_messages] || 'warning'
+      self.schema_search_path = @config[:schema_search_path] || @config[:schema_order]
 
       # Use standard-conforming strings if available so we don't have to do the E'...' dance.
       set_standard_conforming_strings
@@ -93,7 +94,7 @@ module ArJdbc
 
       # SET statements from :variables config hash
       # http://www.postgresql.org/docs/8.3/static/sql-set.html
-      (config[:variables] || {}).map do |k, v|
+      (@config[:variables] || {}).map do |k, v|
         if v == ':default' || v == :default
           # Sets the value to the global or compile default
           execute("SET SESSION #{k} TO DEFAULT", 'SCHEMA')
@@ -101,6 +102,8 @@ module ArJdbc
           execute("SET SESSION #{k} TO #{quote(v)}", 'SCHEMA')
         end
       end
+
+      reload_type_map
     end
 
     # @private
@@ -120,14 +123,15 @@ module ArJdbc
       citext:       { name: 'citext' },
       date:         { name: 'date' },
       daterange:    { name: 'daterange' },
-      datetime:     { name: 'timestamp' },
+      datetime:     {}, # set dynamically based on datetime_type
+      timestamptz:  { name: 'timestamptz' },
       decimal:      { name: 'decimal' }, # :limit => 1000
       float:        { name: 'float' },
       hstore:       { name: 'hstore' },
       inet:         { name: 'inet' },
       int4range:    { name: 'int4range' },
       int8range:    { name: 'int8range' },
-      integer:      { name: 'integer' },
+      integer:      { name: 'integer', limit: 4 },
       interval:     { name: 'interval' },
       json:         { name: 'json' },
       jsonb:        { name: 'jsonb' },
@@ -150,17 +154,10 @@ module ArJdbc
       tstzrange:    { name: 'tstzrange' },
       tsvector:     { name: 'tsvector' },
       uuid:         { name: 'uuid' },
-      xml:          { name: 'xml' }
+      xml:          { name: 'xml' },
+      enum:         {} # special type https://www.postgresql.org/docs/current/datatype-enum.html
     }
 
-    def native_database_types
-      NATIVE_DATABASE_TYPES
-    end
-
-    def valid_type?(type)
-      !native_database_types[type].nil?
-    end
-
     def set_standard_conforming_strings
       execute("SET standard_conforming_strings = on", "SCHEMA")
     end
@@ -232,6 +229,18 @@ module ArJdbc
     alias supports_insert_on_duplicate_update? supports_insert_on_conflict?
     alias supports_insert_conflict_target? supports_insert_on_conflict?
 
+    def supports_virtual_columns?
+      database_version >= 12_00_00 # >= 12.0
+    end
+
+    def supports_identity_columns? # :nodoc:
+      database_version >= 10_00_00 # >= 10.0
+    end
+
+    def supports_nulls_not_distinct?
+      database_version >= 15_00_00 # >= 15.0
+    end
+
     def index_algorithms
       { concurrently: 'CONCURRENTLY' }
     end
@@ -297,14 +306,21 @@ module ArJdbc
       query_value("SELECT pg_advisory_unlock(#{lock_id})")
     end
 
-    def enable_extension(name)
-      exec_query("CREATE EXTENSION IF NOT EXISTS \"#{name}\"").tap {
-        reload_type_map
-      }
+    def enable_extension(name, **)
+      schema, name = name.to_s.split(".").values_at(-2, -1)
+      sql = +"CREATE EXTENSION IF NOT EXISTS \"#{name}\""
+      sql << " SCHEMA #{schema}" if schema
+
+      internal_exec_query(sql).tap { reload_type_map }
     end
 
-    def disable_extension(name)
-      exec_query("DROP EXTENSION IF EXISTS \"#{name}\" CASCADE").tap {
+    # Removes an extension from the database.
+    #
+    # [<tt>:force</tt>]
+    #   Set to +:cascade+ to drop dependent objects as well.
+    #   Defaults to false.
+    def disable_extension(name, force: false)
+      internal_exec_query("DROP EXTENSION IF EXISTS \"#{name}\"#{' CASCADE' if force == :cascade}").tap {
         reload_type_map
       }
     end
@@ -318,39 +334,106 @@ module ArJdbc
     end
 
     def extensions
-      exec_query("SELECT extname FROM pg_extension", "SCHEMA").cast_values
+      internal_exec_query("SELECT extname FROM pg_extension", "SCHEMA", allow_retry: true, materialize_transactions: false).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;
+        SELECT
+          type.typname AS name,
+          type.OID AS oid,
+          n.nspname AS schema,
+          string_agg(enum.enumlabel, ',' ORDER BY enum.enumsortorder) AS value
+        FROM pg_enum AS enum
+        JOIN pg_type AS type ON (type.oid = enum.enumtypid)
+        JOIN pg_namespace n ON type.typnamespace = n.oid
+        WHERE n.nspname = ANY (current_schemas(false))
+        GROUP BY type.OID, n.nspname, type.typname;
       SQL
-      exec_query(query, "SCHEMA").cast_values
+
+      internal_exec_query(query, "SCHEMA", allow_retry: true, materialize_transactions: false).cast_values.each_with_object({}) do |row, memo|
+        name, schema = row[0], row[2]
+        schema = nil if schema == current_schema
+        full_name = [schema, name].compact.join(".")
+        memo[full_name] = row.last
+      end.to_a
     end
 
     # Given a name and an array of values, creates an enum type.
-    def create_enum(name, values)
-      sql_values = values.map { |s| "'#{s}'" }.join(", ")
+    def create_enum(name, values, **options)
+      sql_values = values.map { |s| quote(s) }.join(", ")
+      scope = quoted_scope(name)
+      query = <<~SQL
+        DO $$
+        BEGIN
+            IF NOT EXISTS (
+              SELECT 1
+              FROM pg_type t
+              JOIN pg_namespace n ON t.typnamespace = n.oid
+              WHERE t.typname = #{scope[:name]}
+                AND n.nspname = #{scope[:schema]}
+            ) THEN
+                CREATE TYPE #{quote_table_name(name)} AS ENUM (#{sql_values});
+            END IF;
+        END
+        $$;
+      SQL
+
+      internal_exec_query(query).tap { reload_type_map }
+    end
+
+    # Drops an enum type.
+    #
+    # If the <tt>if_exists: true</tt> option is provided, the enum is dropped
+    # only if it exists. Otherwise, if the enum doesn't exist, an error is
+    # raised.
+    #
+    # The +values+ parameter will be ignored if present. It can be helpful
+    # to provide this in a migration's +change+ method so it can be reverted.
+    # In that case, +values+ will be used by #create_enum.
+    def drop_enum(name, values = nil, **options)
       query = <<~SQL
-          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
-          $$;
+        DROP TYPE#{' IF EXISTS' if options[:if_exists]} #{quote_table_name(name)};
       SQL
-      exec_query(query)
+      internal_exec_query(query).tap { reload_type_map }
+    end
+
+    # Rename an existing enum type to something else.
+    def rename_enum(name, options = {})
+      to = options.fetch(:to) { raise ArgumentError, ":to is required" }
+
+      exec_query("ALTER TYPE #{quote_table_name(name)} RENAME TO #{to}").tap { reload_type_map }
+    end
+
+    # Add enum value to an existing enum type.
+    def add_enum_value(type_name, value, options = {})
+      before, after = options.values_at(:before, :after)
+      sql = +"ALTER TYPE #{quote_table_name(type_name)} ADD VALUE '#{value}'"
+
+      if before && after
+        raise ArgumentError, "Cannot have both :before and :after at the same time"
+      elsif before
+        sql << " BEFORE '#{before}'"
+      elsif after
+        sql << " AFTER '#{after}'"
+      end
+
+      execute(sql).tap { reload_type_map }
+    end
+
+    # Rename enum value on an existing enum type.
+    def rename_enum_value(type_name, options = {})
+      unless database_version >= 10_00_00 # >= 10.0
+        raise ArgumentError, "Renaming enum values is only supported in PostgreSQL 10 or later"
+      end
+
+      from = options.fetch(:from) { raise ArgumentError, ":from is required" }
+      to = options.fetch(:to) { raise ArgumentError, ":to is required" }
+
+      execute("ALTER TYPE #{quote_table_name(type_name)} RENAME VALUE '#{from}' TO '#{to}'").tap {
+        reload_type_map
+      }
     end
 
     # Returns the configured supported identifier length supported by PostgreSQL
@@ -370,7 +453,7 @@ module ArJdbc
 
     def get_database_version # :nodoc:
       begin
-        version = @connection.database_product
+        version = valid_raw_connection.database_product
         if match = version.match(/([\d\.]*\d).*?/)
           version = match[1].split('.').map(&:to_i)
           # PostgreSQL version representation does not have more than 4 digits
@@ -426,8 +509,7 @@ module ArJdbc
       end
     end
 
-
-    def exec_insert(sql, name = nil, binds = [], pk = nil, sequence_name = nil)
+    def exec_insert(sql, name = nil, binds = [], pk = nil, sequence_name = nil, returning: nil) # :nodoc:
       val = super
       if !use_insert_returning? && pk
         unless sequence_name
@@ -445,11 +527,6 @@ module ArJdbc
       execute(combine_multi_statements(statements), name)
     end
 
-    def explain(arel, binds = [])
-      sql, binds = to_sql_and_binds(arel, binds)
-      ActiveRecord::ConnectionAdapters::PostgreSQL::ExplainPrettyPrinter.new.pp(exec_query("EXPLAIN #{sql}", 'EXPLAIN', binds))
-    end
-
     # from ActiveRecord::ConnectionAdapters::PostgreSQL::DatabaseStatements
     READ_QUERY = ActiveRecord::ConnectionAdapters::AbstractAdapter.build_read_query_regexp(
       :close, :declare, :fetch, :move, :set, :show
@@ -464,18 +541,33 @@ module ArJdbc
     # since apparently calling close on the statement object
     # doesn't always free the server resources and calling
     # 'DISCARD ALL' fails if we are inside a transaction
-    def clear_cache!
-      super
-      # Make sure all query plans are *really* gone
-      @connection.execute 'DEALLOCATE ALL' if active?
-    end
+    # def clear_cache!
+    #   super
+    #   # Make sure all query plans are *really* gone
+    #   @connection.execute 'DEALLOCATE ALL' if active?
+    # end
 
     def reset!
-      clear_cache!
-      reset_transaction
-      @connection.rollback # Have to deal with rollbacks differently than the AR adapter
-      @connection.execute 'DISCARD ALL'
-      @connection.configure_connection
+      @lock.synchronize do
+        return connect! unless @raw_connection
+
+        # Have to deal with rollbacks differently than the AR adapter
+        @raw_connection.rollback
+
+        @raw_connection.execute("DISCARD ALL")
+
+        super
+      end
+    end
+
+    # Disconnects from the database if already connected. Otherwise, this
+    # method does nothing.
+    def disconnect!
+      @lock.synchronize do
+        super
+        @raw_connection&.close
+        @raw_connection = nil
+      end
     end
 
     def default_sequence_name(table_name, pk = "id") #:nodoc:
@@ -593,17 +685,19 @@ module ArJdbc
     #  - format_type includes the column size constraint, e.g. varchar(50)
     #  - ::regclass is a function that gives the id for a table name
     def column_definitions(table_name)
-      select_rows(<<~SQL, 'SCHEMA')
-        SELECT a.attname, format_type(a.atttypid, a.atttypmod),
-               pg_get_expr(d.adbin, d.adrelid), a.attnotnull, a.atttypid, a.atttypmod,
-               c.collname, col_description(a.attrelid, a.attnum) AS comment
-          FROM pg_attribute a
-          LEFT JOIN pg_attrdef d ON a.attrelid = d.adrelid AND a.attnum = d.adnum
-          LEFT JOIN pg_type t ON a.atttypid = t.oid
-          LEFT JOIN pg_collation c ON a.attcollation = c.oid AND a.attcollation <> t.typcollation
-         WHERE a.attrelid = #{quote(quote_table_name(table_name))}::regclass
-           AND a.attnum > 0 AND NOT a.attisdropped
-         ORDER BY a.attnum
+      query(<<~SQL, "SCHEMA")
+          SELECT a.attname, format_type(a.atttypid, a.atttypmod),
+                 pg_get_expr(d.adbin, d.adrelid), a.attnotnull, a.atttypid, a.atttypmod,
+                 c.collname, col_description(a.attrelid, a.attnum) AS comment,
+                 #{supports_identity_columns? ? 'attidentity' : quote('')} AS identity,
+                 #{supports_virtual_columns? ? 'attgenerated' : quote('')} as attgenerated
+            FROM pg_attribute a
+            LEFT JOIN pg_attrdef d ON a.attrelid = d.adrelid AND a.attnum = d.adnum
+            LEFT JOIN pg_type t ON a.atttypid = t.oid
+            LEFT JOIN pg_collation c ON a.attcollation = c.oid AND a.attcollation <> t.typcollation
+           WHERE a.attrelid = #{quote(quote_table_name(table_name))}::regclass
+             AND a.attnum > 0 AND NOT a.attisdropped
+           ORDER BY a.attnum
       SQL
     end
 
@@ -618,22 +712,27 @@ module ArJdbc
 
     # Pulled from ActiveRecord's Postgres adapter and modified to use execute
     def can_perform_case_insensitive_comparison_for?(column)
-      @case_insensitive_cache ||= {}
-      @case_insensitive_cache[column.sql_type] ||= begin
-        sql = <<~SQL
-          SELECT exists(
-            SELECT * FROM pg_proc
-            WHERE proname = 'lower'
-              AND proargtypes = ARRAY[#{quote column.sql_type}::regtype]::oidvector
-          ) OR exists(
-            SELECT * FROM pg_proc
-            INNER JOIN pg_cast
-              ON ARRAY[casttarget]::oidvector = proargtypes
-            WHERE proname = 'lower'
-              AND castsource = #{quote column.sql_type}::regtype
-          )
-        SQL
-        select_value(sql, 'SCHEMA')
+      # NOTE: citext is an exception. It is possible to perform a
+      #       case-insensitive comparison using `LOWER()`, but it is
+      #       unnecessary, as `citext` is case-insensitive by definition.
+      @case_insensitive_cache ||= { "citext" => false }
+      @case_insensitive_cache.fetch(column.sql_type) do
+        @case_insensitive_cache[column.sql_type] = begin
+          sql = <<~SQL
+            SELECT exists(
+              SELECT * FROM pg_proc
+              WHERE proname = 'lower'
+                AND proargtypes = ARRAY[#{quote column.sql_type}::regtype]::oidvector
+            ) OR exists(
+              SELECT * FROM pg_proc
+              INNER JOIN pg_cast
+                ON ARRAY[casttarget]::oidvector = proargtypes
+              WHERE proname = 'lower'
+                AND castsource = #{quote column.sql_type}::regtype
+            )
+          SQL
+          select_value(sql, 'SCHEMA')
+        end
       end
     end
 
@@ -642,6 +741,8 @@ module ArJdbc
 
       # TODO: Can we base these on an error code of some kind?
       case exception.message
+      when /could not create unique index/
+        ::ActiveRecord::RecordNotUnique.new(message, sql: sql, binds: binds, connection_pool: @pool)
       when /duplicate key value violates unique constraint/
         ::ActiveRecord::RecordNotUnique.new(message, sql: sql, binds: binds)
       when /violates not-null constraint/
@@ -660,6 +761,10 @@ module ArJdbc
         ::ActiveRecord::LockWaitTimeout.new(message, sql: sql, binds: binds)
       when /canceling statement/ # This needs to come after lock timeout because the lock timeout message also contains "canceling statement"
         ::ActiveRecord::QueryCanceled.new(message, sql: sql, binds: binds)
+      when /relation .* does not exist/i
+        ::ActiveRecord::StatementInvalid.new(message, sql: sql, binds: binds, connection_pool: @pool)
+      when /syntax error at or near/i
+        ::ActiveRecord::StatementInvalid.new(message, sql: sql, binds: binds, connection_pool: @pool)
       else
         super
       end
@@ -742,7 +847,7 @@ module ActiveRecord::ConnectionAdapters
     include ActiveRecord::ConnectionAdapters::PostgreSQL::SchemaStatements
     include ActiveRecord::ConnectionAdapters::PostgreSQL::Quoting
 
-    include Jdbc::ConnectionPoolCallbacks
+    # include Jdbc::ConnectionPoolCallbacks
 
     include ArJdbc::Abstract::Core
     include ArJdbc::Abstract::ConnectionManagement
@@ -753,6 +858,8 @@ module ActiveRecord::ConnectionAdapters
 
     require 'arjdbc/postgresql/oid_types'
     include ::ArJdbc::PostgreSQL::OIDTypes
+    include ::ArJdbc::PostgreSQL::DatabaseStatements
+    include ::ArJdbc::PostgreSQL::SchemaStatements
 
     include ::ArJdbc::PostgreSQL::ColumnHelpers
 
@@ -761,16 +868,46 @@ module ActiveRecord::ConnectionAdapters
     # AR expects OID to be available on the adapter
     OID = ActiveRecord::ConnectionAdapters::PostgreSQL::OID
 
-    def initialize(connection, logger = nil, connection_parameters = nil, config = {})
+    class << self
+      def jdbc_connection_class
+        ::ActiveRecord::ConnectionAdapters::PostgreSQLJdbcConnection
+      end
+
+      def new_client(conn_params, adapter_instance)
+        jdbc_connection_class.new(conn_params, adapter_instance)
+      end
+
+      def dbconsole(config, options = {})
+        pg_config = config.configuration_hash
+
+        ENV["PGUSER"]         = pg_config[:username] if pg_config[:username]
+        ENV["PGHOST"]         = pg_config[:host] if pg_config[:host]
+        ENV["PGPORT"]         = pg_config[:port].to_s if pg_config[:port]
+        ENV["PGPASSWORD"]     = pg_config[:password].to_s if pg_config[:password] && options[:include_password]
+        ENV["PGSSLMODE"]      = pg_config[:sslmode].to_s if pg_config[:sslmode]
+        ENV["PGSSLCERT"]      = pg_config[:sslcert].to_s if pg_config[:sslcert]
+        ENV["PGSSLKEY"]       = pg_config[:sslkey].to_s if pg_config[:sslkey]
+        ENV["PGSSLROOTCERT"]  = pg_config[:sslrootcert].to_s if pg_config[:sslrootcert]
+        if pg_config[:variables]
+          ENV["PGOPTIONS"] = pg_config[:variables].filter_map do |name, value|
+            "-c #{name}=#{value.to_s.gsub(/[ \\]/, '\\\\\0')}" unless value == ":default" || value == :default
+          end.join(" ")
+        end
+        find_cmd_and_exec("psql", config.database)
+      end
+    end
+
+    def initialize(...)
+      super
+
+      conn_params = @config.compact
+
+      @connection_parameters = conn_params
+
       # @local_tz is initialized as nil to avoid warnings when connect tries to use it
       @local_tz = nil
       @max_identifier_length = nil
 
-      super(connection, logger, config) # configure_connection happens in super
-
-      @type_map = Type::HashLookupTypeMap.new
-      initialize_type_map
-
       @use_insert_returning = @config.key?(:insert_returning) ?
         self.class.type_cast_config_to_boolean(@config[:insert_returning]) : true
     end
@@ -793,8 +930,16 @@ module ActiveRecord::ConnectionAdapters
     public :sql_for_insert
     alias :postgresql_version :database_version
 
-    def jdbc_connection_class(spec)
-      ::ArJdbc::PostgreSQL.jdbc_connection_class
+    def native_database_types # :nodoc:
+      self.class.native_database_types
+    end
+
+    def self.native_database_types # :nodoc:
+      @native_database_types ||= begin
+        types = NATIVE_DATABASE_TYPES.dup
+        types[:datetime] = types[datetime_type]
+        types
+      end
     end
 
     private
@@ -829,8 +974,10 @@ module ActiveRecord::ConnectionAdapters
 
       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)
+        with_raw_connection do |conn|
+          result = conn.exec_params(sql, type_casted_binds)
+          verified!
+          result
         end
       end
     end

data/lib/arjdbc/postgresql/database_statements.rb

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

data/lib/arjdbc/postgresql/oid_types.rb

@@ -67,28 +67,6 @@ module ArJdbc
 
     # @private
     module OIDTypes
-
-      # @override
-      def enable_extension(name)
-        result = super(name)
-        @extensions = nil
-        reload_type_map
-        result
-      end
-
-      # @override
-      def disable_extension(name)
-        result = super(name)
-        @extensions = nil
-        reload_type_map
-        result
-      end
-
-      # @override
-      def extensions
-        @extensions ||= super
-      end
-
       def get_oid_type(oid, fmod, column_name, sql_type = '') # :nodoc:
         # 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
@@ -118,8 +96,15 @@ module ArJdbc
       end
 
       def reload_type_map
-          type_map.clear
+        @lock.synchronize do
+          if @type_map
+            type_map.clear
+          else
+            @type_map = Type::HashLookupTypeMap.new
+          end
+
           initialize_type_map
+        end
       end
 
         def initialize_type_map_inner(m)
@@ -274,10 +259,6 @@ module ArJdbc
         $1.to_i if sql_type =~ /\((\d+)(,\d+)?\)/
       end
 
-      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
       ActiveRecord::Type.add_modifier({ array: true }, OID::Array, adapter: :postgresql)
       ActiveRecord::Type.add_modifier({ range: true }, OID::Range, adapter: :postgresql)