activerecord 5.0.7.2 → 5.1.0.beta1

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

@@ -11,11 +11,22 @@ module ActiveRecord
         #     t.timestamps
         #   end
         #
-        # By default, this will use the +uuid_generate_v4()+ function from the
-        # +uuid-ossp+ extension, which MUST be enabled on your database. To enable
-        # the +uuid-ossp+ extension, you can use the +enable_extension+ method in your
-        # migrations. To use a UUID primary key without +uuid-ossp+ enabled, you can
-        # set the +:default+ option to +nil+:
+        # By default, this will use the +gen_random_uuid()+ 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:
+        #
+        #   create_table :stuffs, id: false do |t|
+        #     t.primary_key :id, :uuid, default: "uuid_generate_v4()"
+        #     t.uuid :foo_id
+        #     t.timestamps
+        #   end
+        #
+        # To enable the appropriate extension, which is a requirement, use
+        # the +enable_extension+ method in your migrations.
+        #
+        # To use a UUID primary key without any of the extensions, set the
+        # +:default+ option to +nil+:
         #
         #   create_table :stuffs, id: false do |t|
         #     t.primary_key :id, :uuid, default: nil
@@ -23,15 +34,25 @@ module ActiveRecord
         #     t.timestamps
         #   end
         #
-        # You may also pass a different UUID generation function from +uuid-ossp+
-        # or another library.
+        # You may also pass a custom stored procedure that returns a UUID or use a
+        # different UUID generation function from another library.
         #
         # Note that setting the UUID primary key default value to +nil+ will
         # require you to assure that you always provide a UUID value before saving
         # a record (as primary keys cannot be +nil+). This might be done via the
         # +SecureRandom.uuid+ method and a +before_save+ callback, for instance.
         def primary_key(name, type = :primary_key, **options)
-          options[:default] = options.fetch(:default, 'uuid_generate_v4()') if type == :uuid
+          options[:auto_increment] = true if [:integer, :bigint].include?(type) && !options.key?(:default)
+          if type == :uuid
+            options[:default] = options.fetch(:default, "gen_random_uuid()")
+          elsif options.delete(:auto_increment) == true && %i(integer bigint).include?(type)
+            type = if type == :bigint || options[:limit] == 8
+              :bigserial
+            else
+              :serial
+            end
+          end
+
           super
         end
 
@@ -67,6 +88,10 @@ module ActiveRecord
           args.each { |name| column(name, :inet, options) }
         end
 
+        def interval(*args, **options)
+          args.each { |name| column(name, :interval, options) }
+        end
+
         def int4range(*args, **options)
           args.each { |name| column(name, :int4range, options) }
         end
@@ -99,6 +124,10 @@ module ActiveRecord
           args.each { |name| column(name, :numrange, options) }
         end
 
+        def oid(*args, **options)
+          args.each { |name| column(name, :oid, options) }
+        end
+
         def point(*args, **options)
           args.each { |name| column(name, :point, options) }
         end
@@ -152,24 +181,8 @@ module ActiveRecord
         end
       end
 
-      class ColumnDefinition < ActiveRecord::ConnectionAdapters::ColumnDefinition
-        attr_accessor :array
-      end
-
       class TableDefinition < ActiveRecord::ConnectionAdapters::TableDefinition
         include ColumnMethods
-
-        def new_column_definition(name, type, options) # :nodoc:
-          column = super
-          column.array = options[:array]
-          column
-        end
-
-        private
-
-          def create_column_definition(name, type)
-            PostgreSQL::ColumnDefinition.new name, type
-          end
       end
 
       class Table < ActiveRecord::ConnectionAdapters::Table

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

@@ -1,19 +1,11 @@
 module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
-      module ColumnDumper
-        def column_spec_for_primary_key(column)
-          spec = super
-          if schema_type(column) == :uuid
-            spec[:default] ||= 'nil'
-          end
-          spec
-        end
-
+      module ColumnDumper # :nodoc:
         # Adds +:array+ option to the default set
         def prepare_column_options(column)
           spec = super
-          spec[:array] = 'true' if column.array?
+          spec[:array] = "true" if column.array?
           spec
         end
 
@@ -24,23 +16,27 @@ module ActiveRecord
 
         private
 
-        def default_primary_key?(column)
-          schema_type(column) == :serial
-        end
+          def default_primary_key?(column)
+            schema_type(column) == :bigserial
+          end
+
+          def explicit_primary_key_default?(column)
+            column.type == :uuid || (column.type == :integer && !column.serial?)
+          end
 
-        def schema_type(column)
-          return super unless column.serial?
+          def schema_type(column)
+            return super unless column.serial?
 
-          if column.bigint?
-            :bigserial
-          else
-            :serial
+            if column.bigint?
+              :bigserial
+            else
+              :serial
+            end
           end
-        end
 
-        def schema_expression(column)
-          super unless column.serial?
-        end
+          def schema_expression(column)
+            super unless column.serial?
+          end
       end
     end
   end

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

@@ -1,24 +1,8 @@
-require 'active_support/core_ext/string/strip'
+require "active_support/core_ext/string/strip"
 
 module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
-      class SchemaCreation < AbstractAdapter::SchemaCreation
-        private
-
-        def visit_ColumnDefinition(o)
-          o.sql_type = type_to_sql(o.type, o.limit, o.precision, o.scale, o.array)
-          super
-        end
-
-        def add_column_options!(sql, options)
-          if options[:collation]
-            sql << " COLLATE \"#{options[:collation]}\""
-          end
-          super
-        end
-      end
-
       module SchemaStatements
         # Drops the database specified on the +name+ attribute
         # and creates it again using the provided +options+.
@@ -36,26 +20,26 @@ module ActiveRecord
         #   create_database config[:database], config
         #   create_database 'foo_development', encoding: 'unicode'
         def create_database(name, options = {})
-          options = { encoding: 'utf8' }.merge!(options.symbolize_keys)
+          options = { encoding: "utf8" }.merge!(options.symbolize_keys)
 
           option_string = options.inject("") do |memo, (key, value)|
             memo += case key
-            when :owner
-              " OWNER = \"#{value}\""
-            when :template
-              " TEMPLATE = \"#{value}\""
-            when :encoding
-              " ENCODING = '#{value}'"
-            when :collation
-              " LC_COLLATE = '#{value}'"
-            when :ctype
-              " LC_CTYPE = '#{value}'"
-            when :tablespace
-              " TABLESPACE = \"#{value}\""
-            when :connection_limit
-              " CONNECTION LIMIT = #{value}"
+                    when :owner
+                      " OWNER = \"#{value}\""
+                    when :template
+                      " TEMPLATE = \"#{value}\""
+                    when :encoding
+                      " ENCODING = '#{value}'"
+                    when :collation
+                      " LC_COLLATE = '#{value}'"
+                    when :ctype
+                      " LC_CTYPE = '#{value}'"
+                    when :tablespace
+                      " TABLESPACE = \"#{value}\""
+                    when :connection_limit
+                      " CONNECTION LIMIT = #{value}"
             else
-              ""
+                      ""
             end
           end
 
@@ -71,22 +55,26 @@ module ActiveRecord
         end
 
         # Returns the list of all tables in the schema search path.
-        def tables(name = nil)
-          if name
-            ActiveSupport::Deprecation.warn(<<-MSG.squish)
-              Passing arguments to #tables is deprecated without replacement.
-            MSG
-          end
-
-          select_values("SELECT tablename FROM pg_tables WHERE schemaname = ANY(current_schemas(false))", 'SCHEMA')
+        def tables
+          select_values("SELECT tablename FROM pg_tables WHERE schemaname = ANY(current_schemas(false))", "SCHEMA")
         end
 
         def data_sources # :nodoc
-          select_values(<<-SQL, 'SCHEMA')
+          select_values(<<-SQL, "SCHEMA")
             SELECT c.relname
             FROM pg_class c
             LEFT JOIN pg_namespace n ON n.oid = c.relnamespace
-            WHERE c.relkind IN ('r', 'v','m') -- (r)elation/table, (v)iew, (m)aterialized view
+            WHERE c.relkind IN ('r','v','m') -- (r)elation/table, (v)iew, (m)aterialized view
+            AND n.nspname = ANY (current_schemas(false))
+          SQL
+        end
+
+        def views # :nodoc:
+          select_values(<<-SQL, "SCHEMA")
+            SELECT c.relname
+            FROM pg_class c
+            LEFT JOIN pg_namespace n ON n.oid = c.relnamespace
+            WHERE c.relkind IN ('v','m') -- (v)iew, (m)aterialized view
             AND n.nspname = ANY (current_schemas(false))
           SQL
         end
@@ -95,36 +83,28 @@ module ActiveRecord
         # If the schema is not specified as part of +name+ then it will only find tables within
         # the current schema search path (regardless of permissions to access tables in other schemas)
         def table_exists?(name)
-          ActiveSupport::Deprecation.warn(<<-MSG.squish)
-            #table_exists? currently checks both tables and views.
-            This behavior is deprecated and will be changed with Rails 5.1 to only check tables.
-            Use #data_source_exists? instead.
-          MSG
-
-          data_source_exists?(name)
-        end
-
-        def data_source_exists?(name)
           name = Utils.extract_schema_qualified_name(name.to_s)
           return false unless name.identifier
 
-          select_value(<<-SQL, 'SCHEMA').to_i > 0
-              SELECT COUNT(*)
-              FROM pg_class c
-              LEFT JOIN pg_namespace n ON n.oid = c.relnamespace
-              WHERE c.relkind IN ('r','v','m') -- (r)elation/table, (v)iew, (m)aterialized view
-              AND c.relname = '#{name.identifier}'
-              AND n.nspname = #{name.schema ? "'#{name.schema}'" : 'ANY (current_schemas(false))'}
+          select_values(<<-SQL, "SCHEMA").any?
+            SELECT tablename
+            FROM pg_tables
+            WHERE tablename = #{quote(name.identifier)}
+            AND schemaname = #{name.schema ? quote(name.schema) : "ANY (current_schemas(false))"}
           SQL
         end
 
-        def views # :nodoc:
-          select_values(<<-SQL, 'SCHEMA')
+        def data_source_exists?(name) # :nodoc:
+          name = Utils.extract_schema_qualified_name(name.to_s)
+          return false unless name.identifier
+
+          select_values(<<-SQL, "SCHEMA").any?
             SELECT c.relname
             FROM pg_class c
             LEFT JOIN pg_namespace n ON n.oid = c.relnamespace
-            WHERE c.relkind IN ('v','m') -- (v)iew, (m)aterialized view
-            AND n.nspname = ANY (current_schemas(false))
+            WHERE c.relkind IN ('r','v','m') -- (r)elation/table, (v)iew, (m)aterialized view
+            AND c.relname = #{quote(name.identifier)}
+            AND n.nspname = #{name.schema ? quote(name.schema) : "ANY (current_schemas(false))"}
           SQL
         end
 
@@ -132,13 +112,13 @@ module ActiveRecord
           name = Utils.extract_schema_qualified_name(view_name.to_s)
           return false unless name.identifier
 
-          select_values(<<-SQL, 'SCHEMA').any?
+          select_values(<<-SQL, "SCHEMA").any?
             SELECT c.relname
             FROM pg_class c
             LEFT JOIN pg_namespace n ON n.oid = c.relnamespace
             WHERE c.relkind IN ('v','m') -- (v)iew, (m)aterialized view
-            AND c.relname = '#{name.identifier}'
-            AND n.nspname = #{name.schema ? "'#{name.schema}'" : 'ANY (current_schemas(false))'}
+            AND c.relname = #{quote(name.identifier)}
+            AND n.nspname = #{name.schema ? quote(name.schema) : "ANY (current_schemas(false))"}
           SQL
         end
 
@@ -148,15 +128,20 @@ module ActiveRecord
 
         # Returns true if schema exists.
         def schema_exists?(name)
-          select_value("SELECT COUNT(*) FROM pg_namespace WHERE nspname = '#{name}'", 'SCHEMA').to_i > 0
+          select_value("SELECT COUNT(*) FROM pg_namespace WHERE nspname = '#{name}'", "SCHEMA").to_i > 0
         end
 
         # Verifies existence of an index with a given name.
-        def index_name_exists?(table_name, index_name, default)
+        def index_name_exists?(table_name, index_name, default = nil)
+          unless default.nil?
+            ActiveSupport::Deprecation.warn(<<-MSG.squish)
+              Passing default to #index_name_exists? is deprecated without replacement.
+            MSG
+          end
           table = Utils.extract_schema_qualified_name(table_name.to_s)
           index = Utils.extract_schema_qualified_name(index_name.to_s)
 
-          select_value(<<-SQL, 'SCHEMA').to_i > 0
+          select_value(<<-SQL, "SCHEMA").to_i > 0
             SELECT COUNT(*)
             FROM pg_class t
             INNER JOIN pg_index d ON t.oid = d.indrelid
@@ -170,10 +155,16 @@ module ActiveRecord
         end
 
         # Returns an array of indexes for the given table.
-        def indexes(table_name, name = nil)
+        def indexes(table_name, name = nil) # :nodoc:
+          if name
+            ActiveSupport::Deprecation.warn(<<-MSG.squish)
+              Passing name to #indexes is deprecated without replacement.
+            MSG
+          end
+
           table = Utils.extract_schema_qualified_name(table_name.to_s)
 
-          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,
             (SELECT COUNT(*) FROM pg_opclass o
@@ -221,21 +212,23 @@ module ActiveRecord
           end.compact
         end
 
-        # Returns the list of all column definitions for a table.
-        def columns(table_name) # :nodoc:
-          table_name = table_name.to_s
-          column_definitions(table_name).map do |column_name, type, default, notnull, oid, fmod, collation, comment|
-            oid = oid.to_i
-            fmod = fmod.to_i
-            type_metadata = fetch_type_metadata(column_name, type, oid, fmod)
-            default_value = extract_value_from_default(default)
-            default_function = extract_default_function(default_value, default)
-            new_column(column_name, default_value, type_metadata, !notnull, table_name, default_function, collation, comment: comment.presence, max_identifier_length: max_identifier_length)
-          end
-        end
-
-        def new_column(*args) # :nodoc:
-          PostgreSQLColumn.new(*args)
+        def new_column_from_field(table_name, field) # :nondoc:
+          column_name, type, default, notnull, oid, fmod, collation, comment = field
+          oid = oid.to_i
+          fmod = fmod.to_i
+          type_metadata = fetch_type_metadata(column_name, type, oid, fmod)
+          default_value = extract_value_from_default(default)
+          default_function = extract_default_function(default_value, default)
+          PostgreSQLColumn.new(
+            column_name,
+            default_value,
+            type_metadata,
+            !notnull,
+            table_name,
+            default_function,
+            collation,
+            comment: comment.presence
+          )
         end
 
         def table_options(table_name) # :nodoc:
@@ -248,7 +241,7 @@ module ActiveRecord
         def table_comment(table_name) # :nodoc:
           name = Utils.extract_schema_qualified_name(table_name.to_s)
           if name.identifier
-            select_value(<<-SQL.strip_heredoc, 'SCHEMA')
+            select_value(<<-SQL.strip_heredoc, "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
@@ -261,32 +254,32 @@ module ActiveRecord
 
         # Returns the current database name.
         def current_database
-          select_value('select current_database()', 'SCHEMA')
+          select_value("select current_database()", "SCHEMA")
         end
 
         # Returns the current schema name.
         def current_schema
-          select_value('SELECT current_schema', 'SCHEMA')
+          select_value("SELECT current_schema", "SCHEMA")
         end
 
         # Returns the current database encoding format.
         def encoding
-          select_value("SELECT pg_encoding_to_char(encoding) FROM pg_database WHERE datname LIKE '#{current_database}'", 'SCHEMA')
+          select_value("SELECT pg_encoding_to_char(encoding) FROM pg_database WHERE datname LIKE '#{current_database}'", "SCHEMA")
         end
 
         # Returns the current database collation.
         def collation
-          select_value("SELECT datcollate FROM pg_database WHERE datname LIKE '#{current_database}'", 'SCHEMA')
+          select_value("SELECT datcollate FROM pg_database WHERE datname LIKE '#{current_database}'", "SCHEMA")
         end
 
         # Returns the current database ctype.
         def ctype
-          select_value("SELECT datctype FROM pg_database WHERE datname LIKE '#{current_database}'", 'SCHEMA')
+          select_value("SELECT datctype FROM pg_database WHERE datname LIKE '#{current_database}'", "SCHEMA")
         end
 
         # Returns an array of schema names.
         def schema_names
-          select_values(<<-SQL, 'SCHEMA')
+          select_values(<<-SQL, "SCHEMA")
             SELECT nspname
               FROM pg_namespace
              WHERE nspname !~ '^pg_.*'
@@ -296,7 +289,7 @@ module ActiveRecord
         end
 
         # Creates a schema for the given schema name.
-        def create_schema schema_name
+        def create_schema(schema_name)
           execute "CREATE SCHEMA #{quote_schema_name(schema_name)}"
         end
 
@@ -312,37 +305,37 @@ module ActiveRecord
         # This should be not be called manually but set in database.yml.
         def schema_search_path=(schema_csv)
           if schema_csv
-            execute("SET search_path TO #{schema_csv}", 'SCHEMA')
+            execute("SET search_path TO #{schema_csv}", "SCHEMA")
             @schema_search_path = schema_csv
           end
         end
 
         # Returns the active schema search path.
         def schema_search_path
-          @schema_search_path ||= select_value('SHOW search_path', 'SCHEMA')
+          @schema_search_path ||= select_value("SHOW search_path", "SCHEMA")
         end
 
         # Returns the current client message level.
         def client_min_messages
-          select_value('SHOW client_min_messages', 'SCHEMA')
+          select_value("SHOW client_min_messages", "SCHEMA")
         end
 
         # Set the client message level.
         def client_min_messages=(level)
-          execute("SET client_min_messages TO '#{level}'", 'SCHEMA')
+          execute("SET client_min_messages TO '#{level}'", "SCHEMA")
         end
 
         # Returns the sequence name for a table's primary key or some other specified key.
-        def default_sequence_name(table_name, pk = nil) #:nodoc:
-          result = serial_sequence(table_name, pk || 'id')
+        def default_sequence_name(table_name, pk = "id") #:nodoc:
+          result = serial_sequence(table_name, pk)
           return nil unless result
           Utils.extract_schema_qualified_name(result).to_s
         rescue ActiveRecord::StatementInvalid
-          PostgreSQL::Name.new(nil, "#{table_name}_#{pk || 'id'}_seq").to_s
+          PostgreSQL::Name.new(nil, "#{table_name}_#{pk}_seq").to_s
         end
 
         def serial_sequence(table, column)
-          select_value("SELECT pg_get_serial_sequence('#{table}', '#{column}')", 'SCHEMA')
+          select_value("SELECT pg_get_serial_sequence('#{table}', '#{column}')", "SCHEMA")
         end
 
         # Sets the sequence of a table's primary key to the specified value.
@@ -353,7 +346,7 @@ module ActiveRecord
             if sequence
               quoted_sequence = quote_table_name(sequence)
 
-              select_value("SELECT setval('#{quoted_sequence}', #{value})", 'SCHEMA')
+              select_value("SELECT setval('#{quoted_sequence}', #{value})", "SCHEMA")
             else
               @logger.warn "#{table} has primary key #{pk} with no default sequence." if @logger
             end
@@ -362,7 +355,7 @@ module ActiveRecord
 
         # Resets the sequence of a table's primary key to the maximum value.
         def reset_pk_sequence!(table, pk = nil, sequence = nil) #:nodoc:
-          unless pk and sequence
+          unless pk && sequence
             default_pk, default_sequence = pk_and_sequence_for(table)
 
             pk ||= default_pk
@@ -375,17 +368,9 @@ module ActiveRecord
 
           if pk && sequence
             quoted_sequence = quote_table_name(sequence)
-            max_pk = select_value("select MAX(#{quote_column_name pk}) from #{quote_table_name(table)}")
-            if max_pk.nil?
-              if postgresql_version >= 100000
-                minvalue = select_value("SELECT seqmin from pg_sequence where seqrelid = '#{quoted_sequence}'::regclass")
-              else
-                minvalue = select_value("SELECT min_value FROM #{quoted_sequence}")
-              end
-            end
 
             select_value(<<-end_sql, "SCHEMA")
-              SELECT setval('#{quoted_sequence}', #{max_pk ? max_pk : minvalue}, #{max_pk ? true : false})
+              SELECT setval('#{quoted_sequence}', (SELECT COALESCE(MAX(#{quote_column_name pk})+(SELECT increment_by FROM #{quoted_sequence}), (SELECT min_value FROM #{quoted_sequence})) FROM #{quote_table_name(table)}), false)
             end_sql
           end
         end
@@ -394,7 +379,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(<<-end_sql, "SCHEMA")[0]
             SELECT attr.attname, nsp.nspname, seq.relname
             FROM pg_class      seq,
                  pg_attribute  attr,
@@ -413,8 +398,8 @@ module ActiveRecord
               AND dep.refobjid      = '#{quote_table_name(table)}'::regclass
           end_sql
 
-          if result.nil? or result.empty?
-            result = query(<<-end_sql, 'SCHEMA')[0]
+          if result.nil? || result.empty?
+            result = query(<<-end_sql, "SCHEMA")[0]
               SELECT attr.attname, nsp.nspname,
                 CASE
                   WHEN pg_get_expr(def.adbin, def.adrelid) !~* 'nextval' THEN NULL
@@ -445,17 +430,18 @@ module ActiveRecord
         end
 
         def primary_keys(table_name) # :nodoc:
-          select_values(<<-SQL.strip_heredoc, 'SCHEMA')
-            WITH pk_constraint AS (
-              SELECT conrelid, unnest(conkey) AS connum FROM pg_constraint
-              WHERE contype = 'p'
-                AND conrelid = '#{quote_table_name(table_name)}'::regclass
-            ), cons AS (
-              SELECT conrelid, connum, row_number() OVER() AS rownum FROM pk_constraint
-            )
-            SELECT attr.attname FROM pg_attribute attr
-            INNER JOIN cons ON attr.attrelid = cons.conrelid AND attr.attnum = cons.connum
-            ORDER BY cons.rownum
+          name = Utils.extract_schema_qualified_name(table_name.to_s)
+          select_values(<<-SQL.strip_heredoc, "SCHEMA")
+            SELECT column_name
+              FROM information_schema.key_column_usage kcu
+              JOIN information_schema.table_constraints tc
+                ON kcu.table_name = tc.table_name
+               AND kcu.table_schema = tc.table_schema
+               AND kcu.constraint_name = tc.constraint_name
+             WHERE constraint_type = 'PRIMARY KEY'
+               AND kcu.table_name = #{quote(name.identifier)}
+               AND kcu.table_schema = #{name.schema ? quote(name.schema) : "ANY (current_schemas(false))"}
+             ORDER BY kcu.ordinal_position
           SQL
         end
 
@@ -490,7 +476,7 @@ module ActiveRecord
           clear_cache!
           quoted_table_name = quote_table_name(table_name)
           quoted_column_name = quote_column_name(column_name)
-          sql_type = type_to_sql(type, options[:limit], options[:precision], options[:scale], options[:array])
+          sql_type = type_to_sql(type, options)
           sql = "ALTER TABLE #{quoted_table_name} ALTER COLUMN #{quoted_column_name} TYPE #{sql_type}"
           if options[:collation]
             sql << " COLLATE \"#{options[:collation]}\""
@@ -498,7 +484,7 @@ module ActiveRecord
           if options[:using]
             sql << " USING #{options[:using]}"
           elsif options[:cast_as]
-            cast_as_type = type_to_sql(options[:cast_as], options[:limit], options[:precision], options[:scale], options[:array])
+            cast_as_type = type_to_sql(options[:cast_as], options)
             sql << " USING CAST(#{quoted_column_name} AS #{cast_as_type})"
           end
           execute sql
@@ -593,7 +579,7 @@ module ActiveRecord
         end
 
         def foreign_keys(table_name)
-          fk_info = select_all(<<-SQL.strip_heredoc, 'SCHEMA')
+          fk_info = select_all(<<-SQL.strip_heredoc, "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
             FROM pg_constraint c
             JOIN pg_class t1 ON c.conrelid = t1.oid
@@ -609,70 +595,75 @@ module ActiveRecord
 
           fk_info.map do |row|
             options = {
-              column: row['column'],
-              name: row['name'],
-              primary_key: row['primary_key']
+              column: row["column"],
+              name: row["name"],
+              primary_key: row["primary_key"]
             }
 
-            options[:on_delete] = extract_foreign_key_action(row['on_delete'])
-            options[:on_update] = extract_foreign_key_action(row['on_update'])
+            options[:on_delete] = extract_foreign_key_action(row["on_delete"])
+            options[:on_update] = extract_foreign_key_action(row["on_update"])
 
-            ForeignKeyDefinition.new(table_name, row['to_table'], options)
+            ForeignKeyDefinition.new(table_name, row["to_table"], options)
           end
         end
 
         def extract_foreign_key_action(specifier) # :nodoc:
           case specifier
-          when 'c'; :cascade
-          when 'n'; :nullify
-          when 'r'; :restrict
+          when "c"; :cascade
+          when "n"; :nullify
+          when "r"; :restrict
           end
         end
 
+        def index_name_length
+          63
+        end
+
         # Maps logical Rails types to PostgreSQL-specific data types.
-        def type_to_sql(type, limit = nil, precision = nil, scale = nil, array = nil)
-          sql = case type.to_s
-          when 'binary'
-            # PostgreSQL doesn't support limits on binary (bytea) columns.
-            # 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}.")
-            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.")
-            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.")
+        def type_to_sql(type, limit: nil, precision: nil, scale: nil, array: nil, **) # :nodoc:
+          sql = \
+            case type.to_s
+            when "binary"
+              # PostgreSQL doesn't support limits on binary (bytea) columns.
+              # 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}.")
+              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.")
+              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.")
+              end
+            else
+              super
             end
-          else
-            super(type, limit, precision, scale)
-          end
 
-          sql << '[]' if array && type != :primary_key
+          sql << "[]" if array && type != :primary_key
           sql
         end
 
         # PostgreSQL requires the ORDER BY columns in the select list for distinct queries, and
         # requires that the ORDER BY include the distinct column.
         def columns_for_distinct(columns, orders) #:nodoc:
-          order_columns = orders.reject(&:blank?).map{ |s|
+          order_columns = orders.reject(&:blank?).map { |s|
               # Convert Arel node to string
               s = s.to_sql unless s.is_a?(String)
               # Remove any ASC/DESC modifiers
-              s.gsub(/\s+(?:ASC|DESC)\b/i, '')
-               .gsub(/\s+NULLS\s+(?:FIRST|LAST)\b/i, '')
+              s.gsub(/\s+(?:ASC|DESC)\b/i, "")
+               .gsub(/\s+NULLS\s+(?:FIRST|LAST)\b/i, "")
             }.reject(&:blank?).map.with_index { |column, i| "#{column} AS alias_#{i}" }
 
-          [super, *order_columns].join(', ')
+          [super, *order_columns].join(", ")
         end
 
         def fetch_type_metadata(column_name, sql_type, oid, fmod)