activerecord 5.1.7 → 5.2.0.beta1

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

@@ -1,63 +1,40 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/hash/compact"
+
 module ActiveRecord
   module ConnectionAdapters # :nodoc:
-    # The goal of this module is to move Adapter specific column
-    # definitions to the Adapter instead of having it in the schema
-    # dumper itself. This code represents the normal case.
-    # We can then redefine how certain data types may be handled in the schema dumper on the
-    # Adapter level by over-writing this code inside the database specific adapters
-    module ColumnDumper
-      def column_spec(column)
-        [schema_type_with_virtual(column), prepare_column_options(column)]
+    class SchemaDumper < SchemaDumper # :nodoc:
+      def self.create(connection, options)
+        new(connection, options)
       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
-      # extended datatypes (Example: Adding an array option in the
-      # PostgreSQL::ColumnDumper)
-      def prepare_column_options(column)
-        spec = {}
-
-        if limit = schema_limit(column)
-          spec[:limit] = limit
+      private
+        def column_spec(column)
+          [schema_type_with_virtual(column), prepare_column_options(column)]
         end
 
-        if precision = schema_precision(column)
-          spec[:precision] = precision
+        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
 
-        if scale = schema_scale(column)
-          spec[:scale] = scale
+        def prepare_column_options(column)
+          spec = {}
+          spec[:limit] = schema_limit(column)
+          spec[:precision] = schema_precision(column)
+          spec[:scale] = schema_scale(column)
+          spec[:default] = schema_default(column)
+          spec[:null] = "false" unless column.null
+          spec[:collation] = schema_collation(column)
+          spec[:comment] = column.comment.inspect if column.comment.present?
+          spec.compact!
+          spec
         end
 
-        default = schema_default(column) if column.has_default?
-        spec[:default] = default unless default.nil?
-
-        spec[:null] = "false" unless column.null
-
-        if collation = schema_collation(column)
-          spec[:collation] = collation
-        end
-
-        spec[:comment] = column.comment.inspect if column.comment.present?
-
-        spec
-      end
-
-      # Lists the valid migration options
-      def migration_keys # :nodoc:
-        column_options_keys
-      end
-      deprecate :migration_keys
-
-      private
-
         def default_primary_key?(column)
           schema_type(column) == :bigint
         end
@@ -67,7 +44,7 @@ module ActiveRecord
         end
 
         def schema_type_with_virtual(column)
-          if supports_virtual_columns? && column.virtual?
+          if @connection.supports_virtual_columns? && column.virtual?
             :virtual
           else
             schema_type(column)
@@ -84,7 +61,7 @@ module ActiveRecord
 
         def schema_limit(column)
           limit = column.limit unless column.bigint?
-          limit.inspect if limit && limit != native_database_types[column.type][:limit]
+          limit.inspect if limit && limit != @connection.native_database_types[column.type][:limit]
         end
 
         def schema_precision(column)
@@ -96,7 +73,8 @@ module ActiveRecord
         end
 
         def schema_default(column)
-          type = lookup_cast_type_from_column(column)
+          return unless column.has_default?
+          type = @connection.lookup_cast_type_from_column(column)
           default = type.deserialize(column.default)
           if default.nil?
             schema_expression(column)

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

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 require "active_record/migration/join_table"
 require "active_support/core_ext/string/access"
-require "digest"
+require "digest/sha2"
 
 module ActiveRecord
   module ConnectionAdapters # :nodoc:
@@ -77,7 +79,7 @@ module ActiveRecord
       end
 
       # Returns an array of indexes for the given table.
-      def indexes(table_name, name = nil)
+      def indexes(table_name)
         raise NotImplementedError, "#indexes is not implemented"
       end
 
@@ -105,10 +107,12 @@ module ActiveRecord
         indexes(table_name).any? { |i| checks.all? { |check| check[i] } }
       end
 
-      # Returns an array of Column objects for the table specified by +table_name+.
-      # See the concrete implementation for details on the expected parameter values.
+      # Returns an array of +Column+ objects for the table specified by +table_name+.
       def columns(table_name)
-        raise NotImplementedError, "#columns is not implemented"
+        table_name = table_name.to_s
+        column_definitions(table_name).map do |field|
+          new_column_from_field(table_name, field)
+        end
       end
 
       # Checks to see if a column exists in a given table.
@@ -186,6 +190,8 @@ module ActiveRecord
       #   The name of the primary key, if one is to be added automatically.
       #   Defaults to +id+. If <tt>:id</tt> is false, then this option is ignored.
       #
+      #   If an array is passed, a composite primary key will be created.
+      #
       #   Note that Active Record models will automatically detect their
       #   primary key. This can be avoided by using
       #   {self.primary_key=}[rdoc-ref:AttributeMethods::PrimaryKey::ClassMethods#primary_key=] on the model
@@ -210,7 +216,7 @@ module ActiveRecord
       # generates:
       #
       #   CREATE TABLE suppliers (
-      #     id int auto_increment PRIMARY KEY
+      #     id bigint auto_increment PRIMARY KEY
       #   ) ENGINE=InnoDB DEFAULT CHARSET=utf8
       #
       # ====== Rename the primary key column
@@ -222,7 +228,7 @@ module ActiveRecord
       # generates:
       #
       #   CREATE TABLE objects (
-      #     guid int auto_increment PRIMARY KEY,
+      #     guid bigint auto_increment PRIMARY KEY,
       #     name varchar(80)
       #   )
       #
@@ -239,18 +245,35 @@ module ActiveRecord
       #     label varchar
       #   )
       #
+      # ====== Create a composite primary key
+      #
+      #   create_table(:orders, primary_key: [:product_id, :client_id]) do |t|
+      #     t.belongs_to :product
+      #     t.belongs_to :client
+      #   end
+      #
+      # generates:
+      #
+      #   CREATE TABLE order (
+      #       product_id bigint NOT NULL,
+      #       client_id bigint NOT NULL
+      #   );
+      #
+      #   ALTER TABLE ONLY "orders"
+      #     ADD CONSTRAINT orders_pkey PRIMARY KEY (product_id, client_id);
+      #
       # ====== Do not add a primary key column
       #
       #   create_table(:categories_suppliers, id: false) do |t|
-      #     t.column :category_id, :integer
-      #     t.column :supplier_id, :integer
+      #     t.column :category_id, :bigint
+      #     t.column :supplier_id, :bigint
       #   end
       #
       # generates:
       #
       #   CREATE TABLE categories_suppliers (
-      #     category_id int,
-      #     supplier_id int
+      #     category_id bigint,
+      #     supplier_id bigint
       #   )
       #
       # ====== Create a temporary table based on a query
@@ -338,8 +361,8 @@ module ActiveRecord
       # generates:
       #
       #   CREATE TABLE assemblies_parts (
-      #     assembly_id int NOT NULL,
-      #     part_id int NOT NULL,
+      #     assembly_id bigint NOT NULL,
+      #     part_id bigint NOT NULL,
       #   ) ENGINE=InnoDB DEFAULT CHARSET=utf8
       #
       def create_join_table(table_1, table_2, column_options: {}, **options)
@@ -383,6 +406,8 @@ module ActiveRecord
       #
       #   Defaults to false.
       #
+      #   Only supported on the MySQL adapter, ignored elsewhere.
+      #
       # ====== Add a column
       #
       #   change_table(:suppliers) do |t|
@@ -407,7 +432,7 @@ module ActiveRecord
       #     t.references :company
       #   end
       #
-      # Creates a <tt>company_id(integer)</tt> column.
+      # Creates a <tt>company_id(bigint)</tt> column.
       #
       # ====== Add a polymorphic foreign key column
       #
@@ -415,7 +440,7 @@ module ActiveRecord
       #    t.belongs_to :company, polymorphic: true
       #  end
       #
-      # Creates <tt>company_type(varchar)</tt> and <tt>company_id(integer)</tt> columns.
+      # Creates <tt>company_type(varchar)</tt> and <tt>company_id(bigint)</tt> columns.
       #
       # ====== Remove a column
       #
@@ -488,15 +513,17 @@ module ActiveRecord
       # * <tt>:limit</tt> -
       #   Requests a maximum column length. This is the number of characters for a <tt>:string</tt> column
       #   and number of bytes for <tt>:text</tt>, <tt>:binary</tt> and <tt>:integer</tt> columns.
+      #   This option is ignored by some backends.
       # * <tt>:default</tt> -
       #   The column's default value. Use +nil+ for +NULL+.
       # * <tt>:null</tt> -
-      #   Allows or disallows +NULL+ values in the column. This option could
-      #   have been named <tt>:null_allowed</tt>.
+      #   Allows or disallows +NULL+ values in the column.
       # * <tt>:precision</tt> -
       #   Specifies the precision for the <tt>:decimal</tt> and <tt>:numeric</tt> columns.
       # * <tt>:scale</tt> -
       #   Specifies the scale for the <tt>:decimal</tt> and <tt>:numeric</tt> columns.
+      # * <tt>:comment</tt> -
+      #   Specifies the comment for the column. This option is ignored by some backends.
       #
       # Note: The precision is the total number of significant digits,
       # and the scale is the number of digits that can be stored following
@@ -757,7 +784,7 @@ module ActiveRecord
       def rename_index(table_name, old_name, new_name)
         validate_index_length!(table_name, new_name)
 
-        # this is a naive implementation; some DBs may support this more efficiently (Postgres, for instance)
+        # this is a naive implementation; some DBs may support this more efficiently (PostgreSQL, for instance)
         old_index_def = indexes(table_name).detect { |i| i.name == old_name }
         return unless old_index_def
         add_index(table_name, old_index_def.columns, name: new_name, unique: old_index_def.unique)
@@ -779,24 +806,19 @@ module ActiveRecord
       end
 
       # Verifies the existence of an index with a given name.
-      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
+      def index_name_exists?(table_name, index_name)
         index_name = index_name.to_s
         indexes(table_name).detect { |i| i.name == index_name }
       end
 
-      # Adds a reference. The reference column is an integer by default,
+      # Adds a reference. The reference column is a bigint by default,
       # the <tt>:type</tt> option can be used to specify a different type.
       # Optionally adds a +_type+ column, if <tt>:polymorphic</tt> option is provided.
       # #add_reference and #add_belongs_to are acceptable.
       #
       # The +options+ hash can include the following keys:
       # [<tt>:type</tt>]
-      #   The reference column type. Defaults to +:integer+.
+      #   The reference column type. Defaults to +:bigint+.
       # [<tt>:index</tt>]
       #   Add an appropriate index. Defaults to true.
       #   See #add_index for usage of this option.
@@ -807,7 +829,7 @@ module ActiveRecord
       # [<tt>:null</tt>]
       #   Whether the column allows nulls. Defaults to true.
       #
-      # ====== Create a user_id integer column
+      # ====== Create a user_id bigint column
       #
       #   add_reference(:products, :user)
       #
@@ -974,16 +996,6 @@ module ActiveRecord
         foreign_key_for(from_table, options_or_to_table).present?
       end
 
-      def foreign_key_for(from_table, options_or_to_table = {}) # :nodoc:
-        return unless supports_foreign_keys?
-        foreign_keys(from_table).detect { |fk| fk.defined_for? options_or_to_table }
-      end
-
-      def foreign_key_for!(from_table, options_or_to_table = {}) # :nodoc:
-        foreign_key_for(from_table, options_or_to_table) || \
-          raise(ArgumentError, "Table '#{from_table}' has no foreign key for #{options_or_to_table}")
-      end
-
       def foreign_key_column_for(table_name) # :nodoc:
         prefix = Base.table_name_prefix
         suffix = Base.table_name_suffix
@@ -1003,29 +1015,6 @@ module ActiveRecord
         insert_versions_sql(versions) if versions.any?
       end
 
-      def insert_versions_sql(versions) # :nodoc:
-        sm_table = quote_table_name(ActiveRecord::SchemaMigration.table_name)
-
-        if versions.is_a?(Array)
-          sql = "INSERT INTO #{sm_table} (version) VALUES\n"
-          sql << versions.map { |v| "(#{quote(v)})" }.join(",\n")
-          sql << ";\n\n"
-          sql
-        else
-          "INSERT INTO #{sm_table} (version) VALUES (#{quote(versions)});"
-        end
-      end
-
-      def initialize_schema_migrations_table # :nodoc:
-        ActiveRecord::SchemaMigration.create_table
-      end
-      deprecate :initialize_schema_migrations_table
-
-      def initialize_internal_metadata_table # :nodoc:
-        ActiveRecord::InternalMetadata.create_table
-      end
-      deprecate :initialize_internal_metadata_table
-
       def internal_string_options_for_primary_key # :nodoc:
         { primary_key: true }
       end
@@ -1170,10 +1159,14 @@ module ActiveRecord
       end
 
       # Changes the comment for a column or removes it if +nil+.
-      def change_column_comment(table_name, column_name, comment) #:nodoc:
+      def change_column_comment(table_name, column_name, comment)
         raise NotImplementedError, "#{self.class} does not support changing column comments"
       end
 
+      def create_schema_dumper(options) # :nodoc:
+        SchemaDumper.create(self, options)
+      end
+
       private
         def column_options_keys
           [:limit, :precision, :scale, :default, :null, :collation, :comment]
@@ -1261,6 +1254,10 @@ module ActiveRecord
           end
         end
 
+        def schema_creation
+          SchemaCreation.new(self)
+        end
+
         def create_table_definition(*args)
           TableDefinition.new(*args)
         end
@@ -1269,6 +1266,17 @@ module ActiveRecord
           AlterTable.new create_table_definition(name)
         end
 
+        def fetch_type_metadata(sql_type)
+          cast_type = lookup_cast_type(sql_type)
+          SqlTypeMetadata.new(
+            sql_type: sql_type,
+            type: cast_type.type,
+            limit: cast_type.limit,
+            precision: cast_type.precision,
+            scale: cast_type.scale,
+          )
+        end
+
         def index_column_names(column_names)
           if column_names.is_a?(String) && /\W/.match?(column_names)
             column_names
@@ -1286,13 +1294,32 @@ module ActiveRecord
         end
 
         def foreign_key_name(table_name, options)
-          identifier = "#{table_name}_#{options.fetch(:column)}_fk"
-          hashed_identifier = Digest::SHA256.hexdigest(identifier).first(10)
           options.fetch(:name) do
+            identifier = "#{table_name}_#{options.fetch(:column)}_fk"
+            hashed_identifier = Digest::SHA256.hexdigest(identifier).first(10)
+
             "fk_rails_#{hashed_identifier}"
           end
         end
 
+        def foreign_key_for(from_table, options_or_to_table = {})
+          return unless supports_foreign_keys?
+          foreign_keys(from_table).detect { |fk| fk.defined_for? options_or_to_table }
+        end
+
+        def foreign_key_for!(from_table, options_or_to_table = {})
+          foreign_key_for(from_table, options_or_to_table) || \
+            raise(ArgumentError, "Table '#{from_table}' has no foreign key for #{options_or_to_table}")
+        end
+
+        def extract_foreign_key_action(specifier)
+          case specifier
+          when "CASCADE"; :cascade
+          when "SET NULL"; :nullify
+          when "RESTRICT"; :restrict
+          end
+        end
+
         def validate_index_length!(table_name, new_name, internal = false)
           max_index_length = internal ? index_name_length : allowed_index_name_length
 
@@ -1313,6 +1340,19 @@ module ActiveRecord
           options.is_a?(Hash) && options.key?(:name) && options.except(:name, :algorithm).empty?
         end
 
+        def insert_versions_sql(versions)
+          sm_table = quote_table_name(ActiveRecord::SchemaMigration.table_name)
+
+          if versions.is_a?(Array)
+            sql = "INSERT INTO #{sm_table} (version) VALUES\n".dup
+            sql << versions.map { |v| "(#{quote(v)})" }.join(",\n")
+            sql << ";\n\n"
+            sql
+          else
+            "INSERT INTO #{sm_table} (version) VALUES (#{quote(versions)});"
+          end
+        end
+
         def data_source_sql(name = nil, type: nil)
           raise NotImplementedError
         end