activerecord-sqlserver-adapter 7.0.2.0 → 7.0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9c5135f809d1709197eef056bbac22e09adefd4ead979cc32e72a2e12c52453a
-  data.tar.gz: 6a0f0b78026468b273926d259a93c7edb38dc8de176f88e32d8bd64c1667c90c
+  metadata.gz: 41b4642838dbc7178a170c4b002937e5481bf0c7154446d43cff2dae7800a938
+  data.tar.gz: fa20040c55e79a8417ec58c414b5ad6617acaa2fe808c5b48fc44c6e3187c5d7
 SHA512:
-  metadata.gz: 299fe79b88ebbfb2edfac1145c4969c3cde3e7eec25bf5415e671b8bc5e3564cf66cca398a1ca7285cc1b4950a0a0326162860b359a41e018c4bae8c058921ba
-  data.tar.gz: 13566655cfaba356a7b1a1f63e95ad2a38ab0a95a6f85eaf9af4571e04ee1db03e8b2cbd4a9d58599de289c3769046e27ee23ef3898219ecc55fd24f7ec31faf
+  metadata.gz: b7786aeaaf3f90af8a69208e76901c1263e20ef1c4f410948319108531e128ff2d5247838efb10cbcda0fe6b035d1b130576647824e027a668b0fc3df1988305
+  data.tar.gz: 3d9db5b28f4b8b8468b71049b14b7000e25c7aa7afcac55f6fec0ec234f0e4cdf76c4158069328da464ad0a718f45ee9b45b2b6f19f00fc058b7d4ab87071308

data/CHANGELOG.md

@@ -1,3 +1,26 @@
+## v7.0.4.0
+
+#### Changed
+
+- [#1073](https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/pull/1073) Improve performance of view default function lookup
+
+#### Fixed
+
+- [#1088](https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/pull/1088) Fix creation of stored procedures that contain insert statements
+- [#1089](https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/pull/1089) When changing columns set date-time columns to datetime(6) by default
+
+## v7.0.3.0
+
+#### Fixed
+
+- [#1052](https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/pull/1052) Ignore casing of VALUES clause when inserting records using SQL
+- [#1053](https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/pull/1053) Fix insertion of records to non-default schema table using raw SQL
+- [#1059](https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/pull/1059) Fix enums defined on string columns
+
+#### Changed
+
+- [#1057](https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/pull/1057) Set precision 6 by default for timestamps.
+
 ## v7.0.2.0
 
 [Full changelog](https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/compare/v7.0.1.0...v7.0.2.0)

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2008-2022
+Copyright (c) Ken Collins
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -13,9 +13,9 @@ Interested in older versions? We follow a rational versioning policy that tracks
 
 | Adapter Version | Rails Version | Support                                                                                     |
 |-----------------| ------------- | ------------------------------------------------------------------------------------------- |
-| `7.0.1.0`       | `7.0.x`       | [active](https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/tree/main)   |
+| `7.0.4.0`       | `7.0.x`       | [active](https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/tree/main)   |
 | `6.1.2.1`       | `6.1.x`       | [active](https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/tree/6-1-stable) |
-| `6.0.2`         | `6.0.x`       | [active](https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/tree/6-0-stable) |
+| `6.0.3`         | `6.0.x`       | [active](https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/tree/6-0-stable) |
 | `5.2.1`         | `5.2.x`       | [ended](https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/tree/5-2-stable) |
 | `5.1.6`         | `5.1.x`       | [ended](https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/tree/5-1-stable)  |
 | `4.2.18`        | `4.2.x`       | [ended](https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/tree/4-2-stable)  |
@@ -29,7 +29,11 @@ We support every data type supported by FreeTDS. All simplified Rails types in m
 
 The following types (`date`, `datetime2`, `datetimeoffset`, `time`) all require TDS version `7.3` with TinyTDS. We recommend using FreeTDS 1.0 or higher which default to using `TDSVER` to `7.3`. The adapter also sets TinyTDS's `tds_version` to this as well if non is specified.
 
-The Rails v5 adapter supports ActiveRecord's `datetime_with_precision` setting. This means that passing `:precision` to a datetime column is supported. Using a precision with the `:datetime` type will signal the adapter to use the `datetime2` type under the hood.
+The adapter supports ActiveRecord's `datetime_with_precision` setting. This means that passing `:precision` to a datetime column is supported.
+
+By default, precision 6 is used for `:datetime` types if precision is not specified. Any non-nil precision will tell
+the adapter to use the `datetime2` column type. To create a `datetime` column using a migration a precision of `nil`
+should be specified, otherwise the precision will default to 6 and a `datetime2` column will be created.
 
 
 #### Identity Inserts with Triggers
@@ -186,6 +190,7 @@ Many many people have contributed. If you do not see your name here and it shoul
 
 You can see an up-to-date list of contributors here: http://github.com/rails-sqlserver/activerecord-sqlserver-adapter/contributors
 
+
 ## License
 
-Copyright © 2008-2022. It is free software, and may be redistributed under the terms specified in the [MIT-LICENSE](MIT-LICENSE) file.
+ActiveRecord SQL Server Adapter is released under the [MIT License](https://opensource.org/licenses/MIT).

data/VERSION

@@ -1 +1 @@
-7.0.2.0
+7.0.4.0

data/activerecord-sqlserver-adapter.gemspec

@@ -10,7 +10,7 @@ Gem::Specification.new do |spec|
   spec.required_ruby_version = ">= 2.7.0"
 
   spec.license       = "MIT"
-  spec.authors       = ["Ken Collins", "Anna Carey", "Will Bond", "Murray Steele", "Shawn Balestracci", "Joe Rafaniello", "Tom Ward"]
+  spec.authors       = ["Ken Collins", "Anna Carey", "Will Bond", "Murray Steele", "Shawn Balestracci", "Joe Rafaniello", "Tom Ward", "Aidan Haran"]
   spec.email         = ["ken@metaskills.net", "will@wbond.net"]
   spec.homepage      = "http://github.com/rails-sqlserver/activerecord-sqlserver-adapter"
   spec.summary       = "ActiveRecord SQL Server Adapter."

data/lib/active_record/connection_adapters/sqlserver/database_statements.rb

@@ -278,11 +278,11 @@ module ActiveRecord
                     id_sql_type = exclude_output_inserted.is_a?(TrueClass) ? "bigint" : exclude_output_inserted
                     <<~SQL.squish
                       DECLARE @ssaIdInsertTable table (#{quoted_pk} #{id_sql_type});
-                      #{sql.dup.insert sql.index(/ (DEFAULT )?VALUES/), " OUTPUT INSERTED.#{quoted_pk} INTO @ssaIdInsertTable"}
+                      #{sql.dup.insert sql.index(/ (DEFAULT )?VALUES/i), " OUTPUT INSERTED.#{quoted_pk} INTO @ssaIdInsertTable"}
                       SELECT CAST(#{quoted_pk} AS #{id_sql_type}) FROM @ssaIdInsertTable
                     SQL
                   else
-                    sql.dup.insert sql.index(/ (DEFAULT )?VALUES/), " OUTPUT INSERTED.#{quoted_pk}"
+                    sql.dup.insert sql.index(/ (DEFAULT )?VALUES/i), " OUTPUT INSERTED.#{quoted_pk}"
                   end
                 else
                   "#{sql}; SELECT CAST(SCOPE_IDENTITY() AS bigint) AS Ident"
@@ -392,7 +392,7 @@ module ActiveRecord
           self.class.exclude_output_inserted_table_names[table_name]
         end
 
-        def exec_insert_requires_identity?(sql, pk, binds)
+        def exec_insert_requires_identity?(sql, _pk, _binds)
           query_requires_identity_insert?(sql)
         end
 
@@ -402,11 +402,11 @@ module ActiveRecord
           raw_table_name = get_raw_table_name(sql)
           id_column = identity_columns(raw_table_name).first
 
-          id_column && sql =~ /^\s*(INSERT|EXEC sp_executesql N'INSERT)[^(]+\([^)]*\b(#{id_column.name})\b,?[^)]*\)/i ? SQLServer::Utils.extract_identifiers(raw_table_name).object : false
+          id_column && sql =~ /^\s*(INSERT|EXEC sp_executesql N'INSERT)[^(]+\([^)]*\b(#{id_column.name})\b,?[^)]*\)/i ? SQLServer::Utils.extract_identifiers(raw_table_name).quoted : false
         end
 
         def insert_sql?(sql)
-          !(sql =~ /^\s*(INSERT|EXEC sp_executesql N'INSERT)/i).nil?
+          !(sql =~ /\A\s*(INSERT|EXEC sp_executesql N'INSERT)/i).nil?
         end
 
         def identity_columns(table_name)

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

@@ -143,6 +143,15 @@ module ActiveRecord
         def change_column(table_name, column_name, type, options = {})
           sql_commands = []
           indexes = []
+
+          if type == :datetime
+            # If no precision then default it to 6.
+            options[:precision] = 6 unless options.key?(:precision)
+
+            # If there is precision then column must be of type 'datetime2'.
+            type = :datetime2 unless options[:precision].nil?
+          end
+
           column_object = schema_cache.columns(table_name).find { |c| c.name.to_s == column_name.to_s }
           without_constraints = options.key?(:default) || options.key?(:limit)
           default = if !options.key?(:default) && column_object
@@ -150,24 +159,29 @@ module ActiveRecord
                     else
                       options[:default]
                     end
+
           if without_constraints || (column_object && column_object.type != type.to_sym)
             remove_default_constraint(table_name, column_name)
             indexes = indexes(table_name).select { |index| index.columns.include?(column_name.to_s) }
             remove_indexes(table_name, column_name)
           end
+
           sql_commands << "UPDATE #{quote_table_name(table_name)} SET #{quote_column_name(column_name)}=#{quote_default_expression(options[:default], column_object)} WHERE #{quote_column_name(column_name)} IS NULL" if !options[:null].nil? && options[:null] == false && !options[:default].nil?
           alter_command = "ALTER TABLE #{quote_table_name(table_name)} ALTER COLUMN #{quote_column_name(column_name)} #{type_to_sql(type, limit: options[:limit], precision: options[:precision], scale: options[:scale])}"
           alter_command += " COLLATE #{options[:collation]}" if options[:collation].present?
           alter_command += " NOT NULL" if !options[:null].nil? && options[:null] == false
           sql_commands << alter_command
+
           if without_constraints
             default = quote_default_expression(default, column_object || column_for(table_name, column_name))
             sql_commands << "ALTER TABLE #{quote_table_name(table_name)} ADD CONSTRAINT #{default_constraint_name(table_name, column_name)} DEFAULT #{default} FOR #{quote_column_name(column_name)}"
           end
+
           # Add any removed indexes back
           indexes.each do |index|
             sql_commands << "CREATE INDEX #{quote_table_name(index.name)} ON #{quote_table_name(table_name)} (#{index.columns.map { |c| quote_column_name(c) }.join(', ')})"
           end
+
           sql_commands.each { |c| do_execute(c) }
           clear_cache!
         end
@@ -229,6 +243,7 @@ module ActiveRecord
         def type_to_sql(type, limit: nil, precision: nil, scale: nil, **)
           type_limitable = %w(string integer float char nchar varchar nvarchar).include?(type.to_s)
           limit = nil unless type_limitable
+
           case type.to_s
           when "integer"
             case limit
@@ -346,7 +361,7 @@ module ActiveRecord
             datetime2: { name: "datetime2" },
             datetimeoffset: { name: "datetimeoffset" },
             smalldatetime: { name: "smalldatetime" },
-            timestamp: { name: "datetime" },
+            timestamp: { name: "datetime2(6)" },
             time: { name: "time" },
             char: { name: "char" },
             varchar: { name: "varchar", limit: 8000 },
@@ -371,6 +386,15 @@ module ActiveRecord
           view_exists = view_exists?(table_name)
           view_tblnm  = view_table_name(table_name) if view_exists
 
+          if view_exists
+            results = sp_executesql %{
+              SELECT c.COLUMN_NAME AS [name], c.COLUMN_DEFAULT AS [default]
+              FROM #{database}.INFORMATION_SCHEMA.COLUMNS c
+              WHERE c.TABLE_NAME = #{quote(view_tblnm)}
+            }.squish, "SCHEMA", []
+            default_functions = results.each.with_object({}) {|row, out| out[row["name"]] = row["default"] }.compact
+          end
+
           sql = column_definitions_sql(database, identifier)
 
           binds = []
@@ -402,13 +426,8 @@ module ActiveRecord
             ci[:default_function] = begin
               default = ci[:default_value]
               if default.nil? && view_exists
-                default = select_value %{
-                  SELECT c.COLUMN_DEFAULT
-                  FROM #{database}.INFORMATION_SCHEMA.COLUMNS c
-                  WHERE
-                    c.TABLE_NAME = '#{view_tblnm}'
-                    AND c.COLUMN_NAME = '#{views_real_column_name(table_name, ci[:name])}'
-                }.squish, "SCHEMA"
+                view_column = views_real_column_name(table_name, ci[:name])
+                default = default_functions[view_column] if view_column.present?
               end
               case default
               when nil

data/lib/active_record/connection_adapters/sqlserver/table_definition.rb

@@ -101,11 +101,16 @@ module ActiveRecord
 
         def new_column_definition(name, type, **options)
           case type
-          when :datetime
-            type = :datetime2 if options[:precision]
+          when :datetime, :timestamp
+            # If no precision then default it to 6.
+            options[:precision] = 6 unless options.key?(:precision)
+
+            # If there is precision then column must be of type 'datetime2'.
+            type = :datetime2 unless options[:precision].nil?
           when :primary_key
             options[:is_identity] = true
           end
+
           super
         end
       end

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

@@ -27,6 +27,12 @@ module ActiveRecord
           end
 
           def eql?(other)
+            # Support comparing `Type::Char`, `Type::Varchar` and `VarcharMax` with strings.
+            # This happens when we use enum with string columns.
+            if other.is_a?(::String)
+              return type.is_a?(ActiveRecord::ConnectionAdapters::SQLServer::Type::String) && value == other
+            end
+
             self.class == other.class && value == other.value
           end
           alias :== :eql?

data/lib/active_record/connection_adapters/sqlserver/utils.rb

@@ -9,7 +9,7 @@ module ActiveRecord
         QUOTED_STRING_PREFIX = "N"
 
         # Value object to return identifiers from SQL Server names http://bit.ly/1CZ3EiL
-        # Inspiried from Rails PostgreSQL::Name adapter object in their own Utils.
+        # Inspired from Rails PostgreSQL::Name adapter object in their own Utils.
         #
         class Name
           SEPARATOR = "."

data/test/cases/adapter_test_sqlserver.rb

@@ -193,17 +193,31 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
       @identity_insert_sql_unquoted = "INSERT INTO funny_jokes (id, name) VALUES(420, 'Knock knock')"
       @identity_insert_sql_unordered = "INSERT INTO [funny_jokes] ([name],[id]) VALUES('Knock knock',420)"
       @identity_insert_sql_sp = "EXEC sp_executesql N'INSERT INTO [funny_jokes] ([id],[name]) VALUES (@0, @1)', N'@0 int, @1 nvarchar(255)', @0 = 420, @1 = N'Knock knock'"
-      @identity_insert_sql_unquoted_sp = "EXEC sp_executesql N'INSERT INTO [funny_jokes] (id, name) VALUES (@0, @1)', N'@0 int, @1 nvarchar(255)', @0 = 420, @1 = N'Knock knock'"
+      @identity_insert_sql_unquoted_sp = "EXEC sp_executesql N'INSERT INTO funny_jokes (id, name) VALUES (@0, @1)', N'@0 int, @1 nvarchar(255)', @0 = 420, @1 = N'Knock knock'"
       @identity_insert_sql_unordered_sp = "EXEC sp_executesql N'INSERT INTO [funny_jokes] ([name],[id]) VALUES (@0, @1)', N'@0 nvarchar(255), @1  int', @0 = N'Knock knock', @1 = 420"
+
+      @identity_insert_sql_non_dbo = "INSERT INTO [test].[aliens] ([id],[name]) VALUES(420,'Mork')"
+      @identity_insert_sql_non_dbo_unquoted = "INSERT INTO test.aliens ([id],[name]) VALUES(420,'Mork')"
+      @identity_insert_sql_non_dbo_unordered = "INSERT INTO [test].[aliens] ([name],[id]) VALUES('Mork',420)"
+      @identity_insert_sql_non_dbo_sp = "EXEC sp_executesql N'INSERT INTO [test].[aliens] ([id],[name]) VALUES (@0, @1)', N'@0 int, @1 nvarchar(255)', @0 = 420, @1 = N'Mork'"
+      @identity_insert_sql_non_dbo_unquoted_sp = "EXEC sp_executesql N'INSERT INTO test.aliens (id, name) VALUES (@0, @1)', N'@0 int, @1 nvarchar(255)', @0 = 420, @1 = N'Mork'"
+      @identity_insert_sql_non_dbo_unordered_sp = "EXEC sp_executesql N'INSERT INTO [test].[aliens] ([name],[id]) VALUES (@0, @1)', N'@0 nvarchar(255), @1  int', @0 = N'Mork', @1 = 420"
     end
 
-    it "return unquoted table_name to #query_requires_identity_insert? when INSERT sql contains id column" do
-      assert_equal "funny_jokes", connection.send(:query_requires_identity_insert?, @identity_insert_sql)
-      assert_equal "funny_jokes", connection.send(:query_requires_identity_insert?, @identity_insert_sql_unquoted)
-      assert_equal "funny_jokes", connection.send(:query_requires_identity_insert?, @identity_insert_sql_unordered)
-      assert_equal "funny_jokes", connection.send(:query_requires_identity_insert?, @identity_insert_sql_sp)
-      assert_equal "funny_jokes", connection.send(:query_requires_identity_insert?, @identity_insert_sql_unquoted_sp)
-      assert_equal "funny_jokes", connection.send(:query_requires_identity_insert?, @identity_insert_sql_unordered_sp)
+    it "return quoted table_name to #query_requires_identity_insert? when INSERT sql contains id column" do
+      assert_equal "[funny_jokes]",   connection.send(:query_requires_identity_insert?, @identity_insert_sql)
+      assert_equal "[funny_jokes]",   connection.send(:query_requires_identity_insert?, @identity_insert_sql_unquoted)
+      assert_equal "[funny_jokes]",   connection.send(:query_requires_identity_insert?, @identity_insert_sql_unordered)
+      assert_equal "[funny_jokes]",   connection.send(:query_requires_identity_insert?, @identity_insert_sql_sp)
+      assert_equal "[funny_jokes]",   connection.send(:query_requires_identity_insert?, @identity_insert_sql_unquoted_sp)
+      assert_equal "[funny_jokes]",   connection.send(:query_requires_identity_insert?, @identity_insert_sql_unordered_sp)
+
+      assert_equal "[test].[aliens]", connection.send(:query_requires_identity_insert?, @identity_insert_sql_non_dbo)
+      assert_equal "[test].[aliens]", connection.send(:query_requires_identity_insert?, @identity_insert_sql_non_dbo_unquoted)
+      assert_equal "[test].[aliens]", connection.send(:query_requires_identity_insert?, @identity_insert_sql_non_dbo_unordered)
+      assert_equal "[test].[aliens]", connection.send(:query_requires_identity_insert?, @identity_insert_sql_non_dbo_sp)
+      assert_equal "[test].[aliens]", connection.send(:query_requires_identity_insert?, @identity_insert_sql_non_dbo_unquoted_sp)
+      assert_equal "[test].[aliens]", connection.send(:query_requires_identity_insert?, @identity_insert_sql_non_dbo_unordered_sp)
     end
 
     it "return false to #query_requires_identity_insert? for normal SQL" do
@@ -532,4 +546,26 @@ class AdapterTestSQLServer < ActiveRecord::TestCase
       end
     end
   end
+
+  describe 'table is in non-dbo schema' do
+    it "records can be created successfully" do
+      Alien.create!(name: 'Trisolarans')
+    end
+
+    it 'records can be inserted using SQL' do
+      Alien.connection.exec_insert("insert into [test].[aliens] (id, name) VALUES(1, 'Trisolarans'), (2, 'Xenomorph')")
+    end
+  end
+
+  describe "exec_insert" do
+    it 'values clause should be case-insensitive' do
+      assert_difference("Post.count", 4) do
+        first_insert = connection.exec_insert("INSERT INTO [posts] ([id],[title],[body]) VALUES(100, 'Title', 'Body'), (102, 'Title', 'Body')")
+        second_insert = connection.exec_insert("INSERT INTO [posts] ([id],[title],[body]) values(113, 'Body', 'Body'), (114, 'Body', 'Body')")
+
+        assert_equal first_insert.rows.map(&:first), [100, 102]
+        assert_equal second_insert.rows.map(&:first), [113, 114]
+      end
+    end
+  end
 end

data/test/cases/coerced_tests.rb

@@ -450,7 +450,7 @@ class CalculationsTest < ActiveRecord::TestCase
       FROM companies
       INNER JOIN accounts ON companies.id = accounts.firm_id
       WHERE companies.id = ?
-      GROUP BY companies.id, companies.type, companies.firm_id, companies.firm_name, companies.name, companies.client_of, companies.rating, companies.account_id, companies.description
+      GROUP BY companies.id, companies.type, companies.firm_id, companies.firm_name, companies.name, companies.client_of, companies.rating, companies.account_id, companies.description, companies.status
       ORDER BY companies.id
       OFFSET 0 ROWS FETCH NEXT 1 ROWS ONLY
     SQL
@@ -476,7 +476,7 @@ class CalculationsTest < ActiveRecord::TestCase
              .select("companies.*", "AVG(CAST(accounts.credit_limit AS DECIMAL)) AS avg_credit_limit")
              .where(id: rails_core)
              .joins(:account)
-             .group(:id, :type, :firm_id, :firm_name, :name, :client_of, :rating, :account_id, :description)
+             .group(:id, :type, :firm_id, :firm_name, :name, :client_of, :rating, :account_id, :description, :status)
              .take!
 
     # all the DependentFirm attributes should be present
@@ -543,7 +543,7 @@ module ActiveRecord
         assert_equal "hello", five.default
       end
 
-      # Rails adds precision 6 by default, sql server uses datetime2 for datetimes with precision
+      # Use precision 6 by default for datetime/timestamp columns. SQL Server uses `datetime2` for date-times with precision.
       coerce_tests! :test_add_column_with_postgresql_datetime_type
       def test_add_column_with_postgresql_datetime_type_coerced
         connection.create_table :testings do |t|
@@ -556,7 +556,7 @@ module ActiveRecord
         assert_equal "datetime2(6)", column.sql_type
       end
 
-      # timestamp is datetime with default limit
+      # Use precision 6 by default for datetime/timestamp columns. SQL Server uses `datetime2` for date-times with precision.
       coerce_tests! :test_change_column_with_timestamp_type
       def test_change_column_with_timestamp_type_coerced
         connection.create_table :testings do |t|
@@ -568,7 +568,20 @@ module ActiveRecord
         column = connection.columns(:testings).find { |c| c.name == "foo" }
 
         assert_equal :datetime, column.type
-        assert_equal "datetime", column.sql_type
+        assert_equal "datetime2(6)", column.sql_type
+      end
+
+      # Use precision 6 by default for datetime/timestamp columns. SQL Server uses `datetime2` for date-times with precision.
+      coerce_tests! :test_add_column_with_timestamp_type
+      def test_add_column_with_timestamp_type_coerced
+        connection.create_table :testings do |t|
+          t.column :foo, :timestamp
+        end
+
+        column = connection.columns(:testings).find { |c| c.name == "foo" }
+
+        assert_equal :datetime, column.type
+        assert_equal "datetime2(6)", column.sql_type
       end
     end
   end
@@ -1297,9 +1310,26 @@ class RelationTest < ActiveRecord::TestCase
   # We are not doing order duplicate removal anymore.
   coerce_tests! :test_default_scope_order_with_scope_order
 
-  # Leave it up to users to format selects/functions so HAVING works correctly.
+  # Order column must be in the GROUP clause.
   coerce_tests! :test_multiple_where_and_having_clauses
+  def test_multiple_where_and_having_clauses_coerced
+    post = Post.first
+    having_then_where = Post.having(id: post.id).where(title: post.title)
+                            .having(id: post.id).where(title: post.title).group(:id).select(:id)
+
+    assert_equal [post], having_then_where
+  end
+
+  # Order column must be in the GROUP clause.
   coerce_tests! :test_having_with_binds_for_both_where_and_having
+  def test_having_with_binds_for_both_where_and_having
+    post = Post.first
+    having_then_where = Post.having(id: post.id).where(title: post.title).group(:id).select(:id)
+    where_then_having = Post.where(title: post.title).having(id: post.id).group(:id).select(:id)
+
+    assert_equal [post], having_then_where
+    assert_equal [post], where_then_having
+  end
 
   # Find any limit via our expression.
   coerce_tests! %r{relations don't load all records in #inspect}
@@ -1309,10 +1339,18 @@ class RelationTest < ActiveRecord::TestCase
     end
   end
 
-  # I wanted to add `.order("author_id")` scope to avoid error: Column "posts.id" is invalid in the ORDER BY
-  # However, this pull request on Rails core drops order on exists relation. https://github.com/rails/rails/pull/28699
-  # so we are skipping all together.
+  # Order column must be in the GROUP clause.
   coerce_tests! :test_empty_complex_chained_relations
+  def test_empty_complex_chained_relations_coerced
+    posts = Post.select("comments_count").where("id is not null").group("author_id", "id").where("legacy_comments_count > 0")
+
+    assert_queries(1) { assert_equal false, posts.empty? }
+    assert_not_predicate posts, :loaded?
+
+    no_posts = posts.where(title: "")
+    assert_queries(1) { assert_equal true, no_posts.empty? }
+    assert_not_predicate no_posts, :loaded?
+  end
 
   # Can't apply offset without ORDER
   coerce_tests! %r{using a custom table affects the wheres}
@@ -2107,6 +2145,17 @@ class FieldOrderedValuesTest < ActiveRecord::TestCase
     Book.where(author_id: nil, name: nil).delete_all
     Book.connection.add_index(:books, [:author_id, :name], unique: true)
   end
+
+  # Need to remove index as SQL Server considers NULLs on a unique-index to be equal unlike PostgreSQL/MySQL/SQLite.
+  coerce_tests! :test_in_order_of_with_nil
+  def test_in_order_of_with_nil_coerced
+    Book.connection.remove_index(:books, column: [:author_id, :name])
+    
+    original_test_in_order_of_with_nil
+  ensure
+    Book.where(author_id: nil, name: nil).delete_all
+    Book.connection.add_index(:books, [:author_id, :name], unique: true)
+  end
 end
 
 require "models/dashboard"

data/test/cases/enum_test_sqlserver.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "cases/helper_sqlserver"
+
+class EnumTestSQLServer < ActiveRecord::TestCase
+
+  # Check that enums are supported for all string types.
+  # For each type we check: cast, serialize, and update by declaration.
+  # We create a custom class for each type to test.
+  %w[char_10 varchar_50 varchar_max text nchar_10 nvarchar_50 nvarchar_max ntext].each do |col_name|
+    describe "support #{col_name} enums" do
+      let(:klass) do
+        Class.new(ActiveRecord::Base) do
+          self.table_name = 'sst_datatypes'
+
+          enum col_name => { alpha: "A", beta: "B" }
+        end
+      end
+
+      it "type.cast" do
+        type = klass.type_for_attribute(col_name)
+
+        assert_equal "alpha",  type.cast('A')
+        assert_equal "beta",   type.cast('B')
+      end
+
+      it "type.serialize" do
+        type = klass.type_for_attribute(col_name)
+
+        assert_equal 'A', type.serialize('A')
+        assert_equal 'B', type.serialize('B')
+
+        assert_equal 'A', type.serialize(:alpha)
+        assert_equal 'B', type.serialize(:beta)
+      end
+
+      it "update by declaration" do
+        r = klass.new
+
+        r.alpha!
+        assert_predicate r, :alpha?
+
+        r.beta!
+        assert_not_predicate r, :alpha?
+        assert_predicate r, :beta?
+      end
+    end
+  end
+end

data/test/cases/migration_test_sqlserver.rb

@@ -115,4 +115,22 @@ class MigrationTestSQLServer < ActiveRecord::TestCase
       refute_includes schemas, { "name" => "some schema" }
     end
   end
+
+  describe 'creating stored procedure' do
+    it 'stored procedure contains inserts are created successfully' do
+      sql = <<-SQL
+          CREATE OR ALTER PROCEDURE do_some_task
+          AS
+          IF NOT EXISTS(SELECT * FROM sys.objects WHERE type = 'U' AND name = 'SomeTableName')
+          BEGIN
+            CREATE TABLE SomeTableName (SomeNum int PRIMARY KEY CLUSTERED);
+            INSERT INTO SomeTableName(SomeNum) VALUES(1);
+          END
+        SQL
+
+      assert_nothing_raised { connection.execute(sql) }
+    ensure
+      connection.execute("DROP PROCEDURE IF EXISTS dbo.do_some_task;")
+    end
+  end
 end

data/test/cases/schema_dumper_test_sqlserver.rb

@@ -10,122 +10,130 @@ class SchemaDumperTestSQLServer < ActiveRecord::TestCase
 
   it "sst_datatypes" do
     generate_schema_for_table "sst_datatypes"
-    assert_line :bigint,            type: "bigint",       limit: nil,           precision: nil,   scale: nil,  default: 42
-    assert_line :int,               type: "integer",      limit: nil,           precision: nil,   scale: nil,  default: 42
-    assert_line :smallint,          type: "integer",      limit: 2,             precision: nil,   scale: nil,  default: 42
-    assert_line :tinyint,           type: "integer",      limit: 1,             precision: nil,   scale: nil,  default: 42
-    assert_line :bit,               type: "boolean",      limit: nil,           precision: nil,   scale: nil,  default: true
-    assert_line :decimal_9_2,       type: "decimal",      limit: nil,           precision: 9,     scale: 2,    default: 12345.01
-    assert_line :numeric_18_0,      type: "decimal",      limit: nil,           precision: 18,    scale: nil,  default: 191
-    assert_line :numeric_36_2,      type: "decimal",      limit: nil,           precision: 36,    scale: 2,    default: 12345678901234567890.01
-    assert_line :money,             type: "money",        limit: nil,           precision: 19,    scale: 4,    default: 4.2
-    assert_line :smallmoney,        type: "smallmoney",   limit: nil,           precision: 10,    scale: 4,    default: 4.2
+
+    assert_line :bigint,            type: "bigint",                                                     default: 42
+    assert_line :int,               type: "integer",                                                    default: 42
+    assert_line :smallint,          type: "integer",       limit: 2,                                    default: 42
+    assert_line :tinyint,           type: "integer",       limit: 1,                                    default: 42
+    assert_line :bit,               type: "boolean",                                                    default: true
+    assert_line :decimal_9_2,       type: "decimal",                     precision: 9,     scale: 2,    default: 12345.01
+    assert_line :numeric_18_0,      type: "decimal",                     precision: 18,                 default: 191
+    assert_line :numeric_36_2,      type: "decimal",                     precision: 36,    scale: 2,    default: 12345678901234567890.01
+    assert_line :money,             type: "money",                       precision: 19,    scale: 4,    default: 4.2
+    assert_line :smallmoney,        type: "smallmoney",                  precision: 10,    scale: 4,    default: 4.2
     # Approximate Numerics
-    assert_line :float,             type: "float",        limit: nil,           precision: nil,   scale: nil,  default: 123.00000001
-    assert_line :real,              type: "real",         limit: nil,           precision: nil,   scale: nil,  default: 123.45
+    assert_line :float,             type: "float",                                                      default: 123.00000001
+    assert_line :real,              type: "real",                                                       default: 123.45
     # Date and Time
-    assert_line :date,              type: "date",         limit: nil,           precision: nil,   scale: nil,  default: "01-01-0001"
-    assert_line :datetime,          type: "datetime",     limit: nil,           precision: nil,   scale: nil,  default: "01-01-1753 00:00:00.123"
+    assert_line :date,              type: "date",                                                       default: "01-01-0001"
+    assert_line :datetime,          type: "datetime",                    precision: nil,                default: "01-01-1753 00:00:00.123"
     if connection_dblib_73?
-      assert_line :datetime2_7,       type: "datetime",     limit: nil,           precision: 7,     scale: nil,  default: "12-31-9999 23:59:59.9999999"
-      assert_line :datetime2_3,       type: "datetime",     limit: nil,           precision: 3,     scale: nil,  default: nil
-      assert_line :datetime2_1,       type: "datetime",     limit: nil,           precision: 1,     scale: nil,  default: nil
+      assert_line :datetime2_7,     type: "datetime",                    precision: 7,                  default: "12-31-9999 23:59:59.9999999"
+      assert_line :datetime2_3,     type: "datetime",                    precision: 3
+      assert_line :datetime2_1,     type: "datetime",                    precision: 1
     end
-    assert_line :smalldatetime, type: "smalldatetime", limit: nil, precision: nil, scale: nil, default: "01-01-1901 15:45:00.0"
+    assert_line :smalldatetime,     type: "smalldatetime",                                              default: "01-01-1901 15:45:00.0"
     if connection_dblib_73?
-      assert_line :time_7,            type: "time",         limit: nil,           precision: 7,     scale: nil,  default: "04:20:00.2883215"
-      assert_line :time_2,            type: "time",         limit: nil,           precision: 2,     scale: nil,  default: nil
-      assert_line :time_default,      type: "time",         limit: nil,           precision: 7,     scale: nil,  default: "15:03:42.0621978"
+      assert_line :time_7,          type: "time",                        precision: 7,                  default: "04:20:00.2883215"
+      assert_line :time_2,          type: "time",                        precision: 2
+      assert_line :time_default,    type: "time",                        precision: 7,                  default: "15:03:42.0621978"
     end
     # Character Strings
-    assert_line :char_10,           type: "char",         limit: 10,            precision: nil,   scale: nil,  default: "1234567890",           collation: nil
-    assert_line :varchar_50,        type: "varchar",      limit: 50,            precision: nil,   scale: nil,  default: "test varchar_50",      collation: nil
-    assert_line :varchar_max,       type: "varchar_max",  limit: nil,           precision: nil,   scale: nil,  default: "test varchar_max",     collation: nil
-    assert_line :text,              type: "text_basic",   limit: nil,           precision: nil,   scale: nil,  default: "test text",            collation: nil
+    assert_line :char_10,           type: "char",          limit: 10,                                   default: "1234567890"
+    assert_line :varchar_50,        type: "varchar",       limit: 50,                                   default: "test varchar_50"
+    assert_line :varchar_max,       type: "varchar_max",                                                default: "test varchar_max"
+    assert_line :text,              type: "text_basic",                                                 default: "test text"
     # Unicode Character Strings
-    assert_line :nchar_10,          type: "nchar",        limit: 10,            precision: nil,   scale: nil,  default: "12345678åå",           collation: nil
-    assert_line :nvarchar_50,       type: "string",       limit: 50,            precision: nil,   scale: nil,  default: "test nvarchar_50 åå",  collation: nil
-    assert_line :nvarchar_max,      type: "text",         limit: nil,           precision: nil,   scale: nil,  default: "test nvarchar_max åå", collation: nil
-    assert_line :ntext,             type: "ntext",        limit: nil,           precision: nil,   scale: nil,  default: "test ntext åå",        collation: nil
+    assert_line :nchar_10,          type: "nchar",         limit: 10,                                   default: "12345678åå"
+    assert_line :nvarchar_50,       type: "string",        limit: 50,                                   default: "test nvarchar_50 åå"
+    assert_line :nvarchar_max,      type: "text",                                                       default: "test nvarchar_max åå"
+    assert_line :ntext,             type: "ntext",                                                      default: "test ntext åå"
     # Binary Strings
-    assert_line :binary_49,         type: "binary_basic", limit: 49,            precision: nil,   scale: nil,  default: nil
-    assert_line :varbinary_49,      type: "varbinary",    limit: 49,            precision: nil,   scale: nil,  default: nil
-    assert_line :varbinary_max,     type: "binary",       limit: nil,           precision: nil,   scale: nil,  default: nil
+    assert_line :binary_49,         type: "binary_basic",  limit: 49
+    assert_line :varbinary_49,      type: "varbinary",     limit: 49
+    assert_line :varbinary_max,     type: "binary"
     # Other Data Types
-    assert_line :uniqueidentifier,  type: "uuid",         limit: nil,           precision: nil,   scale: nil,  default: -> { "newid()" }
-    assert_line :timestamp,         type: "ss_timestamp", limit: nil,           precision: nil,   scale: nil,  default: nil
+    assert_line :uniqueidentifier,  type: "uuid",                                                       default: -> { "newid()" }
+    assert_line :timestamp,         type: "ss_timestamp"
   end
 
   it "sst_datatypes_migration" do
     columns = SSTestDatatypeMigration.columns_hash
     generate_schema_for_table "sst_datatypes_migration"
+
     # Simple Rails conventions
-    _(columns["integer_col"].sql_type).must_equal      "int(4)"
-    _(columns["bigint_col"].sql_type).must_equal       "bigint(8)"
-    _(columns["boolean_col"].sql_type).must_equal      "bit"
-    _(columns["decimal_col"].sql_type).must_equal      "decimal(18,0)"
-    _(columns["float_col"].sql_type).must_equal        "float"
-    _(columns["string_col"].sql_type).must_equal       "nvarchar(4000)"
-    _(columns["text_col"].sql_type).must_equal         "nvarchar(max)"
-    _(columns["datetime_col"].sql_type).must_equal     "datetime2(6)"
-    _(columns["timestamp_col"].sql_type).must_equal    "datetime"
-    _(columns["time_col"].sql_type).must_equal         "time(7)"
-    _(columns["date_col"].sql_type).must_equal         "date"
-    _(columns["binary_col"].sql_type).must_equal       "varbinary(max)"
-    assert_line :integer_col,     type: "integer",      limit: nil,          precision: nil,  scale: nil, default: nil
-    assert_line :bigint_col,      type: "bigint",       limit: nil,          precision: nil,  scale: nil, default: nil
-    assert_line :boolean_col,     type: "boolean",      limit: nil,          precision: nil,  scale: nil, default: nil
-    assert_line :decimal_col,     type: "decimal",      limit: nil,          precision: 18,   scale: nil, default: nil
-    assert_line :float_col,       type: "float",        limit: nil,          precision: nil,  scale: nil, default: nil
-    assert_line :string_col,      type: "string",       limit: nil,          precision: nil,  scale: nil, default: nil
-    assert_line :text_col,        type: "text",         limit: nil,          precision: nil,  scale: nil, default: nil
-    assert_line :datetime_col,    type: "datetime",     limit: nil,          precision: nil,  scale: nil, default: nil
-    assert_line :timestamp_col,   type: "datetime",     limit: nil,          precision: nil,  scale: nil, default: nil
-    assert_line :time_col,        type: "time",         limit: nil,          precision: 7,    scale: nil, default: nil
-    assert_line :date_col,        type: "date",         limit: nil,          precision: nil,  scale: nil, default: nil
-    assert_line :binary_col,      type: "binary",       limit: nil,          precision: nil,  scale: nil, default: nil
+    _(columns["integer_col"].sql_type).must_equal                "int(4)"
+    _(columns["bigint_col"].sql_type).must_equal                 "bigint(8)"
+    _(columns["boolean_col"].sql_type).must_equal                "bit"
+    _(columns["decimal_col"].sql_type).must_equal                "decimal(18,0)"
+    _(columns["float_col"].sql_type).must_equal                  "float"
+    _(columns["string_col"].sql_type).must_equal                 "nvarchar(4000)"
+    _(columns["text_col"].sql_type).must_equal                   "nvarchar(max)"
+    _(columns["datetime_nil_precision_col"].sql_type).must_equal "datetime"
+    _(columns["datetime_col"].sql_type).must_equal               "datetime2(6)"
+    _(columns["timestamp_col"].sql_type).must_equal              "datetime2(6)"
+    _(columns["time_col"].sql_type).must_equal                   "time(7)"
+    _(columns["date_col"].sql_type).must_equal                   "date"
+    _(columns["binary_col"].sql_type).must_equal                 "varbinary(max)"
+
+    assert_line :integer_col,                type: "integer"
+    assert_line :bigint_col,                 type: "bigint"
+    assert_line :boolean_col,                type: "boolean"
+    assert_line :decimal_col,                type: "decimal",              precision: 18
+    assert_line :float_col,                  type: "float"
+    assert_line :string_col,                 type: "string"
+    assert_line :text_col,                   type: "text"
+    assert_line :datetime_nil_precision_col, type: "datetime",             precision: nil
+    assert_line :datetime_col,               type: "datetime"
+    assert_line :datetime_col,               type: "datetime"
+    assert_line :timestamp_col,              type: "datetime"
+    assert_line :time_col,                   type: "time",                 precision: 7
+    assert_line :date_col,                   type: "date"
+    assert_line :binary_col,                 type: "binary"
+
     # Our type methods.
-    _(columns["real_col"].sql_type).must_equal         "real"
-    _(columns["money_col"].sql_type).must_equal        "money"
+    _(columns["real_col"].sql_type).must_equal          "real"
+    _(columns["money_col"].sql_type).must_equal         "money"
     _(columns["smalldatetime_col"].sql_type).must_equal "smalldatetime"
-    _(columns["datetime2_col"].sql_type).must_equal    "datetime2(7)"
-    _(columns["datetimeoffset"].sql_type).must_equal   "datetimeoffset(7)"
-    _(columns["smallmoney_col"].sql_type).must_equal   "smallmoney"
-    _(columns["char_col"].sql_type).must_equal         "char(1)"
-    _(columns["varchar_col"].sql_type).must_equal      "varchar(8000)"
-    _(columns["text_basic_col"].sql_type).must_equal   "text"
-    _(columns["nchar_col"].sql_type).must_equal        "nchar(1)"
-    _(columns["ntext_col"].sql_type).must_equal        "ntext"
-    _(columns["binary_basic_col"].sql_type).must_equal "binary(1)"
-    _(columns["varbinary_col"].sql_type).must_equal    "varbinary(8000)"
-    _(columns["uuid_col"].sql_type).must_equal         "uniqueidentifier"
-    _(columns["sstimestamp_col"].sql_type).must_equal  "timestamp"
-    _(columns["json_col"].sql_type).must_equal         "nvarchar(max)"
-    assert_line :real_col,          type: "real",           limit: nil,           precision: nil,   scale: nil,  default: nil
-    assert_line :money_col,         type: "money",          limit: nil,           precision: 19,    scale: 4,    default: nil
-    assert_line :smalldatetime_col, type: "smalldatetime",  limit: nil,           precision: nil,   scale: nil,  default: nil
-    assert_line :datetime2_col,     type: "datetime",       limit: nil,           precision: 7,     scale: nil,  default: nil
-    assert_line :datetimeoffset,    type: "datetimeoffset", limit: nil,           precision: 7,     scale: nil,  default: nil
-    assert_line :smallmoney_col,    type: "smallmoney",     limit: nil,           precision: 10,    scale: 4,    default: nil
-    assert_line :char_col,          type: "char",           limit: 1,             precision: nil,   scale: nil,  default: nil
-    assert_line :varchar_col,       type: "varchar",        limit: nil,           precision: nil,   scale: nil,  default: nil
-    assert_line :text_basic_col,    type: "text_basic",     limit: nil,           precision: nil,   scale: nil,  default: nil
-    assert_line :nchar_col,         type: "nchar",          limit: 1,             precision: nil,   scale: nil,  default: nil
-    assert_line :ntext_col,         type: "ntext",          limit: nil,           precision: nil,   scale: nil,  default: nil
-    assert_line :binary_basic_col,  type: "binary_basic",   limit: 1,             precision: nil,   scale: nil,  default: nil
-    assert_line :varbinary_col,     type: "varbinary",      limit: nil,           precision: nil,   scale: nil,  default: nil
-    assert_line :uuid_col,          type: "uuid",           limit: nil,           precision: nil,   scale: nil,  default: nil
-    assert_line :sstimestamp_col,   type: "ss_timestamp",   limit: nil,           precision: nil,   scale: nil,  default: nil
-    assert_line :json_col,          type: "text",           limit: nil,           precision: nil,   scale: nil,  default: nil
+    _(columns["datetime2_col"].sql_type).must_equal     "datetime2(7)"
+    _(columns["datetimeoffset"].sql_type).must_equal    "datetimeoffset(7)"
+    _(columns["smallmoney_col"].sql_type).must_equal    "smallmoney"
+    _(columns["char_col"].sql_type).must_equal          "char(1)"
+    _(columns["varchar_col"].sql_type).must_equal       "varchar(8000)"
+    _(columns["text_basic_col"].sql_type).must_equal    "text"
+    _(columns["nchar_col"].sql_type).must_equal         "nchar(1)"
+    _(columns["ntext_col"].sql_type).must_equal         "ntext"
+    _(columns["binary_basic_col"].sql_type).must_equal  "binary(1)"
+    _(columns["varbinary_col"].sql_type).must_equal     "varbinary(8000)"
+    _(columns["uuid_col"].sql_type).must_equal          "uniqueidentifier"
+    _(columns["sstimestamp_col"].sql_type).must_equal   "timestamp"
+    _(columns["json_col"].sql_type).must_equal          "nvarchar(max)"
+
+    assert_line :real_col,          type: "real"
+    assert_line :money_col,         type: "money",                      precision: 19,  scale: 4
+    assert_line :smalldatetime_col, type: "smalldatetime"
+    assert_line :datetime2_col,     type: "datetime",                   precision: 7
+    assert_line :datetimeoffset,    type: "datetimeoffset",             precision: 7
+    assert_line :smallmoney_col,    type: "smallmoney",                 precision: 10,  scale: 4
+    assert_line :char_col,          type: "char",           limit: 1
+    assert_line :varchar_col,       type: "varchar"
+    assert_line :text_basic_col,    type: "text_basic"
+    assert_line :nchar_col,         type: "nchar",          limit: 1
+    assert_line :ntext_col,         type: "ntext"
+    assert_line :binary_basic_col,  type: "binary_basic",   limit: 1
+    assert_line :varbinary_col,     type: "varbinary"
+    assert_line :uuid_col,          type: "uuid"
+    assert_line :sstimestamp_col,   type: "ss_timestamp",                                           null: false
+    assert_line :json_col,          type: "text"
   end
 
   it "dump column collation" do
     generate_schema_for_table('sst_string_collation')
 
-    assert_line :string_without_collation, type: "string", limit: nil, default: nil, collation: nil
-    assert_line :string_default_collation, type: "varchar", limit: nil, default: nil, collation: nil
-    assert_line :string_with_collation, type: "varchar", limit: nil, default: nil, collation: "SQL_Latin1_General_CP1_CS_AS"
-    assert_line :varchar_with_collation, type: "varchar", limit: nil, default: nil, collation: "SQL_Latin1_General_CP1_CS_AS"
+    assert_line :string_without_collation, type: "string"
+    assert_line :string_default_collation, type: "varchar"
+    assert_line :string_with_collation,    type: "varchar",                           collation: "SQL_Latin1_General_CP1_CS_AS"
+    assert_line :varchar_with_collation,   type: "varchar",                           collation: "SQL_Latin1_General_CP1_CS_AS"
   end
 
   # Special Cases
@@ -140,8 +148,9 @@ class SchemaDumperTestSQLServer < ActiveRecord::TestCase
 
   it "no id with model driven primary key" do
     output = generate_schema_for_table "sst_no_pk_data"
+
     _(output).must_match %r{create_table "sst_no_pk_data".*id:\sfalse.*do}
-    assert_line :name, type: "string", limit: nil, default: nil, collation: nil
+    assert_line :name, type: "string"
   end
 
   it "dumps field with unique key constraints only once" do
@@ -154,6 +163,7 @@ class SchemaDumperTestSQLServer < ActiveRecord::TestCase
 
   def generate_schema_for_table(*table_names)
     require "stringio"
+
     stream = StringIO.new
     ActiveRecord::SchemaDumper.ignore_tables = all_tables - table_names
     ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, stream)
@@ -173,15 +183,19 @@ class SchemaDumperTestSQLServer < ActiveRecord::TestCase
     @schema_lines[column_name.to_s]
   end
 
-  def assert_line(column_name, options = {})
+  def assert_line(column_name, expected_options = {})
     line = line(column_name)
     assert line, "Could not find line with column name: #{column_name.inspect} in schema:\n#{schema}"
 
-    [:type, :limit, :precision, :scale, :collation, :default].each do |key|
-      next unless options.key?(key)
+    # Check that the expected and actual option keys.
+    expected_options_keys = expected_options.keys
+    expected_options_keys.delete(:type)
+    _(expected_options_keys.sort).must_equal (line.options.keys.sort), "For column '#{column_name}' expected schema options and actual schema options do not match."
 
+    # Check the expected and actual option values.
+    expected_options.each do |key, expected|
       actual   = key == :type ? line.send(:type_method) : line.send(key)
-      expected = options[key]
+
       message  = "#{key.to_s.titleize} of #{expected.inspect} not found in:\n#{line}"
 
       if expected.nil?
@@ -207,7 +221,13 @@ class SchemaDumperTestSQLServer < ActiveRecord::TestCase
                 :options
 
     def self.option(method_name)
-      define_method(method_name) { options.present? ? options[method_name.to_sym] : nil }
+      define_method(method_name) do
+        if options.key?(method_name.to_sym)
+          options[method_name.to_sym]
+        else
+          throw "Schema line does include the '#{method_name}' option!"
+        end
+      end
     end
 
     def initialize(line)
@@ -220,6 +240,7 @@ class SchemaDumperTestSQLServer < ActiveRecord::TestCase
     option :scale
     option :default
     option :collation
+    option :null
 
     def to_s
       line.squish
@@ -234,6 +255,7 @@ class SchemaDumperTestSQLServer < ActiveRecord::TestCase
     def parse_line
       _all, type_method, col_name, options = @line.match(LINE_PARSER).to_a
       options = parse_options(options)
+
       [type_method, col_name, options]
     end
 
@@ -243,8 +265,6 @@ class SchemaDumperTestSQLServer < ActiveRecord::TestCase
       else
         {}
       end
-    rescue SyntaxError
-      {}
     end
   end
 end

data/test/cases/schema_test_sqlserver.rb

@@ -47,9 +47,5 @@ class SchemaTestSQLServer < ActiveRecord::TestCase
       assert_equal 255, columns.find { |c| c.name == "n_name" }.limit
       assert_equal 1000, columns.find { |c| c.name == "n_description" }.limit
     end
-
-    it "creates new record" do
-      Alien.create!(name: 'Trisolarans')
-    end
   end
 end

data/test/cases/utils_test_sqlserver.rb

@@ -77,7 +77,7 @@ class UtilsTestSQLServer < ActiveRecord::TestCase
       _(extract_identifiers(" ").object).must_be_nil
     end
 
-    it "has a #quoted that returns a fully quoted name with all identifiers as orginially passed in" do
+    it "has a #quoted that returns a fully quoted name with all identifiers as originally passed in" do
       _(extract_identifiers("object").quoted).must_equal "[object]"
       _(extract_identifiers("server.database..object").quoted).must_equal "[server].[database]..[object]"
       _(extract_identifiers("[server]...[object]").quoted).must_equal "[server]...[object]"
@@ -92,7 +92,7 @@ class UtilsTestSQLServer < ActiveRecord::TestCase
       _(extract_identifiers("[obj.name].[foo]").quoted).must_equal "[obj.name].[foo]"
     end
 
-    it "should indicate if a name is fully qualitified" do
+    it "should indicate if a name is fully qualified" do
       _(extract_identifiers("object").fully_qualified?).must_equal false
       _(extract_identifiers("schema.object").fully_qualified?).must_equal false
       _(extract_identifiers("database.schema.object").fully_qualified?).must_equal false

data/test/schema/sqlserver_specific_schema.rb

@@ -14,8 +14,9 @@ ActiveRecord::Schema.define do
     t.float     :float_col
     t.string    :string_col
     t.text      :text_col
-    t.datetime  :datetime_col
-    t.timestamp :timestamp_col
+    t.datetime  :datetime_nil_precision_col, precision: nil
+    t.datetime  :datetime_col  # Precision defaults to 6
+    t.timestamp :timestamp_col # Precision defaults to 6
     t.time      :time_col
     t.date      :date_col
     t.binary    :binary_col
@@ -316,6 +317,7 @@ ActiveRecord::Schema.define do
   execute "IF EXISTS(SELECT * FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = 'aliens' and TABLE_SCHEMA = 'test') DROP TABLE test.aliens"
   execute <<-TABLE_IN_OTHER_SCHEMA_USED_BY_MODEL
     CREATE TABLE test.aliens(
+      id int IDENTITY NOT NULL primary key,
       name varchar(255)
     )
   TABLE_IN_OTHER_SCHEMA_USED_BY_MODEL

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-sqlserver-adapter
 version: !ruby/object:Gem::Version
-  version: 7.0.2.0
+  version: 7.0.4.0
 platform: ruby
 authors:
 - Ken Collins
@@ -11,10 +11,11 @@ authors:
 - Shawn Balestracci
 - Joe Rafaniello
 - Tom Ward
+- Aidan Haran
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-04-18 00:00:00.000000000 Z
+date: 2023-09-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -152,6 +153,7 @@ files:
 - test/cases/dbconsole.rb
 - test/cases/disconnected_test_sqlserver.rb
 - test/cases/eager_load_too_many_ids_test_sqlserver.rb
+- test/cases/enum_test_sqlserver.rb
 - test/cases/execute_procedure_test_sqlserver.rb
 - test/cases/fetch_test_sqlserver.rb
 - test/cases/fully_qualified_identifier_test_sqlserver.rb
@@ -228,8 +230,8 @@ licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/issues
-  changelog_uri: https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/blob/v7.0.2.0/CHANGELOG.md
-  source_code_uri: https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/tree/v7.0.2.0
+  changelog_uri: https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/blob/v7.0.4.0/CHANGELOG.md
+  source_code_uri: https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/tree/v7.0.4.0
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -245,7 +247,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.33
+rubygems_version: 3.4.10
 signing_key: 
 specification_version: 4
 summary: ActiveRecord SQL Server Adapter.
@@ -265,6 +267,7 @@ test_files:
 - test/cases/dbconsole.rb
 - test/cases/disconnected_test_sqlserver.rb
 - test/cases/eager_load_too_many_ids_test_sqlserver.rb
+- test/cases/enum_test_sqlserver.rb
 - test/cases/execute_procedure_test_sqlserver.rb
 - test/cases/fetch_test_sqlserver.rb
 - test/cases/fully_qualified_identifier_test_sqlserver.rb