activerecord 5.2.6 → 6.0.0

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

@@ -22,7 +22,7 @@ module ActiveRecord
             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)
 
@@ -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_statements.rb

@@ -22,8 +22,8 @@ module ActiveRecord
         def create_database(name, options = {})
           options = { encoding: "utf8" }.merge!(options.symbolize_keys)
 
-          option_string = options.inject("") do |memo, (key, value)|
-            memo += case key
+          option_string = options.each_with_object(+"") do |(key, value), memo|
+            memo << case key
                     when :owner
                       " OWNER = \"#{value}\""
                     when :template
@@ -68,7 +68,7 @@ module ActiveRecord
           table = quoted_scope(table_name)
           index = quoted_scope(index_name)
 
-          query_value(<<-SQL, "SCHEMA").to_i > 0
+          query_value(<<~SQL, "SCHEMA").to_i > 0
             SELECT COUNT(*)
             FROM pg_class t
             INNER JOIN pg_index d ON t.oid = d.indrelid
@@ -85,7 +85,7 @@ module ActiveRecord
         def indexes(table_name) # :nodoc:
           scope = quoted_scope(table_name)
 
-          result = query(<<-SQL, "SCHEMA")
+          result = query(<<~SQL, "SCHEMA")
             SELECT distinct i.relname, d.indisunique, d.indkey, pg_get_indexdef(d.indexrelid), t.oid,
                             pg_catalog.obj_description(i.oid, 'pg_class') AS comment
             FROM pg_class t
@@ -115,7 +115,7 @@ module ActiveRecord
             if indkey.include?(0)
               columns = expressions
             else
-              columns = Hash[query(<<-SQL.strip_heredoc, "SCHEMA")].values_at(*indkey).compact
+              columns = Hash[query(<<~SQL, "SCHEMA")].values_at(*indkey).compact
                 SELECT a.attnum, a.attname
                 FROM pg_attribute a
                 WHERE a.attrelid = #{oid}
@@ -158,7 +158,7 @@ module ActiveRecord
         def table_comment(table_name) # :nodoc:
           scope = quoted_scope(table_name, type: "BASE TABLE")
           if scope[:name]
-            query_value(<<-SQL.strip_heredoc, "SCHEMA")
+            query_value(<<~SQL, "SCHEMA")
               SELECT pg_catalog.obj_description(c.oid, 'pg_class')
               FROM pg_catalog.pg_class c
                 LEFT JOIN pg_namespace n ON n.oid = c.relnamespace
@@ -196,7 +196,7 @@ module ActiveRecord
 
         # Returns an array of schema names.
         def schema_names
-          query_values(<<-SQL, "SCHEMA")
+          query_values(<<~SQL, "SCHEMA")
             SELECT nspname
               FROM pg_namespace
              WHERE nspname !~ '^pg_.*'
@@ -287,7 +287,7 @@ module ActiveRecord
             quoted_sequence = quote_table_name(sequence)
             max_pk = query_value("SELECT MAX(#{quote_column_name pk}) FROM #{quote_table_name(table)}", "SCHEMA")
             if max_pk.nil?
-              if postgresql_version >= 100000
+              if database_version >= 100000
                 minvalue = query_value("SELECT seqmin FROM pg_sequence WHERE seqrelid = #{quote(quoted_sequence)}::regclass", "SCHEMA")
               else
                 minvalue = query_value("SELECT min_value FROM #{quoted_sequence}", "SCHEMA")
@@ -302,7 +302,7 @@ module ActiveRecord
         def pk_and_sequence_for(table) #:nodoc:
           # First try looking for a sequence with a dependency on the
           # given table's primary key.
-          result = query(<<-end_sql, "SCHEMA")[0]
+          result = query(<<~SQL, "SCHEMA")[0]
             SELECT attr.attname, nsp.nspname, seq.relname
             FROM pg_class      seq,
                  pg_attribute  attr,
@@ -319,10 +319,10 @@ module ActiveRecord
               AND cons.contype      = 'p'
               AND dep.classid       = 'pg_class'::regclass
               AND dep.refobjid      = #{quote(quote_table_name(table))}::regclass
-          end_sql
+          SQL
 
           if result.nil? || result.empty?
-            result = query(<<-end_sql, "SCHEMA")[0]
+            result = query(<<~SQL, "SCHEMA")[0]
               SELECT attr.attname, nsp.nspname,
                 CASE
                   WHEN pg_get_expr(def.adbin, def.adrelid) !~* 'nextval' THEN NULL
@@ -339,7 +339,7 @@ module ActiveRecord
               WHERE t.oid = #{quote(quote_table_name(table))}::regclass
                 AND cons.contype = 'p'
                 AND pg_get_expr(def.adbin, def.adrelid) ~* 'nextval|uuid_generate'
-            end_sql
+            SQL
           end
 
           pk = result.shift
@@ -353,7 +353,7 @@ module ActiveRecord
         end
 
         def primary_keys(table_name) # :nodoc:
-          query_values(<<-SQL.strip_heredoc, "SCHEMA")
+          query_values(<<~SQL, "SCHEMA")
             SELECT a.attname
               FROM (
                      SELECT indrelid, indkey, generate_subscripts(indkey, 1) idx
@@ -368,31 +368,6 @@ module ActiveRecord
           SQL
         end
 
-        def bulk_change_table(table_name, operations)
-          sql_fragments = []
-          non_combinable_operations = []
-
-          operations.each do |command, args|
-            table, arguments = args.shift, args
-            method = :"#{command}_for_alter"
-
-            if respond_to?(method, true)
-              sqls, procs = Array(send(method, table, *arguments)).partition { |v| v.is_a?(String) }
-              sql_fragments << sqls
-              non_combinable_operations.concat(procs)
-            else
-              execute "ALTER TABLE #{quote_table_name(table_name)} #{sql_fragments.join(", ")}" unless sql_fragments.empty?
-              non_combinable_operations.each(&:call)
-              sql_fragments = []
-              non_combinable_operations = []
-              send(command, table, *arguments)
-            end
-          end
-
-          execute "ALTER TABLE #{quote_table_name(table_name)} #{sql_fragments.join(", ")}" unless sql_fragments.empty?
-          non_combinable_operations.each(&:call)
-        end
-
         # Renames a table.
         # Also renames a table's primary key sequence if the sequence name exists and
         # matches the Active Record default.
@@ -443,14 +418,16 @@ module ActiveRecord
         end
 
         # Adds comment for given table column or drops it if +comment+ is a +nil+
-        def change_column_comment(table_name, column_name, comment) # :nodoc:
+        def change_column_comment(table_name, column_name, comment_or_changes) # :nodoc:
           clear_cache!
+          comment = extract_new_comment_value(comment_or_changes)
           execute "COMMENT ON COLUMN #{quote_table_name(table_name)}.#{quote_column_name(column_name)} IS #{quote(comment)}"
         end
 
         # Adds comment for given table or drops it if +comment+ is a +nil+
-        def change_table_comment(table_name, comment) # :nodoc:
+        def change_table_comment(table_name, comment_or_changes) # :nodoc:
           clear_cache!
+          comment = extract_new_comment_value(comment_or_changes)
           execute "COMMENT ON TABLE #{quote_table_name(table_name)} IS #{quote(comment)}"
         end
 
@@ -502,7 +479,7 @@ module ActiveRecord
 
         def foreign_keys(table_name)
           scope = quoted_scope(table_name)
-          fk_info = exec_query(<<-SQL.strip_heredoc, "SCHEMA")
+          fk_info = exec_query(<<~SQL, "SCHEMA")
             SELECT t2.oid::regclass::text AS to_table, a1.attname AS column, a2.attname AS primary_key, c.conname AS name, c.confupdtype AS on_update, c.confdeltype AS on_delete, c.convalidated AS valid
             FROM pg_constraint c
             JOIN pg_class t1 ON c.conrelid = t1.oid
@@ -548,21 +525,21 @@ module ActiveRecord
               # The hard limit is 1GB, because of a 32-bit size field, and TOAST.
               case limit
               when nil, 0..0x3fffffff; super(type)
-              else raise(ActiveRecordError, "No binary type has byte size #{limit}.")
+              else raise ArgumentError, "No binary type has byte size #{limit}. The limit on binary can be at most 1GB - 1byte."
               end
             when "text"
               # PostgreSQL doesn't support limits on text columns.
               # The hard limit is 1GB, according to section 8.3 in the manual.
               case limit
               when nil, 0..0x3fffffff; super(type)
-              else raise(ActiveRecordError, "The limit on text can be at most 1GB - 1byte.")
+              else raise ArgumentError, "No text type has byte size #{limit}. The limit on text can be at most 1GB - 1byte."
               end
             when "integer"
               case limit
               when 1, 2; "smallint"
               when nil, 3, 4; "integer"
               when 5..8; "bigint"
-              else raise(ActiveRecordError, "No integer type has byte size #{limit}. Use a numeric with scale 0 instead.")
+              else raise ArgumentError, "No integer type has byte size #{limit}. Use a numeric with scale 0 instead."
               end
             else
               super
@@ -623,10 +600,10 @@ module ActiveRecord
         #   validate_foreign_key :accounts, name: :special_fk_name
         #
         # The +options+ hash accepts the same keys as SchemaStatements#add_foreign_key.
-        def validate_foreign_key(from_table, options_or_to_table = {})
+        def validate_foreign_key(from_table, to_table = nil, **options)
           return unless supports_validate_constraints?
 
-          fk_name_to_validate = foreign_key_for!(from_table, options_or_to_table).name
+          fk_name_to_validate = foreign_key_for!(from_table, to_table: to_table, **options).name
 
           validate_constraint from_table, fk_name_to_validate
         end
@@ -637,7 +614,7 @@ module ActiveRecord
           end
 
           def create_table_definition(*args)
-            PostgreSQL::TableDefinition.new(*args)
+            PostgreSQL::TableDefinition.new(self, *args)
           end
 
           def create_alter_table(name)
@@ -650,16 +627,19 @@ module ActiveRecord
             default_value = extract_value_from_default(default)
             default_function = extract_default_function(default_value, default)
 
-            PostgreSQLColumn.new(
+            if match = default_function&.match(/\Anextval\('"?(?<sequence_name>.+_(?<suffix>seq\d*))"?'::regclass\)\z/)
+              serial = sequence_name_from_parts(table_name, column_name, match[:suffix]) == match[:sequence_name]
+            end
+
+            PostgreSQL::Column.new(
               column_name,
               default_value,
               type_metadata,
               !notnull,
-              table_name,
               default_function,
-              collation,
+              collation: collation,
               comment: comment.presence,
-              max_identifier_length: max_identifier_length
+              serial: serial
             )
           end
 
@@ -672,7 +652,23 @@ module ActiveRecord
               precision: cast_type.precision,
               scale: cast_type.scale,
             )
-            PostgreSQLTypeMetadata.new(simple_type, oid: oid, fmod: fmod)
+            PostgreSQL::TypeMetadata.new(simple_type, oid: oid, fmod: fmod)
+          end
+
+          def sequence_name_from_parts(table_name, column_name, suffix)
+            over_length = [table_name, column_name, suffix].sum(&:length) + 2 - max_identifier_length
+
+            if over_length > 0
+              column_name_length = [(max_identifier_length - suffix.length - 2) / 2, column_name.length].min
+              over_length -= column_name.length - column_name_length
+              column_name = column_name[0, column_name_length - [over_length, 0].min]
+            end
+
+            if over_length > 0
+              table_name = table_name[0, table_name.length - over_length]
+            end
+
+            "#{table_name}_#{column_name}_#{suffix}"
           end
 
           def extract_foreign_key_action(specifier)
@@ -716,6 +712,12 @@ module ActiveRecord
           end
 
           def add_timestamps_for_alter(table_name, options = {})
+            options[:null] = false if options[:null].nil?
+
+            if !options.key?(:precision) && supports_datetime_with_precision?
+              options[:precision] = 6
+            end
+
             [add_column_for_alter(table_name, :created_at, :datetime, options), add_column_for_alter(table_name, :updated_at, :datetime, options)]
           end
 
@@ -739,7 +741,7 @@ module ActiveRecord
             scope = quoted_scope(name, type: type)
             scope[:type] ||= "'r','v','m','p','f'" # (r)elation/table, (v)iew, (m)aterialized view, (p)artitioned table, (f)oreign table
 
-            sql = "SELECT c.relname FROM pg_class c LEFT JOIN pg_namespace n ON n.oid = c.relnamespace".dup
+            sql = +"SELECT c.relname FROM pg_class c LEFT JOIN pg_namespace n ON n.oid = c.relnamespace"
             sql << " WHERE n.nspname = #{scope[:schema]}"
             sql << " AND c.relname = #{scope[:name]}" if scope[:name]
             sql << " AND c.relkind IN (#{scope[:type]})"

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

@@ -1,39 +1,36 @@
 # frozen_string_literal: true
 
 module ActiveRecord
+  # :stopdoc:
   module ConnectionAdapters
-    class PostgreSQLTypeMetadata < DelegateClass(SqlTypeMetadata)
-      undef to_yaml if method_defined?(:to_yaml)
+    module PostgreSQL
+      class TypeMetadata < DelegateClass(SqlTypeMetadata)
+        undef to_yaml if method_defined?(:to_yaml)
 
-      attr_reader :oid, :fmod, :array
+        attr_reader :oid, :fmod
 
-      def initialize(type_metadata, oid: nil, fmod: nil)
-        super(type_metadata)
-        @type_metadata = type_metadata
-        @oid = oid
-        @fmod = fmod
-        @array = /\[\]$/.match?(type_metadata.sql_type)
-      end
-
-      def sql_type
-        super.gsub(/\[\]$/, "".freeze)
-      end
-
-      def ==(other)
-        other.is_a?(PostgreSQLTypeMetadata) &&
-          attributes_for_hash == other.attributes_for_hash
-      end
-      alias eql? ==
-
-      def hash
-        attributes_for_hash.hash
-      end
+        def initialize(type_metadata, oid: nil, fmod: nil)
+          super(type_metadata)
+          @oid = oid
+          @fmod = fmod
+        end
 
-      protected
+        def ==(other)
+          other.is_a?(TypeMetadata) &&
+            __getobj__ == other.__getobj__ &&
+            oid == other.oid &&
+            fmod == other.fmod
+        end
+        alias eql? ==
 
-        def attributes_for_hash
-          [self.class, @type_metadata, oid, fmod]
+        def hash
+          TypeMetadata.hash ^
+            __getobj__.hash ^
+            oid.hash ^
+            fmod.hash
         end
+      end
     end
+    PostgreSQLTypeMetadata = PostgreSQL::TypeMetadata
   end
 end