Change Default Primary Keys to BIGINT

activerecord/CHANGELOG.md

@@ -1,3 +1,7 @@
+*   PostgreSQL & MySQL: Use big integer as primary key type for new tables
+
+    *Jon McCartie*, *Pavel Pravosud*
+
 *   Change the type argument of `ActiveRecord::Base#attribute` to be optional.
     The default is now `ActiveRecord::Type::Value.new`, which provides no type
     casting behavior.

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

@@ -71,7 +71,7 @@ def initialize(
         polymorphic: false,
         index: true,
         foreign_key: false,
-        type: :integer,
+        type: :bigint,
         **options
       )
         @name = name

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

@@ -56,7 +56,7 @@ def migration_keys
       private
 
         def default_primary_key?(column)
-          schema_type(column) == :integer
+          schema_type(column) == :bigint
         end
 
         def schema_type(column)

activerecord/lib/active_record/connection_adapters/abstract_mysql_adapter.rb

@@ -39,7 +39,7 @@ def arel_visitor # :nodoc:
       self.emulate_booleans = true
 
       NATIVE_DATABASE_TYPES = {
-        primary_key: "int auto_increment PRIMARY KEY",
+        primary_key: "BIGINT(8) UNSIGNED auto_increment PRIMARY KEY",
         string:      { name: "varchar", limit: 255 },
         text:        { name: "text", limit: 65535 },
         integer:     { name: "int", limit: 4 },
@@ -736,13 +736,23 @@ def add_options_for_index_columns(quoted_columns, **options)
         ER_NO_REFERENCED_ROW_2  = 1452
         ER_DATA_TOO_LONG        = 1406
         ER_LOCK_DEADLOCK        = 1213
+        ER_CANNOT_ADD_FOREIGN   = 1215
+        ER_CANNOT_CREATE_TABLE  = 1005
 
         def translate_exception(exception, message)
           case error_number(exception)
           when ER_DUP_ENTRY
             RecordNotUnique.new(message)
           when ER_NO_REFERENCED_ROW_2
             InvalidForeignKey.new(message)
+          when ER_CANNOT_ADD_FOREIGN
+            mismatched_foreign_key(message)
+          when ER_CANNOT_CREATE_TABLE
+            if message.include?("errno: 150")
+              mismatched_foreign_key(message)
+            else
+              super
+            end
           when ER_DATA_TOO_LONG
             ValueTooLong.new(message)
           when ER_LOCK_DEADLOCK
@@ -914,6 +924,18 @@ def create_table_definition(*args) # :nodoc:
           MySQL::TableDefinition.new(*args)
         end
 
+        def mismatched_foreign_key(message)
+          parts = message.scan(/`(\w+)`[ $)]/).flatten
+          MismatchedForeignKey.new(
+            self,
+            message: message,
+            table: parts[0],
+            foreign_key: parts[1],
+            target_table: parts[2],
+            primary_key: parts[3],
+          )
+        end
+
         def extract_schema_qualified_name(string) # :nodoc:
           schema, name = string.to_s.scan(/[^`.\s]+|`[^`]*`/)
           schema, name = @config[:database], schema unless name

activerecord/lib/active_record/connection_adapters/mysql/schema_definitions.rb

@@ -3,7 +3,10 @@ module ConnectionAdapters
     module MySQL
       module ColumnMethods
         def primary_key(name, type = :primary_key, **options)
-          options[:auto_increment] = true if type == :bigint && !options.key?(:default)
+          if type == :primary_key && !options.key?(:default)
+            options[:auto_increment] = true
+            options[:limit] = 8
+          end
           super
         end
 

activerecord/lib/active_record/connection_adapters/mysql/schema_dumper.rb

@@ -3,11 +3,9 @@ module ConnectionAdapters
     module MySQL
       module ColumnDumper
         def column_spec_for_primary_key(column)
-          if column.bigint?
-            spec = { id: :bigint.inspect }
-            spec[:default] = schema_default(column) || "nil" unless column.auto_increment?
-          else
-            spec = super
+          spec = super
+          if column.type == :integer && !column.auto_increment?
+            spec[:default] = schema_default(column) || "nil"
           end
           spec[:unsigned] = "true" if column.unsigned?
           spec

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

@@ -25,7 +25,7 @@ def migration_keys
         private
 
           def default_primary_key?(column)
-            schema_type(column) == :serial
+            schema_type(column) == :bigserial
           end
 
           def schema_type(column)

activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb

@@ -70,7 +70,7 @@ class PostgreSQLAdapter < AbstractAdapter
       ADAPTER_NAME = "PostgreSQL".freeze
 
       NATIVE_DATABASE_TYPES = {
-        primary_key: "serial primary key",
+        primary_key: "bigserial primary key",
         string:      { name: "character varying" },
         text:        { name: "text" },
         integer:     { name: "integer" },

activerecord/lib/active_record/connection_adapters/sqlite3/schema_dumper.rb

@@ -0,0 +1,13 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module SQLite3
+      module ColumnDumper
+        private
+
+          def default_primary_key?(column)
+            schema_type(column) == :integer
+          end
+      end
+    end
+  end
+end

activerecord/lib/active_record/connection_adapters/sqlite3_adapter.rb

@@ -4,6 +4,7 @@
 require "active_record/connection_adapters/sqlite3/quoting"
 require "active_record/connection_adapters/sqlite3/schema_creation"
 require "active_record/connection_adapters/sqlite3/schema_definitions"
+require "active_record/connection_adapters/sqlite3/schema_dumper"
 
 gem "sqlite3", "~> 1.3.6"
 require "sqlite3"
@@ -53,6 +54,7 @@ class SQLite3Adapter < AbstractAdapter
       ADAPTER_NAME = "SQLite".freeze
 
       include SQLite3::Quoting
+      include SQLite3::ColumnDumper
 
       NATIVE_DATABASE_TYPES = {
         primary_key:  "INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL",

activerecord/lib/active_record/errors.rb

@@ -123,6 +123,34 @@ class RecordNotUnique < WrappedDatabaseException
   class InvalidForeignKey < WrappedDatabaseException
   end
 
+  # Raised when a foreign key constraint cannot be added because the column type does not match the referenced column type.
+  class MismatchedForeignKey < WrappedDatabaseException
+    def initialize(adapter = nil, message: nil, table: nil, foreign_key: nil, target_table: nil, primary_key: nil)
+      @adapter = adapter
+      if table
+        msg = <<-EOM.strip_heredoc
+          Column `#{foreign_key}` on table `#{table}` has a type of `#{column_type(table, foreign_key)}`.
+          This does not match column `#{primary_key}` on `#{target_table}`, which has type `#{column_type(target_table, primary_key)}`.
+          To resolve this issue, change the type of the `#{foreign_key}` column on `#{table}` to be :integer. (For example `t.integer #{foreign_key}`).
+        EOM
+      else
+        msg = <<-EOM
+          There is a mismatch between the foreign key and primary key column types.
+          Verify that the foreign key column type and the primary key of the associated table match types.
+        EOM
+      end
+      if message
+        msg << "\nOriginal message: #{message}"
+      end
+      super(msg)
+    end
+
+    private
+      def column_type(table, column)
+        @adapter.columns(table).detect { |c| c.name == column }.sql_type
+      end
+  end
+
   # Raised when a record cannot be inserted or updated because a value too long for a column type.
   class ValueTooLong < StatementInvalid
   end

activerecord/lib/active_record/migration/compatibility.rb

@@ -104,11 +104,21 @@ def index_name_for_remove(table_name, options = {})
 
       class V5_0 < V5_1
         def create_table(table_name, options = {})
-          if ActiveRecord::Base.connection.adapter_name == "PostgreSQL"
+          connection_name = self.connection.adapter_name
+          if connection_name == "PostgreSQL"
             if options[:id] == :uuid && !options[:default]
               options[:default] = "uuid_generate_v4()"
             end
           end
+
+          # Since 5.1 Postgres adapter uses bigserial type for primary
+          # keys by default and MySQL uses bigint. This compat layer makes old migrations utilize
+          # serial/int type instead -- the way it used to work before 5.1.
+          if options[:id].blank?
+            options[:id] = :integer
+            options[:auto_increment] = true
+          end
+
           super
         end
       end

activerecord/test/cases/adapters/mysql2/legacy_migration_test.rb

@@ -0,0 +1,60 @@
+require "cases/helper"
+
+class MysqlLegacyMigrationTest < ActiveRecord::Mysql2TestCase
+  self.use_transactional_tests = false
+
+  class GenerateTableWithoutBigint < ActiveRecord::Migration[5.0]
+    def change
+      create_table :legacy_integer_pk do |table|
+        table.string :foo
+      end
+
+      create_table :override_pk, id: :bigint do |table|
+        table.string :bar
+      end
+    end
+  end
+
+  def setup
+    super
+    @connection = ActiveRecord::Base.connection
+
+    @migration_verbose_old = ActiveRecord::Migration.verbose
+    ActiveRecord::Migration.verbose = false
+
+    migrations = [GenerateTableWithoutBigint.new(nil, 1)]
+
+    ActiveRecord::Migrator.new(:up, migrations).migrate
+  end
+
+  def teardown
+    ActiveRecord::Migration.verbose = @migration_verbose_old
+    @connection.drop_table("legacy_integer_pk")
+    @connection.drop_table("override_pk")
+    ActiveRecord::SchemaMigration.delete_all rescue nil
+    super
+  end
+
+  def test_create_table_uses_integer_as_pkey_by_default
+    col = column(:legacy_integer_pk, :id)
+    assert_equal "int(11)", sql_type_for(col)
+    assert col.auto_increment?
+  end
+
+  def test_create_tables_respects_pk_column_type_override
+    col = column(:override_pk, :id)
+    assert_equal "bigint(20)", sql_type_for(col)
+  end
+
+  private
+
+    def column(table_name, column_name)
+      ActiveRecord::Base.connection
+        .columns(table_name.to_s)
+        .detect { |c| c.name == column_name.to_s }
+    end
+
+    def sql_type_for(col)
+      col && col.sql_type
+    end
+end

activerecord/test/cases/adapters/mysql2/mysql2_adapter_test.rb

@@ -65,6 +65,19 @@ def order.to_sql
       @conn.columns_for_distinct("posts.id", [order])
   end
 
+  def test_errors_for_bigint_fks_on_integer_pk_table
+    # table old_cars has primary key of integer
+
+    error = assert_raises(ActiveRecord::MismatchedForeignKey) do
+      @conn.add_reference :engines, :old_car
+      @conn.add_foreign_key :engines, :old_cars
+    end
+
+    assert_match "Column `old_car_id` on table `engines` has a type of `bigint(20)`", error.message
+    assert_not_nil error.cause
+    @conn.exec_query("ALTER TABLE engines DROP COLUMN old_car_id")
+  end
+
   private
 
     def with_example_table(definition = "id int auto_increment primary key, number int, data varchar(255)", &block)

activerecord/test/cases/adapters/postgresql/legacy_migration_test.rb

@@ -0,0 +1,54 @@
+require "cases/helper"
+
+class PostgresqlLegacyMigrationTest < ActiveRecord::PostgreSQLTestCase
+  class GenerateTableWithoutBigserial < ActiveRecord::Migration[5.0]
+    def change
+      create_table :legacy_integer_pk do |table|
+        table.string :foo
+      end
+
+      create_table :override_pk, id: :bigint do |table|
+        table.string :bar
+      end
+    end
+  end
+
+  def setup
+    super
+
+    @migration_verbose_old = ActiveRecord::Migration.verbose
+    ActiveRecord::Migration.verbose = false
+
+    migrations = [GenerateTableWithoutBigserial.new(nil, 1)]
+    ActiveRecord::Migrator.new(:up, migrations).migrate
+  end
+
+  def teardown
+    ActiveRecord::Migration.verbose = @migration_verbose_old
+
+    super
+  end
+
+  def test_create_table_uses_serial_as_pkey_by_default
+    col = column(:legacy_integer_pk, :id)
+    assert_equal "integer", sql_type_for(col)
+    assert col.serial?
+  end
+
+  def test_create_tables_respects_pk_column_type_override
+    col = column(:override_pk, :id)
+    assert_equal "bigint", sql_type_for(col)
+  end
+
+  private
+
+    def column(table_name, column_name)
+      ActiveRecord::Base.connection.
+        columns(table_name.to_s).
+        detect { |c| c.name == column_name.to_s }
+    end
+
+    def sql_type_for(col)
+      col && col.sql_type
+    end
+end