activerecord-sqlserver-adapter 7.0.2.0 → 7.0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9c5135f809d1709197eef056bbac22e09adefd4ead979cc32e72a2e12c52453a
-  data.tar.gz: 6a0f0b78026468b273926d259a93c7edb38dc8de176f88e32d8bd64c1667c90c
+  metadata.gz: 4a8fb3b90e33355b2f91c6b6cd6e7494f822a0f348881f385bbaee8fbe3b2eee
+  data.tar.gz: a1a24523b114d48249c543c445d15c77b50239c39aa022468f9f06efe378efeb
 SHA512:
-  metadata.gz: 299fe79b88ebbfb2edfac1145c4969c3cde3e7eec25bf5415e671b8bc5e3564cf66cca398a1ca7285cc1b4950a0a0326162860b359a41e018c4bae8c058921ba
-  data.tar.gz: 13566655cfaba356a7b1a1f63e95ad2a38ab0a95a6f85eaf9af4571e04ee1db03e8b2cbd4a9d58599de289c3769046e27ee23ef3898219ecc55fd24f7ec31faf
+  metadata.gz: 813a2f3bf0752a8c9f310997d01e1ffb7a4216381bcd58cb082c811370f36f81e2c8c17a84b2aafc23493afcda7e86af499cc609721e59f0e0bd4b2931709b90
+  data.tar.gz: d99ed863a56ab7d9036e433521b64fb04d0e8f2764c01d1109d6767a9f62beb46adbacbb36709d6702dc27f31afd0cdbf0adec148cdd5952a1a343f6392bf90d

data/CHANGELOG.md

@@ -1,3 +1,15 @@
+## 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/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.3.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

data/VERSION

@@ -1 +1 @@
-7.0.2.0
+7.0.3.0

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,7 +402,7 @@ 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)

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

@@ -346,7 +346,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 },

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

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/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.3.0
 platform: ruby
 authors:
 - Ken Collins
@@ -14,7 +14,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-04-18 00:00:00.000000000 Z
+date: 2023-06-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -152,6 +152,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 +229,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.3.0/CHANGELOG.md
+  source_code_uri: https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/tree/v7.0.3.0
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -245,7 +246,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.33
+rubygems_version: 3.4.6
 signing_key: 
 specification_version: 4
 summary: ActiveRecord SQL Server Adapter.
@@ -265,6 +266,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