activerecord 6.0.0 → 7.2.3

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "active_support/duration"
+
+module ActiveRecord
+  module ConnectionAdapters
+    module PostgreSQL
+      module OID # :nodoc:
+        class Interval < Type::Value # :nodoc:
+          def type
+            :interval
+          end
+
+          def cast_value(value)
+            case value
+            when ::ActiveSupport::Duration
+              value
+            when ::String
+              begin
+                ::ActiveSupport::Duration.parse(value)
+              rescue ::ActiveSupport::Duration::ISO8601Parser::ParsingError
+                nil
+              end
+            else
+              super
+            end
+          end
+
+          def serialize(value)
+            case value
+            when ::ActiveSupport::Duration
+              value.iso8601(precision: self.precision)
+            when ::Numeric
+              # Sometimes operations on Times returns just float number of seconds so we need to handle that.
+              # Example: Time.current - (Time.current + 1.hour) # => -3600.000001776 (Float)
+              ActiveSupport::Duration.build(value).iso8601(precision: self.precision)
+            else
+              super
+            end
+          end
+
+          def type_cast_for_schema(value)
+            serialize(value).inspect
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -14,7 +14,7 @@ module ActiveRecord
           def cast(value)
             case value
             when ::String
-              if value[0] == "(" && value[-1] == ")"
+              if value.start_with?("(") && value.end_with?(")")
                 value = value[1...-1]
               end
               cast(value.split(","))
@@ -34,9 +34,8 @@ module ActiveRecord
           end
 
           private
-
             def number_for_point(number)
-              number.to_s.gsub(/\.0$/, "")
+              number.to_s.delete_suffix(".0")
             end
         end
       end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module PostgreSQL
+      module OID # :nodoc:
+        class Macaddr < Type::String # :nodoc:
+          def type
+            :macaddr
+          end
+
+          def changed?(old_value, new_value, _new_value_before_type_cast)
+            old_value.class != new_value.class ||
+              new_value && old_value.casecmp(new_value) != 0
+          end
+
+          def changed_in_place?(raw_old_value, new_value)
+            raw_old_value.class != new_value.class ||
+              new_value && raw_old_value.casecmp(new_value) != 0
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -26,10 +26,11 @@ module ActiveRecord
 
             value = value.sub(/^\((.+)\)$/, '-\1') # (4)
             case value
-            when /^-?\D*[\d,]+\.\d{2}$/  # (1)
-              value.gsub!(/[^-\d.]/, "")
-            when /^-?\D*[\d.]+,\d{2}$/  # (2)
-              value.gsub!(/[^-\d,]/, "").sub!(/,/, ".")
+            when /^-?\D*+[\d,]+\.\d{2}$/  # (1)
+              value.delete!("^-0-9.")
+            when /^-?\D*+[\d.]+,\d{2}$/  # (2)
+              value.delete!("^-0-9,")
+              value.tr!(",", ".")
             end
 
             super(value)

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

@@ -4,7 +4,7 @@ module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
       module OID # :nodoc:
-        class Oid < Type::Integer # :nodoc:
+        class Oid < Type::UnsignedInteger # :nodoc:
           def type
             :oid
           end

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

@@ -18,7 +18,7 @@ module ActiveRecord
             when ::String
               return if value.blank?
 
-              if value[0] == "(" && value[-1] == ")"
+              if value.start_with?("(") && value.end_with?(")")
                 value = value[1...-1]
               end
               x, y = value.split(",")
@@ -50,9 +50,8 @@ module ActiveRecord
           end
 
           private
-
             def number_for_point(number)
-              number.to_s.gsub(/\.0$/, "")
+              number.to_s.delete_suffix(".0")
             end
 
             def build_point(x, y)

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

@@ -18,7 +18,7 @@ module ActiveRecord
           end
 
           def cast_value(value)
-            return if value == "empty"
+            return if ["empty", ""].include? value
             return value unless value.is_a?(::String)
 
             extracted = extract_bounds(value)
@@ -28,7 +28,7 @@ module ActiveRecord
             if !infinity?(from) && extracted[:exclude_start]
               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])
+            ::Range.new(*sanitize_bounds(from, to), extracted[:exclude_end])
           end
 
           def serialize(value)
@@ -58,7 +58,6 @@ module ActiveRecord
           end
 
           private
-
             def type_cast_single(value)
               infinity?(value) ? value : @subtype.deserialize(value)
             end
@@ -68,15 +67,43 @@ module ActiveRecord
             end
 
             def extract_bounds(value)
-              from, to = value[1..-2].split(",")
+              from, to = value[1..-2].split(",", 2)
               {
-                from:          (value[1] == "," || from == "-infinity") ? infinity(negative: true) : from,
-                to:            (value[-2] == "," || to == "infinity") ? infinity : to,
-                exclude_start: (value[0] == "("),
-                exclude_end:   (value[-1] == ")")
+                from:          (from == "" || from == "-infinity") ? infinity(negative: true) : unquote(from),
+                to:            (to == "" || to == "infinity") ? infinity : unquote(to),
+                exclude_start: value.start_with?("("),
+                exclude_end:   value.end_with?(")")
               }
             end
 
+            INFINITE_FLOAT_RANGE = (-::Float::INFINITY)..(::Float::INFINITY) # :nodoc:
+
+            def sanitize_bounds(from, to)
+              [
+                (from == -::Float::INFINITY && !INFINITE_FLOAT_RANGE.cover?(to)) ? nil : from,
+                (to == ::Float::INFINITY && !INFINITE_FLOAT_RANGE.cover?(from)) ? nil : to
+              ]
+            end
+
+            # When formatting the bound values of range types, PostgreSQL quotes
+            # the bound value using double-quotes in certain conditions. Within
+            # a double-quoted string, literal " and \ characters are themselves
+            # escaped. In input, PostgreSQL accepts multiple escape styles for "
+            # (either \" or "") but in output always uses "".
+            # See:
+            # * https://www.postgresql.org/docs/current/rangetypes.html#RANGETYPES-IO
+            # * https://www.postgresql.org/docs/current/rowtypes.html#ROWTYPES-IO-SYNTAX
+            def unquote(value)
+              if value.start_with?('"') && value.end_with?('"')
+                unquoted_value = value[1..-2]
+                unquoted_value.gsub!('""', '"')
+                unquoted_value.gsub!("\\\\", "\\")
+                unquoted_value
+              else
+                value
+              end
+            end
+
             def infinity(negative: false)
               if subtype.respond_to?(:infinity)
                 subtype.infinity(negative: negative)

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

@@ -9,7 +9,7 @@ module ActiveRecord
 
           def initialize(type, **options)
             @type = type
-            super(options)
+            super(**options)
           end
         end
       end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module PostgreSQL
+      module OID # :nodoc:
+        class Timestamp < DateTime # :nodoc:
+          def type
+            real_type_unless_aliased(:timestamp)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module PostgreSQL
+      module OID # :nodoc:
+        class TimestampWithTimeZone < DateTime # :nodoc:
+          def type
+            real_type_unless_aliased(:timestamptz)
+          end
+
+          def cast_value(value)
+            return if value.blank?
+
+            time = super
+            return time if time.is_a?(ActiveSupport::TimeWithZone) || !time.acts_like?(:time)
+
+            # While in UTC mode, the PG gem may not return times back in "UTC" even if they were provided to PostgreSQL in UTC.
+            # We prefer times always in UTC, so here we convert back.
+            if is_utc?
+              time.getutc
+            else
+              time.getlocal
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -33,15 +33,27 @@ module ActiveRecord
             composites.each { |row| register_composite_type(row) }
           end
 
-          def query_conditions_for_initial_load
+          def query_conditions_for_known_type_names
             known_type_names = @store.keys.map { |n| "'#{n}'" }
-            known_type_types = %w('r' 'e' 'd')
-            <<~SQL % [known_type_names.join(", "), known_type_types.join(", ")]
+            <<~SQL % known_type_names.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 query_conditions_for_known_type_types
+            known_type_types = %w('r' 'e' 'd')
+            <<~SQL % known_type_types.join(", ")
+              WHERE
+                t.typtype IN (%s)
+            SQL
+          end
+
+          def query_conditions_for_array_types
+            known_type_oids = @store.keys.reject { |k| k.is_a?(String) }
+            <<~SQL % [known_type_oids.join(", ")]
+              WHERE
+                t.typelem IN (%s)
             SQL
           end
 

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

@@ -6,18 +6,37 @@ module ActiveRecord
       module OID # :nodoc:
         class Uuid < Type::Value # :nodoc:
           ACCEPTABLE_UUID = %r{\A(\{)?([a-fA-F0-9]{4}-?){8}(?(1)\}|)\z}
+          CANONICAL_UUID = %r{\A[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}\z}
 
-          alias_method :serialize, :deserialize
+          alias :serialize :deserialize
 
           def type
             :uuid
           end
 
-          private
+          def changed?(old_value, new_value, _new_value_before_type_cast)
+            old_value.class != new_value.class ||
+              new_value != old_value
+          end
+
+          def changed_in_place?(raw_old_value, new_value)
+            raw_old_value.class != new_value.class ||
+              new_value != raw_old_value
+          end
 
+          private
             def cast_value(value)
-              casted = value.to_s
-              casted if casted.match?(ACCEPTABLE_UUID)
+              value = value.to_s
+              format_uuid(value) if value.match?(ACCEPTABLE_UUID)
+            end
+
+            def format_uuid(uuid)
+              if uuid.match?(CANONICAL_UUID)
+                uuid
+              else
+                uuid = uuid.delete("{}-").downcase
+                "#{uuid[..7]}-#{uuid[8..11]}-#{uuid[12..15]}-#{uuid[16..19]}-#{uuid[20..]}"
+              end
             end
         end
       end

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

@@ -11,13 +11,17 @@ 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/interval"
 require "active_record/connection_adapters/postgresql/oid/jsonb"
+require "active_record/connection_adapters/postgresql/oid/macaddr"
 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/timestamp"
+require "active_record/connection_adapters/postgresql/oid/timestamp_with_time_zone"
 require "active_record/connection_adapters/postgresql/oid/uuid"
 require "active_record/connection_adapters/postgresql/oid/vector"
 require "active_record/connection_adapters/postgresql/oid/xml"

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

@@ -4,51 +4,143 @@ module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
       module Quoting
+        extend ActiveSupport::Concern
+
+        QUOTED_COLUMN_NAMES = Concurrent::Map.new # :nodoc:
+        QUOTED_TABLE_NAMES = Concurrent::Map.new # :nodoc:
+
+        module ClassMethods # :nodoc:
+          def column_name_matcher
+            /
+              \A
+              (
+                (?:
+                  # "schema_name"."table_name"."column_name"::type_name | function(one or no argument)::type_name
+                  ((?:\w+\.|"\w+"\.){,2}(?:\w+|"\w+")(?:::\w+)? | \w+\((?:|\g<2>)\)(?:::\w+)?)
+                )
+                (?:(?:\s+AS)?\s+(?:\w+|"\w+"))?
+              )
+              (?:\s*,\s*\g<1>)*
+              \z
+            /ix
+          end
+
+          def column_name_with_order_matcher
+            /
+              \A
+              (
+                (?:
+                  # "schema_name"."table_name"."column_name"::type_name | function(one or no argument)::type_name
+                  ((?:\w+\.|"\w+"\.){,2}(?:\w+|"\w+")(?:::\w+)? | \w+\((?:|\g<2>)\)(?:::\w+)?)
+                )
+                (?:\s+COLLATE\s+"\w+")?
+                (?:\s+ASC|\s+DESC)?
+                (?:\s+NULLS\s+(?:FIRST|LAST))?
+              )
+              (?:\s*,\s*\g<1>)*
+              \z
+            /ix
+          end
+
+          # Quotes column names for use in SQL queries.
+          def quote_column_name(name) # :nodoc:
+            QUOTED_COLUMN_NAMES[name] ||= PG::Connection.quote_ident(name.to_s).freeze
+          end
+
+          # Checks the following cases:
+          #
+          # - table_name
+          # - "table.name"
+          # - schema_name.table_name
+          # - schema_name."table.name"
+          # - "schema.name".table_name
+          # - "schema.name"."table.name"
+          def quote_table_name(name) # :nodoc:
+            QUOTED_TABLE_NAMES[name] ||= Utils.extract_schema_qualified_name(name.to_s).quoted.freeze
+          end
+        end
+
+        class IntegerOutOf64BitRange < StandardError
+          def initialize(msg)
+            super(msg)
+          end
+        end
+
         # Escapes binary strings for bytea input to the database.
         def escape_bytea(value)
-          @connection.escape_bytea(value) if value
+          valid_raw_connection.escape_bytea(value) if value
         end
 
         # Unescapes bytea output from a database to the binary string it represents.
         # NOTE: This is NOT an inverse of escape_bytea! This is only to be used
         # on escaped binary output from database drive.
         def unescape_bytea(value)
-          @connection.unescape_bytea(value) if value
+          valid_raw_connection.unescape_bytea(value) if value
         end
 
-        # Quotes strings for use in SQL input.
-        def quote_string(s) #:nodoc:
-          @connection.escape(s)
+        def check_int_in_range(value)
+          if value.to_int > 9223372036854775807 || value.to_int < -9223372036854775808
+            exception = <<~ERROR
+              Provided value outside of the range of a signed 64bit integer.
+
+              PostgreSQL will treat the column type in question as a numeric.
+              This may result in a slow sequential scan due to a comparison
+              being performed between an integer or bigint value and a numeric value.
+
+              To allow for this potentially unwanted behavior, set
+              ActiveRecord.raise_int_wider_than_64bit to false.
+            ERROR
+            raise IntegerOutOf64BitRange.new exception
+          end
         end
 
-        # Checks the following cases:
-        #
-        # - table_name
-        # - "table.name"
-        # - schema_name.table_name
-        # - schema_name."table.name"
-        # - "schema.name".table_name
-        # - "schema.name"."table.name"
-        def quote_table_name(name) # :nodoc:
-          self.class.quoted_table_names[name] ||= Utils.extract_schema_qualified_name(name.to_s).quoted.freeze
+        def quote(value) # :nodoc:
+          if ActiveRecord.raise_int_wider_than_64bit && value.is_a?(Integer)
+            check_int_in_range(value)
+          end
+
+          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 Numeric
+            if value.finite?
+              super
+            else
+              "'#{value}'"
+            end
+          when OID::Array::Data
+            quote(encode_array(value))
+          when Range
+            quote(encode_range(value))
+          else
+            super
+          end
         end
 
-        # Quotes schema names for use in SQL queries.
-        def quote_schema_name(name)
-          PG::Connection.quote_ident(name)
+        # Quotes strings for use in SQL input.
+        def quote_string(s) # :nodoc:
+          with_raw_connection(allow_retry: true, materialize_transactions: false) do |connection|
+            connection.escape(s)
+          end
         end
 
         def quote_table_name_for_assignment(table, attr)
           quote_column_name(attr)
         end
 
-        # Quotes column names for use in SQL queries.
-        def quote_column_name(name) # :nodoc:
-          self.class.quoted_column_names[name] ||= PG::Connection.quote_ident(super).freeze
+        # Quotes schema names for use in SQL queries.
+        def quote_schema_name(schema_name)
+          quote_column_name(schema_name)
         end
 
         # Quote date/time values for use in SQL input.
-        def quoted_date(value) #:nodoc:
+        def quoted_date(value) # :nodoc:
           if value.year <= 0
             bce_year = format("%04d", -value.year + 1)
             super.sub(/^-?\d+/, bce_year) + " BC"
@@ -64,105 +156,46 @@ module ActiveRecord
         def quote_default_expression(value, column) # :nodoc:
           if value.is_a?(Proc)
             value.call
-          elsif column.type == :uuid && value.is_a?(String) && /\(\)/.match?(value)
+          elsif column.type == :uuid && value.is_a?(String) && value.include?("()")
             value # Does not quote function default values for UUID columns
           elsif column.respond_to?(:array?)
-            value = type_cast_from_column(column, value)
-            quote(value)
+            type = lookup_cast_type_from_column(column)
+            quote(type.serialize(value))
           else
             super
           end
         end
 
-        def lookup_cast_type_from_column(column) # :nodoc:
-          type_map.lookup(column.oid, column.fmod, column.sql_type)
-        end
-
-        def column_name_matcher
-          COLUMN_NAME
+        def type_cast(value) # :nodoc:
+          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)
+          when Rational
+            value.to_f
+          else
+            super
+          end
         end
 
-        def column_name_with_order_matcher
-          COLUMN_NAME_WITH_ORDER
+        def lookup_cast_type_from_column(column) # :nodoc:
+          verify! if type_map.nil?
+          type_map.lookup(column.oid, column.fmod, column.sql_type)
         end
 
-        COLUMN_NAME = /
-          \A
-          (
-            (?:
-              # "table_name"."column_name"::type_name | function(one or no argument)::type_name
-              ((?:\w+\.|"\w+"\.)?(?:\w+|"\w+")(?:::\w+)?) | \w+\((?:|\g<2>)\)(?:::\w+)?
-            )
-            (?:\s+AS\s+(?:\w+|"\w+"))?
-          )
-          (?:\s*,\s*\g<1>)*
-          \z
-        /ix
-
-        COLUMN_NAME_WITH_ORDER = /
-          \A
-          (
-            (?:
-              # "table_name"."column_name"::type_name | function(one or no argument)::type_name
-              ((?:\w+\.|"\w+"\.)?(?:\w+|"\w+")(?:::\w+)?) | \w+\((?:|\g<2>)\)(?:::\w+)?
-            )
-            (?:\s+ASC|\s+DESC)?
-            (?:\s+NULLS\s+(?:FIRST|LAST))?
-          )
-          (?:\s*,\s*\g<1>)*
-          \z
-        /ix
-
-        private_constant :COLUMN_NAME, :COLUMN_NAME_WITH_ORDER
-
         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 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 Numeric
-              if value.finite?
-                super
-              else
-                "'#{value}'"
-              end
-            when OID::Array::Data
-              _quote(encode_array(value))
-            when Range
-              _quote(encode_range(value))
-            else
-              super
-            end
-          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
-          end
-
           def encode_array(array_data)
             encoder = array_data.encoder
             values = type_cast_array(array_data.values)
@@ -188,7 +221,7 @@ module ActiveRecord
           def type_cast_array(values)
             case values
             when ::Array then values.map { |item| type_cast_array(item) }
-            else _type_cast(values)
+            else type_cast(values)
             end
           end