activerecord-jdbc-alt-adapter 61.2.0-java → 70.0.0.rc2-java

data/lib/arjdbc/mssql/adapter.rb

@@ -35,14 +35,15 @@ module ActiveRecord
       ADAPTER_NAME = 'MSSQL'.freeze
 
       MSSQL_VERSION_YEAR = {
-        8 => '2000',
-        9 => '2005',
+        8  => '2000',
+        9  => '2005',
         10 => '2008',
         11 => '2012',
         12 => '2014',
         13 => '2016',
         14 => '2017',
-        15 => '2019'
+        15 => '2019',
+        16 => '2022'
       }.freeze
 
       include Jdbc::ConnectionPoolCallbacks
@@ -143,13 +144,32 @@ module ActiveRecord
       def supports_insert_on_conflict?
         false
       end
+
       alias supports_insert_on_duplicate_skip? supports_insert_on_conflict?
       alias supports_insert_on_duplicate_update? supports_insert_on_conflict?
       alias supports_insert_conflict_target? supports_insert_on_conflict?
 
+      def supports_insert_returning?
+        true
+      end
+
       def build_insert_sql(insert) # :nodoc:
         # TODO: hope we can implement an upsert like feature
-        "INSERT #{insert.into} #{insert.values_list}"
+        # "INSERT #{insert.into} #{insert.values_list}"
+        sql = +"INSERT #{insert.into}"
+
+        if returning = insert.send(:insert_all).returning
+          returning_sql = if returning.is_a?(String)
+                            returning
+                          else
+                            returning.map { |column| "INSERTED.#{quote_column_name(column)}" }.join(', ')
+                          end
+
+          sql << " OUTPUT #{returning_sql}"
+        end
+
+        sql << " #{insert.values_list}"
+        sql
       end
 
       # Overrides abstract method which always returns false
@@ -158,7 +178,7 @@ module ActiveRecord
       end
 
       def clear_cache!
-        reload_type_map
+        # reload_type_map
         super
       end
 
@@ -309,8 +329,121 @@ module ActiveRecord
         end
       end
 
+      class << self
+        private
+
+        # This method is called indirectly by the abstract method
+        # 'fetch_type_metadata' which then it is called by the java part when
+        # calculating a table's columns.
+        def initialize_type_map(map)
+          # Build the type mapping from SQL Server to ActiveRecord
+
+          # Integer types.
+          map.register_type 'int',      MSSQL::Type::Integer.new(limit: 4)
+          map.register_type 'tinyint',  MSSQL::Type::TinyInteger.new(limit: 1)
+          map.register_type 'smallint', MSSQL::Type::SmallInteger.new(limit: 2)
+          map.register_type 'bigint',   MSSQL::Type::BigInteger.new(limit: 8)
+
+          # Exact Numeric types.
+          map.register_type %r{\Adecimal}i do |sql_type|
+            scale = extract_scale(sql_type)
+            precision = extract_precision(sql_type)
+            if scale == 0
+              MSSQL::Type::DecimalWithoutScale.new(precision: precision)
+            else
+              MSSQL::Type::Decimal.new(precision: precision, scale: scale)
+            end
+          end
+          map.register_type %r{\Amoney\z}i,      MSSQL::Type::Money.new
+          map.register_type %r{\Asmallmoney\z}i, MSSQL::Type::SmallMoney.new
+
+          # Approximate Numeric types.
+          map.register_type %r{\Afloat\z}i,    MSSQL::Type::Float.new
+          map.register_type %r{\Areal\z}i,     MSSQL::Type::Real.new
+
+          # Character strings CHAR and VARCHAR (it can become Unicode UTF-8)
+          map.register_type 'varchar(max)', MSSQL::Type::VarcharMax.new
+          map.register_type %r{\Avarchar\(\d+\)} do |sql_type|
+            limit = extract_limit(sql_type)
+            MSSQL::Type::Varchar.new(limit: limit)
+          end
+          map.register_type %r{\Achar\(\d+\)} do |sql_type|
+            limit = extract_limit(sql_type)
+            MSSQL::Type::Char.new(limit: limit)
+          end
+
+          # Character strings NCHAR and NVARCHAR (by default Unicode UTF-16)
+          map.register_type %r{\Anvarchar\(\d+\)} do |sql_type|
+            limit = extract_limit(sql_type)
+            MSSQL::Type::Nvarchar.new(limit: limit)
+          end
+          map.register_type %r{\Anchar\(\d+\)} do |sql_type|
+            limit = extract_limit(sql_type)
+            MSSQL::Type::Nchar.new(limit: limit)
+          end
+          map.register_type 'nvarchar(max)', MSSQL::Type::NvarcharMax.new
+          map.register_type 'nvarchar(4000)', MSSQL::Type::Nvarchar.new
+
+          # Binary data types.
+          map.register_type              'varbinary(max)',       MSSQL::Type::VarbinaryMax.new
+          register_class_with_limit map, %r{\Abinary\(\d+\)},    MSSQL::Type::BinaryBasic
+          register_class_with_limit map, %r{\Avarbinary\(\d+\)}, MSSQL::Type::Varbinary
+
+          # Miscellaneous types, Boolean, XML, UUID
+          # FIXME The xml data needs to be reviewed and fixed
+          map.register_type 'bit',                     MSSQL::Type::Boolean.new
+          map.register_type %r{\Auniqueidentifier\z}i, MSSQL::Type::UUID.new
+          map.register_type %r{\Axml\z}i,              MSSQL::Type::XML.new
+
+          # Date and time types
+          map.register_type 'date',          MSSQL::Type::Date.new
+          map.register_type 'datetime',      MSSQL::Type::DateTime.new
+          map.register_type 'smalldatetime', MSSQL::Type::SmallDateTime.new
+          register_class_with_precision map, %r{\Atime\(\d+\)}i, MSSQL::Type::Time
+          map.register_type 'time(7)',       MSSQL::Type::Time.new
+          register_class_with_precision map, %r{\Adatetime2\(\d+\)}i, MSSQL::Type::DateTime2
+          # map.register_type 'datetime2(7)',  MSSQL::Type::DateTime2.new
+
+          # TODO: we should have identity separated from the sql_type
+          # let's say in another attribute (this will help to pass more AR tests),
+          # also we add collation attribute per column.
+          # aliases
+          map.alias_type 'int identity',    'int'
+          map.alias_type 'bigint identity', 'bigint'
+          map.alias_type 'integer',         'int'
+          map.alias_type 'integer',         'int'
+          map.alias_type 'INTEGER',         'int'
+          map.alias_type 'TINYINT',         'tinyint'
+          map.alias_type 'SMALLINT',        'smallint'
+          map.alias_type 'BIGINT',          'bigint'
+          map.alias_type %r{\Anumeric}i,    'decimal'
+          map.alias_type %r{\Anumber}i,     'decimal'
+          map.alias_type %r{\Adouble\z}i,   'float'
+          map.alias_type 'string',          'nvarchar(4000)'
+          map.alias_type %r{\Aboolean\z}i,  'bit'
+          map.alias_type 'DATE',            'date'
+          map.alias_type 'DATETIME',        'datetime'
+          map.alias_type 'SMALLDATETIME',   'smalldatetime'
+          map.alias_type %r{\Atime\z}i,     'time(7)'
+          map.alias_type %r{\Abinary\z}i,   'varbinary(max)'
+          map.alias_type %r{\Ablob\z}i,     'varbinary(max)'
+          map.alias_type %r{\Adatetime2\z}i, 'datetime2(7)'
+
+          # Deprecated SQL Server types.
+          map.register_type 'text',  MSSQL::Type::Text.new
+          map.register_type 'ntext', MSSQL::Type::Ntext.new
+          map.register_type 'image', MSSQL::Type::Image.new
+        end
+      end
+
+      TYPE_MAP = Type::TypeMap.new.tap { |m| initialize_type_map(m) }
+
       private
 
+      def type_map
+        TYPE_MAP
+      end
+
       def translate_exception(exception, message:, sql:, binds:)
         case message
         when /no connection available/i
@@ -334,109 +467,6 @@ module ActiveRecord
         end
       end
 
-      # This method is called indirectly by the abstract method
-      # 'fetch_type_metadata' which then it is called by the java part when
-      # calculating a table's columns.
-      def initialize_type_map(map = type_map)
-        # Build the type mapping from SQL Server to ActiveRecord
-
-        # Integer types.
-        map.register_type 'int',      MSSQL::Type::Integer.new(limit: 4)
-        map.register_type 'tinyint',  MSSQL::Type::TinyInteger.new(limit: 1)
-        map.register_type 'smallint', MSSQL::Type::SmallInteger.new(limit: 2)
-        map.register_type 'bigint',   MSSQL::Type::BigInteger.new(limit: 8)
-
-        # Exact Numeric types.
-        map.register_type %r{\Adecimal}i do |sql_type|
-          scale = extract_scale(sql_type)
-          precision = extract_precision(sql_type)
-          if scale == 0
-            MSSQL::Type::DecimalWithoutScale.new(precision: precision)
-          else
-            MSSQL::Type::Decimal.new(precision: precision, scale: scale)
-          end
-        end
-        map.register_type %r{\Amoney\z}i,      MSSQL::Type::Money.new
-        map.register_type %r{\Asmallmoney\z}i, MSSQL::Type::SmallMoney.new
-
-        # Approximate Numeric types.
-        map.register_type %r{\Afloat\z}i,    MSSQL::Type::Float.new
-        map.register_type %r{\Areal\z}i,     MSSQL::Type::Real.new
-
-        # Character strings CHAR and VARCHAR (it can become Unicode UTF-8)
-        map.register_type 'varchar(max)', MSSQL::Type::VarcharMax.new
-        map.register_type %r{\Avarchar\(\d+\)} do |sql_type|
-          limit = extract_limit(sql_type)
-          MSSQL::Type::Varchar.new(limit: limit)
-        end
-        map.register_type %r{\Achar\(\d+\)} do |sql_type|
-          limit = extract_limit(sql_type)
-          MSSQL::Type::Char.new(limit: limit)
-        end
-
-        # Character strings NCHAR and NVARCHAR (by default Unicode UTF-16)
-        map.register_type %r{\Anvarchar\(\d+\)} do |sql_type|
-          limit = extract_limit(sql_type)
-          MSSQL::Type::Nvarchar.new(limit: limit)
-        end
-        map.register_type %r{\Anchar\(\d+\)} do |sql_type|
-          limit = extract_limit(sql_type)
-          MSSQL::Type::Nchar.new(limit: limit)
-        end
-        map.register_type 'nvarchar(max)', MSSQL::Type::NvarcharMax.new
-        map.register_type 'nvarchar(4000)', MSSQL::Type::Nvarchar.new
-
-        # Binary data types.
-        map.register_type              'varbinary(max)',       MSSQL::Type::VarbinaryMax.new
-        register_class_with_limit map, %r{\Abinary\(\d+\)},    MSSQL::Type::BinaryBasic
-        register_class_with_limit map, %r{\Avarbinary\(\d+\)}, MSSQL::Type::Varbinary
-
-        # Miscellaneous types, Boolean, XML, UUID
-        # FIXME The xml data needs to be reviewed and fixed
-        map.register_type 'bit',                     MSSQL::Type::Boolean.new
-        map.register_type %r{\Auniqueidentifier\z}i, MSSQL::Type::UUID.new
-        map.register_type %r{\Axml\z}i,              MSSQL::Type::XML.new
-
-        # Date and time types
-        map.register_type 'date',          MSSQL::Type::Date.new
-        map.register_type 'datetime',      MSSQL::Type::DateTime.new
-        map.register_type 'smalldatetime', MSSQL::Type::SmallDateTime.new
-        register_class_with_precision map, %r{\Atime\(\d+\)}i, MSSQL::Type::Time
-        map.register_type 'time(7)',       MSSQL::Type::Time.new
-        register_class_with_precision map, %r{\Adatetime2\(\d+\)}i, MSSQL::Type::DateTime2
-        map.register_type 'datetime2(7)',  MSSQL::Type::DateTime2.new
-
-        # TODO: we should have identity separated from the sql_type
-        # let's say in another attribute (this will help to pass more AR tests),
-        # also we add collation attribute per column.
-        # aliases
-        map.alias_type 'int identity',    'int'
-        map.alias_type 'bigint identity', 'bigint'
-        map.alias_type 'integer',         'int'
-        map.alias_type 'integer',         'int'
-        map.alias_type 'INTEGER',         'int'
-        map.alias_type 'TINYINT',         'tinyint'
-        map.alias_type 'SMALLINT',        'smallint'
-        map.alias_type 'BIGINT',          'bigint'
-        map.alias_type %r{\Anumeric}i,    'decimal'
-        map.alias_type %r{\Anumber}i,     'decimal'
-        map.alias_type %r{\Adouble\z}i,   'float'
-        map.alias_type 'string',          'nvarchar(4000)'
-        map.alias_type %r{\Aboolean\z}i,  'bit'
-        map.alias_type 'DATE',            'date'
-        map.alias_type 'DATETIME',        'datetime'
-        map.alias_type 'SMALLDATETIME',   'smalldatetime'
-        map.alias_type %r{\Atime\z}i,     'time(7)'
-        map.alias_type %r{\Abinary\z}i,   'varbinary(max)'
-        map.alias_type %r{\Ablob\z}i,     'varbinary(max)'
-        map.alias_type %r{\Adatetime2\z}i, 'datetime2(7)'
-
-        # Deprecated SQL Server types.
-        map.register_type 'text',  MSSQL::Type::Text.new
-        map.register_type 'ntext', MSSQL::Type::Ntext.new
-        map.register_type 'image', MSSQL::Type::Image.new
-      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.
       # NOTE: This is ready, all implemented in the java part of adapter,

data/lib/arjdbc/mssql/quoting.rb

@@ -4,8 +4,30 @@ module ActiveRecord
   module ConnectionAdapters
     module MSSQL
       module Quoting
-        QUOTED_TRUE  = '1'.freeze
-        QUOTED_FALSE = '0'.freeze
+        QUOTED_TRUE  = '1'
+        QUOTED_FALSE = '0'
+
+        def quote(value)
+          # FIXME: this needs improvements to handle other custom types.
+          # Also check if it's possible insert integer into a NVARCHAR
+          case value
+          when ActiveRecord::Type::Binary::Data
+            "0x#{value.hex}"
+          # when SomeOtherBinaryData then BLOB_VALUE_MARKER
+          # when SomeOtherData then "yyy"
+          when String, ActiveSupport::Multibyte::Chars
+            "N'#{quote_string(value)}'"
+          # when OnlyTimeType then "'#{quoted_time(value)}'"
+          when Date, Time
+            "'#{quoted_date(value)}'"
+          when TrueClass
+            quoted_true
+          when FalseClass
+            quoted_false
+          else
+            super
+          end
+        end
 
         # Quote date/time values for use in SQL input, includes microseconds
         # with three digits only if the value is a Time responding to usec.
@@ -15,7 +37,7 @@ module ActiveRecord
             value = time_with_db_timezone(value)
           end
 
-          result = value.to_s(:db)
+          result = value.to_fs(:db)
 
           if value.respond_to?(:usec) && value.usec > 0
             "#{result}.#{sprintf("%06d", value.usec)}"
@@ -105,7 +127,7 @@ module ActiveRecord
         private
 
         def time_with_db_timezone(value)
-          zone_conv_method = if ActiveRecord::Base.default_timezone == :utc
+          zone_conv_method = if ActiveRecord.default_timezone == :utc
                                :getutc
                              else
                                :getlocal
@@ -117,29 +139,6 @@ module ActiveRecord
             value
           end
         end
-
-        # @override
-        # FIXME: it need to be improved to handle other custom types.
-        # Also check if it's possible insert integer into a NVARCHAR
-        def _quote(value)
-          case value
-          when ActiveRecord::Type::Binary::Data
-            "0x#{value.hex}"
-          # when SomeOtherBinaryData then BLOB_VALUE_MARKER
-          # when SomeOtherData then "yyy"
-          when String, ActiveSupport::Multibyte::Chars
-            "N'#{quote_string(value)}'"
-          # when OnlyTimeType then "'#{quoted_time(value)}'"
-          when Date, Time
-            "'#{quoted_date(value)}'"
-          when TrueClass
-            quoted_true
-          when FalseClass
-            quoted_false
-          else
-            super
-          end
-        end
       end
     end
   end

data/lib/arjdbc/mssql/schema_creation.rb

@@ -29,7 +29,7 @@ module ActiveRecord
             end
 
             if supports_foreign_keys?
-              statements.concat(o.foreign_keys.map { |to_table, options| foreign_key_in_create(o.name, to_table, options) })
+              statements.concat(o.foreign_keys.map { |fk| accept fk })
             end
 
             create_sql << "(#{statements.join(', ')})" if statements.present?

data/lib/arjdbc/mssql/schema_definitions.rb

@@ -14,80 +14,95 @@ module ActiveRecord
 
         # datetime with seconds always zero (:00) and without fractional seconds
         def smalldatetime(*args, **options)
-          args.each { |name| column(name, :smalldatetime, options) }
+          args.each { |name| column(name, :smalldatetime, **options) }
         end
 
         # this is the old sql server datetime type, the precision is as follow
         # xx1, xx3, and xx7
         def datetime_basic(*args, **options)
-          args.each { |name| column(name, :datetime_basic, options) }
+          args.each { |name| column(name, :datetime_basic, **options) }
         end
 
         def real(*args, **options)
-          args.each { |name| column(name, :real, options) }
+          args.each { |name| column(name, :real, **options) }
         end
 
         def money(*args, **options)
-          args.each { |name| column(name, :money, options) }
+          args.each { |name| column(name, :money, **options) }
         end
 
         def smallmoney(*args, **options)
-          args.each { |name| column(name, :smallmoney, options) }
+          args.each { |name| column(name, :smallmoney, **options) }
         end
 
         def char(*args, **options)
-          args.each { |name| column(name, :char, options) }
+          args.each { |name| column(name, :char, **options) }
         end
 
         def varchar(*args, **options)
-          args.each { |name| column(name, :varchar, options) }
+          args.each { |name| column(name, :varchar, **options) }
         end
 
         def varchar_max(*args, **options)
-          args.each { |name| column(name, :varchar_max, options) }
+          args.each { |name| column(name, :varchar_max, **options) }
         end
 
         def text_basic(*args, **options)
-          args.each { |name| column(name, :text_basic, options) }
+          args.each { |name| column(name, :text_basic, **options) }
         end
 
         def nchar(*args, **options)
-          args.each { |name| column(name, :nchar, options) }
+          args.each { |name| column(name, :nchar, **options) }
         end
 
         def ntext(*args, **options)
-          args.each { |name| column(name, :ntext, options) }
+          args.each { |name| column(name, :ntext, **options) }
         end
 
         def binary_basic(*args, **options)
-          args.each { |name| column(name, :binary_basic, options) }
+          args.each { |name| column(name, :binary_basic, **options) }
         end
 
         def varbinary(*args, **options)
-          args.each { |name| column(name, :varbinary, options) }
+          args.each { |name| column(name, :varbinary, **options) }
         end
 
         def uuid(*args, **options)
-          args.each { |name| column(name, :uniqueidentifier, options) }
+          args.each { |name| column(name, :uniqueidentifier, **options) }
         end
       end
 
       class TableDefinition < ActiveRecord::ConnectionAdapters::TableDefinition
         include ColumnMethods
 
+        def column(name, type, index: nil, **options)
+          # TODO: remove this when the below changed is released
+          #   Fix erroneous nil default precision on virtual datetime columns #46110
+          #   https://github.com/rails/rails/pull/46110
+          #
+          if @conn.supports_datetime_with_precision?
+            if type == :datetime && !options.key?(:precision)
+              options[:precision] = 7
+            end
+          end
+
+          super
+        end
+
+
         def new_column_definition(name, type, **options)
           case type
           when :primary_key
             options[:is_identity] = true
+          when :datetime
+            options[:precision] = 7 if !options.key?(:precision) && @conn.supports_datetime_with_precision?
           end
 
           super
         end
 
         def timestamps(**options)
-          if !options.key?(:precision) && @conn.supports_datetime_with_precision?
-            options[:precision] = 7
-          end
+          options[:precision] = 7 if !options.key?(:precision) && @conn.supports_datetime_with_precision?
 
           super
         end

data/lib/arjdbc/mssql/schema_dumper.rb

@@ -28,11 +28,23 @@ module ActiveRecord
           super && column.identity?
         end
 
+        def schema_precision(column)
+          case column.type
+          when :datetime
+            if column.precision == 7
+              nil
+            else
+              column.precision.inspect
+            end
+          else
+            super
+          end
+        end
+
         # def schema_collation(column)
         #   return unless column.collation
         #   column.collation if column.collation != collation
         # end
-
       end
     end
   end

data/lib/arjdbc/mssql/schema_statements.rb

@@ -7,36 +7,36 @@ module ActiveRecord
 
         NATIVE_DATABASE_TYPES = {
           # Logical Rails types to SQL Server types
-          primary_key:   'bigint NOT NULL IDENTITY(1,1) PRIMARY KEY',
-          integer:       { name: 'int', limit: 4 },
-          boolean:       { name: 'bit' },
-          decimal:       { name: 'decimal' },
-          float:         { name: 'float' },
-          date:          { name: 'date' },
-          time:          { name: 'time' },
-          datetime:      { name: 'datetime2' },
-          string:        { name: 'nvarchar', limit: 4000 },
-          text:          { name: 'nvarchar(max)' },
-          binary:        { name: 'varbinary(max)' },
+          primary_key:    'bigint NOT NULL IDENTITY(1,1) PRIMARY KEY',
+          integer:        { name: 'int', limit: 4 },
+          boolean:        { name: 'bit' },
+          decimal:        { name: 'decimal' },
+          float:          { name: 'float' },
+          date:           { name: 'date' },
+          time:           { name: 'time' },
+          datetime:       { name: 'datetime2' },
+          string:         { name: 'nvarchar', limit: 4000 },
+          text:           { name: 'nvarchar(max)' },
+          binary:         { name: 'varbinary(max)' },
           # Other types or SQL Server specific
-          bigint:        { name: 'bigint' },
-          smalldatetime: { name: 'smalldatetime' },
+          bigint:         { name: 'bigint' },
+          smalldatetime:  { name: 'smalldatetime' },
           datetime_basic: { name: 'datetime' },
-          timestamp:     { name: 'datetime' },
-          real:          { name: 'real' },
-          money:         { name: 'money' },
-          smallmoney:    { name: 'smallmoney' },
-          char:          { name: 'char' },
-          nchar:         { name: 'nchar' },
-          varchar:       { name: 'varchar', limit: 8000 },
-          varchar_max:   { name: 'varchar(max)' },
-          uuid:          { name: 'uniqueidentifier' },
-          binary_basic:  { name: 'binary' },
-          varbinary:     { name: 'varbinary', limit: 8000 },
+          timestamp:      { name: 'datetime' },
+          real:           { name: 'real' },
+          money:          { name: 'money' },
+          smallmoney:     { name: 'smallmoney' },
+          char:           { name: 'char' },
+          nchar:          { name: 'nchar' },
+          varchar:        { name: 'varchar', limit: 8000 },
+          varchar_max:    { name: 'varchar(max)' },
+          uuid:           { name: 'uniqueidentifier' },
+          binary_basic:   { name: 'binary' },
+          varbinary:      { name: 'varbinary', limit: 8000 },
           # Deprecated SQL Server types
-          image:         { name: 'image' },
-          ntext:         { name: 'ntext' },
-          text_basic:    { name: 'text' }
+          image:          { name: 'image' },
+          ntext:          { name: 'ntext' },
+          text_basic:     { name: 'text' }
         }.freeze
 
         def native_database_types
@@ -127,9 +127,17 @@ module ActiveRecord
           create_database(name, options)
         end
 
-        def remove_column(table_name, column_name, type = nil, options = {})
-          raise ArgumentError.new('You must specify at least one column name.  Example: remove_column(:people, :first_name)') if column_name.is_a? Array
+        def remove_columns(table_name, *column_names, type: nil, **options)
+          if column_names.empty?
+            raise ArgumentError.new('You must specify at least one column name. Example: remove_columns(:people, :first_name)')
+          end
+
+          column_names.each do |column_name|
+            remove_column(table_name, column_name, type, **options)
+          end
+        end
 
+        def remove_column(table_name, column_name, _type = nil, **options)
           return if options[:if_exists] == true && !column_exists?(table_name, column_name)
 
           remove_check_constraints(table_name, column_name)
@@ -138,7 +146,7 @@ module ActiveRecord
           execute "ALTER TABLE #{quote_table_name(table_name)} DROP COLUMN #{quote_column_name(column_name)}"
         end
 
-        def drop_table(table_name, options = {})
+        def drop_table(table_name, **options)
           # mssql cannot recreate referenced table with force: :cascade
           # https://docs.microsoft.com/en-us/sql/t-sql/statements/drop-table-transact-sql?view=sql-server-2017
           if options[:force] == :cascade
@@ -248,7 +256,7 @@ module ActiveRecord
           (order_columns << super).join(', ')
         end
 
-        def add_timestamps(table_name, options = {})
+        def add_timestamps(table_name, **options)
           if !options.key?(:precision) && supports_datetime_with_precision?
             options[:precision] = 7
           end
@@ -256,6 +264,16 @@ module ActiveRecord
           super
         end
 
+        def add_column(table_name, column_name, type, **options)
+          if supports_datetime_with_precision?
+            if type == :datetime && !options.key?(:precision)
+              options[:precision] = 7
+            end
+          end
+
+          super
+        end
+
         def create_schema_dumper(options)
           MSSQL::SchemaDumper.create(self, options)
         end
@@ -323,16 +341,20 @@ module ActiveRecord
           quoted_table = quote_table_name(table_name)
           quoted_column = quote_column_name(column_name)
           quoted_default = quote(default)
+
           unless null || default.nil?
             execute("UPDATE #{quoted_table} SET #{quoted_column}=#{quoted_default} WHERE #{quoted_column} IS NULL")
           end
+
+          options = { limit: column.limit, precision: column.precision, scale: column.scale }
+
           sql_alter = [
             "ALTER TABLE #{quoted_table}",
-            "ALTER COLUMN #{quoted_column} #{type_to_sql(column.type, limit: column.limit, precision: column.precision, scale: column.scale)}",
-            (' NOT NULL' unless null)
+            "ALTER COLUMN #{quoted_column} #{type_to_sql(column.type, **options)}",
+            ('NOT NULL' unless null)
           ]
 
-          execute(sql_alter.join(' '))
+          execute(sql_alter.compact.join(' '))
         end
 
         def update_table_definition(table_name, base) #:nodoc:
@@ -345,11 +367,14 @@ module ActiveRecord
           MSSQL::SchemaCreation.new(self)
         end
 
-        def create_table_definition(*args)
-          MSSQL::TableDefinition.new(self, *args)
+        def create_table_definition(name, **options)
+          MSSQL::TableDefinition.new(self, name, **options)
         end
 
         def new_column_from_field(table_name, field)
+          # NOTE: this method is used by the columns method in the abstract Class
+          # to map column_definitions. It would be good if column_definitions is
+          # implemented in ruby
           field
         end