activerecord 6.1.7 → 7.1.0

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

@@ -1,10 +1,14 @@
 # frozen_string_literal: true
 
+require "strscan"
+
 module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
       module OID # :nodoc:
         class Hstore < Type::Value # :nodoc:
+          ERROR = "Invalid Hstore document: %s"
+
           include ActiveModel::Type::Helpers::Mutable
 
           def type
@@ -12,15 +16,56 @@ module ActiveRecord
           end
 
           def deserialize(value)
-            if value.is_a?(::String)
-              ::Hash[value.scan(HstorePair).map { |k, v|
-                v = v.upcase == "NULL" ? nil : v.gsub(/\A"(.*)"\Z/m, '\1').gsub(/\\(.)/, '\1')
-                k = k.gsub(/\A"(.*)"\Z/m, '\1').gsub(/\\(.)/, '\1')
-                [k, v]
-              }]
-            else
-              value
+            return value unless value.is_a?(::String)
+
+            scanner = StringScanner.new(value)
+            hash = {}
+
+            until scanner.eos?
+              unless scanner.skip(/"/)
+                raise(ArgumentError, ERROR % scanner.string.inspect)
+              end
+
+              unless key = scanner.scan(/^(\\[\\"]|[^\\"])*?(?=")/)
+                raise(ArgumentError, ERROR % scanner.string.inspect)
+              end
+
+              unless scanner.skip(/"=>?/)
+                raise(ArgumentError, ERROR % scanner.string.inspect)
+              end
+
+              if scanner.scan(/NULL/)
+                value = nil
+              else
+                unless scanner.skip(/"/)
+                  raise(ArgumentError, ERROR % scanner.string.inspect)
+                end
+
+                unless value = scanner.scan(/^(\\[\\"]|[^\\"])*?(?=")/)
+                  raise(ArgumentError, ERROR % scanner.string.inspect)
+                end
+
+                unless scanner.skip(/"/)
+                  raise(ArgumentError, ERROR % scanner.string.inspect)
+                end
+              end
+
+              key.gsub!('\"', '"')
+              key.gsub!("\\\\", "\\")
+
+              if value
+                value.gsub!('\"', '"')
+                value.gsub!("\\\\", "\\")
+              end
+
+              hash[key] = value
+
+              unless scanner.skip(/, /) || scanner.eos?
+                raise(ArgumentError, ERROR % scanner.string.inspect)
+              end
             end
+
+            hash
           end
 
           def serialize(value)
@@ -46,12 +91,6 @@ module ActiveRecord
           end
 
           private
-            HstorePair = begin
-              quoted_string = /"[^"\\]*(?:\\.[^"\\]*)*"/
-              unquoted_string = /(?:\\.|[^\s,])[^\s=,\\]*(?:\\.[^\s=,\\]*|=[^,>])*/
-              /(#{quoted_string}|#{unquoted_string})\s*=>\s*(#{quoted_string}|#{unquoted_string})/
-            end
-
             def escape_hstore(value)
               if value.nil?
                 "NULL"

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)
@@ -76,6 +76,15 @@ module ActiveRecord
               }
             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
@@ -88,7 +97,7 @@ module ActiveRecord
               if value.start_with?('"') && value.end_with?('"')
                 unquoted_value = value[1..-2]
                 unquoted_value.gsub!('""', '"')
-                unquoted_value.gsub!('\\\\', '\\')
+                unquoted_value.gsub!("\\\\", "\\")
                 unquoted_value
               else
                 value

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 Postgres 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.rb

@@ -20,6 +20,8 @@ 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,21 +4,77 @@ module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
       module Quoting
+        QUOTED_COLUMN_NAMES = Concurrent::Map.new # :nodoc:
+        QUOTED_TABLE_NAMES = Concurrent::Map.new # :nodoc:
+
+        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
+
+        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
+
+        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 strings for use in SQL input.
-        def quote_string(s) #:nodoc:
-          PG::Connection.escape(s)
+        def quote_string(s) # :nodoc:
+          with_raw_connection(allow_retry: true, materialize_transactions: false) do |connection|
+            connection.escape(s)
+          end
         end
 
         # Checks the following cases:
@@ -30,7 +86,7 @@ module ActiveRecord
         # - "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
+          QUOTED_TABLE_NAMES[name] ||= Utils.extract_schema_qualified_name(name.to_s).quoted.freeze
         end
 
         # Quotes schema names for use in SQL queries.
@@ -44,11 +100,11 @@ module ActiveRecord
 
         # 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
+          QUOTED_COLUMN_NAMES[name] ||= PG::Connection.quote_ident(super).freeze
         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,7 +120,7 @@ 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?)
             type = lookup_cast_type_from_column(column)
@@ -74,7 +130,26 @@ module ActiveRecord
           end
         end
 
+        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)
+          else
+            super
+          end
+        end
+
         def lookup_cast_type_from_column(column) # :nodoc:
+          verify! if type_map.nil?
           type_map.lookup(column.oid, column.fmod, column.sql_type)
         end
 
@@ -90,8 +165,8 @@ module ActiveRecord
           \A
           (
             (?:
-              # "table_name"."column_name"::type_name | function(one or no argument)::type_name
-              ((?:\w+\.|"\w+"\.)?(?:\w+|"\w+")(?:::\w+)?) | \w+\((?:|\g<2>)\)(?:::\w+)?
+              # "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+"))?
           )
@@ -103,9 +178,10 @@ module ActiveRecord
           \A
           (
             (?:
-              # "table_name"."column_name"::type_name | function(one or no argument)::type_name
-              ((?:\w+\.|"\w+"\.)?(?:\w+|"\w+")(?:::\w+)?) | \w+\((?:|\g<2>)\)(?:::\w+)?
+              # "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))?
           )
@@ -120,49 +196,6 @@ module ActiveRecord
             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
 

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

@@ -37,6 +37,34 @@ Rails needs superuser privileges to disable referential integrity.
           rescue ActiveRecord::ActiveRecordError
           end
         end
+
+        def check_all_foreign_keys_valid! # :nodoc:
+          sql = <<~SQL
+            do $$
+              declare r record;
+            BEGIN
+            FOR r IN (
+              SELECT FORMAT(
+                'UPDATE pg_constraint SET convalidated=false WHERE conname = ''%I'' AND connamespace::regnamespace = ''%I''::regnamespace; ALTER TABLE %I.%I VALIDATE CONSTRAINT %I;',
+                constraint_name,
+                table_schema,
+                table_schema,
+                table_name,
+                constraint_name
+              ) AS constraint_check
+              FROM information_schema.table_constraints WHERE constraint_type = 'FOREIGN KEY'
+            )
+              LOOP
+                EXECUTE (r.constraint_check);
+              END LOOP;
+            END;
+            $$;
+          SQL
+
+          transaction(requires_new: true) do
+            execute(sql)
+          end
+        end
       end
     end
   end

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

@@ -5,12 +5,28 @@ module ActiveRecord
     module PostgreSQL
       class SchemaCreation < SchemaCreation # :nodoc:
         private
+          delegate :quoted_include_columns_for_index, to: :@conn
+
           def visit_AlterTable(o)
-            super << o.constraint_validations.map { |fk| visit_ValidateConstraint fk }.join(" ")
+            sql = super
+            sql << o.constraint_validations.map { |fk| visit_ValidateConstraint fk }.join(" ")
+            sql << o.exclusion_constraint_adds.map { |con| visit_AddExclusionConstraint con }.join(" ")
+            sql << o.exclusion_constraint_drops.map { |con| visit_DropExclusionConstraint con }.join(" ")
+            sql << o.unique_constraint_adds.map { |con| visit_AddUniqueConstraint con }.join(" ")
+            sql << o.unique_constraint_drops.map { |con| visit_DropUniqueConstraint con }.join(" ")
           end
 
           def visit_AddForeignKey(o)
-            super.dup.tap { |sql| sql << " NOT VALID" unless o.validate? }
+            super.dup.tap do |sql|
+              sql << " DEFERRABLE INITIALLY #{o.options[:deferrable].to_s.upcase}" if o.deferrable
+              sql << " NOT VALID" unless o.validate?
+            end
+          end
+
+          def visit_ForeignKeyDefinition(o)
+            super.dup.tap do |sql|
+              sql << " DEFERRABLE INITIALLY #{o.deferrable.to_s.upcase}" if o.deferrable
+            end
           end
 
           def visit_CheckConstraintDefinition(o)
@@ -21,6 +37,54 @@ module ActiveRecord
             "VALIDATE CONSTRAINT #{quote_column_name(name)}"
           end
 
+          def visit_ExclusionConstraintDefinition(o)
+            sql = ["CONSTRAINT"]
+            sql << quote_column_name(o.name)
+            sql << "EXCLUDE"
+            sql << "USING #{o.using}" if o.using
+            sql << "(#{o.expression})"
+            sql << "WHERE (#{o.where})" if o.where
+            sql << "DEFERRABLE INITIALLY #{o.deferrable.to_s.upcase}" if o.deferrable
+
+            sql.join(" ")
+          end
+
+          def visit_UniqueConstraintDefinition(o)
+            column_name = Array(o.column).map { |column| quote_column_name(column) }.join(", ")
+
+            sql = ["CONSTRAINT"]
+            sql << quote_column_name(o.name)
+            sql << "UNIQUE"
+
+            if o.using_index
+              sql << "USING INDEX #{quote_column_name(o.using_index)}"
+            else
+              sql << "(#{column_name})"
+            end
+
+            if o.deferrable
+              sql << "DEFERRABLE INITIALLY #{o.deferrable.to_s.upcase}"
+            end
+
+            sql.join(" ")
+          end
+
+          def visit_AddExclusionConstraint(o)
+            "ADD #{accept(o)}"
+          end
+
+          def visit_DropExclusionConstraint(name)
+            "DROP CONSTRAINT #{quote_column_name(name)}"
+          end
+
+          def visit_AddUniqueConstraint(o)
+            "ADD #{accept(o)}"
+          end
+
+          def visit_DropUniqueConstraint(name)
+            "DROP CONSTRAINT #{quote_column_name(name)}"
+          end
+
           def visit_ChangeColumnDefinition(o)
             column = o.column
             column.sql_type = type_to_sql(column.type, **column.options)
@@ -57,13 +121,39 @@ module ActiveRecord
             change_column_sql
           end
 
+          def visit_ChangeColumnDefaultDefinition(o)
+            sql = +"ALTER COLUMN #{quote_column_name(o.column.name)} "
+            if o.default.nil?
+              sql << "DROP DEFAULT"
+            else
+              sql << "SET DEFAULT #{quote_default_expression(o.default, o.column)}"
+            end
+          end
+
           def add_column_options!(sql, options)
             if options[:collation]
               sql << " COLLATE \"#{options[:collation]}\""
             end
+
+            if as = options[:as]
+              sql << " GENERATED ALWAYS AS (#{as})"
+
+              if options[:stored]
+                sql << " STORED"
+              else
+                raise ArgumentError, <<~MSG
+                  PostgreSQL currently does not support VIRTUAL (not persisted) generated columns.
+                  Specify 'stored: true' option for '#{options[:column].name}'
+                MSG
+              end
+            end
             super
           end
 
+          def quoted_include_columns(o)
+            String === o ? o : quoted_include_columns_for_index(o)
+          end
+
           # Returns any SQL string to go between CREATE and TABLE. May be nil.
           def table_modifier_in_create(o)
             # A table cannot be both TEMPORARY and UNLOGGED, since all TEMPORARY