activerecord 4.2.0 → 5.2.8.1

data/lib/active_record/connection_adapters/postgresql/oid/range.rb

@@ -1,4 +1,4 @@
-require 'active_support/core_ext/string/filters'
+# frozen_string_literal: true
 
 module ActiveRecord
   module ConnectionAdapters
@@ -6,72 +6,90 @@ module ActiveRecord
       module OID # :nodoc:
         class Range < Type::Value # :nodoc:
           attr_reader :subtype, :type
+          delegate :user_input_in_time_zone, to: :subtype
 
-          def initialize(subtype, type)
+          def initialize(subtype, type = :range)
             @subtype = subtype
             @type = type
           end
 
           def type_cast_for_schema(value)
-            value.inspect.gsub('Infinity', '::Float::INFINITY')
+            value.inspect.gsub("Infinity", "::Float::INFINITY")
           end
 
           def cast_value(value)
-            return if value == 'empty'
-            return value if value.is_a?(::Range)
+            return if value == "empty"
+            return value unless value.is_a?(::String)
 
             extracted = extract_bounds(value)
             from = type_cast_single extracted[:from]
             to = type_cast_single extracted[:to]
 
             if !infinity?(from) && extracted[:exclude_start]
-              if from.respond_to?(:succ)
-                from = from.succ
-                ActiveSupport::Deprecation.warn(<<-MSG.squish)
-                  Excluding the beginning of a Range is only partialy supported
-                  through `#succ`. This is not reliable and will be removed in
-                  the future.
-                MSG
-              else
-                raise ArgumentError, "The Ruby Range object does not support excluding the beginning of a Range. (unsupported value: '#{value}')"
-              end
+              raise ArgumentError, "The Ruby Range object does not support excluding the beginning of a Range. (unsupported value: '#{value}')"
             end
             ::Range.new(from, to, extracted[:exclude_end])
           end
 
-          def type_cast_for_database(value)
+          def serialize(value)
             if value.is_a?(::Range)
               from = type_cast_single_for_database(value.begin)
               to = type_cast_single_for_database(value.end)
-              "[#{from},#{to}#{value.exclude_end? ? ')' : ']'}"
+              ::Range.new(from, to, value.exclude_end?)
             else
               super
             end
           end
 
-          private
-
-          def type_cast_single(value)
-            infinity?(value) ? value : @subtype.type_cast_from_database(value)
+          def ==(other)
+            other.is_a?(Range) &&
+              other.subtype == subtype &&
+              other.type == type
           end
 
-          def type_cast_single_for_database(value)
-            infinity?(value) ? '' : @subtype.type_cast_for_database(value)
+          def map(value) # :nodoc:
+            new_begin = yield(value.begin)
+            new_end = yield(value.end)
+            ::Range.new(new_begin, new_end, value.exclude_end?)
           end
 
-          def extract_bounds(value)
-            from, to = value[1..-2].split(',')
-            {
-              from:          (value[1] == ',' || from == '-infinity') ? @subtype.infinity(negative: true) : from,
-              to:            (value[-2] == ',' || to == 'infinity') ? @subtype.infinity : to,
-              exclude_start: (value[0] == '('),
-              exclude_end:   (value[-1] == ')')
-            }
+          def force_equality?(value)
+            value.is_a?(::Range)
           end
 
-          def infinity?(value)
-            value.respond_to?(:infinite?) && value.infinite?
-          end
+          private
+
+            def type_cast_single(value)
+              infinity?(value) ? value : @subtype.deserialize(value)
+            end
+
+            def type_cast_single_for_database(value)
+              infinity?(value) ? value : @subtype.serialize(value)
+            end
+
+            def extract_bounds(value)
+              from, to = value[1..-2].split(",")
+              {
+                from:          (value[1] == "," || from == "-infinity") ? infinity(negative: true) : from,
+                to:            (value[-2] == "," || to == "infinity") ? infinity : to,
+                exclude_start: (value[0] == "("),
+                exclude_end:   (value[-1] == ")")
+              }
+            end
+
+            def infinity(negative: false)
+              if subtype.respond_to?(:infinity)
+                subtype.infinity(negative: negative)
+              elsif negative
+                -::Float::INFINITY
+              else
+                ::Float::INFINITY
+              end
+            end
+
+            def infinity?(value)
+              value.respond_to?(:infinite?) && value.infinite?
+            end
         end
       end
     end

data/lib/active_record/connection_adapters/postgresql/oid/specialized_string.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
@@ -5,8 +7,9 @@ module ActiveRecord
         class SpecializedString < Type::String # :nodoc:
           attr_reader :type
 
-          def initialize(type)
+          def initialize(type, **options)
             @type = type
+            super(options)
           end
         end
       end

data/lib/active_record/connection_adapters/postgresql/oid/type_map_initializer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
@@ -13,13 +15,13 @@ module ActiveRecord
           end
 
           def run(records)
-            nodes = records.reject { |row| @store.key? row['oid'].to_i }
-            mapped, nodes = nodes.partition { |row| @store.key? row['typname'] }
-            ranges, nodes = nodes.partition { |row| row['typtype'] == 'r' }
-            enums, nodes = nodes.partition { |row| row['typtype'] == 'e' }
-            domains, nodes = nodes.partition { |row| row['typtype'] == 'd' }
-            arrays, nodes = nodes.partition { |row| row['typinput'] == 'array_in' }
-            composites, nodes = nodes.partition { |row| row['typelem'] != '0' }
+            nodes = records.reject { |row| @store.key? row["oid"].to_i }
+            mapped, nodes = nodes.partition { |row| @store.key? row["typname"] }
+            ranges, nodes = nodes.partition { |row| row["typtype"] == "r".freeze }
+            enums, nodes = nodes.partition { |row| row["typtype"] == "e".freeze }
+            domains, nodes = nodes.partition { |row| row["typtype"] == "d".freeze }
+            arrays, nodes = nodes.partition { |row| row["typinput"] == "array_in".freeze }
+            composites, nodes = nodes.partition { |row| row["typelem"].to_i != 0 }
 
             mapped.each     { |row| register_mapped_type(row)    }
             enums.each      { |row| register_enum_type(row)      }
@@ -29,67 +31,79 @@ module ActiveRecord
             composites.each { |row| register_composite_type(row) }
           end
 
-          private
-          def register_mapped_type(row)
-            alias_type row['oid'], row['typname']
+          def query_conditions_for_initial_load
+            known_type_names = @store.keys.map { |n| "'#{n}'" }
+            known_type_types = %w('r' 'e' 'd')
+            <<-SQL % [known_type_names.join(", "), known_type_types.join(", ")]
+              WHERE
+                t.typname IN (%s)
+                OR t.typtype IN (%s)
+                OR t.typinput = 'array_in(cstring,oid,integer)'::regprocedure
+                OR t.typelem != 0
+            SQL
           end
 
-          def register_enum_type(row)
-            register row['oid'], OID::Enum.new
-          end
+          private
+            def register_mapped_type(row)
+              alias_type row["oid"], row["typname"]
+            end
 
-          def register_array_type(row)
-            register_with_subtype(row['oid'], row['typelem'].to_i) do |subtype|
-              OID::Array.new(subtype, row['typdelim'])
+            def register_enum_type(row)
+              register row["oid"], OID::Enum.new
             end
-          end
 
-          def register_range_type(row)
-            register_with_subtype(row['oid'], row['rngsubtype'].to_i) do |subtype|
-              OID::Range.new(subtype, row['typname'].to_sym)
+            def register_array_type(row)
+              register_with_subtype(row["oid"], row["typelem"].to_i) do |subtype|
+                OID::Array.new(subtype, row["typdelim"])
+              end
             end
-          end
 
-          def register_domain_type(row)
-            if base_type = @store.lookup(row["typbasetype"].to_i)
-              register row['oid'], base_type
-            else
-              warn "unknown base type (OID: #{row["typbasetype"]}) for domain #{row["typname"]}."
+            def register_range_type(row)
+              register_with_subtype(row["oid"], row["rngsubtype"].to_i) do |subtype|
+                OID::Range.new(subtype, row["typname"].to_sym)
+              end
+            end
+
+            def register_domain_type(row)
+              if base_type = @store.lookup(row["typbasetype"].to_i)
+                register row["oid"], base_type
+              else
+                warn "unknown base type (OID: #{row["typbasetype"]}) for domain #{row["typname"]}."
+              end
             end
-          end
 
-          def register_composite_type(row)
-            if subtype = @store.lookup(row['typelem'].to_i)
-              register row['oid'], OID::Vector.new(row['typdelim'], subtype)
+            def register_composite_type(row)
+              if subtype = @store.lookup(row["typelem"].to_i)
+                register row["oid"], OID::Vector.new(row["typdelim"], subtype)
+              end
             end
-          end
 
-          def register(oid, oid_type = nil, &block)
-            oid = assert_valid_registration(oid, oid_type || block)
-            if block_given?
-              @store.register_type(oid, &block)
-            else
-              @store.register_type(oid, oid_type)
+            def register(oid, oid_type = nil, &block)
+              oid = assert_valid_registration(oid, oid_type || block)
+              if block_given?
+                @store.register_type(oid, &block)
+              else
+                @store.register_type(oid, oid_type)
+              end
             end
-          end
 
-          def alias_type(oid, target)
-            oid = assert_valid_registration(oid, target)
-            @store.alias_type(oid, target)
-          end
+            def alias_type(oid, target)
+              oid = assert_valid_registration(oid, target)
+              @store.alias_type(oid, target)
+            end
 
-          def register_with_subtype(oid, target_oid)
-            if @store.key?(target_oid)
-              register(oid) do |_, *args|
-                yield @store.lookup(target_oid, *args)
+            def register_with_subtype(oid, target_oid)
+              if @store.key?(target_oid)
+                register(oid) do |_, *args|
+                  yield @store.lookup(target_oid, *args)
+                end
               end
             end
-          end
 
-          def assert_valid_registration(oid, oid_type)
-            raise ArgumentError, "can't register nil type for OID #{oid}" if oid_type.nil?
-            oid.to_i
-          end
+            def assert_valid_registration(oid, oid_type)
+              raise ArgumentError, "can't register nil type for OID #{oid}" if oid_type.nil?
+              oid.to_i
+            end
         end
       end
     end

data/lib/active_record/connection_adapters/postgresql/oid/uuid.rb

@@ -1,17 +1,19 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
       module OID # :nodoc:
         class Uuid < Type::Value # :nodoc:
-          ACCEPTABLE_UUID = %r{\A\{?([a-fA-F0-9]{4}-?){8}\}?\z}x
+          ACCEPTABLE_UUID = %r{\A(\{)?([a-fA-F0-9]{4}-?){8}(?(1)\}|)\z}
 
-          alias_method :type_cast_for_database, :type_cast_from_database
+          alias_method :serialize, :deserialize
 
           def type
             :uuid
           end
 
-          def type_cast(value)
+          def cast(value)
             value.to_s[ACCEPTABLE_UUID, 0]
           end
         end

data/lib/active_record/connection_adapters/postgresql/oid/vector.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
@@ -16,7 +18,7 @@ module ActiveRecord
           # FIXME: this should probably split on +delim+ and use +subtype+
           # to cast the values.  Unfortunately, the current Rails behavior
           # is to just return the string.
-          def type_cast(value)
+          def cast(value)
             value
           end
         end

data/lib/active_record/connection_adapters/postgresql/oid/xml.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
@@ -7,7 +9,7 @@ module ActiveRecord
             :xml
           end
 
-          def type_cast_for_database(value)
+          def serialize(value)
             return unless value
             Data.new(super)
           end

data/lib/active_record/connection_adapters/postgresql/oid.rb

@@ -1,30 +1,28 @@
-require 'active_record/connection_adapters/postgresql/oid/infinity'
+# frozen_string_literal: true
 
-require 'active_record/connection_adapters/postgresql/oid/array'
-require 'active_record/connection_adapters/postgresql/oid/bit'
-require 'active_record/connection_adapters/postgresql/oid/bit_varying'
-require 'active_record/connection_adapters/postgresql/oid/bytea'
-require 'active_record/connection_adapters/postgresql/oid/cidr'
-require 'active_record/connection_adapters/postgresql/oid/date'
-require 'active_record/connection_adapters/postgresql/oid/date_time'
-require 'active_record/connection_adapters/postgresql/oid/decimal'
-require 'active_record/connection_adapters/postgresql/oid/enum'
-require 'active_record/connection_adapters/postgresql/oid/float'
-require 'active_record/connection_adapters/postgresql/oid/hstore'
-require 'active_record/connection_adapters/postgresql/oid/inet'
-require 'active_record/connection_adapters/postgresql/oid/integer'
-require 'active_record/connection_adapters/postgresql/oid/json'
-require 'active_record/connection_adapters/postgresql/oid/jsonb'
-require 'active_record/connection_adapters/postgresql/oid/money'
-require 'active_record/connection_adapters/postgresql/oid/point'
-require 'active_record/connection_adapters/postgresql/oid/range'
-require 'active_record/connection_adapters/postgresql/oid/specialized_string'
-require 'active_record/connection_adapters/postgresql/oid/time'
-require 'active_record/connection_adapters/postgresql/oid/uuid'
-require 'active_record/connection_adapters/postgresql/oid/vector'
-require 'active_record/connection_adapters/postgresql/oid/xml'
+require "active_record/connection_adapters/postgresql/oid/array"
+require "active_record/connection_adapters/postgresql/oid/bit"
+require "active_record/connection_adapters/postgresql/oid/bit_varying"
+require "active_record/connection_adapters/postgresql/oid/bytea"
+require "active_record/connection_adapters/postgresql/oid/cidr"
+require "active_record/connection_adapters/postgresql/oid/date"
+require "active_record/connection_adapters/postgresql/oid/date_time"
+require "active_record/connection_adapters/postgresql/oid/decimal"
+require "active_record/connection_adapters/postgresql/oid/enum"
+require "active_record/connection_adapters/postgresql/oid/hstore"
+require "active_record/connection_adapters/postgresql/oid/inet"
+require "active_record/connection_adapters/postgresql/oid/jsonb"
+require "active_record/connection_adapters/postgresql/oid/money"
+require "active_record/connection_adapters/postgresql/oid/oid"
+require "active_record/connection_adapters/postgresql/oid/point"
+require "active_record/connection_adapters/postgresql/oid/legacy_point"
+require "active_record/connection_adapters/postgresql/oid/range"
+require "active_record/connection_adapters/postgresql/oid/specialized_string"
+require "active_record/connection_adapters/postgresql/oid/uuid"
+require "active_record/connection_adapters/postgresql/oid/vector"
+require "active_record/connection_adapters/postgresql/oid/xml"
 
-require 'active_record/connection_adapters/postgresql/oid/type_map_initializer'
+require "active_record/connection_adapters/postgresql/oid/type_map_initializer"
 
 module ActiveRecord
   module ConnectionAdapters

data/lib/active_record/connection_adapters/postgresql/quoting.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
@@ -27,8 +29,13 @@ module ActiveRecord
         # - schema_name."table.name"
         # - "schema.name".table_name
         # - "schema.name"."table.name"
-        def quote_table_name(name)
-          Utils.extract_schema_qualified_name(name.to_s).quoted
+        def quote_table_name(name) # :nodoc:
+          @quoted_table_names[name] ||= Utils.extract_schema_qualified_name(name.to_s).quoted.freeze
+        end
+
+        # Quotes schema names for use in SQL queries.
+        def quote_schema_name(name)
+          PG::Connection.quote_ident(name)
         end
 
         def quote_table_name_for_assignment(table, attr)
@@ -36,72 +43,125 @@ module ActiveRecord
         end
 
         # Quotes column names for use in SQL queries.
-        def quote_column_name(name) #:nodoc:
-          PGconn.quote_ident(name.to_s)
+        def quote_column_name(name) # :nodoc:
+          @quoted_column_names[name] ||= PG::Connection.quote_ident(super).freeze
         end
 
-        # Quote date/time values for use in SQL input. Includes microseconds
-        # if the value is a Time responding to usec.
+        # Quote date/time values for use in SQL input.
         def quoted_date(value) #:nodoc:
-          result = super
-          if value.acts_like?(:time) && value.respond_to?(:usec)
-            result = "#{result}.#{sprintf("%06d", value.usec)}"
-          end
-
           if value.year <= 0
             bce_year = format("%04d", -value.year + 1)
-            result = result.sub(/^-?\d+/, bce_year) + " BC"
+            super.sub(/^-?\d+/, bce_year) + " BC"
+          else
+            super
           end
-          result
         end
 
-        # Does not quote function default values for UUID columns
-        def quote_default_value(value, column) #:nodoc:
-          if column.type == :uuid && value =~ /\(\)/
-            value
+        def quoted_binary(value) # :nodoc:
+          "'#{escape_bytea(value.to_s)}'"
+        end
+
+        def quote_default_expression(value, column) # :nodoc:
+          if value.is_a?(Proc)
+            value.call
+          elsif column.type == :uuid && value.is_a?(String) && /\(\)/.match?(value)
+            value # Does not quote function default values for UUID columns
+          elsif column.respond_to?(:array?)
+            value = type_cast_from_column(column, value)
+            quote(value)
           else
-            quote(value, column)
+            super
           end
         end
 
+        def lookup_cast_type_from_column(column) # :nodoc:
+          type_map.lookup(column.oid, column.fmod, column.sql_type)
+        end
+
         private
+          def lookup_cast_type(sql_type)
+            super(query_value("SELECT #{quote(sql_type)}::regtype::oid", "SCHEMA").to_i)
+          end
 
-        def _quote(value)
-          case value
-          when Type::Binary::Data
-            "'#{escape_bytea(value.to_s)}'"
-          when OID::Xml::Data
-            "xml '#{quote_string(value.to_s)}'"
-          when OID::Bit::Data
-            if value.binary?
-              "B'#{value}'"
-            elsif value.hex?
-              "X'#{value}'"
+          def _quote(value)
+            case value
+            when OID::Xml::Data
+              "xml '#{quote_string(value.to_s)}'"
+            when OID::Bit::Data
+              if value.binary?
+                "B'#{value}'"
+              elsif value.hex?
+                "X'#{value}'"
+              end
+            when Float
+              if value.infinite? || value.nan?
+                "'#{value}'"
+              else
+                super
+              end
+            when OID::Array::Data
+              _quote(encode_array(value))
+            when Range
+              _quote(encode_range(value))
+            else
+              super
             end
-          when Float
-            if value.infinite? || value.nan?
-              "'#{value}'"
+          end
+
+          def _type_cast(value)
+            case value
+            when Type::Binary::Data
+              # Return a bind param hash with format as binary.
+              # See https://deveiate.org/code/pg/PG/Connection.html#method-i-exec_prepared-doc
+              # for more information
+              { value: value.to_s, format: 1 }
+            when OID::Xml::Data, OID::Bit::Data
+              value.to_s
+            when OID::Array::Data
+              encode_array(value)
+            when Range
+              encode_range(value)
             else
               super
             end
-          else
-            super
           end
-        end
 
-        def _type_cast(value)
-          case value
-          when Type::Binary::Data
-            # Return a bind param hash with format as binary.
-            # See http://deveiate.org/code/pg/PGconn.html#method-i-exec_prepared-doc
-            # for more information
-            { value: value.to_s, format: 1 }
-          when OID::Xml::Data, OID::Bit::Data
-            value.to_s
-          else
-            super
+          def encode_array(array_data)
+            encoder = array_data.encoder
+            values = type_cast_array(array_data.values)
+
+            result = encoder.encode(values)
+            if encoding = determine_encoding_of_strings_in_array(values)
+              result.force_encoding(encoding)
+            end
+            result
+          end
+
+          def encode_range(range)
+            "[#{type_cast_range_value(range.first)},#{type_cast_range_value(range.last)}#{range.exclude_end? ? ')' : ']'}"
+          end
+
+          def determine_encoding_of_strings_in_array(value)
+            case value
+            when ::Array then determine_encoding_of_strings_in_array(value.first)
+            when ::String then value.encoding
+            end
+          end
+
+          def type_cast_array(values)
+            case values
+            when ::Array then values.map { |item| type_cast_array(item) }
+            else _type_cast(values)
+            end
+          end
+
+          def type_cast_range_value(value)
+            infinity?(value) ? "" : type_cast(value)
+          end
+
+          def infinity?(value)
+            value.respond_to?(:infinite?) && value.infinite?
           end
-        end
       end
     end
   end

data/lib/active_record/connection_adapters/postgresql/referential_integrity.rb

@@ -1,27 +1,40 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
       module ReferentialIntegrity # :nodoc:
-        def supports_disable_referential_integrity? # :nodoc:
-          true
-        end
-
         def disable_referential_integrity # :nodoc:
-          if supports_disable_referential_integrity?
-            begin
+          original_exception = nil
+
+          begin
+            transaction(requires_new: true) do
               execute(tables.collect { |name| "ALTER TABLE #{quote_table_name(name)} DISABLE TRIGGER ALL" }.join(";"))
-            rescue
-              execute(tables.collect { |name| "ALTER TABLE #{quote_table_name(name)} DISABLE TRIGGER USER" }.join(";"))
             end
+          rescue ActiveRecord::ActiveRecordError => e
+            original_exception = e
+          end
+
+          begin
+            yield
+          rescue ActiveRecord::InvalidForeignKey => e
+            warn <<-WARNING
+WARNING: Rails was not able to disable referential integrity.
+
+This is most likely caused due to missing permissions.
+Rails needs superuser privileges to disable referential integrity.
+
+    cause: #{original_exception.try(:message)}
+
+              WARNING
+            raise e
           end
-          yield
-        ensure
-          if supports_disable_referential_integrity?
-            begin
+
+          begin
+            transaction(requires_new: true) do
               execute(tables.collect { |name| "ALTER TABLE #{quote_table_name(name)} ENABLE TRIGGER ALL" }.join(";"))
-            rescue
-              execute(tables.collect { |name| "ALTER TABLE #{quote_table_name(name)} ENABLE TRIGGER USER" }.join(";"))
             end
+          rescue ActiveRecord::ActiveRecordError
           end
         end
       end