activerecord 5.0.7 → 5.1.7

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

@@ -3,30 +3,37 @@ module ActiveRecord
     # Abstract representation of an index definition on a table. Instances of
     # this type are typically created and returned by methods in database
     # adapters. e.g. ActiveRecord::ConnectionAdapters::AbstractMysqlAdapter#indexes
-    class IndexDefinition < Struct.new(:table, :name, :unique, :columns, :lengths, :orders, :where, :type, :using, :comment) #:nodoc:
-    end
+    IndexDefinition = Struct.new(:table, :name, :unique, :columns, :lengths, :orders, :where, :type, :using, :comment) #:nodoc:
 
     # Abstract representation of a column definition. Instances of this type
     # are typically created by methods in TableDefinition, and added to the
     # +columns+ attribute of said TableDefinition object, in order to be used
     # for generating a number of table creation or table changing SQL statements.
-    class ColumnDefinition < Struct.new(:name, :type, :limit, :precision, :scale, :default, :null, :first, :after, :auto_increment, :primary_key, :collation, :sql_type, :comment) #:nodoc:
-
+    ColumnDefinition = Struct.new(:name, :type, :options, :sql_type) do # :nodoc:
       def primary_key?
-        primary_key || type.to_sym == :primary_key
+        options[:primary_key]
       end
-    end
 
-    class AddColumnDefinition < Struct.new(:column) # :nodoc:
-    end
+      [:limit, :precision, :scale, :default, :null, :collation, :comment].each do |option_name|
+        module_eval <<-CODE, __FILE__, __LINE__ + 1
+          def #{option_name}
+            options[:#{option_name}]
+          end
 
-    class ChangeColumnDefinition < Struct.new(:column, :name) #:nodoc:
+          def #{option_name}=(value)
+            options[:#{option_name}] = value
+          end
+        CODE
+      end
     end
 
-    class PrimaryKeyDefinition < Struct.new(:name) # :nodoc:
-    end
+    AddColumnDefinition = Struct.new(:column) # :nodoc:
 
-    class ForeignKeyDefinition < Struct.new(:from_table, :to_table, :options) #:nodoc:
+    ChangeColumnDefinition = Struct.new(:column, :name) #:nodoc:
+
+    PrimaryKeyDefinition = Struct.new(:name) # :nodoc:
+
+    ForeignKeyDefinition = Struct.new(:from_table, :to_table, :options) do #:nodoc:
       def name
         options[:name]
       end
@@ -61,9 +68,9 @@ module ActiveRecord
       end
 
       private
-      def default_primary_key
-        "id"
-      end
+        def default_primary_key
+          "id"
+        end
     end
 
     class ReferenceDefinition # :nodoc:
@@ -72,7 +79,7 @@ module ActiveRecord
         polymorphic: false,
         index: true,
         foreign_key: false,
-        type: :integer,
+        type: :bigint,
         **options
       )
         @name = name
@@ -101,49 +108,51 @@ module ActiveRecord
         end
       end
 
+      # TODO Change this to private once we've dropped Ruby 2.2 support.
+      # Workaround for Ruby 2.2 "private attribute?" warning.
       protected
 
-      attr_reader :name, :polymorphic, :index, :foreign_key, :type, :options
+        attr_reader :name, :polymorphic, :index, :foreign_key, :type, :options
 
       private
 
-      def as_options(value)
-        value.is_a?(Hash) ? value : {}
-      end
+        def as_options(value)
+          value.is_a?(Hash) ? value : {}
+        end
 
-      def polymorphic_options
-        as_options(polymorphic).merge(null: options[:null])
-      end
+        def polymorphic_options
+          as_options(polymorphic).merge(options.slice(:null, :first, :after))
+        end
 
-      def index_options
-        as_options(index)
-      end
+        def index_options
+          as_options(index)
+        end
 
-      def foreign_key_options
-        as_options(foreign_key).merge(column: column_name)
-      end
+        def foreign_key_options
+          as_options(foreign_key).merge(column: column_name)
+        end
 
-      def columns
-        result = [[column_name, type, options]]
-        if polymorphic
-          result.unshift(["#{name}_type", :string, polymorphic_options])
+        def columns
+          result = [[column_name, type, options]]
+          if polymorphic
+            result.unshift(["#{name}_type", :string, polymorphic_options])
+          end
+          result
         end
-        result
-      end
 
-      def column_name
-        "#{name}_id"
-      end
+        def column_name
+          "#{name}_id"
+        end
 
-      def column_names
-        columns.map(&:first)
-      end
+        def column_names
+          columns.map(&:first)
+        end
 
-      def foreign_table_name
-        foreign_key_options.fetch(:to_table) do
-          Base.pluralize_table_names ? name.to_s.pluralize : name
+        def foreign_table_name
+          foreign_key_options.fetch(:to_table) do
+            Base.pluralize_table_names ? name.to_s.pluralize : name
+          end
         end
-      end
     end
 
     module ColumnMethods
@@ -172,6 +181,7 @@ module ActiveRecord
         :text,
         :time,
         :timestamp,
+        :virtual,
       ].each do |column_type|
         module_eval <<-CODE, __FILE__, __LINE__ + 1
           def #{column_type}(*args, **options)
@@ -338,9 +348,7 @@ module ActiveRecord
       # <tt>:updated_at</tt> to the table. See {connection.add_timestamps}[rdoc-ref:SchemaStatements#add_timestamps]
       #
       #   t.timestamps null: false
-      def timestamps(*args)
-        options = args.extract_options!
-
+      def timestamps(**options)
         options[:null] = false if options[:null].nil?
 
         column(:created_at, :datetime, options)
@@ -354,38 +362,27 @@ module ActiveRecord
       #
       # See {connection.add_reference}[rdoc-ref:SchemaStatements#add_reference] for details of the options you can use.
       def references(*args, **options)
-        args.each do |col|
-          ReferenceDefinition.new(col, **options).add_to(self)
+        args.each do |ref_name|
+          ReferenceDefinition.new(ref_name, options).add_to(self)
         end
       end
       alias :belongs_to :references
 
-      def new_column_definition(name, type, options) # :nodoc:
+      def new_column_definition(name, type, **options) # :nodoc:
         type = aliased_types(type.to_s, type)
-        column = create_column_definition name, type
-
-        column.limit       = options[:limit]
-        column.precision   = options[:precision]
-        column.scale       = options[:scale]
-        column.default     = options[:default]
-        column.null        = options[:null]
-        column.first       = options[:first]
-        column.after       = options[:after]
-        column.auto_increment = options[:auto_increment]
-        column.primary_key = type == :primary_key || options[:primary_key]
-        column.collation   = options[:collation]
-        column.comment     = options[:comment]
-        column
+        options[:primary_key] ||= type == :primary_key
+        options[:null] = false if options[:primary_key]
+        create_column_definition(name, type, options)
       end
 
       private
-      def create_column_definition(name, type)
-        ColumnDefinition.new name, type
-      end
+        def create_column_definition(name, type, options)
+          ColumnDefinition.new(name, type, options)
+        end
 
-      def aliased_types(name, fallback)
-        'timestamp' == name ? :datetime : fallback
-      end
+        def aliased_types(name, fallback)
+          "timestamp" == name ? :datetime : fallback
+        end
     end
 
     class AlterTable # :nodoc:
@@ -474,7 +471,7 @@ module ActiveRecord
 
       # Checks to see if a column exists.
       #
-      # t.string(:name) unless t.column_exists?(:name, :string)
+      #  t.string(:name) unless t.column_exists?(:name, :string)
       #
       # See {connection.column_exists?}[rdoc-ref:SchemaStatements#column_exists?]
       def column_exists?(column_name, type = nil, options = {})
@@ -495,9 +492,9 @@ module ActiveRecord
 
       # Checks to see if an index exists.
       #
-      # unless t.index_exists?(:branch_id)
-      #   t.index(:branch_id)
-      # end
+      #  unless t.index_exists?(:branch_id)
+      #    t.index(:branch_id)
+      #  end
       #
       # See {connection.index_exists?}[rdoc-ref:SchemaStatements#index_exists?]
       def index_exists?(column_name, options = {})
@@ -588,8 +585,7 @@ module ActiveRecord
       #  t.belongs_to(:supplier, foreign_key: true)
       #
       # See {connection.add_reference}[rdoc-ref:SchemaStatements#add_reference] for details of the options you can use.
-      def references(*args)
-        options = args.extract_options!
+      def references(*args, **options)
         args.each do |ref_name|
           @base.add_reference(name, ref_name, options)
         end
@@ -602,8 +598,7 @@ module ActiveRecord
       #  t.remove_belongs_to(:supplier, polymorphic: true)
       #
       # See {connection.remove_reference}[rdoc-ref:SchemaStatements#remove_reference]
-      def remove_references(*args)
-        options = args.extract_options!
+      def remove_references(*args, **options)
         args.each do |ref_name|
           @base.remove_reference(name, ref_name, options)
         end

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

@@ -7,16 +7,15 @@ module ActiveRecord
     # Adapter level by over-writing this code inside the database specific adapters
     module ColumnDumper
       def column_spec(column)
-        spec = Hash[prepare_column_options(column).map { |k, v| [k, "#{k}: #{v}"] }]
-        spec[:name] = column.name.inspect
-        spec[:type] = schema_type(column).to_s
-        spec
+        [schema_type_with_virtual(column), prepare_column_options(column)]
       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))
+        spec[:default] ||= "nil" if explicit_primary_key_default?(column)
+        spec
       end
 
       # This can be overridden on an Adapter level basis to support other
@@ -38,9 +37,9 @@ module ActiveRecord
         end
 
         default = schema_default(column) if column.has_default?
-        spec[:default]   = default unless default.nil?
+        spec[:default] = default unless default.nil?
 
-        spec[:null] = 'false' unless column.null
+        spec[:null] = "false" unless column.null
 
         if collation = schema_collation(column)
           spec[:collation] = collation
@@ -52,54 +51,67 @@ module ActiveRecord
       end
 
       # Lists the valid migration options
-      def migration_keys
-        [:name, :limit, :precision, :scale, :default, :null, :collation, :comment]
+      def migration_keys # :nodoc:
+        column_options_keys
       end
+      deprecate :migration_keys
 
       private
 
-      def default_primary_key?(column)
-        schema_type(column) == :integer
-      end
+        def default_primary_key?(column)
+          schema_type(column) == :bigint
+        end
 
-      def schema_type(column)
-        if column.bigint?
-          :bigint
-        else
-          column.type
+        def explicit_primary_key_default?(column)
+          false
         end
-      end
 
-      def schema_limit(column)
-        limit = column.limit unless column.bigint?
-        limit.inspect if limit && limit != native_database_types[column.type][:limit]
-      end
+        def schema_type_with_virtual(column)
+          if supports_virtual_columns? && column.virtual?
+            :virtual
+          else
+            schema_type(column)
+          end
+        end
 
-      def schema_precision(column)
-        column.precision.inspect if column.precision
-      end
+        def schema_type(column)
+          if column.bigint?
+            :bigint
+          else
+            column.type
+          end
+        end
 
-      def schema_scale(column)
-        column.scale.inspect if column.scale
-      end
+        def schema_limit(column)
+          limit = column.limit unless column.bigint?
+          limit.inspect if limit && limit != native_database_types[column.type][:limit]
+        end
 
-      def schema_default(column)
-        type = lookup_cast_type_from_column(column)
-        default = type.deserialize(column.default)
-        if default.nil?
-          schema_expression(column)
-        else
-          type.type_cast_for_schema(default)
+        def schema_precision(column)
+          column.precision.inspect if column.precision
         end
-      end
 
-      def schema_expression(column)
-        "-> { #{column.default_function.inspect} }" if column.default_function
-      end
+        def schema_scale(column)
+          column.scale.inspect if column.scale
+        end
 
-      def schema_collation(column)
-        column.collation.inspect if column.collation
-      end
+        def schema_default(column)
+          type = lookup_cast_type_from_column(column)
+          default = type.deserialize(column.default)
+          if default.nil?
+            schema_expression(column)
+          else
+            type.type_cast_for_schema(default)
+          end
+        end
+
+        def schema_expression(column)
+          "-> { #{column.default_function.inspect} }" if column.default_function
+        end
+
+        def schema_collation(column)
+          column.collation.inspect if column.collation
+        end
     end
   end
 end