activerecord-mysql-awesome 0.0.4 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a21a0f151f532f79298ad0c6dff3cc8fc2de50fb
-  data.tar.gz: e7b5019e83e9574918d428ccc5e9d8c60be43a13
+  metadata.gz: 61fbabfdb8b2dbef3e83d6ffbc24e95550aa1822
+  data.tar.gz: 3963c7f71541e73241acc40f8b6745e6821134ac
 SHA512:
-  metadata.gz: 71f8063d4621ac388c7edca128674cd53cf5e45ccb8452678700d520a1b1c45262d21533ad62ba1dbb9df1fd16ab5178b4b8422840e32160675f0ad20a1077d9
-  data.tar.gz: 6f0153a9989ba7b6106416f8d962f7ecfac29d28c0fd796aacf9a499ba4311eb60ee8f8d3b4b277fa905f966a3ba586f546179d74b739993e7308d6b98bd7a9e
+  metadata.gz: c9d4eac2a815ed770221b9c9f0df096603534003dbf15e939fcd868ec7ed7a43974cfd02eec72782ffbe340062c63216f2582afdcb533c41c6240c64757b3ea2
+  data.tar.gz: e436050985e009b96b3aefcb60b5a619519f98a3be5154fefe2f7ae593f443fc007076808695c9bcc53b8ab4e83f9d21c4e59aba00fbd221e485623c2b22f1cd

data/activerecord-mysql-awesome.gemspec

@@ -24,5 +24,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_runtime_dependency "activesupport", "~> 4.0"
   spec.add_runtime_dependency "activerecord", "~> 4.0"
-  spec.add_runtime_dependency "mysql2"
+  spec.add_runtime_dependency "mysql2", ">= 0.3.18"
 end

data/lib/activerecord-mysql-awesome/active_record/connection_adapters/abstract_mysql_adapter.rb

@@ -3,7 +3,18 @@ require 'active_record/connection_adapters/abstract_mysql_adapter'
 module ActiveRecord
   module Mysql
     module Awesome
-      class ChangeColumnDefinition < Struct.new(:column, :name) #:nodoc:
+      class ChangeColumnDefinition < Struct.new(:column, :name)
+      end
+
+      module ColumnMethods
+        def primary_key(name, type = :primary_key, **options)
+          options[:auto_increment] = true if type == :bigint
+          super
+        end
+
+        def unsigned_integer(*args, **options)
+          args.each { |name| column(name, :unsigned_integer, options) }
+        end
       end
 
       class ColumnDefinition < ActiveRecord::ConnectionAdapters::ColumnDefinition
@@ -11,21 +22,26 @@ module ActiveRecord
       end
 
       class TableDefinition < ActiveRecord::ConnectionAdapters::TableDefinition
+        include ColumnMethods
+
         def initialize(types, name, temporary, options, as = nil)
           super(types, name, temporary, options)
           @as = as
         end
 
-        def primary_key(name, type = :primary_key, options = {})
-          options[:auto_increment] ||= type == :bigint
-          super
-        end
-
-        def new_column_definition(name, type, options) # :nodoc:
+        def new_column_definition(name, type, options)
           column = super
-          column.auto_increment = options[:auto_increment]
-          column.unsigned  = options[:unsigned]
-          column.charset   = options[:charset]
+          case column.type
+          when :primary_key
+            column.type = :integer
+            column.auto_increment = true
+          when :unsigned_integer
+            column.type = :integer
+            column.unsigned = true
+          end
+          column.auto_increment ||= options[:auto_increment]
+          column.unsigned ||= options[:unsigned]
+          column.charset = options[:charset]
           column.collation = options[:collation]
           column
         end
@@ -37,6 +53,10 @@ module ActiveRecord
         end
       end
 
+      class Table < ActiveRecord::ConnectionAdapters::Table
+        include ColumnMethods
+      end
+
       module SchemaCreation
         def visit_AddColumn(o)
           add_column_position!("ADD #{accept(o)}", column_options(o))
@@ -89,11 +109,15 @@ module ActiveRecord
           sql
         end
 
-        def type_to_sql(type, limit, precision, scale, unsigned = false)
+        def type_to_sql(type, limit, precision, scale, unsigned)
           @conn.type_to_sql(type.to_sym, limit, precision, scale, unsigned)
         end
       end
 
+      def update_table_definition(table_name, base)
+        Table.new(table_name, base)
+      end
+
       module Column
         def unsigned?
           sql_type =~ /unsigned/i
@@ -108,35 +132,36 @@ module ActiveRecord
         end
       end
 
-      if ActiveRecord::VERSION::STRING < "4.2.0"
-        def quote(value, column = nil) #:nodoc:
-          return super unless column && column.type
+      def quote(value, column = nil)
+        return super unless column && /time/ === column.sql_type
 
-          case column.type
-          when :datetime, :time
-            if value.acts_like?(:time) && value.respond_to?(:usec)
-              zone_conversion_method = ActiveRecord::Base.default_timezone == :utc ? :getutc : :getlocal
-              value = value.send(zone_conversion_method) if value.respond_to?(zone_conversion_method)
-              result = value.to_s(:db)
-              precision = column.precision
-              case precision
-              when 1..6
-                "'#{result}.#{sprintf("%0#{precision}d", value.usec / 10**(6 - precision))}'"
-              else
-                "'#{result}'"
-              end
-            else
-              super
-            end
-          else
-            super
+        if value.acts_like?(:time)
+          zone_conversion_method = ActiveRecord::Base.default_timezone == :utc ? :getutc : :getlocal
+
+          if value.respond_to?(zone_conversion_method)
+            value = value.send(zone_conversion_method)
           end
         end
 
+        if (precision = column.precision) && value.respond_to?(:usec)
+          number_of_insignificant_digits = 6 - precision
+          round_power = 10 ** number_of_insignificant_digits
+          value = value.change(usec: value.usec / round_power * round_power)
+        end
+
+        result = value.to_s(:db)
+        if value.respond_to?(:usec) && value.usec > 0
+          "'#{result}.#{sprintf("%06d", value.usec)}'"
+        else
+          "'#{result}'"
+        end
+      end
+
+      if ActiveRecord::VERSION::STRING < "4.2.0"
         module Column
           def extract_limit(sql_type)
             case sql_type
-            when /^(?:date)?time/i; nil
+            when /time/i; nil
             else
               super
             end
@@ -144,8 +169,12 @@ module ActiveRecord
 
           def extract_precision(sql_type)
             case sql_type
-            when /^(?:date)?time/i
-              $1.to_i if sql_type =~ /\((\d+)(,\d+)?\)/
+            when /time/i
+              if sql_type =~ /\((\d+)(,\d+)?\)/
+                $1.to_i
+              else
+                0
+              end
             else
               super
             end
@@ -156,8 +185,8 @@ module ActiveRecord
 
         def initialize_type_map(m) # :nodoc:
           super
-          register_class_with_precision m, %r(time)i,     MysqlTime
-          register_class_with_precision m, %r(datetime)i, MysqlDateTime
+          register_class_with_precision m, %r(time)i,     Type::Time
+          register_class_with_precision m, %r(datetime)i, Type::DateTime
         end
 
         def register_class_with_precision(mapping, key, klass) # :nodoc:
@@ -167,59 +196,41 @@ module ActiveRecord
           end
         end
 
-        private
-
-        module TimeValueWithPrecision
-          def type_cast_for_database(value)
-            if value.acts_like?(:time) && value.respond_to?(:usec)
-              zone_conversion_method = ActiveRecord::Base.default_timezone == :utc ? :getutc : :getlocal
-              value = value.send(zone_conversion_method) if value.respond_to?(zone_conversion_method)
-              result = value.to_s(:db)
-              case precision
-              when 1..6
-                "#{result}.#{sprintf("%0#{precision}d", value.usec / 10**(6 - precision))}"
-              else
-                result
-              end
-            else
-              super
-            end
+        def extract_precision(sql_type)
+          if /time/ === sql_type
+            super || 0
+          else
+            super
           end
         end
-
-        class MysqlTime < Type::Time # :nodoc:
-          include TimeValueWithPrecision
-        end
-
-        class MysqlDateTime < Type::DateTime # :nodoc:
-          include TimeValueWithPrecision
-        end
       end
 
       public
 
+      def supports_datetime_with_precision?
+        (version[0] == 5 && version[1] >= 6) || version[0] >= 6
+      end
+
       def type_to_sql(type, limit = nil, precision = nil, scale = nil, unsigned = false)
-        return "#{type_to_sql(type, limit, precision, scale)} unsigned" if unsigned && type != :primary_key
-        case type.to_s
-        when 'integer'
+        sql = case type
+        when :integer
           case limit
           when nil, 4, 11; 'int'  # compatibility with MySQL default
           else
             super(type, limit, precision, scale)
           end
-        when 'primary_key'
-          "#{type_to_sql(:integer, limit, precision, scale, unsigned)} auto_increment PRIMARY KEY"
-        when 'datetime', 'time'
-          return super(type, limit, precision, scale) unless precision
-
-          native_type = native_database_types[type.to_sym][:name]
+        when :datetime, :time
           case precision
-          when 0..6; "#{native_type}(#{precision})"
-          else raise(ActiveRecordError, "No #{native_type} type has precision of #{precision}. The allowed range of precision is from 0 to 6")
+          when nil; super(type, limit, precision, scale)
+          when 0..6; "#{type}(#{precision})"
+          else raise(ActiveRecordError, "No #{type} type has precision of #{precision}. The allowed range of precision is from 0 to 6")
           end
         else
           super(type, limit, precision, scale)
         end
+
+        sql << ' unsigned' if unsigned && type != :primary_key
+        sql
       end
 
       def options_for_column_spec(table_name)
@@ -233,8 +244,9 @@ module ActiveRecord
       def column_spec_for_primary_key(column, options)
         spec = {}
         if column.auto_increment?
-          return unless column.bigint?
-          spec[:id] = ':bigint'
+          spec[:id] = ':bigint' if column.bigint?
+          spec[:unsigned] = 'true' if column.unsigned?
+          return if spec.empty?
         else
           spec[:id] = column.type.inspect
           spec.merge!(prepare_column_options(column, options).delete_if { |key, _| [:name, :type, :null].include?(key) })
@@ -244,6 +256,8 @@ module ActiveRecord
 
       def prepare_column_options(column, options) # :nodoc:
         spec = super
+        spec.delete(:precision) if /time/ === column.sql_type && column.precision == 0
+        spec.delete(:limit) if :boolean === column.type
         spec[:unsigned] = 'true' if column.unsigned?
         if column.collation && column.collation != options[:collation]
           spec[:collation] = column.collation.inspect
@@ -265,6 +279,12 @@ module ActiveRecord
         raw_table_options.sub(/(ENGINE=\w+)(?: AUTO_INCREMENT=\d+)/, '\1')
       end
 
+      def drop_table(table_name, options = {})
+        execute "DROP#{' TEMPORARY' if options[:temporary]} TABLE#{' IF EXISTS' if options[:if_exists]} #{quote_table_name(table_name)}#{' CASCADE' if options[:force] == :cascade}"
+      end
+
+      protected
+
       def add_column_sql(table_name, column_name, type, options = {})
         td = create_table_definition(table_name)
         cd = td.new_column_definition(column_name, type, options)

data/lib/activerecord/mysql/awesome/version.rb

@@ -1,7 +1,7 @@
 module ActiveRecord
   module Mysql
     module Awesome
-      VERSION = "0.0.4"
+      VERSION = "0.0.5"
     end
   end
 end

data/test/cases/date_time_precision_test.rb

@@ -0,0 +1,100 @@
+require 'cases/helper'
+require 'support/schema_dumping_helper'
+
+if ActiveRecord::Base.connection.supports_datetime_with_precision?
+class DateTimePrecisionTest < ActiveRecord::TestCase
+  include SchemaDumpingHelper
+
+  class Foo < ActiveRecord::Base; end
+
+  setup do
+    @connection = ActiveRecord::Base.connection
+  end
+
+  teardown do
+    @connection.schema_cache.clear!
+    @connection.drop_table :foos, if_exists: true
+  end
+
+  def test_datetime_data_type_with_precision
+    @connection.create_table(:foos, force: true)
+    @connection.add_column :foos, :created_at, :datetime, precision: 0
+    @connection.add_column :foos, :updated_at, :datetime, precision: 5
+    assert_equal 0, activerecord_column_option('foos', 'created_at', 'precision')
+    assert_equal 5, activerecord_column_option('foos', 'updated_at', 'precision')
+  end
+
+  def test_timestamps_helper_with_custom_precision
+    @connection.create_table(:foos, force: true) do |t|
+      t.timestamps null: false, precision: 4
+    end
+    assert_equal 4, activerecord_column_option('foos', 'created_at', 'precision')
+    assert_equal 4, activerecord_column_option('foos', 'updated_at', 'precision')
+  end
+
+  def test_passing_precision_to_datetime_does_not_set_limit
+    @connection.create_table(:foos, force: true) do |t|
+      t.timestamps null: false, precision: 4
+    end
+    assert_nil activerecord_column_option('foos', 'created_at', 'limit')
+    assert_nil activerecord_column_option('foos', 'updated_at', 'limit')
+  end
+
+  def test_invalid_datetime_precision_raises_error
+    assert_raises ActiveRecord::ActiveRecordError do
+      @connection.create_table(:foos, force: true) do |t|
+        t.timestamps null: false, precision: 7
+      end
+    end
+  end
+
+  def test_database_agrees_with_activerecord_about_precision
+    @connection.create_table(:foos, force: true) do |t|
+      t.timestamps null: false, precision: 4
+    end
+    assert_equal 4, database_datetime_precision('foos', 'created_at')
+    assert_equal 4, database_datetime_precision('foos', 'updated_at')
+  end
+
+  def test_formatting_datetime_according_to_precision
+    @connection.create_table(:foos, force: true) do |t|
+      t.datetime :created_at, precision: 0
+      t.datetime :updated_at, precision: 4
+    end
+    date = ::Time.utc(2014, 8, 17, 12, 30, 0, 999999)
+    Foo.create!(created_at: date, updated_at: date)
+    assert foo = Foo.find_by(created_at: date)
+    assert_equal 1, Foo.where(updated_at: date).count
+    assert_equal date.to_s, foo.created_at.to_s
+    assert_equal date.to_s, foo.updated_at.to_s
+    assert_equal 000000, foo.created_at.usec
+    assert_equal 999900, foo.updated_at.usec
+  end
+
+  def test_schema_dump_includes_datetime_precision
+    @connection.create_table(:foos, force: true) do |t|
+      t.timestamps null: false, precision: 6
+    end
+    output = dump_table_schema("foos")
+    assert_match %r{t\.datetime\s+"created_at",\s+precision: 6,\s+null: false$}, output
+    assert_match %r{t\.datetime\s+"updated_at",\s+precision: 6,\s+null: false$}, output
+  end
+
+  private
+
+  def database_datetime_precision(table_name, column_name)
+    results = @connection.exec_query("SELECT column_name, datetime_precision FROM information_schema.columns WHERE table_name = '#{table_name}'")
+    result = results.find do |result_hash|
+      result_hash["column_name"] == column_name
+    end
+    result && result["datetime_precision"].to_i
+  end
+
+  def activerecord_column_option(tablename, column_name, option)
+    result = @connection.columns(tablename).find do |column|
+      column.name == column_name
+    end
+    result && result.send(option)
+  end
+end
+end

data/test/cases/primary_keys_test.rb

@@ -0,0 +1,65 @@
+require 'cases/helper'
+require 'support/schema_dumping_helper'
+
+class PrimaryKeyAnyTypeTest < ActiveRecord::TestCase
+  include SchemaDumpingHelper
+
+  class Barcode < ActiveRecord::Base
+  end
+
+  setup do
+    @connection = ActiveRecord::Base.connection
+    @connection.create_table(:barcodes, primary_key: "code", id: :string, limit: 42, force: true)
+  end
+
+  teardown do
+    @connection.drop_table 'barcodes', if_exists: true
+  end
+
+  test "primary key with any type and options" do
+    assert_equal "code", Barcode.primary_key
+
+    column = Barcode.columns_hash[Barcode.primary_key]
+    assert_equal :string, column.type
+    assert_equal 42, column.limit
+  end
+
+  test "schema dump primary key includes type and options" do
+    schema = dump_table_schema "barcodes"
+    assert_match %r{create_table "barcodes", primary_key: "code", id: :string, limit: 42}, schema
+  end
+end
+
+class PrimaryKeyBigSerialTest < ActiveRecord::TestCase
+  include SchemaDumpingHelper
+
+  class Widget < ActiveRecord::Base
+  end
+
+  setup do
+    @connection = ActiveRecord::Base.connection
+    @connection.create_table(:widgets, id: :bigint, unsigned: true, force: true)
+  end
+
+  teardown do
+    @connection.drop_table 'widgets', if_exists: true
+  end
+
+  test "primary key column type with bigint" do
+    column = @connection.columns(:widgets).find { |c| c.name == 'id' }
+    assert column.auto_increment?
+    assert_equal :integer, column.type
+    assert_equal 8, column.limit
+    assert column.unsigned?
+  end
+
+  test "primary key with bigserial are automatically numbered" do
+    widget = Widget.create!
+    assert_not_nil widget.id
+  end
+
+  test "schema dump primary key with bigint" do
+    schema = dump_table_schema "widgets"
+    assert_match %r{create_table "widgets", id: :bigint, unsigned: true}, schema
+  end
+end

data/test/cases/time_precision_test.rb

@@ -0,0 +1,96 @@
+require 'cases/helper'
+require 'support/schema_dumping_helper'
+
+if ActiveRecord::Base.connection.supports_datetime_with_precision?
+class TimePrecisionTest < ActiveRecord::TestCase
+  include SchemaDumpingHelper
+
+  class Foo < ActiveRecord::Base; end
+
+  setup do
+    @connection = ActiveRecord::Base.connection
+  end
+
+  teardown do
+    @connection.schema_cache.clear!
+    @connection.drop_table :foos, if_exists: true
+  end
+
+  def test_time_data_type_with_precision
+    @connection.create_table(:foos, force: true)
+    @connection.add_column :foos, :start,  :time, precision: 3
+    @connection.add_column :foos, :finish, :time, precision: 6
+    assert_equal 3, activerecord_column_option('foos', 'start',  'precision')
+    assert_equal 6, activerecord_column_option('foos', 'finish', 'precision')
+  end
+
+  def test_passing_precision_to_time_does_not_set_limit
+    @connection.create_table(:foos, force: true) do |t|
+      t.time :start,  precision: 3
+      t.time :finish, precision: 6
+    end
+    assert_nil activerecord_column_option('foos', 'start',  'limit')
+    assert_nil activerecord_column_option('foos', 'finish', 'limit')
+  end
+
+  def test_invalid_time_precision_raises_error
+    assert_raises ActiveRecord::ActiveRecordError do
+      @connection.create_table(:foos, force: true) do |t|
+        t.time :start,  precision: 7
+        t.time :finish, precision: 7
+      end
+    end
+  end
+
+  def test_database_agrees_with_activerecord_about_precision
+    @connection.create_table(:foos, force: true) do |t|
+      t.time :start,  precision: 2
+      t.time :finish, precision: 4
+    end
+    assert_equal 2, database_datetime_precision('foos', 'start')
+    assert_equal 4, database_datetime_precision('foos', 'finish')
+  end
+
+  def test_formatting_time_according_to_precision
+    @connection.create_table(:foos, force: true) do |t|
+      t.time :start,  precision: 0
+      t.time :finish, precision: 4
+    end
+    time = ::Time.utc(2000, 1, 1, 12, 30, 0, 999999)
+    Foo.create!(start: time, finish: time)
+    assert foo = Foo.find_by(start: time)
+    assert_equal 1, Foo.where(finish: time).count
+    assert_equal time.to_s, foo.start.to_s
+    assert_equal time.to_s, foo.finish.to_s
+    assert_equal 000000, foo.start.usec
+    assert_equal 999900, foo.finish.usec
+  end
+
+  def test_schema_dump_includes_time_precision
+    @connection.create_table(:foos, force: true) do |t|
+      t.time :start,  precision: 4
+      t.time :finish, precision: 6
+    end
+    output = dump_table_schema("foos")
+    assert_match %r{t\.time\s+"start",\s+precision: 4$}, output
+    assert_match %r{t\.time\s+"finish",\s+precision: 6$}, output
+  end
+
+  private
+
+  def database_datetime_precision(table_name, column_name)
+    results = @connection.exec_query("SELECT column_name, datetime_precision FROM information_schema.columns WHERE table_name = '#{table_name}'")
+    result = results.find do |result_hash|
+      result_hash["column_name"] == column_name
+    end
+    result && result["datetime_precision"].to_i
+  end
+
+  def activerecord_column_option(tablename, column_name, option)
+    result = @connection.columns(tablename).find do |column|
+      column.name == column_name
+    end
+    result && result.send(option)
+  end
+end
+end

data/test/cases/unsigned_type_test.rb

@@ -10,7 +10,6 @@ class UnsignedTypeTest < ActiveRecord::TestCase
   setup do
     @connection = ActiveRecord::Base.connection
     @connection.create_table("unsigned_types", force: true) do |t|
-      t.column :unsigned_integer, "int unsigned"
       t.integer :unsigned_integer, unsigned: true
       t.float   :unsigned_float,   unsigned: true
       t.decimal :unsigned_decimal, unsigned: true, precision: 10, scale: 2
@@ -18,10 +17,15 @@ class UnsignedTypeTest < ActiveRecord::TestCase
   end
 
   teardown do
-    ActiveRecord::Base.connection.drop_table "unsigned_types"
+    @connection.drop_table "unsigned_types", if_exists: true
   end
 
-  def test_minus_value_is_out_of_range
+  test "unsigned int max value is in range" do
+    assert expected = UnsignedType.create(unsigned_integer: 4294967295)
+    assert_equal expected, UnsignedType.find_by(unsigned_integer: 4294967295)
+  end
+
+  test "minus value is out of range" do
     assert_raise(ActiveRecord::StatementInvalid, RangeError) do
       UnsignedType.create(unsigned_integer: -10)
     end
@@ -33,7 +37,17 @@ class UnsignedTypeTest < ActiveRecord::TestCase
     end
   end
 
-  def test_schema_dump_includes_unsigned_option
+  test "schema definition can use unsigned_integer type" do
+    @connection.change_table("unsigned_types") do |t|
+      t.unsigned_integer :unsigned_number
+    end
+
+    column = @connection.columns("unsigned_types").find { |c| c.name == 'unsigned_number' }
+    assert_equal :integer, column.type
+    assert column.unsigned?
+  end
+
+  test "schema dump includes unsigned option" do
     schema = dump_table_schema "unsigned_types"
     assert_match %r{t.integer\s+"unsigned_integer",(?:\s+limit: 4,)?\s+unsigned: true$}, schema
     assert_match %r{t.float\s+"unsigned_float",(?:\s+limit: 24,)?\s+unsigned: true$}, schema

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-mysql-awesome
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors:
 - Ryuta Kamizono
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-29 00:00:00.000000000 Z
+date: 2015-03-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -72,14 +72,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.3.18
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.3.18
 description: Awesome patches backported for ActiveRecord MySQL adapters
 email:
 - kamipo@gmail.com
@@ -105,12 +105,13 @@ files:
 - test/.gitignore
 - test/cases/bigint_pk_test.rb
 - test/cases/charset_collation_test.rb
-- test/cases/datetime_test.rb
+- test/cases/date_time_precision_test.rb
 - test/cases/helper.rb
-- test/cases/primary_key_any_type_test.rb
+- test/cases/primary_keys_test.rb
 - test/cases/strict_mode_test.rb
 - test/cases/table_options_test.rb
 - test/cases/test_case.rb
+- test/cases/time_precision_test.rb
 - test/cases/unsigned_type_test.rb
 - test/config.example.yml
 - test/config.rb
@@ -146,12 +147,13 @@ test_files:
 - test/.gitignore
 - test/cases/bigint_pk_test.rb
 - test/cases/charset_collation_test.rb
-- test/cases/datetime_test.rb
+- test/cases/date_time_precision_test.rb
 - test/cases/helper.rb
-- test/cases/primary_key_any_type_test.rb
+- test/cases/primary_keys_test.rb
 - test/cases/strict_mode_test.rb
 - test/cases/table_options_test.rb
 - test/cases/test_case.rb
+- test/cases/time_precision_test.rb
 - test/cases/unsigned_type_test.rb
 - test/config.example.yml
 - test/config.rb

data/test/cases/datetime_test.rb

@@ -1,98 +0,0 @@
-require 'cases/helper'
-require 'support/schema_dumping_helper'
-
-if mysql_56?
-  class DateTimeTest < ActiveRecord::TestCase
-    include SchemaDumpingHelper
-
-    class Foo < ActiveRecord::Base; end
-
-    def test_default_datetime_precision
-      ActiveRecord::Base.connection.create_table(:foos, force: true)
-      ActiveRecord::Base.connection.add_column :foos, :created_at, :datetime
-      ActiveRecord::Base.connection.add_column :foos, :updated_at, :datetime
-      assert_nil activerecord_column_option('foos', 'created_at', 'precision')
-    end
-
-    def test_datetime_data_type_with_precision
-      ActiveRecord::Base.connection.create_table(:foos, force: true)
-      ActiveRecord::Base.connection.add_column :foos, :created_at, :datetime, precision: 1
-      ActiveRecord::Base.connection.add_column :foos, :updated_at, :datetime, precision: 5
-      assert_equal 1, activerecord_column_option('foos', 'created_at', 'precision')
-      assert_equal 5, activerecord_column_option('foos', 'updated_at', 'precision')
-    end
-
-    def test_timestamps_helper_with_custom_precision
-      ActiveRecord::Base.connection.create_table(:foos, force: true) do |t|
-        t.timestamps null: true, precision: 4
-      end
-      assert_equal 4, activerecord_column_option('foos', 'created_at', 'precision')
-      assert_equal 4, activerecord_column_option('foos', 'updated_at', 'precision')
-    end
-
-    def test_passing_precision_to_datetime_does_not_set_limit
-      ActiveRecord::Base.connection.create_table(:foos, force: true) do |t|
-        t.timestamps null: true, precision: 4
-      end
-      assert_nil activerecord_column_option("foos", "created_at", "limit")
-      assert_nil activerecord_column_option("foos", "updated_at", "limit")
-    end
-
-    def test_invalid_datetime_precision_raises_error
-      assert_raises ActiveRecord::ActiveRecordError do
-        ActiveRecord::Base.connection.create_table(:foos, force: true) do |t|
-          t.timestamps null: true, precision: 7
-        end
-      end
-    end
-
-    def test_mysql_agrees_with_activerecord_about_precision
-      ActiveRecord::Base.connection.create_table(:foos, force: true) do |t|
-        t.timestamps null: true, precision: 4
-      end
-      assert_equal 4, mysql_datetime_precision('foos', 'created_at')
-      assert_equal 4, mysql_datetime_precision('foos', 'updated_at')
-    end
-
-    def test_datetime_format_according_to_precision
-      ActiveRecord::Base.connection.create_table(:foos, force: true) do |t|
-        t.datetime :created_at, precision: 0
-        t.datetime :updated_at, precision: 4
-      end
-      date = ::Time.utc(2014, 8, 17, 12, 30, 0, 999999)
-      Foo.create!(created_at: date, updated_at: date)
-      assert foo = Foo.find_by(created_at: date)
-      assert_equal date.to_s, foo.created_at.to_s
-      assert_equal date.to_s, foo.updated_at.to_s
-      assert_equal 000000, foo.created_at.usec
-      assert_equal 999900, foo.updated_at.usec
-    end
-
-    def test_schema_dump_includes_datetime_precision
-      ActiveRecord::Base.connection.create_table(:foos, force: true) do |t|
-        t.datetime :created_at, precision: 4
-        t.datetime :updated_at, precision: 6
-      end
-      schema = dump_table_schema "foos"
-      assert_match %r{t.datetime\s+"created_at",\s+precision: 4$}, schema
-      assert_match %r{t.datetime\s+"updated_at",\s+precision: 6$}, schema
-    end
-
-    private
-
-    def mysql_datetime_precision(table_name, column_name)
-      results = ActiveRecord::Base.connection.exec_query("SELECT column_name, datetime_precision FROM information_schema.columns WHERE table_name ='#{table_name}'")
-      result = results.find do |result_hash|
-        result_hash["column_name"] == column_name
-      end
-      result && result["datetime_precision"]
-    end
-
-    def activerecord_column_option(tablename, column_name, option)
-      result = ActiveRecord::Base.connection.columns(tablename).find do |column|
-        column.name == column_name
-      end
-      result && result.send(option)
-    end
-  end
-end

data/test/cases/primary_key_any_type_test.rb

@@ -1,31 +0,0 @@
-require 'cases/helper'
-require 'support/schema_dumping_helper'
-
-class PrimaryKeyAnyTypeTest < ActiveRecord::TestCase
-  include SchemaDumpingHelper
-
-  class Barcode < ActiveRecord::Base
-  end
-
-  setup do
-    @connection = ActiveRecord::Base.connection
-    @connection.create_table(:barcodes, primary_key: "code", id: :string, limit: 42, force: true)
-  end
-
-  teardown do
-    @connection.execute("DROP TABLE IF EXISTS barcodes")
-  end
-
-  test "primary key with any type and options" do
-    assert_equal "code", Barcode.primary_key
-
-    column = Barcode.columns_hash[Barcode.primary_key]
-    assert_equal :string, column.type
-    assert_equal 42, column.limit
-  end
-
-  test "schema dump primary key includes type and options" do
-    schema = dump_table_schema "barcodes"
-    assert_match %r{create_table "barcodes", primary_key: "code", id: :string, limit: 42}, schema
-  end
-end