activerecord 5.2.8.1 → 6.0.6

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

@@ -58,25 +58,43 @@ module ActiveRecord
           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)
+              infinity?(value) ? value : @subtype.serialize(@subtype.cast(value))
             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
 
+            # 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/type_map_initializer.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "active_support/core_ext/array/extract"
+
 module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
@@ -16,12 +18,12 @@ module ActiveRecord
 
           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".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 = nodes.extract! { |row| @store.key? row["typname"] }
+            ranges = nodes.extract! { |row| row["typtype"] == "r" }
+            enums = nodes.extract! { |row| row["typtype"] == "e" }
+            domains = nodes.extract! { |row| row["typtype"] == "d" }
+            arrays = nodes.extract! { |row| row["typinput"] == "array_in" }
+            composites = nodes.extract! { |row| row["typelem"].to_i != 0 }
 
             mapped.each     { |row| register_mapped_type(row)    }
             enums.each      { |row| register_enum_type(row)      }
@@ -34,7 +36,7 @@ module ActiveRecord
           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(", ")]
+            <<~SQL % [known_type_names.join(", "), known_type_types.join(", ")]
               WHERE
                 t.typname IN (%s)
                 OR t.typtype IN (%s)

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

@@ -13,9 +13,11 @@ module ActiveRecord
             :uuid
           end
 
-          def cast(value)
-            value.to_s[ACCEPTABLE_UUID, 0]
-          end
+          private
+            def cast_value(value)
+              casted = value.to_s
+              casted if casted.match?(ACCEPTABLE_UUID)
+            end
         end
       end
     end

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

@@ -30,7 +30,7 @@ module ActiveRecord
         # - "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
+          self.class.quoted_table_names[name] ||= Utils.extract_schema_qualified_name(name.to_s).quoted.freeze
         end
 
         # Quotes schema names for use in SQL queries.
@@ -44,7 +44,7 @@ module ActiveRecord
 
         # Quotes column names for use in SQL queries.
         def quote_column_name(name) # :nodoc:
-          @quoted_column_names[name] ||= PG::Connection.quote_ident(super).freeze
+          self.class.quoted_column_names[name] ||= PG::Connection.quote_ident(super).freeze
         end
 
         # Quote date/time values for use in SQL input.
@@ -78,6 +78,43 @@ module ActiveRecord
           type_map.lookup(column.oid, column.fmod, column.sql_type)
         end
 
+        def column_name_matcher
+          COLUMN_NAME
+        end
+
+        def column_name_with_order_matcher
+          COLUMN_NAME_WITH_ORDER
+        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)
@@ -93,11 +130,11 @@ module ActiveRecord
               elsif value.hex?
                 "X'#{value}'"
               end
-            when Float
-              if value.infinite? || value.nan?
-                "'#{value}'"
-              else
+            when Numeric
+              if value.finite?
                 super
+              else
+                "'#{value}'"
               end
             when OID::Array::Data
               _quote(encode_array(value))
@@ -138,7 +175,7 @@ module ActiveRecord
           end
 
           def encode_range(range)
-            "[#{type_cast_range_value(range.first)},#{type_cast_range_value(range.last)}#{range.exclude_end? ? ')' : ']'}"
+            "[#{type_cast_range_value(range.begin)},#{type_cast_range_value(range.end)}#{range.exclude_end? ? ')' : ']'}"
           end
 
           def determine_encoding_of_strings_in_array(value)

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

@@ -26,7 +26,7 @@ Rails needs superuser privileges to disable referential integrity.
 
     cause: #{original_exception.try(:message)}
 
-              WARNING
+            WARNING
             raise e
           end
 

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

@@ -19,10 +19,10 @@ module ActiveRecord
 
           def visit_ChangeColumnDefinition(o)
             column = o.column
-            column.sql_type = type_to_sql(column.type, column.options)
+            column.sql_type = type_to_sql(column.type, **column.options)
             quoted_column_name = quote_column_name(o.name)
 
-            change_column_sql = "ALTER COLUMN #{quoted_column_name} TYPE #{column.sql_type}".dup
+            change_column_sql = +"ALTER COLUMN #{quoted_column_name} TYPE #{column.sql_type}"
 
             options = column_options(column)
 
@@ -33,7 +33,7 @@ module ActiveRecord
             if options[:using]
               change_column_sql << " USING #{options[:using]}"
             elsif options[:cast_as]
-              cast_as_type = type_to_sql(options[:cast_as], options)
+              cast_as_type = type_to_sql(options[:cast_as], **options)
               change_column_sql << " USING CAST(#{quoted_column_name} AS #{cast_as_type})"
             end
 
@@ -59,6 +59,17 @@ module ActiveRecord
             end
             super
           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
+            # tables are already UNLOGGED.
+            if o.temporary
+              " TEMPORARY"
+            elsif o.unlogged
+              " UNLOGGED"
+            end
+          end
       end
     end
   end

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

@@ -4,6 +4,8 @@ module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
       module ColumnMethods
+        extend ActiveSupport::Concern
+
         # Defines the primary key field.
         # Use of the native PostgreSQL UUID type is supported, and can be used
         # by defining your tables as such:
@@ -13,10 +15,10 @@ module ActiveRecord
         #     t.timestamps
         #   end
         #
-        # By default, this will use the +gen_random_uuid()+ function from the
+        # By default, this will use the <tt>gen_random_uuid()</tt> function from the
         # +pgcrypto+ extension. As that extension is only available in
         # PostgreSQL 9.4+, for earlier versions an explicit default can be set
-        # to use +uuid_generate_v4()+ from the +uuid-ossp+ extension instead:
+        # to use <tt>uuid_generate_v4()</tt> from the +uuid-ossp+ extension instead:
         #
         #   create_table :stuffs, id: false do |t|
         #     t.primary_key :id, :uuid, default: "uuid_generate_v4()"
@@ -51,130 +53,144 @@ module ActiveRecord
           super
         end
 
-        def bigserial(*args, **options)
-          args.each { |name| column(name, :bigserial, options) }
-        end
+        ##
+        # :method: bigserial
+        # :call-seq: bigserial(*names, **options)
 
-        def bit(*args, **options)
-          args.each { |name| column(name, :bit, options) }
-        end
+        ##
+        # :method: bit
+        # :call-seq: bit(*names, **options)
 
-        def bit_varying(*args, **options)
-          args.each { |name| column(name, :bit_varying, options) }
-        end
+        ##
+        # :method: bit_varying
+        # :call-seq: bit_varying(*names, **options)
 
-        def cidr(*args, **options)
-          args.each { |name| column(name, :cidr, options) }
-        end
+        ##
+        # :method: cidr
+        # :call-seq: cidr(*names, **options)
 
-        def citext(*args, **options)
-          args.each { |name| column(name, :citext, options) }
-        end
+        ##
+        # :method: citext
+        # :call-seq: citext(*names, **options)
 
-        def daterange(*args, **options)
-          args.each { |name| column(name, :daterange, options) }
-        end
+        ##
+        # :method: daterange
+        # :call-seq: daterange(*names, **options)
 
-        def hstore(*args, **options)
-          args.each { |name| column(name, :hstore, options) }
-        end
+        ##
+        # :method: hstore
+        # :call-seq: hstore(*names, **options)
 
-        def inet(*args, **options)
-          args.each { |name| column(name, :inet, options) }
-        end
+        ##
+        # :method: inet
+        # :call-seq: inet(*names, **options)
 
-        def interval(*args, **options)
-          args.each { |name| column(name, :interval, options) }
-        end
+        ##
+        # :method: interval
+        # :call-seq: interval(*names, **options)
 
-        def int4range(*args, **options)
-          args.each { |name| column(name, :int4range, options) }
-        end
+        ##
+        # :method: int4range
+        # :call-seq: int4range(*names, **options)
 
-        def int8range(*args, **options)
-          args.each { |name| column(name, :int8range, options) }
-        end
+        ##
+        # :method: int8range
+        # :call-seq: int8range(*names, **options)
 
-        def jsonb(*args, **options)
-          args.each { |name| column(name, :jsonb, options) }
-        end
+        ##
+        # :method: jsonb
+        # :call-seq: jsonb(*names, **options)
 
-        def ltree(*args, **options)
-          args.each { |name| column(name, :ltree, options) }
-        end
+        ##
+        # :method: ltree
+        # :call-seq: ltree(*names, **options)
 
-        def macaddr(*args, **options)
-          args.each { |name| column(name, :macaddr, options) }
-        end
+        ##
+        # :method: macaddr
+        # :call-seq: macaddr(*names, **options)
 
-        def money(*args, **options)
-          args.each { |name| column(name, :money, options) }
-        end
+        ##
+        # :method: money
+        # :call-seq: money(*names, **options)
 
-        def numrange(*args, **options)
-          args.each { |name| column(name, :numrange, options) }
-        end
+        ##
+        # :method: numrange
+        # :call-seq: numrange(*names, **options)
 
-        def oid(*args, **options)
-          args.each { |name| column(name, :oid, options) }
-        end
+        ##
+        # :method: oid
+        # :call-seq: oid(*names, **options)
 
-        def point(*args, **options)
-          args.each { |name| column(name, :point, options) }
-        end
+        ##
+        # :method: point
+        # :call-seq: point(*names, **options)
 
-        def line(*args, **options)
-          args.each { |name| column(name, :line, options) }
-        end
+        ##
+        # :method: line
+        # :call-seq: line(*names, **options)
 
-        def lseg(*args, **options)
-          args.each { |name| column(name, :lseg, options) }
-        end
+        ##
+        # :method: lseg
+        # :call-seq: lseg(*names, **options)
 
-        def box(*args, **options)
-          args.each { |name| column(name, :box, options) }
-        end
+        ##
+        # :method: box
+        # :call-seq: box(*names, **options)
 
-        def path(*args, **options)
-          args.each { |name| column(name, :path, options) }
-        end
+        ##
+        # :method: path
+        # :call-seq: path(*names, **options)
 
-        def polygon(*args, **options)
-          args.each { |name| column(name, :polygon, options) }
-        end
+        ##
+        # :method: polygon
+        # :call-seq: polygon(*names, **options)
 
-        def circle(*args, **options)
-          args.each { |name| column(name, :circle, options) }
-        end
+        ##
+        # :method: circle
+        # :call-seq: circle(*names, **options)
 
-        def serial(*args, **options)
-          args.each { |name| column(name, :serial, options) }
-        end
+        ##
+        # :method: serial
+        # :call-seq: serial(*names, **options)
 
-        def tsrange(*args, **options)
-          args.each { |name| column(name, :tsrange, options) }
-        end
+        ##
+        # :method: tsrange
+        # :call-seq: tsrange(*names, **options)
 
-        def tstzrange(*args, **options)
-          args.each { |name| column(name, :tstzrange, options) }
-        end
+        ##
+        # :method: tstzrange
+        # :call-seq: tstzrange(*names, **options)
 
-        def tsvector(*args, **options)
-          args.each { |name| column(name, :tsvector, options) }
-        end
+        ##
+        # :method: tsvector
+        # :call-seq: tsvector(*names, **options)
 
-        def uuid(*args, **options)
-          args.each { |name| column(name, :uuid, options) }
-        end
+        ##
+        # :method: uuid
+        # :call-seq: uuid(*names, **options)
+
+        ##
+        # :method: xml
+        # :call-seq: xml(*names, **options)
 
-        def xml(*args, **options)
-          args.each { |name| column(name, :xml, options) }
+        included do
+          define_column_methods :bigserial, :bit, :bit_varying, :cidr, :citext, :daterange,
+            :hstore, :inet, :interval, :int4range, :int8range, :jsonb, :ltree, :macaddr,
+            :money, :numrange, :oid, :point, :line, :lseg, :box, :path, :polygon, :circle,
+            :serial, :tsrange, :tstzrange, :tsvector, :uuid, :xml
         end
       end
 
       class TableDefinition < ActiveRecord::ConnectionAdapters::TableDefinition
         include ColumnMethods
 
+        attr_reader :unlogged
+
+        def initialize(*, **)
+          super
+          @unlogged = ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.create_unlogged_tables
+        end
+
         private
           def integer_like_primary_key_type(type, options)
             if type == :bigint || options[:limit] == 8

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

@@ -5,7 +5,6 @@ module ActiveRecord
     module PostgreSQL
       class SchemaDumper < ConnectionAdapters::SchemaDumper # :nodoc:
         private
-
           def extensions(stream)
             extensions = @connection.extensions
             if extensions.any?