added implementation of 'for update' locking feature for ef core

Author: mnacmargaryan

Readme.md

@@ -1,19 +1,58 @@
 # Pandatech.EFCore.PostgresExtensions
-
+Pandatech.EFCore.PostgresExtensions is a NuGet package that enhances Entity Framework Core with support for PostgreSQL-specific syntax for update operations.
 
 ## Introduction
-
-
+You can install the Pandatech.EFCore.PostgresExtensions NuGet package via the NuGet Package Manager UI or the Package Manager Console using the following command:
+Install-Package Pandatech.EFCore.PostgresExtensions
 
 ## Features
-
+Adds support for PostgreSQL-specific update syntax.
+Simplifies handling of update operations when working with PostgreSQL databases.
 
 ## Installation
+1. Install Pandatech.EFCore.PostgresExtensions Package
+Command: Install-Package Pandatech.EFCore.PostgresExtensions
+ 
+2. Enable Query Locks
 
+Inside the AddDbContext or AddDbContextPool method, after calling UseNpgsql(), call the UseQueryLocks() method on the DbContextOptionsBuilder to enable query locks.
 
+services.AddDbContext<MyDbContext>(options =>
+{
+    options.UseNpgsql(Configuration.GetConnectionString("MyDatabaseConnection"))
+           .UseQueryLocks();
+});
 
-## Usage
 
+## Usage
+Use the provided ForUpdate extension method on IQueryable within your application to apply PostgreSQL-specific update syntax.
+
+using Pandatech.EFCore.PostgresExtensions;
+using Microsoft.EntityFrameworkCore;
+
+// Inside your service or repository method
+using (var transaction = _dbContext.Database.BeginTransaction())
+{
+    try
+    {
+        // Use the ForUpdate extension method on IQueryable inside the transaction scope
+        var entityToUpdate = _dbContext.Entities
+            .Where(e => e.Id == id)
+            .ForUpdate()
+            .FirstOrDefault();
+
+        // Perform updates on entityToUpdate
+
+        await _dbContext.SaveChangesAsync();
+
+        transaction.Commit();
+    }
+    catch (Exception ex)
+    {
+        transaction.Rollback();
+        // Handle exception
+    }
+}
 
 ## License
 

src/EFCore.PostgresExtensions/EFCore.PostgresExtensions.csproj

@@ -18,8 +18,12 @@
     </PropertyGroup>
 
     <ItemGroup>
-        <None Include="..\..\pandatech.png" Pack="true" PackagePath="\"/>
-        <None Include="..\..\Readme.md" Pack="true" PackagePath="\"/>
+        <None Include="..\..\pandatech.png" Pack="true" PackagePath="\" />
+        <None Include="..\..\Readme.md" Pack="true" PackagePath="\" />
+    </ItemGroup>
+
+    <ItemGroup>
+      <PackageReference Include="Microsoft.EntityFrameworkCore.Relational" Version="8.0.3" />
     </ItemGroup>
 
 </Project>

src/EFCore.PostgresExtensions/Enums/LockBehavior.cs

@@ -0,0 +1,31 @@
+namespace EFCore.PostgresExtensions.Enums
+{
+    public enum LockBehavior
+    {
+        /// <summary>
+        /// Using this behavior forces transaction to wait until row is unlocked.
+        /// </summary>
+        Default = 0,
+
+        /// <summary>
+        /// Using this behavior will skip rows that are locked by another transaction.
+        /// </summary>
+        SkipLocked = 1,
+
+        /// <summary>
+        /// Using this behavior will throw an exception if requested rows are locked by another transaction.
+        /// </summary>
+        NoWait = 2,
+    }
+
+    public static class LockBehaviorExtensions
+    {
+        public static string GetSqlKeyword(this LockBehavior lockBehavior) => lockBehavior switch
+        {
+            LockBehavior.Default => string.Empty,
+            LockBehavior.SkipLocked => "skip locked",
+            LockBehavior.NoWait => "nowait",
+            _ => string.Empty,
+        };
+    }
+}

src/EFCore.PostgresExtensions/Extensions/OptionsBuilderExtensions.cs

@@ -0,0 +1,15 @@
+using EFCore.PostgresExtensions.Interceptors;
+using Microsoft.EntityFrameworkCore;
+
+namespace EFCore.PostgresExtensions.Extensions
+{
+    public static class OptionsBuilderExtensions
+    {
+        public static DbContextOptionsBuilder UseQueryLocks(this DbContextOptionsBuilder builder)
+        {
+            builder.AddInterceptors(new TaggedQueryCommandInterceptor());
+
+            return builder;
+        }
+    }
+}

src/EFCore.PostgresExtensions/Extensions/QueryableExtensions.cs

@@ -0,0 +1,24 @@
+using EFCore.PostgresExtensions.Enums;
+using Microsoft.EntityFrameworkCore;
+
+namespace EFCore.PostgresExtensions.Extensions
+{
+    public static class QueryableExtensions
+    {
+        internal const string ForUpdateKey = "for update ";
+        /// <summary>
+        /// Use this method for selecting data with locking.
+        /// <para>Attention! Be aware that this method works only inside the transaction scope(dbContext.BeginTransaction) and you need to register it in startup.</para>
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="query">Query to lock.</param>
+        /// <param name="lockBehavior">Behavior organizes the way data should be locked, for more information check enum values.</param>
+        /// <returns>The same query with locking behavior added.</returns>
+        public static IQueryable<T> ForUpdate<T>(this IQueryable<T> query, LockBehavior lockBehavior = LockBehavior.Default)
+        {
+            query = query.TagWith(ForUpdateKey + lockBehavior.GetSqlKeyword());
+
+            return query.AsQueryable();
+        }
+    }
+}

src/EFCore.PostgresExtensions/Interceptors/TaggedQueryCommandInterceptor.cs

@@ -0,0 +1,40 @@
+using EFCore.PostgresExtensions.Extensions;
+using Microsoft.EntityFrameworkCore.Diagnostics;
+using System.Data.Common;
+
+namespace EFCore.PostgresExtensions.Interceptors
+{
+    public class TaggedQueryCommandInterceptor : DbCommandInterceptor
+    {
+        public override InterceptionResult<DbDataReader> ReaderExecuting(
+            DbCommand command,
+            CommandEventData eventData,
+            InterceptionResult<DbDataReader> result)
+        {
+            ManipulateCommand(command);
+
+            return result;
+        }
+
+        public override ValueTask<InterceptionResult<DbDataReader>> ReaderExecutingAsync(
+            DbCommand command,
+            CommandEventData eventData,
+            InterceptionResult<DbDataReader> result,
+            CancellationToken cancellationToken = default)
+        {
+            ManipulateCommand(command);
+
+            return new ValueTask<InterceptionResult<DbDataReader>>(result);
+        }
+
+        private static void ManipulateCommand(DbCommand command)
+        {
+            if (command.CommandText.StartsWith($"-- {QueryableExtensions.ForUpdateKey}", StringComparison.Ordinal))
+            {
+                var tagEndIndex = command.CommandText.IndexOf('\n');
+
+                command.CommandText += command.CommandText[2..tagEndIndex];
+            }
+        }
+    }
+}