[Rails5] Support for supports_datetime_with_precision.

Author: metaskills

CHANGELOG.md

@@ -3,7 +3,7 @@
 
 #### Added
 
-* ...
+* Support for `supports_datetime_with_precision`.
 
 #### Changed
 

lib/active_record/connection_adapters/sqlserver/schema_statements.rb

@@ -188,6 +188,16 @@ def type_to_sql(type, limit = nil, precision = nil, scale = nil)
             when 5..8       then  'bigint'
             else raise(ActiveRecordError, "No integer type has byte size #{limit}. Use a numeric with precision 0 instead.")
             end
+          when 'datetime2'
+            column_type_sql = super
+            if precision
+              if (0..7) === precision
+                column_type_sql << "(#{precision})"
+              else
+                raise(ActiveRecordError, "The dattime2 type has precision of #{precision}. The allowed range of precision is from 0 to 7")
+              end
+            end
+            column_type_sql
           else
             super
           end
@@ -202,6 +212,10 @@ def columns_for_distinct(columns, orders)
           [super, *order_columns].join(', ')
         end
 
+        def update_table_definition(table_name, base)
+          SQLServer::Table.new(table_name, base)
+        end
+
         def change_column_null(table_name, column_name, allow_null, default = nil)
           table_id = SQLServer::Utils.extract_identifiers(table_name)
           column_id = SQLServer::Utils.extract_identifiers(column_name)

lib/active_record/connection_adapters/sqlserver/table_definition.rb

@@ -1,7 +1,8 @@
 module ActiveRecord
   module ConnectionAdapters
     module SQLServer
-      class TableDefinition < ActiveRecord::ConnectionAdapters::TableDefinition
+
+      module ColumnMethods
 
         def primary_key(name, type = :primary_key, **options)
           return super unless type == :uuid
@@ -10,67 +11,90 @@ def primary_key(name, type = :primary_key, **options)
           column name, type, options
         end
 
-        def real(name, options = {})
-          column(name, :real, options)
+        def real(*args, **options)
+          args.each { |name| column(name, :real, options) }
+        end
+
+        def money(*args, **options)
+          args.each { |name| column(name, :money, options) }
         end
 
-        def money(name, options = {})
-          column(name, :money, options)
+        def datetime(*args, **options)
+          args.each do |name|
+            if options[:precision]
+              datetime2(name, options)
+            else
+              column(name, :datetime, options)
+            end
+          end
         end
 
-        def datetime2(name, options = {})
-          column(name, :datetime2, options)
+        def datetime2(*args, **options)
+          args.each { |name| column(name, :datetime2, options) }
         end
 
-        def datetimeoffset(name, options = {})
-          column(name, :datetimeoffset, options)
+        def datetimeoffset(*args, **options)
+          args.each { |name| column(name, :datetimeoffset, options) }
         end
 
-        def smallmoney(name, options = {})
-          column(name, :smallmoney, options)
+        def smallmoney(*args, **options)
+          args.each { |name| column(name, :smallmoney, options) }
         end
 
-        def char(name, options = {})
-          column(name, :char, options)
+        def char(*args, **options)
+          args.each { |name| column(name, :char, options) }
         end
 
-        def varchar(name, options = {})
-          column(name, :varchar, options)
+        def varchar(*args, **options)
+          args.each { |name| column(name, :varchar, options) }
         end
 
-        def varchar_max(name, options = {})
-          column(name, :varchar_max, options)
+        def varchar_max(*args, **options)
+          args.each { |name| column(name, :varchar_max, options) }
         end
 
-        def text_basic(name, options = {})
-          column(name, :text_basic, options)
+        def text_basic(*args, **options)
+          args.each { |name| column(name, :text_basic, options) }
         end
 
-        def nchar(name, options = {})
-          column(name, :nchar, options)
+        def nchar(*args, **options)
+          args.each { |name| column(name, :nchar, options) }
         end
 
-        def ntext(name, options = {})
-          column(name, :ntext, options)
+        def ntext(*args, **options)
+          args.each { |name| column(name, :ntext, options) }
         end
 
-        def binary_basic(name, options = {})
-          column(name, :binary_basic, options)
+        def binary_basic(*args, **options)
+          args.each { |name| column(name, :binary_basic, options) }
         end
 
-        def varbinary(name, options = {})
-          column(name, :varbinary, options)
+        def varbinary(*args, **options)
+          args.each { |name| column(name, :varbinary, options) }
         end
 
-        def uuid(name, options = {})
-          column(name, :uniqueidentifier, options)
+        def uuid(*args, **options)
+          args.each { |name| column(name, :uniqueidentifier, options) }
         end
 
-        def ss_timestamp(name, options = {})
-          column(name, :ss_timestamp, options)
+        def ss_timestamp(*args, **options)
+          args.each { |name| column(name, :ss_timestamp, options) }
         end
 
       end
+
+      class TableDefinition < ActiveRecord::ConnectionAdapters::TableDefinition
+        include ColumnMethods
+
+        def new_column_definition(name, type, options)
+          type = :datetime2 if type == :datetime && options[:precision]
+          super name, type, options
+        end
+      end
+
+      class Table < ActiveRecord::ConnectionAdapters::Table
+        include ColumnMethods
+      end
     end
   end
 end

lib/active_record/connection_adapters/sqlserver/type/datetime.rb

@@ -6,11 +6,6 @@ class DateTime < ActiveRecord::Type::DateTime
 
           include TimeValueFractional
 
-          def initialize(*args)
-            super
-            @precision = nil if self.class == DateTime
-          end
-
           def sqlserver_type
             'datetime'.freeze
           end

lib/active_record/connection_adapters/sqlserver/type/time_value_fractional.rb

@@ -9,18 +9,20 @@ module TimeValueFractional
 
           def apply_seconds_precision(value)
             return value if !value.respond_to?(fractional_property) || value.send(fractional_property).zero?
-            frac_seconds = if fractional_scale == 0
-                             0
-                           else
-                             seconds = value.send(fractional_property).to_f / fractional_operator.to_f
-                             seconds = ((seconds * (1 / fractional_precision)).round / (1 / fractional_precision)).round(fractional_scale)
-                             (seconds * fractional_operator).to_i
-                           end
-            value.change fractional_property => frac_seconds
+            value.change fractional_property => seconds_precision(value)
+          end
+
+          def seconds_precision(value)
+            return 0 if fractional_scale == 0
+            seconds = value.send(fractional_property).to_f / fractional_operator.to_f
+            seconds = ((seconds * (1 / fractional_precision)).round / (1 / fractional_precision)).round(fractional_scale)
+            (seconds * fractional_operator).round(0).to_i
           end
 
           def quote_fractional(value)
-            seconds = (value.send(fractional_property).to_f / fractional_operator.to_f).round(fractional_scale)
+            return 0 if fractional_scale == 0
+            frac_seconds = seconds_precision(value)
+            seconds = (frac_seconds.to_f / fractional_operator.to_f).round(fractional_scale)
             seconds.to_d.to_s.split('.').last.to(fractional_scale-1)
           end
 
@@ -52,6 +54,11 @@ module TimeValueFractional2
 
           private
 
+          def seconds_precision(value)
+            seconds = super
+            seconds > fractional_max ? fractional_scale_max : seconds
+          end
+
           def fractional_property
             :nsec
           end
@@ -68,6 +75,14 @@ def fractional_scale
             precision
           end
 
+          def fractional_max
+            999999999
+          end
+
+          def fractional_scale_max
+            ('9' * fractional_scale) + ('0' * (fractional_digits - fractional_scale))
+          end
+
         end
 
       end

lib/active_record/connection_adapters/sqlserver_adapter.rb

@@ -128,7 +128,7 @@ def supports_views?
       end
 
       def supports_datetime_with_precision?
-        false
+        true
       end
 
       def supports_json?
@@ -268,10 +268,13 @@ def initialize_type_map(m)
         m.register_type              'real',              SQLServer::Type::Real.new
         # Date and Time
         m.register_type              'date',              SQLServer::Type::Date.new
-        m.register_type              'datetime',          SQLServer::Type::DateTime.new
-        m.register_type              %r{\Adatetime2}i do |sql_type|
+        m.register_type              %r{\Adatetime} do |sql_type|
           precision = extract_precision(sql_type)
-          SQLServer::Type::DateTime2.new precision: precision
+          if precision
+            SQLServer::Type::DateTime2.new precision: precision
+          else
+            SQLServer::Type::DateTime.new
+          end
         end
         m.register_type              %r{\Adatetimeoffset}i do |sql_type|
           precision = extract_precision(sql_type)

test/cases/coerced_tests.rb

@@ -612,3 +612,29 @@ def test_types_of_virtual_columns_are_not_changed_on_round_trip_coerced
     assert_equal 5, dumped.posts_count
   end
 end
+
+
+
+
+class DateTimePrecisionTest < ActiveRecord::TestCase
+  # Original test had `7` which we support vs `8` which we use.
+  coerce_tests! :test_invalid_datetime_precision_raises_error
+  def test_invalid_datetime_precision_raises_error_coerced
+    assert_raises ActiveRecord::ActiveRecordError do
+      @connection.create_table(:foos, force: true) do |t|
+        t.timestamps precision: 8
+      end
+    end
+  end
+
+  # Original test uses `datetime` vs `datetime2` type which we dynamically use.
+  coerce_tests! :test_schema_dump_includes_datetime_precision
+  def test_schema_dump_includes_datetime_precision_coerced
+    @connection.create_table(:foos, force: true) do |t|
+      t.timestamps precision: 6
+    end
+    output = dump_table_schema("foos")
+    assert_match %r{t\.datetime2\s+"created_at",\s+precision: 6,\s+null: false$}, output
+    assert_match %r{t\.datetime2\s+"updated_at",\s+precision: 6,\s+null: false$}, output
+  end
+end