activerecord 6.0.6.1 → 6.1.0.rc1

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

@@ -2,151 +2,188 @@
 
 module ActiveRecord
   module ConnectionAdapters
-    class AbstractAdapter
-      class SchemaCreation # :nodoc:
-        def initialize(conn)
-          @conn = conn
-          @cache = {}
+    class SchemaCreation # :nodoc:
+      def initialize(conn)
+        @conn = conn
+        @cache = {}
+      end
+
+      def accept(o)
+        m = @cache[o.class] ||= "visit_#{o.class.name.split('::').last}"
+        send m, o
+      end
+
+      delegate :quote_column_name, :quote_table_name, :quote_default_expression, :type_to_sql,
+        :options_include_default?, :supports_indexes_in_create?, :supports_foreign_keys?, :foreign_key_options,
+        :quoted_columns_for_index, :supports_partial_index?, :supports_check_constraints?, :check_constraint_options,
+        to: :@conn, private: true
+
+      private
+        def visit_AlterTable(o)
+          sql = +"ALTER TABLE #{quote_table_name(o.name)} "
+          sql << o.adds.map { |col| accept col }.join(" ")
+          sql << o.foreign_key_adds.map { |fk| visit_AddForeignKey fk }.join(" ")
+          sql << o.foreign_key_drops.map { |fk| visit_DropForeignKey fk }.join(" ")
+          sql << o.check_constraint_adds.map { |con| visit_AddCheckConstraint con }.join(" ")
+          sql << o.check_constraint_drops.map { |con| visit_DropCheckConstraint con }.join(" ")
+        end
+
+        def visit_ColumnDefinition(o)
+          o.sql_type = type_to_sql(o.type, **o.options)
+          column_sql = +"#{quote_column_name(o.name)} #{o.sql_type}"
+          add_column_options!(column_sql, column_options(o)) unless o.type == :primary_key
+          column_sql
         end
 
-        def accept(o)
-          m = @cache[o.class] ||= "visit_#{o.class.name.split('::').last}"
-          send m, o
+        def visit_AddColumnDefinition(o)
+          +"ADD #{accept(o.column)}"
         end
 
-        delegate :quote_column_name, :quote_table_name, :quote_default_expression, :type_to_sql,
-          :options_include_default?, :supports_indexes_in_create?, :supports_foreign_keys?, :foreign_key_options,
-          to: :@conn, private: true
+        def visit_TableDefinition(o)
+          create_sql = +"CREATE#{table_modifier_in_create(o)} TABLE "
+          create_sql << "IF NOT EXISTS " if o.if_not_exists
+          create_sql << "#{quote_table_name(o.name)} "
 
-        private
-          def visit_AlterTable(o)
-            sql = +"ALTER TABLE #{quote_table_name(o.name)} "
-            sql << o.adds.map { |col| accept col }.join(" ")
-            sql << o.foreign_key_adds.map { |fk| visit_AddForeignKey fk }.join(" ")
-            sql << o.foreign_key_drops.map { |fk| visit_DropForeignKey fk }.join(" ")
+          statements = o.columns.map { |c| accept c }
+          statements << accept(o.primary_keys) if o.primary_keys
+
+          if supports_indexes_in_create?
+            statements.concat(o.indexes.map { |column_name, options| index_in_create(o.name, column_name, options) })
           end
 
-          def visit_ColumnDefinition(o)
-            o.sql_type = type_to_sql(o.type, **o.options)
-            column_sql = +"#{quote_column_name(o.name)} #{o.sql_type}"
-            add_column_options!(column_sql, column_options(o)) unless o.type == :primary_key
-            column_sql
+          if supports_foreign_keys?
+            statements.concat(o.foreign_keys.map { |to_table, options| foreign_key_in_create(o.name, to_table, options) })
           end
 
-          def visit_AddColumnDefinition(o)
-            +"ADD #{accept(o.column)}"
+          if supports_check_constraints?
+            statements.concat(o.check_constraints.map { |expression, options| check_constraint_in_create(o.name, expression, options) })
           end
 
-          def visit_TableDefinition(o)
-            create_sql = +"CREATE#{table_modifier_in_create(o)} TABLE "
-            create_sql << "IF NOT EXISTS " if o.if_not_exists
-            create_sql << "#{quote_table_name(o.name)} "
+          create_sql << "(#{statements.join(', ')})" if statements.present?
+          add_table_options!(create_sql, o)
+          create_sql << " AS #{to_sql(o.as)}" if o.as
+          create_sql
+        end
 
-            statements = o.columns.map { |c| accept c }
-            statements << accept(o.primary_keys) if o.primary_keys
+        def visit_PrimaryKeyDefinition(o)
+          "PRIMARY KEY (#{o.name.map { |name| quote_column_name(name) }.join(', ')})"
+        end
 
-            if supports_indexes_in_create?
-              statements.concat(o.indexes.map { |column_name, options| index_in_create(o.name, column_name, options) })
-            end
+        def visit_ForeignKeyDefinition(o)
+          sql = +<<~SQL
+            CONSTRAINT #{quote_column_name(o.name)}
+            FOREIGN KEY (#{quote_column_name(o.column)})
+              REFERENCES #{quote_table_name(o.to_table)} (#{quote_column_name(o.primary_key)})
+          SQL
+          sql << " #{action_sql('DELETE', o.on_delete)}" if o.on_delete
+          sql << " #{action_sql('UPDATE', o.on_update)}" if o.on_update
+          sql
+        end
 
-            if supports_foreign_keys?
-              statements.concat(o.foreign_keys.map { |to_table, options| foreign_key_in_create(o.name, to_table, options) })
-            end
+        def visit_AddForeignKey(o)
+          "ADD #{accept(o)}"
+        end
 
-            create_sql << "(#{statements.join(', ')})" if statements.present?
-            add_table_options!(create_sql, table_options(o))
-            create_sql << " AS #{to_sql(o.as)}" if o.as
-            create_sql
-          end
+        def visit_DropForeignKey(name)
+          "DROP CONSTRAINT #{quote_column_name(name)}"
+        end
 
-          def visit_PrimaryKeyDefinition(o)
-            "PRIMARY KEY (#{o.name.map { |name| quote_column_name(name) }.join(', ')})"
-          end
+        def visit_CreateIndexDefinition(o)
+          index = o.index
+
+          sql = ["CREATE"]
+          sql << "UNIQUE" if index.unique
+          sql << "INDEX"
+          sql << "IF NOT EXISTS" if o.if_not_exists
+          sql << o.algorithm if o.algorithm
+          sql << index.type if index.type
+          sql << "#{quote_column_name(index.name)} ON #{quote_table_name(index.table)}"
+          sql << "USING #{index.using}" if supports_index_using? && index.using
+          sql << "(#{quoted_columns(index)})"
+          sql << "WHERE #{index.where}" if supports_partial_index? && index.where
+
+          sql.join(" ")
+        end
 
-          def visit_ForeignKeyDefinition(o)
-            sql = +<<~SQL
-              CONSTRAINT #{quote_column_name(o.name)}
-              FOREIGN KEY (#{quote_column_name(o.column)})
-                REFERENCES #{quote_table_name(o.to_table)} (#{quote_column_name(o.primary_key)})
-            SQL
-            sql << " #{action_sql('DELETE', o.on_delete)}" if o.on_delete
-            sql << " #{action_sql('UPDATE', o.on_update)}" if o.on_update
-            sql
-          end
+        def visit_CheckConstraintDefinition(o)
+          "CONSTRAINT #{o.name} CHECK (#{o.expression})"
+        end
 
-          def visit_AddForeignKey(o)
-            "ADD #{accept(o)}"
-          end
+        def visit_AddCheckConstraint(o)
+          "ADD #{accept(o)}"
+        end
 
-          def visit_DropForeignKey(name)
-            "DROP CONSTRAINT #{quote_column_name(name)}"
-          end
+        def visit_DropCheckConstraint(name)
+          "DROP CONSTRAINT #{quote_column_name(name)}"
+        end
 
-          def table_options(o)
-            table_options = {}
-            table_options[:comment] = o.comment
-            table_options[:options] = o.options
-            table_options
-          end
+        def quoted_columns(o)
+          String === o.columns ? o.columns : quoted_columns_for_index(o.columns, o.column_options)
+        end
 
-          def add_table_options!(create_sql, options)
-            if options_sql = options[:options]
-              create_sql << " #{options_sql}"
-            end
-            create_sql
-          end
+        def supports_index_using?
+          true
+        end
 
-          def column_options(o)
-            o.options.merge(column: o)
-          end
+        def add_table_options!(create_sql, o)
+          create_sql << " #{o.options}" if o.options
+          create_sql
+        end
 
-          def add_column_options!(sql, options)
-            sql << " DEFAULT #{quote_default_expression(options[:default], options[:column])}" if options_include_default?(options)
-            # must explicitly check for :null to allow change_column to work on migrations
-            if options[:null] == false
-              sql << " NOT NULL"
-            end
-            if options[:auto_increment] == true
-              sql << " AUTO_INCREMENT"
-            end
-            if options[:primary_key] == true
-              sql << " PRIMARY KEY"
-            end
-            sql
-          end
+        def column_options(o)
+          o.options.merge(column: o)
+        end
 
-          def to_sql(sql)
-            sql = sql.to_sql if sql.respond_to?(:to_sql)
-            sql
+        def add_column_options!(sql, options)
+          sql << " DEFAULT #{quote_default_expression(options[:default], options[:column])}" if options_include_default?(options)
+          # must explicitly check for :null to allow change_column to work on migrations
+          if options[:null] == false
+            sql << " NOT NULL"
           end
-
-          # Returns any SQL string to go between CREATE and TABLE. May be nil.
-          def table_modifier_in_create(o)
-            " TEMPORARY" if o.temporary
+          if options[:auto_increment] == true
+            sql << " AUTO_INCREMENT"
           end
-
-          def foreign_key_in_create(from_table, to_table, options)
-            prefix = ActiveRecord::Base.table_name_prefix
-            suffix = ActiveRecord::Base.table_name_suffix
-            to_table = "#{prefix}#{to_table}#{suffix}"
-            options = foreign_key_options(from_table, to_table, options)
-            accept ForeignKeyDefinition.new(from_table, to_table, options)
+          if options[:primary_key] == true
+            sql << " PRIMARY KEY"
           end
+          sql
+        end
 
-          def action_sql(action, dependency)
-            case dependency
-            when :nullify then "ON #{action} SET NULL"
-            when :cascade  then "ON #{action} CASCADE"
-            when :restrict then "ON #{action} RESTRICT"
-            else
-              raise ArgumentError, <<~MSG
-                '#{dependency}' is not supported for :on_update or :on_delete.
-                Supported values are: :nullify, :cascade, :restrict
-              MSG
-            end
+        def to_sql(sql)
+          sql = sql.to_sql if sql.respond_to?(:to_sql)
+          sql
+        end
+
+        # Returns any SQL string to go between CREATE and TABLE. May be nil.
+        def table_modifier_in_create(o)
+          " TEMPORARY" if o.temporary
+        end
+
+        def foreign_key_in_create(from_table, to_table, options)
+          prefix = ActiveRecord::Base.table_name_prefix
+          suffix = ActiveRecord::Base.table_name_suffix
+          to_table = "#{prefix}#{to_table}#{suffix}"
+          options = foreign_key_options(from_table, to_table, options)
+          accept ForeignKeyDefinition.new(from_table, to_table, options)
+        end
+
+        def check_constraint_in_create(table_name, expression, options)
+          options = check_constraint_options(table_name, expression, options)
+          accept CheckConstraintDefinition.new(table_name, expression, options)
+        end
+
+        def action_sql(action, dependency)
+          case dependency
+          when :nullify then "ON #{action} SET NULL"
+          when :cascade  then "ON #{action} CASCADE"
+          when :restrict then "ON #{action} RESTRICT"
+          else
+            raise ArgumentError, <<~MSG
+              '#{dependency}' is not supported for :on_update or :on_delete.
+              Supported values are: :nullify, :cascade, :restrict
+            MSG
           end
-      end
+        end
     end
-    SchemaCreation = AbstractAdapter::SchemaCreation # :nodoc:
   end
 end

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

@@ -33,6 +33,14 @@ module ActiveRecord
         @comment = comment
       end
 
+      def column_options
+        {
+          length: lengths,
+          order: orders,
+          opclass: opclasses,
+        }
+      end
+
       private
         def concise_options(options)
           if columns.size == options.size && options.values.uniq.size == 1
@@ -63,16 +71,14 @@ module ActiveRecord
           end
         CODE
       end
-
-      def aliased_types(name, fallback)
-        "timestamp" == name ? :datetime : fallback
-      end
     end
 
     AddColumnDefinition = Struct.new(:column) # :nodoc:
 
     ChangeColumnDefinition = Struct.new(:column, :name) #:nodoc:
 
+    CreateIndexDefinition = Struct.new(:index, :algorithm, :if_not_exists) # :nodoc:
+
     PrimaryKeyDefinition = Struct.new(:name) # :nodoc:
 
     ForeignKeyDefinition = Struct.new(:from_table, :to_table, :options) do #:nodoc:
@@ -121,6 +127,21 @@ module ActiveRecord
         end
     end
 
+    CheckConstraintDefinition = Struct.new(:table_name, :expression, :options) do
+      def name
+        options[:name]
+      end
+
+      def validate?
+        options.fetch(:validate, true)
+      end
+      alias validated? validate?
+
+      def export_name_on_schema_dump?
+        !ActiveRecord::SchemaDumper.chk_ignore_pattern.match?(name) if name
+      end
+    end
+
     class ReferenceDefinition # :nodoc:
       def initialize(
         name,
@@ -143,13 +164,12 @@ module ActiveRecord
       end
 
       def add_to(table)
-        columns.each do |column_options|
-          kwargs = column_options.extract_options!
-          table.column(*column_options, **kwargs)
+        columns.each do |name, type, options|
+          table.column(name, type, **options)
         end
 
         if index
-          table.index(column_names, index_options)
+          table.index(column_names, **index_options(table.name))
         end
 
         if foreign_key
@@ -168,8 +188,14 @@ module ActiveRecord
           as_options(polymorphic).merge(options.slice(:null, :first, :after))
         end
 
-        def index_options
-          as_options(index)
+        def polymorphic_index_name(table_name)
+          "index_#{table_name}_on_#{name}"
+        end
+
+        def index_options(table_name)
+          index_options = as_options(index)
+          index_options[:name] ||= polymorphic_index_name(table_name) if polymorphic
+          index_options
         end
 
         def foreign_key_options
@@ -227,7 +253,7 @@ module ActiveRecord
       end
 
       class_methods do
-        private def define_column_methods(*column_types) # :nodoc:
+        def define_column_methods(*column_types) # :nodoc:
           column_types.each do |column_type|
             module_eval <<-RUBY, __FILE__, __LINE__ + 1
               def #{column_type}(*names, **options)
@@ -237,6 +263,7 @@ module ActiveRecord
             RUBY
           end
         end
+        private :define_column_methods
       end
     end
 
@@ -246,7 +273,7 @@ module ActiveRecord
     # Inside migration files, the +t+ object in {create_table}[rdoc-ref:SchemaStatements#create_table]
     # is actually of this type:
     #
-    #   class SomeMigration < ActiveRecord::Migration[5.0]
+    #   class SomeMigration < ActiveRecord::Migration[6.0]
     #     def up
     #       create_table :foo do |t|
     #         puts t.class  # => "ActiveRecord::ConnectionAdapters::TableDefinition"
@@ -261,7 +288,7 @@ module ActiveRecord
     class TableDefinition
       include ColumnMethods
 
-      attr_reader :name, :temporary, :if_not_exists, :options, :as, :comment, :indexes, :foreign_keys
+      attr_reader :name, :temporary, :if_not_exists, :options, :as, :comment, :indexes, :foreign_keys, :check_constraints
 
       def initialize(
         conn,
@@ -278,6 +305,7 @@ module ActiveRecord
         @indexes = []
         @foreign_keys = []
         @primary_keys = nil
+        @check_constraints = []
         @temporary = temporary
         @if_not_exists = if_not_exists
         @options = options
@@ -366,7 +394,7 @@ module ActiveRecord
       #     t.references :tagger, polymorphic: true
       #     t.references :taggable, polymorphic: { default: 'Photo' }, index: false
       #   end
-      def column(name, type, **options)
+      def column(name, type, index: nil, **options)
         name = name.to_s
         type = type.to_sym if type
 
@@ -378,9 +406,13 @@ module ActiveRecord
           end
         end
 
-        index_options = options.delete(:index)
-        index(name, index_options.is_a?(Hash) ? index_options : {}) if index_options
         @columns_hash[name] = new_column_definition(name, type, **options)
+
+        if index
+          index_options = index.is_a?(Hash) ? index : {}
+          index(name, **index_options)
+        end
+
         self
       end
 
@@ -394,7 +426,7 @@ module ActiveRecord
       # This is primarily used to track indexes that need to be created after the table
       #
       #   index(:account_id, name: 'index_projects_on_account_id')
-      def index(column_name, options = {})
+      def index(column_name, **options)
         indexes << [column_name, options]
       end
 
@@ -402,6 +434,10 @@ module ActiveRecord
         foreign_keys << [table_name, options]
       end
 
+      def check_constraint(expression, **options)
+        check_constraints << [expression, options]
+      end
+
       # Appends <tt>:datetime</tt> columns <tt>:created_at</tt> and
       # <tt>:updated_at</tt> to the table. See {connection.add_timestamps}[rdoc-ref:SchemaStatements#add_timestamps]
       #
@@ -461,14 +497,16 @@ module ActiveRecord
 
     class AlterTable # :nodoc:
       attr_reader :adds
-      attr_reader :foreign_key_adds
-      attr_reader :foreign_key_drops
+      attr_reader :foreign_key_adds, :foreign_key_drops
+      attr_reader :check_constraint_adds, :check_constraint_drops
 
       def initialize(td)
         @td   = td
         @adds = []
         @foreign_key_adds = []
         @foreign_key_drops = []
+        @check_constraint_adds = []
+        @check_constraint_drops = []
       end
 
       def name; @td.name; end
@@ -481,6 +519,14 @@ module ActiveRecord
         @foreign_key_drops << name
       end
 
+      def add_check_constraint(expression, options)
+        @check_constraint_adds << CheckConstraintDefinition.new(name, expression, options)
+      end
+
+      def drop_check_constraint(constraint_name)
+        @check_constraint_drops << constraint_name
+      end
+
       def add_column(name, type, **options)
         name = name.to_s
         type = type.to_sym
@@ -501,9 +547,11 @@ module ActiveRecord
     #     t.timestamps
     #     t.change
     #     t.change_default
+    #     t.change_null
     #     t.rename
     #     t.references
     #     t.belongs_to
+    #     t.check_constraint
     #     t.string
     #     t.text
     #     t.integer
@@ -525,6 +573,7 @@ module ActiveRecord
     #     t.remove_references
     #     t.remove_belongs_to
     #     t.remove_index
+    #     t.remove_check_constraint
     #     t.remove_timestamps
     #   end
     #
@@ -543,10 +592,12 @@ module ActiveRecord
       #  t.column(:name, :string)
       #
       # See TableDefinition#column for details of the options you can use.
-      def column(column_name, type, **options)
-        index_options = options.delete(:index)
+      def column(column_name, type, index: nil, **options)
         @base.add_column(name, column_name, type, **options)
-        index(column_name, index_options.is_a?(Hash) ? index_options : {}) if index_options
+        if index
+          index_options = index.is_a?(Hash) ? index : {}
+          index(column_name, **index_options)
+        end
       end
 
       # Checks to see if a column exists.
@@ -566,8 +617,8 @@ module ActiveRecord
       #  t.index([:branch_id, :party_id], unique: true, name: 'by_branch_party')
       #
       # See {connection.add_index}[rdoc-ref:SchemaStatements#add_index] for details of the options you can use.
-      def index(column_name, options = {})
-        @base.add_index(name, column_name, options)
+      def index(column_name, **options)
+        @base.add_index(name, column_name, **options)
       end
 
       # Checks to see if an index exists.
@@ -605,8 +656,8 @@ module ActiveRecord
       #  t.change(:description, :text)
       #
       # See TableDefinition#column for details of the options you can use.
-      def change(column_name, type, options = {})
-        @base.change_column(name, column_name, type, options)
+      def change(column_name, type, **options)
+        @base.change_column(name, column_name, type, **options)
       end
 
       # Sets a new default value for a column.
@@ -620,14 +671,24 @@ module ActiveRecord
         @base.change_column_default(name, column_name, default_or_changes)
       end
 
+      # Sets or removes a NOT NULL constraint on a column.
+      #
+      #  t.change_null(:qualification, true)
+      #  t.change_null(:qualification, false, 0)
+      #
+      # See {connection.change_column_null}[rdoc-ref:SchemaStatements#change_column_null]
+      def change_null(column_name, null, default = nil)
+        @base.change_column_null(name, column_name, null, default)
+      end
+
       # Removes the column(s) from the table definition.
       #
       #  t.remove(:qualification)
       #  t.remove(:qualification, :experience)
       #
       # See {connection.remove_columns}[rdoc-ref:SchemaStatements#remove_columns]
-      def remove(*column_names)
-        @base.remove_columns(name, *column_names)
+      def remove(*column_names, **options)
+        @base.remove_columns(name, *column_names, **options)
       end
 
       # Removes the given index from the table.
@@ -635,10 +696,11 @@ module ActiveRecord
       #   t.remove_index(:branch_id)
       #   t.remove_index(column: [:branch_id, :party_id])
       #   t.remove_index(name: :by_branch_party)
+      #   t.remove_index(:branch_id, name: :by_branch_party)
       #
       # See {connection.remove_index}[rdoc-ref:SchemaStatements#remove_index]
-      def remove_index(options = {})
-        @base.remove_index(name, options)
+      def remove_index(column_name = nil, **options)
+        @base.remove_index(name, column_name, **options)
       end
 
       # Removes the timestamp columns (+created_at+ and +updated_at+) from the table.
@@ -713,6 +775,24 @@ module ActiveRecord
       def foreign_key_exists?(*args, **options)
         @base.foreign_key_exists?(name, *args, **options)
       end
+
+      # Adds a check constraint.
+      #
+      #  t.check_constraint("price > 0", name: "price_check")
+      #
+      # See {connection.add_check_constraint}[rdoc-ref:SchemaStatements#add_check_constraint]
+      def check_constraint(*args)
+        @base.add_check_constraint(name, *args)
+      end
+
+      # Removes the given check constraint from the table.
+      #
+      #  t.remove_check_constraint(name: "price_check")
+      #
+      # See {connection.remove_check_constraint}[rdoc-ref:SchemaStatements#remove_check_constraint]
+      def remove_check_constraint(*args)
+        @base.remove_check_constraint(name, *args)
+      end
     end
   end
 end

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

@@ -13,9 +13,9 @@ module ActiveRecord
         end
 
         def column_spec_for_primary_key(column)
-          return {} if default_primary_key?(column)
-          spec = { id: schema_type(column).inspect }
-          spec.merge!(prepare_column_options(column).except!(:null, :comment))
+          spec = {}
+          spec[:id] = schema_type(column).inspect unless default_primary_key?(column)
+          spec.merge!(prepare_column_options(column).except!(:null))
           spec[:default] ||= "nil" if explicit_primary_key_default?(column)
           spec
         end