CREATE SEQUENCE for decimal (sql server)

src/EFCore.SqlServer/Migrations/SqlServerMigrationsSqlGenerator.cs

@@ -874,7 +874,7 @@ protected override void Generate(
 
                 builder
                     .Append(" AS ")
-                    .Append(typeMapping.StoreType);
+                    .Append(typeMapping.StoreTypeNameBase);
             }
 
             builder

test/EFCore.Relational.Specification.Tests/Migrations/MigrationsTestBase.cs

@@ -1354,6 +1354,30 @@ public virtual Task Create_sequence()
                     Assert.Equal("TestSequence", sequence.Name);
                 });
 
+
+        [ConditionalFact]
+        public virtual Task Create_sequence_long()
+            => Test(
+                builder => { },
+                builder => builder.HasSequence<long>("TestSequence"),
+                model =>
+                {
+                    var sequence = Assert.Single(model.Sequences);
+                    Assert.Equal("TestSequence", sequence.Name);
+                });
+
+        [ConditionalFact]
+        public virtual Task Create_sequence_short()
+            => Test(
+                builder => { },
+                builder => builder.HasSequence<short>("TestSequence"),
+                model =>
+                {
+                    var sequence = Assert.Single(model.Sequences);
+                    Assert.Equal("TestSequence", sequence.Name);
+                });
+
+
         [ConditionalFact]
         public virtual Task Create_sequence_all_settings()
             => Test(

test/EFCore.SqlServer.FunctionalTests/Migrations/MigrationsSqlServerTest.cs

@@ -1765,6 +1765,53 @@ public override async Task Create_sequence()
                 @"CREATE SEQUENCE [TestSequence] AS int START WITH 1 INCREMENT BY 1 NO MINVALUE NO MAXVALUE NO CYCLE;");
         }
 
+        [ConditionalFact]
+        public async Task Create_sequence_byte()
+        {
+            await Test(
+                builder => { },
+                builder => builder.HasSequence<byte>("TestSequence"),
+                model =>
+                {
+                    var sequence = Assert.Single(model.Sequences);
+                    Assert.Equal("TestSequence", sequence.Name);
+                });
+            AssertSql(
+                @"CREATE SEQUENCE [TestSequence] AS tinyint START WITH 1 INCREMENT BY 1 NO MINVALUE NO MAXVALUE NO CYCLE;");
+        }
+
+        [ConditionalFact]
+        public async Task Create_sequence_decimal()
+        {
+            await Test(
+                builder => { },
+                builder => builder.HasSequence<decimal>("TestSequence"),
+                model =>
+                {
+                    var sequence = Assert.Single(model.Sequences);
+                    Assert.Equal("TestSequence", sequence.Name);
+                });
+
+            AssertSql(
+                @"CREATE SEQUENCE [TestSequence] AS decimal START WITH 1 INCREMENT BY 1 NO MINVALUE NO MAXVALUE NO CYCLE;");
+        }
+
+        public override async Task Create_sequence_long()
+        {
+            await base.Create_sequence_long();
+
+            AssertSql(
+                @"CREATE SEQUENCE [TestSequence] START WITH 1 INCREMENT BY 1 NO MINVALUE NO MAXVALUE NO CYCLE;");
+        }
+
+        public override async Task Create_sequence_short()
+        {
+            await base.Create_sequence_short();
+
+            AssertSql(
+                @"CREATE SEQUENCE [TestSequence] AS smallint START WITH 1 INCREMENT BY 1 NO MINVALUE NO MAXVALUE NO CYCLE;");
+        }
+
         public override async Task Create_sequence_all_settings()
         {
             await base.Create_sequence_all_settings();

test/EFCore.Sqlite.FunctionalTests/Migrations/MigrationsSqliteTest.cs

@@ -922,6 +922,12 @@ await Test(
         public override Task Create_sequence()
             => AssertNotSupportedAsync(base.Create_sequence, SqliteStrings.SequencesNotSupported);
 
+        public override Task Create_sequence_long()
+            => AssertNotSupportedAsync(base.Create_sequence_long, SqliteStrings.SequencesNotSupported);
+
+        public override Task Create_sequence_short()
+            => AssertNotSupportedAsync(base.Create_sequence_short, SqliteStrings.SequencesNotSupported);
+
         public override Task Create_sequence_all_settings()
             => AssertNotSupportedAsync(base.Create_sequence_all_settings, SqliteStrings.SequencesNotSupported);