diff --git a/src/EntityFrameworkCore.Extensions.Sequences.PostgreSQL/EntityFrameworkCore.Extensions.Sequences.PostgreSQL.csproj b/src/EntityFrameworkCore.Extensions.Sequences.PostgreSQL/EntityFrameworkCore.Extensions.Sequences.PostgreSQL.csproj
index 7946598..a70df19 100644
--- a/src/EntityFrameworkCore.Extensions.Sequences.PostgreSQL/EntityFrameworkCore.Extensions.Sequences.PostgreSQL.csproj
+++ b/src/EntityFrameworkCore.Extensions.Sequences.PostgreSQL/EntityFrameworkCore.Extensions.Sequences.PostgreSQL.csproj
@@ -16,7 +16,7 @@
     </ItemGroup>
 
     <ItemGroup>
-      <PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="3.1.4" />
+      <PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="5.0.0" />
     </ItemGroup>
 
 </Project>
diff --git a/src/EntityFrameworkCore.Extensions.Sequences.PostgreSQL/Internal/NpgsqlSequenceTranslator.cs b/src/EntityFrameworkCore.Extensions.Sequences.PostgreSQL/Internal/NpgsqlSequenceTranslator.cs
index 9411995..ea2c1e3 100644
--- a/src/EntityFrameworkCore.Extensions.Sequences.PostgreSQL/Internal/NpgsqlSequenceTranslator.cs
+++ b/src/EntityFrameworkCore.Extensions.Sequences.PostgreSQL/Internal/NpgsqlSequenceTranslator.cs
@@ -1,38 +1,52 @@
 namespace EntityFrameworkCore.Extensions.Sequences.PostgreSQL.Internal
 {
-  using System.Collections.Generic;
-  using System.Diagnostics.CodeAnalysis;
-  using System.Linq;
-  using System.Reflection;
-  using Microsoft.EntityFrameworkCore;
-  using Microsoft.EntityFrameworkCore.Query;
-  using Microsoft.EntityFrameworkCore.Query.SqlExpressions;
-  using Npgsql.EntityFrameworkCore.PostgreSQL.Query.Internal;
-  using DbFunctionsExtensions = EntityFrameworkCore.Extensions.Sequences.DbFunctionsExtensions;
-
-  internal class NpgsqlSequenceTranslator : IMethodCallTranslator
-  {
-    private static readonly MethodInfo MethodLong = typeof(DbFunctionsExtensions)
-      .GetMethod(nameof(DbFunctionsExtensions.NextValLong), new[] {typeof(DbFunctions), typeof(string)});
-
-    private readonly NpgsqlSqlExpressionFactory factory;
-
-    public NpgsqlSequenceTranslator([NotNull] NpgsqlSqlExpressionFactory factory)
-    {
-      this.factory = factory;
-    }
+    using System.Collections.Generic;
+    using System.Diagnostics.CodeAnalysis;
+    using System.Linq;
+    using System.Reflection;
+    using Microsoft.EntityFrameworkCore;
+    using Microsoft.EntityFrameworkCore.Diagnostics;
+    using Microsoft.EntityFrameworkCore.Query;
+    using Microsoft.EntityFrameworkCore.Query.SqlExpressions;
+    using Npgsql.EntityFrameworkCore.PostgreSQL.Query;
+    using Npgsql.EntityFrameworkCore.PostgreSQL.Query.Internal;
+    using DbFunctionsExtensions = EntityFrameworkCore.Extensions.Sequences.DbFunctionsExtensions;
 
-    public SqlExpression Translate(SqlExpression instance, MethodInfo method, IReadOnlyList<SqlExpression> arguments)
+    internal class NpgsqlSequenceTranslator : IMethodCallTranslator
     {
-      
-      if (method.Equals(NpgsqlSequenceTranslator.MethodLong))
-      {
-        return this.factory.Function("nextval",
-                                     arguments.Skip(1),
-                                     method.ReturnType);
-      }
-
-      return null;
+        private static readonly MethodInfo MethodLong = typeof(DbFunctionsExtensions)
+          .GetMethod(nameof(DbFunctionsExtensions.NextValLong), new[] { typeof(DbFunctions), typeof(string) });
+
+        private readonly NpgsqlSqlExpressionFactory factory;
+
+        public NpgsqlSequenceTranslator([NotNull] NpgsqlSqlExpressionFactory factory)
+        {
+            this.factory = factory;
+        }
+
+        public SqlExpression Translate(SqlExpression instance, MethodInfo method, IReadOnlyList<SqlExpression> arguments)
+        {
+
+            if (method.Equals(NpgsqlSequenceTranslator.MethodLong))
+            {
+                return this.factory.Function("nextval",
+                                             arguments.Skip(1),
+                                             method.ReturnType);
+            }
+
+            return null;
+        }
+
+        public SqlExpression Translate(SqlExpression instance, MethodInfo method, IReadOnlyList<SqlExpression> arguments, IDiagnosticsLogger<DbLoggerCategory.Query> logger)
+        {
+            if (method.Equals(NpgsqlSequenceTranslator.MethodLong))
+            {
+                return this.factory.Function("nextval",
+                                             arguments.Skip(1),
+                                             method.ReturnType);
+            }
+
+            return null;
+        }
     }
-  }
 }
\ No newline at end of file
diff --git a/src/EntityFrameworkCore.Extensions.Sequences.SqlServer/EntityFrameworkCore.Extensions.Sequences.SqlServer.csproj b/src/EntityFrameworkCore.Extensions.Sequences.SqlServer/EntityFrameworkCore.Extensions.Sequences.SqlServer.csproj
index 2e3e019..f9a81ec 100644
--- a/src/EntityFrameworkCore.Extensions.Sequences.SqlServer/EntityFrameworkCore.Extensions.Sequences.SqlServer.csproj
+++ b/src/EntityFrameworkCore.Extensions.Sequences.SqlServer/EntityFrameworkCore.Extensions.Sequences.SqlServer.csproj
@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
     <PropertyGroup>
         <TargetFramework>netstandard2.1</TargetFramework>
@@ -8,7 +8,7 @@
         <RepositoryUrl>https://github.com/moritzrinow/efcore-sequences</RepositoryUrl>
         <PackageLicenseExpression>MIT</PackageLicenseExpression>
         <RepositoryType>github</RepositoryType>
-        <PackageVersion>0.0.2</PackageVersion>
+        <PackageVersion>5.0.0.1</PackageVersion>
     </PropertyGroup>
 
     <ItemGroup>
@@ -16,7 +16,7 @@
     </ItemGroup>
 
     <ItemGroup>
-      <PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" Version="3.1.9" />
+      <PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" Version="5.0.0" />
     </ItemGroup>
 
 </Project>
diff --git a/src/EntityFrameworkCore.Extensions.Sequences.SqlServer/Internal/SqlServerSequenceProvider.cs b/src/EntityFrameworkCore.Extensions.Sequences.SqlServer/Internal/SqlServerSequenceProvider.cs
index 07e321c..9ab9b3a 100644
--- a/src/EntityFrameworkCore.Extensions.Sequences.SqlServer/Internal/SqlServerSequenceProvider.cs
+++ b/src/EntityFrameworkCore.Extensions.Sequences.SqlServer/Internal/SqlServerSequenceProvider.cs
@@ -88,7 +88,7 @@ public T GetNextSequenceValue<T>(string name) where T : struct
       };
 
       var sql =
-        $"SELECT @result = (NEXT VALUE FOR {name})";
+        $"SELECT @result = (NEXT VALUE FOR [{name}])";
 
       var res = this.context.Database.ExecuteSqlRaw(sql, new object[] {result});
 
@@ -104,7 +104,7 @@ public bool CreateSequence<T>(DbSequence<T> sequence) where T : struct
         connection.Open();
       }
 
-      var name = sequence.Schema != null ? $"{sequence.Schema}.{sequence.Name} " : sequence.Name;
+      var name = sequence.Schema != null ? $"[{sequence.Schema}].[{sequence.Name}] " : $"[{sequence.Name}]";
       var start = sequence.StartValue != null ? $"START WITH {sequence.StartValue} " : "";
       var increment = sequence.IncrementBy != null ? $"INCREMENT BY {sequence.IncrementBy} " : "";
       var min = sequence.MinValue != null ? $"MINVALUE {sequence.MinValue} " : "NO MINVALUE ";
@@ -171,7 +171,7 @@ public bool UpdateSequence<T>(string name, DbSequenceUpdate<T> update) where T :
       var cache = update.CacheSize != null ? (update.CacheSize.Value > 0 ? $"CACHE {update.CacheSize}" : "NO CACHE") : "";
 
       var sql =
-        $"ALTER SEQUENCE {name} " +
+        $"ALTER SEQUENCE [{name}] " +
         $"{restart} " +
         $"{increment}" +
         $"{min} " +
@@ -196,7 +196,7 @@ public bool DropSequence(string name, bool conditionally)
       var sql =
         $"DROP SEQUENCE " +
         (conditionally ? $"IF EXISTS " : "") +
-        $"{name}";
+        $"[{name}]";
 
       var result = this.context.Database.ExecuteSqlRaw(sql);
 
@@ -246,7 +246,7 @@ public async Task<T> GetNextSequenceValueAsync<T>(string name, CancellationToken
       };
 
       var sql =
-        $"SELECT @result = (NEXT VALUE FOR {name})";
+        $"SELECT @result = (NEXT VALUE FOR [{name}])";
 
       var res = await this.context.Database.ExecuteSqlRawAsync(sql, new object[] {result}, ct);
 
@@ -271,7 +271,7 @@ public async Task<bool> UpdateSequenceAsync<T>(string name, DbSequenceUpdate<T>
       var cache = update.CacheSize != null ? (update.CacheSize.Value > 0 ? $"CACHE {update.CacheSize}" : "NO CACHE") : "";
 
       var sql =
-        $"ALTER SEQUENCE {name} " +
+        $"ALTER SEQUENCE [{name}] " +
         $"{restart} " +
         $"{increment}" +
         $"{min} " +
diff --git a/src/EntityFrameworkCore.Extensions.Sequences.SqlServer/Internal/SqlServerSequenceTranslator.cs b/src/EntityFrameworkCore.Extensions.Sequences.SqlServer/Internal/SqlServerSequenceTranslator.cs
index 09364db..cd40f91 100644
--- a/src/EntityFrameworkCore.Extensions.Sequences.SqlServer/Internal/SqlServerSequenceTranslator.cs
+++ b/src/EntityFrameworkCore.Extensions.Sequences.SqlServer/Internal/SqlServerSequenceTranslator.cs
@@ -1,104 +1,169 @@
 namespace EntityFrameworkCore.Extensions.Sequences.SqlServer.Internal
 {
-  using System.Collections.Generic;
-  using System.Diagnostics.CodeAnalysis;
-  using System.Linq;
-  using System.Reflection;
-  using Microsoft.EntityFrameworkCore;
-  using Microsoft.EntityFrameworkCore.Query;
-  using Microsoft.EntityFrameworkCore.Query.SqlExpressions;
-  using Microsoft.EntityFrameworkCore.SqlServer.Storage.Internal;
-  using Microsoft.EntityFrameworkCore.Storage;
-  using DbFunctionsExtensions = EntityFrameworkCore.Extensions.Sequences.DbFunctionsExtensions;
-
-  internal class SqlServerSequenceTranslator : IMethodCallTranslator
-  {
-    private static readonly MethodInfo MethodByte = typeof(DbFunctionsExtensions)
-      .GetMethod(nameof(DbFunctionsExtensions.NextValByte), new[] {typeof(DbFunctions), typeof(string)});
-    
-    private static readonly MethodInfo MethodShort = typeof(DbFunctionsExtensions)
-      .GetMethod(nameof(DbFunctionsExtensions.NextValShort), new[] {typeof(DbFunctions), typeof(string)});
-    
-    private static readonly MethodInfo MethodInt = typeof(DbFunctionsExtensions)
-      .GetMethod(nameof(DbFunctionsExtensions.NextValInt), new[] {typeof(DbFunctions), typeof(string)});
-    
-    private static readonly MethodInfo MethodLong = typeof(DbFunctionsExtensions)
-      .GetMethod(nameof(DbFunctionsExtensions.NextValLong), new[] {typeof(DbFunctions), typeof(string)});
-    
-    private static readonly MethodInfo MethodDec = typeof(DbFunctionsExtensions)
-      .GetMethod(nameof(DbFunctionsExtensions.NextValDec), new[] {typeof(DbFunctions), typeof(string)});
-
-    private readonly ISqlExpressionFactory factory;
-
-    public SqlServerSequenceTranslator([NotNull] ISqlExpressionFactory factory)
-    {
-      this.factory = factory;
-    }
+    using System.Collections.Generic;
+    using System.Diagnostics.CodeAnalysis;
+    using System.Linq;
+    using System.Reflection;
+    using Microsoft.EntityFrameworkCore;
+    using Microsoft.EntityFrameworkCore.Diagnostics;
+    using Microsoft.EntityFrameworkCore.Query;
+    using Microsoft.EntityFrameworkCore.Query.SqlExpressions;
+    using Microsoft.EntityFrameworkCore.SqlServer.Storage.Internal;
+    using Microsoft.EntityFrameworkCore.Storage;
+    using DbFunctionsExtensions = EntityFrameworkCore.Extensions.Sequences.DbFunctionsExtensions;
 
-    public virtual SqlExpression Translate(SqlExpression instance,
-      MethodInfo method,
-      IReadOnlyList<SqlExpression> arguments)
+    internal class SqlServerSequenceTranslator : IMethodCallTranslator
     {
-      if (method.Equals(SqlServerSequenceTranslator.MethodByte) ||
-          method.Equals(SqlServerSequenceTranslator.MethodShort) ||
-          method.Equals(SqlServerSequenceTranslator.MethodInt) ||
-          method.Equals(SqlServerSequenceTranslator.MethodLong) ||
-          method.Equals(SqlServerSequenceTranslator.MethodDec))
-      {
-        var typedArguments = new List<SqlExpression>();
-
-        foreach (var arg in arguments.Skip(1))
-        {
-          typedArguments.Add(this.factory.ApplyDefaultTypeMapping(arg));
-        }
+        private static readonly MethodInfo MethodByte = typeof(DbFunctionsExtensions)
+          .GetMethod(nameof(DbFunctionsExtensions.NextValByte), new[] { typeof(DbFunctions), typeof(string) });
 
-        if (method.ReturnType == typeof(byte))
-        {
-          return new NextValueExpression(
-            this.factory.ApplyDefaultTypeMapping(instance),
-            typedArguments,
-            method.ReturnType,
-            new SqlServerByteTypeMapping(SqlServerSequenceDataTypes.TinyInt));
-        }
+        private static readonly MethodInfo MethodShort = typeof(DbFunctionsExtensions)
+          .GetMethod(nameof(DbFunctionsExtensions.NextValShort), new[] { typeof(DbFunctions), typeof(string) });
 
-        if (method.ReturnType == typeof(short))
-        {
-          return new NextValueExpression(
-            this.factory.ApplyDefaultTypeMapping(instance),
-            typedArguments,
-            method.ReturnType,
-            new SqlServerShortTypeMapping(SqlServerSequenceDataTypes.SmallInt));
-        }
-        
-        if (method.ReturnType == typeof(int))
+        private static readonly MethodInfo MethodInt = typeof(DbFunctionsExtensions)
+          .GetMethod(nameof(DbFunctionsExtensions.NextValInt), new[] { typeof(DbFunctions), typeof(string) });
+
+        private static readonly MethodInfo MethodLong = typeof(DbFunctionsExtensions)
+          .GetMethod(nameof(DbFunctionsExtensions.NextValLong), new[] { typeof(DbFunctions), typeof(string) });
+
+        private static readonly MethodInfo MethodDec = typeof(DbFunctionsExtensions)
+          .GetMethod(nameof(DbFunctionsExtensions.NextValDec), new[] { typeof(DbFunctions), typeof(string) });
+
+        private readonly ISqlExpressionFactory factory;
+
+        public SqlServerSequenceTranslator([NotNull] ISqlExpressionFactory factory)
         {
-          return new NextValueExpression(
-            this.factory.ApplyDefaultTypeMapping(instance),
-            typedArguments,
-            method.ReturnType,
-            new IntTypeMapping(SqlServerSequenceDataTypes.Int));
+            this.factory = factory;
         }
-        
-        if (method.ReturnType == typeof(long))
+
+        public virtual SqlExpression Translate(SqlExpression instance,
+          MethodInfo method,
+          IReadOnlyList<SqlExpression> arguments)
         {
-          return new NextValueExpression(
-            this.factory.ApplyDefaultTypeMapping(instance),
-            typedArguments,
-            method.ReturnType,
-            new IntTypeMapping(SqlServerSequenceDataTypes.BigInt));
+            if (method.Equals(SqlServerSequenceTranslator.MethodByte) ||
+                method.Equals(SqlServerSequenceTranslator.MethodShort) ||
+                method.Equals(SqlServerSequenceTranslator.MethodInt) ||
+                method.Equals(SqlServerSequenceTranslator.MethodLong) ||
+                method.Equals(SqlServerSequenceTranslator.MethodDec))
+            {
+                var typedArguments = new List<SqlExpression>();
+
+                foreach (var arg in arguments.Skip(1))
+                {
+                    typedArguments.Add(this.factory.ApplyDefaultTypeMapping(arg));
+                }
+
+                if (method.ReturnType == typeof(byte))
+                {
+                    return new NextValueExpression(
+                      this.factory.ApplyDefaultTypeMapping(instance),
+                      typedArguments,
+                      method.ReturnType,
+                      new SqlServerByteTypeMapping(SqlServerSequenceDataTypes.TinyInt));
+                }
+
+                if (method.ReturnType == typeof(short))
+                {
+                    return new NextValueExpression(
+                      this.factory.ApplyDefaultTypeMapping(instance),
+                      typedArguments,
+                      method.ReturnType,
+                      new SqlServerShortTypeMapping(SqlServerSequenceDataTypes.SmallInt));
+                }
+
+                if (method.ReturnType == typeof(int))
+                {
+                    return new NextValueExpression(
+                      this.factory.ApplyDefaultTypeMapping(instance),
+                      typedArguments,
+                      method.ReturnType,
+                      new IntTypeMapping(SqlServerSequenceDataTypes.Int));
+                }
+
+                if (method.ReturnType == typeof(long))
+                {
+                    return new NextValueExpression(
+                      this.factory.ApplyDefaultTypeMapping(instance),
+                      typedArguments,
+                      method.ReturnType,
+                      new IntTypeMapping(SqlServerSequenceDataTypes.BigInt));
+                }
+
+                if (method.ReturnType == typeof(decimal))
+                {
+                    return new NextValueExpression(
+                      this.factory.ApplyDefaultTypeMapping(instance),
+                      typedArguments,
+                      method.ReturnType,
+                      new SqlServerDecimalTypeMapping(SqlServerSequenceDataTypes.Decimal));
+                }
+            }
+
+            return null;
         }
-        
-        if (method.ReturnType == typeof(decimal))
+
+        public virtual SqlExpression Translate(SqlExpression instance, MethodInfo method, IReadOnlyList<SqlExpression> arguments, IDiagnosticsLogger<DbLoggerCategory.Query> logger)
         {
-          return new NextValueExpression(
-            this.factory.ApplyDefaultTypeMapping(instance),
-            typedArguments,
-            method.ReturnType,
-            new SqlServerDecimalTypeMapping(SqlServerSequenceDataTypes.Decimal));
-        }
-      }
+            if (method.Equals(SqlServerSequenceTranslator.MethodByte) ||
+                method.Equals(SqlServerSequenceTranslator.MethodShort) ||
+                method.Equals(SqlServerSequenceTranslator.MethodInt) ||
+                method.Equals(SqlServerSequenceTranslator.MethodLong) ||
+                method.Equals(SqlServerSequenceTranslator.MethodDec))
+            {
+                var typedArguments = new List<SqlExpression>();
 
-      return null;
+                foreach (var arg in arguments.Skip(1))
+                {
+                    typedArguments.Add(this.factory.ApplyDefaultTypeMapping(arg));
+                }
+
+                if (method.ReturnType == typeof(byte))
+                {
+                    return new NextValueExpression(
+                      this.factory.ApplyDefaultTypeMapping(instance),
+                      typedArguments,
+                      method.ReturnType,
+                      new SqlServerByteTypeMapping(SqlServerSequenceDataTypes.TinyInt));
+                }
+
+                if (method.ReturnType == typeof(short))
+                {
+                    return new NextValueExpression(
+                      this.factory.ApplyDefaultTypeMapping(instance),
+                      typedArguments,
+                      method.ReturnType,
+                      new SqlServerShortTypeMapping(SqlServerSequenceDataTypes.SmallInt));
+                }
+
+                if (method.ReturnType == typeof(int))
+                {
+                    return new NextValueExpression(
+                      this.factory.ApplyDefaultTypeMapping(instance),
+                      typedArguments,
+                      method.ReturnType,
+                      new IntTypeMapping(SqlServerSequenceDataTypes.Int));
+                }
+
+                if (method.ReturnType == typeof(long))
+                {
+                    return new NextValueExpression(
+                      this.factory.ApplyDefaultTypeMapping(instance),
+                      typedArguments,
+                      method.ReturnType,
+                      new IntTypeMapping(SqlServerSequenceDataTypes.BigInt));
+                }
+
+                if (method.ReturnType == typeof(decimal))
+                {
+                    return new NextValueExpression(
+                      this.factory.ApplyDefaultTypeMapping(instance),
+                      typedArguments,
+                      method.ReturnType,
+                      new SqlServerDecimalTypeMapping(SqlServerSequenceDataTypes.Decimal));
+                }
+            }
+
+            return null;
+        }
     }
-  }
 }
\ No newline at end of file
diff --git a/src/EntityFrameworkCore.Extensions.Sequences.Test/EntityFrameworkCore.Extensions.Sequences.Test.csproj b/src/EntityFrameworkCore.Extensions.Sequences.Test/EntityFrameworkCore.Extensions.Sequences.Test.csproj
index c48de8a..b93868b 100644
--- a/src/EntityFrameworkCore.Extensions.Sequences.Test/EntityFrameworkCore.Extensions.Sequences.Test.csproj
+++ b/src/EntityFrameworkCore.Extensions.Sequences.Test/EntityFrameworkCore.Extensions.Sequences.Test.csproj
@@ -20,8 +20,8 @@
     </ItemGroup>
 
     <ItemGroup>
-      <PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" Version="3.1.9" />
-      <PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="3.1.4" />
+      <PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" Version="5.0.0" />
+      <PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="5.0.0" />
     </ItemGroup>
 
 
diff --git a/src/EntityFrameworkCore.Extensions.Sequences.Test/Startup.cs b/src/EntityFrameworkCore.Extensions.Sequences.Test/Startup.cs
index 3b3d02f..1e7cf2d 100644
--- a/src/EntityFrameworkCore.Extensions.Sequences.Test/Startup.cs
+++ b/src/EntityFrameworkCore.Extensions.Sequences.Test/Startup.cs
@@ -31,7 +31,7 @@ public void ConfigureServices(IServiceCollection services)
       if (this.Configuration.GetValue<bool>("TestOptions:RunTestServices"))
       {
         services.AddTransient<ITestService, SqlServerTest>();
-        services.AddTransient<ITestService, NpgsqlTest>();
+        //services.AddTransient<ITestService, NpgsqlTest>();
         services.AddHostedService<TestSuiteService>();
       }
     }
diff --git a/src/EntityFrameworkCore.Extensions.Sequences.Test/appsettings.json b/src/EntityFrameworkCore.Extensions.Sequences.Test/appsettings.json
index d3ad7d1..12b46f6 100644
--- a/src/EntityFrameworkCore.Extensions.Sequences.Test/appsettings.json
+++ b/src/EntityFrameworkCore.Extensions.Sequences.Test/appsettings.json
@@ -9,12 +9,12 @@
   },
   "AllowedHosts": "*",
   "TestOptions": {
-    "RunTestServices": false,
+    "RunTestServices": true,
     "CurrentDatabase": "sqlserver-testdb",
     "Databases": {
       "sqlserver-testdb": {
         "Provider": "sqlserver",
-        "ConnectionString": "connectionString"
+        "ConnectionString": "server=localhost;database=sqlserver-testdb;integrated security=SSPI"
       },
       "npgsql-testdb": {
         "Provider": "npgsql",
diff --git a/src/EntityFrameworkCore.Extensions.Sequences/EntityFrameworkCore.Extensions.Sequences.csproj b/src/EntityFrameworkCore.Extensions.Sequences/EntityFrameworkCore.Extensions.Sequences.csproj
index a79189b..f56f92b 100644
--- a/src/EntityFrameworkCore.Extensions.Sequences/EntityFrameworkCore.Extensions.Sequences.csproj
+++ b/src/EntityFrameworkCore.Extensions.Sequences/EntityFrameworkCore.Extensions.Sequences.csproj
@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
     <PropertyGroup>
         <TargetFramework>netstandard2.1</TargetFramework>
@@ -9,12 +9,12 @@
         <RepositoryUrl>https://github.com/moritzrinow/efcore-sequences</RepositoryUrl>
         <RepositoryType>github</RepositoryType>
         <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
-        <PackageVersion>0.0.2</PackageVersion>
+        <PackageVersion>5.0.0.1</PackageVersion>
     </PropertyGroup>
 
     <ItemGroup>
-      <PackageReference Include="Microsoft.EntityFrameworkCore" Version="3.1.9" />
-      <PackageReference Include="Microsoft.EntityFrameworkCore.Relational" Version="3.1.9" />
+      <PackageReference Include="Microsoft.EntityFrameworkCore" Version="5.0.0" />
+      <PackageReference Include="Microsoft.EntityFrameworkCore.Relational" Version="5.0.0" />
     </ItemGroup>
 
 </Project>
diff --git a/src/EntityFrameworkCore.Extensions.Sequences/NextValueExpression.cs b/src/EntityFrameworkCore.Extensions.Sequences/NextValueExpression.cs
index 3eb2f68..01e4de2 100644
--- a/src/EntityFrameworkCore.Extensions.Sequences/NextValueExpression.cs
+++ b/src/EntityFrameworkCore.Extensions.Sequences/NextValueExpression.cs
@@ -65,10 +65,10 @@ public virtual NextValueExpression Update(SqlExpression instance, IReadOnlyList<
            ? new NextValueExpression(instance, arguments, Type, TypeMapping)
            : this;
 
-    public override void Print(ExpressionPrinter expressionPrinter)
+    protected override void Print(ExpressionPrinter expressionPrinter)
     {
       expressionPrinter.Append(this.Function);
-      expressionPrinter.VisitList(this.Arguments);
+      expressionPrinter.VisitCollection(this.Arguments);
     }
     
     public override bool Equals(object obj)
diff --git a/src/EntityFrameworkCore.Sequences.sln b/src/EntityFrameworkCore.Sequences.sln
index 71c9a2f..3ba66f3 100644
--- a/src/EntityFrameworkCore.Sequences.sln
+++ b/src/EntityFrameworkCore.Sequences.sln
@@ -1,12 +1,17 @@
 
 Microsoft Visual Studio Solution File, Format Version 12.00
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "EntityFrameworkCore.Extensions.Sequences", "EntityFrameworkCore.Extensions.Sequences\EntityFrameworkCore.Extensions.Sequences.csproj", "{9FBF7A6B-A450-4D9E-A61C-58CDEF327718}"
+# Visual Studio Version 17
+VisualStudioVersion = 17.1.32328.378
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "EntityFrameworkCore.Extensions.Sequences", "EntityFrameworkCore.Extensions.Sequences\EntityFrameworkCore.Extensions.Sequences.csproj", "{9FBF7A6B-A450-4D9E-A61C-58CDEF327718}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "EntityFrameworkCore.Extensions.Sequences.SqlServer", "EntityFrameworkCore.Extensions.Sequences.SqlServer\EntityFrameworkCore.Extensions.Sequences.SqlServer.csproj", "{CD0749BF-B1C6-4CD3-8C3D-07A2532BD953}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "EntityFrameworkCore.Extensions.Sequences.SqlServer", "EntityFrameworkCore.Extensions.Sequences.SqlServer\EntityFrameworkCore.Extensions.Sequences.SqlServer.csproj", "{CD0749BF-B1C6-4CD3-8C3D-07A2532BD953}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "EntityFrameworkCore.Extensions.Sequences.PostgreSQL", "EntityFrameworkCore.Extensions.Sequences.PostgreSQL\EntityFrameworkCore.Extensions.Sequences.PostgreSQL.csproj", "{C64445ED-9E81-45AC-87DA-26EFF827AD5E}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "EntityFrameworkCore.Extensions.Sequences.PostgreSQL", "EntityFrameworkCore.Extensions.Sequences.PostgreSQL\EntityFrameworkCore.Extensions.Sequences.PostgreSQL.csproj", "{C64445ED-9E81-45AC-87DA-26EFF827AD5E}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "EntityFrameworkCore.Extensions.Sequences.Test", "EntityFrameworkCore.Extensions.Sequences.Test\EntityFrameworkCore.Extensions.Sequences.Test.csproj", "{DC764EFF-4B56-49CE-86C6-DF11EA24230D}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "EntityFrameworkCore.Extensions.Sequences.Test", "EntityFrameworkCore.Extensions.Sequences.Test\EntityFrameworkCore.Extensions.Sequences.Test.csproj", "{DC764EFF-4B56-49CE-86C6-DF11EA24230D}"
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{BC724D13-517F-4097-A919-79B2B949639D}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
@@ -31,4 +36,10 @@ Global
 		{DC764EFF-4B56-49CE-86C6-DF11EA24230D}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{DC764EFF-4B56-49CE-86C6-DF11EA24230D}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {A707C7CC-13DE-4C98-88E3-4EB02007F001}
+	EndGlobalSection
 EndGlobal