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

data/lib/arjdbc/oracle/adapter.rb

@@ -40,7 +40,7 @@ module ArJdbc
       return if @@_initialized; @@_initialized = true
 
       require 'arjdbc/util/serialized_attributes'
-      Util::SerializedAttributes.setup /LOB\(|LOB$/i, 'after_save_with_oracle_lob'
+      Util::SerializedAttributes.setup %r{LOB\(|LOB$}i, 'after_save_with_oracle_lob'
 
       unless ActiveRecord::ConnectionAdapters::AbstractAdapter.
           instance_methods(false).detect { |m| m.to_s == "prefetch_primary_key?" }
@@ -285,7 +285,7 @@ module ArJdbc
           execute "ALTER TABLE #{quote_table_name(table_name)} ADD CONSTRAINT #{quote_column_name(index_name)} #{index_type} (#{quoted_column_names})"
         end
       end
-    end if AR42
+    end
 
     # @private
     def add_index_options(table_name, column_name, options = {})
@@ -309,7 +309,7 @@ module ArJdbc
 
       quoted_column_names = column_names.map { |e| quote_column_name_or_expression(e) }.join(", ")
       [ index_name, index_type, quoted_column_names, tablespace, index_options ]
-    end if AR42
+    end
 
     # @override
     def remove_index(table_name, options = {})
@@ -327,12 +327,7 @@ module ArJdbc
       end
       execute "ALTER TABLE #{quote_table_name(table_name)} DROP CONSTRAINT #{quote_column_name(index_name)}" rescue nil
       execute "DROP INDEX #{quote_column_name(index_name)}"
-    end if AR42
-
-    # @private
-    def remove_index(table_name, options = {})
-      execute "DROP INDEX #{index_name(table_name, options)}"
-    end unless AR42
+    end
 
     def change_column_default(table_name, column_name, default)
       execute "ALTER TABLE #{quote_table_name(table_name)} MODIFY #{quote_column_name(column_name)} DEFAULT #{quote(default)}"
@@ -361,25 +356,11 @@ module ArJdbc
         "RENAME COLUMN #{quote_column_name(column_name)} TO #{quote_column_name(new_column_name)}"
     end
 
-    if ActiveRecord::VERSION::MAJOR >= 4
-
     # @override
     def remove_column(table_name, column_name, type = nil, options = {})
       do_remove_column(table_name, column_name)
     end
 
-    else
-
-    # @override
-    def remove_column(table_name, *column_names)
-      for column_name in column_names.flatten
-        do_remove_column(table_name, column_name)
-      end
-    end
-    alias remove_columns remove_column
-
-    end
-
     def do_remove_column(table_name, column_name)
       execute "ALTER TABLE #{quote_table_name(table_name)} DROP COLUMN #{quote_column_name(column_name)}"
     end

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