Introduce procedure mode selection for RedisGraph. (#162)

haysch · web-flow · commit 6c9ea151bc57 · 2023-08-01T16:13:42.000+03:00
* Introduce procedure mode selection for RedisGraph.

* Add option to specify procedure mode as specified by `dbms.procedures()`.
* Refactor `GraphCacheList` to use READ mode for `db.labels()`, `db.propertyKeys()`, and `db.relationshipTypes()` in `GraphCache`.

* Document constructor and initialize data array to avoid nulls.

* Minor formatting changes.

* Add tests for CallProcedure and CallProcedureAsync

* Replace lambda with method call

* Trim trailing whitespace
diff --git a/src/NRedisStack/Graph/GraphCacheList.cs b/src/NRedisStack/Graph/GraphCacheList.cs
@@ -1,71 +1,74 @@
 namespace NRedisStack.Graph
 {
-    internal class GraphCacheList
+    internal sealed class GraphCacheList
     {
-        protected readonly string GraphName;
-        protected readonly string Procedure;
-        private string[] _data;
+        private readonly string _graphName;
+        private readonly string _procedure;
 
-        protected readonly GraphCommands graph;
-        protected readonly GraphCommandsAsync asyncGraph;
-        private bool asyncGraphUsed;
+        private string[] _data = Array.Empty<string>();
+
+        private readonly GraphCommandsAsync _redisGraph;
 
         private readonly object _locker = new object();
 
-        internal GraphCacheList(string graphName, string procedure, GraphCommands redisGraph) : this(graphName, procedure)
+        /// <summary>
+        /// Constructs a <see cref="GraphCacheList"/> for providing cached information about the graph.
+        /// </summary>
+        /// <param name="graphName">The name of the graph to cache information for.</param>
+        /// <param name="procedure">The saved procedure to call to populate cache. Must be a `read` procedure.</param>
+        /// <param name="redisGraph">The graph used for the calling the <paramref name="procedure"/>.</param>
+        internal GraphCacheList(string graphName, string procedure, GraphCommands redisGraph)
         {
-            graph = redisGraph;
-            asyncGraphUsed = false;
-        }
+            _graphName = graphName;
+            _procedure = procedure;
 
-        internal GraphCacheList(string graphName, string procedure, GraphCommandsAsync redisGraph) : this(graphName, procedure)
-        {
-            asyncGraph = redisGraph;
-            asyncGraphUsed = true;
+            _redisGraph = redisGraph;
         }
 
-        private GraphCacheList(string graphName, string procedure)
+        /// <summary>
+        /// Constructs a <see cref="GraphCacheList"/> for providing cached information about the graph.
+        /// </summary>
+        /// <param name="graphName">The name of the graph to cache information for.</param>
+        /// <param name="procedure">The saved procedure to call to populate cache. Must be a `read` procedure.</param>
+        /// <param name="redisGraph">The graph used for the calling the <paramref name="procedure"/>.</param>
+        internal GraphCacheList(string graphName, string procedure, GraphCommandsAsync redisGraphAsync)
         {
-            GraphName = graphName;
-            Procedure = procedure;
+            _graphName = graphName;
+            _procedure = procedure;
+
+            _redisGraph = redisGraphAsync;
         }
 
         // TODO: Change this to use Lazy<T>?
         internal string GetCachedData(int index)
         {
-            if (_data == null || index >= _data.Length)
+            if (index >= _data.Length)
             {
                 lock (_locker)
                 {
-                    if (_data == null || index >= _data.Length)
+                    if (index >= _data.Length)
                     {
-                        GetProcedureInfo();
+                        _data = GetProcedureInfo();
                     }
                 }
             }
 
             return _data.ElementAtOrDefault(index);
         }
 
-        private void GetProcedureInfo()
+        private string[] GetProcedureInfo()
         {
-            var resultSet = CallProcedure(asyncGraphUsed);
-            var newData = new string[resultSet.Count];
-            var i = 0;
-
-            foreach (var record in resultSet)
-            {
-                newData[i++] = record.GetString(0);
-            }
-
-            _data = newData;
+            var resultSet = CallProcedure();
+            return resultSet
+                .Select(r => r.GetString(0))
+                .ToArray();
         }
 
-        protected virtual ResultSet CallProcedure(bool asyncGraphUsed = false)
+        private ResultSet CallProcedure()
         {
-            return asyncGraphUsed
-                ? asyncGraph.CallProcedureAsync(GraphName, Procedure).Result
-                : graph.CallProcedure(GraphName, Procedure);
+            return _redisGraph is GraphCommands graphSync
+                ? graphSync.CallProcedure(_graphName, _procedure, ProcedureMode.Read)
+                : _redisGraph.CallProcedureAsync(_graphName, _procedure, ProcedureMode.Read).Result;
         }
     }
 }
diff --git a/src/NRedisStack/Graph/GraphCommands.cs b/src/NRedisStack/Graph/GraphCommands.cs
@@ -8,7 +8,7 @@ namespace NRedisStack
 {
     public class GraphCommands : GraphCommandsAsync, IGraphCommands
     {
-        IDatabase _db;
+        readonly IDatabase _db;
 
         public GraphCommands(IDatabase db) : base(db)
         {
@@ -55,22 +55,21 @@ public ResultSet RO_Query(string graphName, string query, long? timeout = null)
             return new ResultSet(_db.Execute(GraphCommandBuilder.RO_Query(graphName, query, timeout)), _graphCaches[graphName]);
         }
 
-        internal static readonly Dictionary<string, List<string>> EmptyKwargsDictionary =
+        private static readonly Dictionary<string, List<string>> EmptyKwargsDictionary =
             new Dictionary<string, List<string>>();
 
-        // TODO: Check if this is needed:
         /// <inheritdoc/>
-        public ResultSet CallProcedure(string graphName, string procedure) =>
-        CallProcedure(graphName, procedure, Enumerable.Empty<string>(), EmptyKwargsDictionary);
+        public ResultSet CallProcedure(string graphName, string procedure, ProcedureMode procedureMode = ProcedureMode.Write) =>
+            CallProcedure(graphName, procedure, Enumerable.Empty<string>(), EmptyKwargsDictionary, procedureMode);
 
         /// <inheritdoc/>
-        public ResultSet CallProcedure(string graphName, string procedure, IEnumerable<string> args) =>
-        CallProcedure(graphName, procedure, args, EmptyKwargsDictionary);
+        public ResultSet CallProcedure(string graphName, string procedure, IEnumerable<string> args, ProcedureMode procedureMode = ProcedureMode.Write) =>
+            CallProcedure(graphName, procedure, args, EmptyKwargsDictionary, procedureMode);
 
         /// <inheritdoc/>
-        public ResultSet CallProcedure(string graphName, string procedure, IEnumerable<string> args, Dictionary<string, List<string>> kwargs)
+        public ResultSet CallProcedure(string graphName, string procedure, IEnumerable<string> args, Dictionary<string, List<string>> kwargs, ProcedureMode procedureMode = ProcedureMode.Write)
         {
-            args = args.Select(a => QuoteString(a));
+            args = args.Select(QuoteString);
 
             var queryBody = new StringBuilder();
 
@@ -81,7 +80,9 @@ public ResultSet CallProcedure(string graphName, string procedure, IEnumerable<s
                 queryBody.Append(string.Join(",", kwargsList));
             }
 
-            return Query(graphName, queryBody.ToString());
+            return procedureMode is ProcedureMode.Read
+                ? RO_Query(graphName, queryBody.ToString())
+                : Query(graphName, queryBody.ToString());
         }
 
         /// <inheritdoc/>
diff --git a/src/NRedisStack/Graph/GraphCommandsAsync.cs b/src/NRedisStack/Graph/GraphCommandsAsync.cs
@@ -9,7 +9,7 @@ namespace NRedisStack
 {
     public class GraphCommandsAsync : IGraphCommandsAsync
     {
-        IDatabaseAsync _db;
+        readonly IDatabaseAsync _db;
 
         public GraphCommandsAsync(IDatabaseAsync db)
         {
@@ -56,22 +56,21 @@ public async Task<ResultSet> RO_QueryAsync(string graphName, string query, long?
             return new ResultSet(await _db.ExecuteAsync(GraphCommandBuilder.RO_Query(graphName, query, timeout)), _graphCaches[graphName]);
         }
 
-        internal static readonly Dictionary<string, List<string>> EmptyKwargsDictionary =
+        private static readonly Dictionary<string, List<string>> EmptyKwargsDictionary =
             new Dictionary<string, List<string>>();
 
-        // TODO: Check if this is needed:
         /// <inheritdoc/>
-        public async Task<ResultSet> CallProcedureAsync(string graphName, string procedure) =>
-        await CallProcedureAsync(graphName, procedure, Enumerable.Empty<string>(), EmptyKwargsDictionary);
+        public Task<ResultSet> CallProcedureAsync(string graphName, string procedure, ProcedureMode procedureMode = ProcedureMode.Write) =>
+            CallProcedureAsync(graphName, procedure, Enumerable.Empty<string>(), EmptyKwargsDictionary, procedureMode);
 
         /// <inheritdoc/>
-        public async Task<ResultSet> CallProcedureAsync(string graphName, string procedure, IEnumerable<string> args) =>
-        await CallProcedureAsync(graphName, procedure, args, EmptyKwargsDictionary);
+        public Task<ResultSet> CallProcedureAsync(string graphName, string procedure, IEnumerable<string> args, ProcedureMode procedureMode = ProcedureMode.Write) =>
+            CallProcedureAsync(graphName, procedure, args, EmptyKwargsDictionary, procedureMode);
 
         /// <inheritdoc/>
-        public async Task<ResultSet> CallProcedureAsync(string graphName, string procedure, IEnumerable<string> args, Dictionary<string, List<string>> kwargs)
+        public async Task<ResultSet> CallProcedureAsync(string graphName, string procedure, IEnumerable<string> args, Dictionary<string, List<string>> kwargs, ProcedureMode procedureMode = ProcedureMode.Write)
         {
-            args = args.Select(a => QuoteString(a));
+            args = args.Select(QuoteString);
 
             var queryBody = new StringBuilder();
 
@@ -82,7 +81,9 @@ public async Task<ResultSet> CallProcedureAsync(string graphName, string procedu
                 queryBody.Append(string.Join(",", kwargsList));
             }
 
-            return await QueryAsync(graphName, queryBody.ToString());
+            return procedureMode is ProcedureMode.Read
+                ? await RO_QueryAsync(graphName, queryBody.ToString())
+                : await QueryAsync(graphName, queryBody.ToString());
         }
 
 
diff --git a/src/NRedisStack/Graph/IGraphCommands.cs b/src/NRedisStack/Graph/IGraphCommands.cs
@@ -53,17 +53,19 @@ public interface IGraphCommands
         /// </summary>
         /// <param name="graphName">The graph containing the saved procedure.</param>
         /// <param name="procedure">The procedure name.</param>
+        /// <param name="procedureMode">The mode of the saved procedure. Defaults to <see cref="ProcedureMode.Write"/>.</param>
         /// <returns>A result set.</returns>
-        ResultSet CallProcedure(string graphName, string procedure);
+        ResultSet CallProcedure(string graphName, string procedure, ProcedureMode procedureMode = ProcedureMode.Write);
 
         /// <summary>
         /// Call a saved procedure with parameters.
         /// </summary>
         /// <param name="graphName">The graph containing the saved procedure.</param>
         /// <param name="procedure">The procedure name.</param>
         /// <param name="args">A collection of positional arguments.</param>
+        /// <param name="procedureMode">The mode of the saved procedure. Defaults to <see cref="ProcedureMode.Write"/>.</param>
         /// <returns>A result set.</returns>
-        ResultSet CallProcedure(string graphName, string procedure, IEnumerable<string> args);
+        ResultSet CallProcedure(string graphName, string procedure, IEnumerable<string> args, ProcedureMode procedureMode = ProcedureMode.Write);
 
         /// <summary>
         /// Call a saved procedure with parameters.
@@ -72,8 +74,9 @@ public interface IGraphCommands
         /// <param name="procedure">The procedure name.</param>
         /// <param name="args">A collection of positional arguments.</param>
         /// <param name="kwargs">A collection of keyword arguments.</param>
+        /// <param name="procedureMode">The mode of the saved procedure. Defaults to <see cref="ProcedureMode.Write"/>.</param>
         /// <returns>A result set.</returns>
-        ResultSet CallProcedure(string graphName, string procedure, IEnumerable<string> args, Dictionary<string, List<string>> kwargs);
+        ResultSet CallProcedure(string graphName, string procedure, IEnumerable<string> args, Dictionary<string, List<string>> kwargs, ProcedureMode procedureMode = ProcedureMode.Write);
 
         /// <summary>
         /// Delete an existing graph.
diff --git a/src/NRedisStack/Graph/IGraphCommandsAsync.cs b/src/NRedisStack/Graph/IGraphCommandsAsync.cs
@@ -53,17 +53,19 @@ public interface IGraphCommandsAsync
         /// </summary>
         /// <param name="graphName">The graph containing the saved procedure.</param>
         /// <param name="procedure">The procedure name.</param>
+        /// <param name="procedureMode">The mode of the saved procedure. Defaults to <see cref="ProcedureMode.Write"/>.</param>
         /// <returns>A result set.</returns>
-        Task<ResultSet> CallProcedureAsync(string graphName, string procedure);
+        Task<ResultSet> CallProcedureAsync(string graphName, string procedure, ProcedureMode procedureMode = ProcedureMode.Write);
 
         /// <summary>
         /// Call a saved procedure with parameters.
         /// </summary>
         /// <param name="graphName">The graph containing the saved procedure.</param>
         /// <param name="procedure">The procedure name.</param>
         /// <param name="args">A collection of positional arguments.</param>
+        /// <param name="procedureMode">The mode of the saved procedure. Defaults to <see cref="ProcedureMode.Write"/>.</param>
         /// <returns>A result set.</returns>
-        Task<ResultSet> CallProcedureAsync(string graphName, string procedure, IEnumerable<string> args);
+        Task<ResultSet> CallProcedureAsync(string graphName, string procedure, IEnumerable<string> args, ProcedureMode procedureMode = ProcedureMode.Write);
 
         /// <summary>
         /// Call a saved procedure with parameters.
@@ -72,8 +74,9 @@ public interface IGraphCommandsAsync
         /// <param name="procedure">The procedure name.</param>
         /// <param name="args">A collection of positional arguments.</param>
         /// <param name="kwargs">A collection of keyword arguments.</param>
+        /// <param name="procedureMode">The mode of the saved procedure. Defaults to <see cref="ProcedureMode.Write"/>.</param>
         /// <returns>A result set.</returns>
-        Task<ResultSet> CallProcedureAsync(string graphName, string procedure, IEnumerable<string> args, Dictionary<string, List<string>> kwargs);
+        Task<ResultSet> CallProcedureAsync(string graphName, string procedure, IEnumerable<string> args, Dictionary<string, List<string>> kwargs, ProcedureMode procedureMode = ProcedureMode.Write);
 
         /// <summary>
         /// Delete an existing graph.
diff --git a/src/NRedisStack/Graph/ProcedureMode.cs b/src/NRedisStack/Graph/ProcedureMode.cs
@@ -0,0 +1,11 @@
+namespace NRedisStack.Graph
+{
+    /// <summary>
+    /// Defines the mode of a saved procedure.
+    /// </summary>
+    public enum ProcedureMode
+    {
+        Read,
+        Write
+    }
+}
diff --git a/tests/NRedisStack.Tests/Graph/GraphTests.cs b/tests/NRedisStack.Tests/Graph/GraphTests.cs
@@ -956,6 +956,49 @@ public void TestModulePrefixs()
         Assert.NotEqual(graph1.GetHashCode(), graph2.GetHashCode());
     }
 
+    [Fact]
+    public void TestCallProcedureDbLabels()
+    {
+        var db = redisFixture.Redis.GetDatabase();
+        db.Execute("FLUSHALL");
+
+        const string graphName = "social";
+
+        var graph = db.GRAPH();
+        // Create empty graph, otherwise call procedure will throw exception
+        graph.Query(graphName, "RETURN 1");
+
+        var labels0 = graph.CallProcedure(graphName, "db.labels");
+        Assert.Empty(labels0);
+
+        graph.Query(graphName, "CREATE (:Person { name: 'Bob' })");
+
+        var labels1 = graph.CallProcedure(graphName, "db.labels");
+        Assert.Single(labels1);
+    }
+
+    [Fact]
+    public void TestCallProcedureReadOnly()
+    {
+        var db = redisFixture.Redis.GetDatabase();
+        db.Execute("FLUSHALL");
+
+        const string graphName = "social";
+
+        var graph = db.GRAPH();
+        // throws RedisServerException when executing a ReadOnly procedure against non-existing graph.
+        Assert.Throws<RedisServerException>(() => graph.CallProcedure(graphName, "db.labels", ProcedureMode.Read));
+
+        graph.Query(graphName, "CREATE (:Person { name: 'Bob' })");
+        var procedureArgs = new List<string>
+        {
+            "Person",
+            "name"
+        };
+        // throws RedisServerException when executing a Write procedure with Read procedure mode.
+        Assert.Throws<RedisServerException>(() => graph.CallProcedure(graphName, "db.idx.fulltext.createNodeIndex", procedureArgs, ProcedureMode.Read));
+    }
+
     #endregion
 
     #region AsyncTests
@@ -1886,6 +1929,49 @@ public async Task TestModulePrefixsAsync()
         Assert.NotEqual(graph1.GetHashCode(), graph2.GetHashCode());
     }
 
+    [Fact]
+    public async Task TestCallProcedureDbLabelsAsync()
+    {
+        var db = redisFixture.Redis.GetDatabase();
+        db.Execute("FLUSHALL");
+
+        const string graphName = "social";
+
+        var graph = db.GRAPH();
+        // Create empty graph, otherwise call procedure will throw exception
+        await graph.QueryAsync(graphName, "RETURN 1");
+
+        var labels0 = await graph.CallProcedureAsync(graphName, "db.labels");
+        Assert.Empty(labels0);
+
+        await graph.QueryAsync(graphName, "CREATE (:Person { name: 'Bob' })");
+
+        var labels1 = await graph.CallProcedureAsync(graphName, "db.labels");
+        Assert.Single(labels1);
+    }
+
+    [Fact]
+    public async Task TestCallProcedureReadOnlyAsync()
+    {
+        var db = redisFixture.Redis.GetDatabase();
+        db.Execute("FLUSHALL");
+
+        const string graphName = "social";
+
+        var graph = db.GRAPH();
+        // throws RedisServerException when executing a ReadOnly procedure against non-existing graph.
+        await Assert.ThrowsAsync<RedisServerException>(() => graph.CallProcedureAsync(graphName, "db.labels", ProcedureMode.Read));
+
+        await graph.QueryAsync(graphName, "CREATE (:Person { name: 'Bob' })");
+        var procedureArgs = new List<string>
+        {
+            "Person",
+            "name"
+        };
+        // throws RedisServerException when executing a Write procedure with Read procedure mode.
+        await Assert.ThrowsAsync<RedisServerException>(() => graph.CallProcedureAsync(graphName, "db.idx.fulltext.createNodeIndex", procedureArgs, ProcedureMode.Read));
+    }
+
     [Fact]
     public void TestParseInfinity()
     {

Original file line number	Diff line number	Diff line change
`@@ -1,71 +1,74 @@`
`1`	`1`	`namespace NRedisStack.Graph`
`2`	`2`	`{`
`3`		`- internal class GraphCacheList`
	`3`	`+ internal sealed class GraphCacheList`
`4`	`4`	`{`
`5`		`- protected readonly string GraphName;`
`6`		`- protected readonly string Procedure;`
`7`		`- private string[] _data;`
	`5`	`+ private readonly string _graphName;`
	`6`	`+ private readonly string _procedure;`
`8`	`7`
`9`		`- protected readonly GraphCommands graph;`
`10`		`- protected readonly GraphCommandsAsync asyncGraph;`
`11`		`- private bool asyncGraphUsed;`
	`8`	`+ private string[] _data = Array.Empty<string>();`
	`9`	`+`
	`10`	`+ private readonly GraphCommandsAsync _redisGraph;`
`12`	`11`
`13`	`12`	`private readonly object _locker = new object();`
`14`	`13`
`15`		`- internal GraphCacheList(string graphName, string procedure, GraphCommands redisGraph) : this(graphName, procedure)`
	`14`	`+ /// <summary>`
	`15`	`+ /// Constructs a <see cref="GraphCacheList"/> for providing cached information about the graph.`
	`16`	`+ /// </summary>`
	`17`	`+ /// <param name="graphName">The name of the graph to cache information for.</param>`
	`18`	+ /// <param name="procedure">The saved procedure to call to populate cache. Must be a `read` procedure.</param>
	`19`	`+ /// <param name="redisGraph">The graph used for the calling the <paramref name="procedure"/>.</param>`
	`20`	`+ internal GraphCacheList(string graphName, string procedure, GraphCommands redisGraph)`
`16`	`21`	`{`
`17`		`- graph = redisGraph;`
`18`		`- asyncGraphUsed = false;`
`19`		`- }`
	`22`	`+ _graphName = graphName;`
	`23`	`+ _procedure = procedure;`
`20`	`24`
`21`		`- internal GraphCacheList(string graphName, string procedure, GraphCommandsAsync redisGraph) : this(graphName, procedure)`
`22`		`- {`
`23`		`- asyncGraph = redisGraph;`
`24`		`- asyncGraphUsed = true;`
	`25`	`+ _redisGraph = redisGraph;`
`25`	`26`	`}`
`26`	`27`
`27`		`- private GraphCacheList(string graphName, string procedure)`
	`28`	`+ /// <summary>`
	`29`	`+ /// Constructs a <see cref="GraphCacheList"/> for providing cached information about the graph.`
	`30`	`+ /// </summary>`
	`31`	`+ /// <param name="graphName">The name of the graph to cache information for.</param>`
	`32`	+ /// <param name="procedure">The saved procedure to call to populate cache. Must be a `read` procedure.</param>
	`33`	`+ /// <param name="redisGraph">The graph used for the calling the <paramref name="procedure"/>.</param>`
	`34`	`+ internal GraphCacheList(string graphName, string procedure, GraphCommandsAsync redisGraphAsync)`
`28`	`35`	`{`
`29`		`- GraphName = graphName;`
`30`		`- Procedure = procedure;`
	`36`	`+ _graphName = graphName;`
	`37`	`+ _procedure = procedure;`
	`38`	`+`
	`39`	`+ _redisGraph = redisGraphAsync;`
`31`	`40`	`}`
`32`	`41`
`33`	`42`	`// TODO: Change this to use Lazy<T>?`
`34`	`43`	`internal string GetCachedData(int index)`
`35`	`44`	`{`
`36`		`- if (_data == null \|\| index >= _data.Length)`
	`45`	`+ if (index >= _data.Length)`
`37`	`46`	`{`
`38`	`47`	`lock (_locker)`
`39`	`48`	`{`
`40`		`- if (_data == null \|\| index >= _data.Length)`
	`49`	`+ if (index >= _data.Length)`
`41`	`50`	`{`
`42`		`- GetProcedureInfo();`
	`51`	`+ _data = GetProcedureInfo();`
`43`	`52`	`}`
`44`	`53`	`}`
`45`	`54`	`}`
`46`	`55`
`47`	`56`	`return _data.ElementAtOrDefault(index);`
`48`	`57`	`}`
`49`	`58`
`50`		`- private void GetProcedureInfo()`
	`59`	`+ private string[] GetProcedureInfo()`
`51`	`60`	`{`
`52`		`- var resultSet = CallProcedure(asyncGraphUsed);`
`53`		`- var newData = new string[resultSet.Count];`
`54`		`- var i = 0;`
`55`		`-`
`56`		`- foreach (var record in resultSet)`
`57`		`- {`
`58`		`- newData[i++] = record.GetString(0);`
`59`		`- }`
`60`		`-`
`61`		`- _data = newData;`
	`61`	`+ var resultSet = CallProcedure();`
	`62`	`+ return resultSet`
	`63`	`+ .Select(r => r.GetString(0))`
	`64`	`+ .ToArray();`
`62`	`65`	`}`
`63`	`66`
`64`		`- protected virtual ResultSet CallProcedure(bool asyncGraphUsed = false)`
	`67`	`+ private ResultSet CallProcedure()`
`65`	`68`	`{`
`66`		`- return asyncGraphUsed`
`67`		`- ? asyncGraph.CallProcedureAsync(GraphName, Procedure).Result`
`68`		`- : graph.CallProcedure(GraphName, Procedure);`
	`69`	`+ return _redisGraph is GraphCommands graphSync`
	`70`	`+ ? graphSync.CallProcedure(_graphName, _procedure, ProcedureMode.Read)`
	`71`	`+ : _redisGraph.CallProcedureAsync(_graphName, _procedure, ProcedureMode.Read).Result;`
`69`	`72`	`}`
`70`	`73`	`}`
`71`	`74`	`}`
Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,7 @@ namespace NRedisStack`
`8`	`8`	`{`
`9`	`9`	`public class GraphCommands : GraphCommandsAsync, IGraphCommands`
`10`	`10`	`{`
`11`		`- IDatabase _db;`
	`11`	`+ readonly IDatabase _db;`
`12`	`12`
`13`	`13`	`public GraphCommands(IDatabase db) : base(db)`
`14`	`14`	`{`
`@@ -55,22 +55,21 @@ public ResultSet RO_Query(string graphName, string query, long? timeout = null)`
`55`	`55`	`return new ResultSet(_db.Execute(GraphCommandBuilder.RO_Query(graphName, query, timeout)), _graphCaches[graphName]);`
`56`	`56`	`}`
`57`	`57`
`58`		`- internal static readonly Dictionary<string, List<string>> EmptyKwargsDictionary =`
	`58`	`+ private static readonly Dictionary<string, List<string>> EmptyKwargsDictionary =`
`59`	`59`	`new Dictionary<string, List<string>>();`
`60`	`60`
`61`		`- // TODO: Check if this is needed:`
`62`	`61`	`/// <inheritdoc/>`
`63`		`- public ResultSet CallProcedure(string graphName, string procedure) =>`
`64`		`- CallProcedure(graphName, procedure, Enumerable.Empty<string>(), EmptyKwargsDictionary);`
	`62`	`+ public ResultSet CallProcedure(string graphName, string procedure, ProcedureMode procedureMode = ProcedureMode.Write) =>`
	`63`	`+ CallProcedure(graphName, procedure, Enumerable.Empty<string>(), EmptyKwargsDictionary, procedureMode);`
`65`	`64`
`66`	`65`	`/// <inheritdoc/>`
`67`		`- public ResultSet CallProcedure(string graphName, string procedure, IEnumerable<string> args) =>`
`68`		`- CallProcedure(graphName, procedure, args, EmptyKwargsDictionary);`
	`66`	`+ public ResultSet CallProcedure(string graphName, string procedure, IEnumerable<string> args, ProcedureMode procedureMode = ProcedureMode.Write) =>`
	`67`	`+ CallProcedure(graphName, procedure, args, EmptyKwargsDictionary, procedureMode);`
`69`	`68`
`70`	`69`	`/// <inheritdoc/>`
`71`		`- public ResultSet CallProcedure(string graphName, string procedure, IEnumerable<string> args, Dictionary<string, List<string>> kwargs)`
	`70`	`+ public ResultSet CallProcedure(string graphName, string procedure, IEnumerable<string> args, Dictionary<string, List<string>> kwargs, ProcedureMode procedureMode = ProcedureMode.Write)`
`72`	`71`	`{`
`73`		`- args = args.Select(a => QuoteString(a));`
	`72`	`+ args = args.Select(QuoteString);`
`74`	`73`
`75`	`74`	`var queryBody = new StringBuilder();`
`76`	`75`
`@@ -81,7 +80,9 @@ public ResultSet CallProcedure(string graphName, string procedure, IEnumerable<s`
`81`	`80`	`queryBody.Append(string.Join(",", kwargsList));`
`82`	`81`	`}`
`83`	`82`
`84`		`- return Query(graphName, queryBody.ToString());`
	`83`	`+ return procedureMode is ProcedureMode.Read`
	`84`	`+ ? RO_Query(graphName, queryBody.ToString())`
	`85`	`+ : Query(graphName, queryBody.ToString());`
`85`	`86`	`}`
`86`	`87`
`87`	`88`	`/// <inheritdoc/>`
Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,7 @@ namespace NRedisStack`
`9`	`9`	`{`
`10`	`10`	`public class GraphCommandsAsync : IGraphCommandsAsync`
`11`	`11`	`{`
`12`		`- IDatabaseAsync _db;`
	`12`	`+ readonly IDatabaseAsync _db;`
`13`	`13`
`14`	`14`	`public GraphCommandsAsync(IDatabaseAsync db)`
`15`	`15`	`{`
`@@ -56,22 +56,21 @@ public async Task<ResultSet> RO_QueryAsync(string graphName, string query, long?`
`56`	`56`	`return new ResultSet(await _db.ExecuteAsync(GraphCommandBuilder.RO_Query(graphName, query, timeout)), _graphCaches[graphName]);`
`57`	`57`	`}`
`58`	`58`
`59`		`- internal static readonly Dictionary<string, List<string>> EmptyKwargsDictionary =`
	`59`	`+ private static readonly Dictionary<string, List<string>> EmptyKwargsDictionary =`
`60`	`60`	`new Dictionary<string, List<string>>();`
`61`	`61`
`62`		`- // TODO: Check if this is needed:`
`63`	`62`	`/// <inheritdoc/>`
`64`		`- public async Task<ResultSet> CallProcedureAsync(string graphName, string procedure) =>`
`65`		`- await CallProcedureAsync(graphName, procedure, Enumerable.Empty<string>(), EmptyKwargsDictionary);`
	`63`	`+ public Task<ResultSet> CallProcedureAsync(string graphName, string procedure, ProcedureMode procedureMode = ProcedureMode.Write) =>`
	`64`	`+ CallProcedureAsync(graphName, procedure, Enumerable.Empty<string>(), EmptyKwargsDictionary, procedureMode);`
`66`	`65`
`67`	`66`	`/// <inheritdoc/>`
`68`		`- public async Task<ResultSet> CallProcedureAsync(string graphName, string procedure, IEnumerable<string> args) =>`
`69`		`- await CallProcedureAsync(graphName, procedure, args, EmptyKwargsDictionary);`
	`67`	`+ public Task<ResultSet> CallProcedureAsync(string graphName, string procedure, IEnumerable<string> args, ProcedureMode procedureMode = ProcedureMode.Write) =>`
	`68`	`+ CallProcedureAsync(graphName, procedure, args, EmptyKwargsDictionary, procedureMode);`
`70`	`69`
`71`	`70`	`/// <inheritdoc/>`
`72`		`- public async Task<ResultSet> CallProcedureAsync(string graphName, string procedure, IEnumerable<string> args, Dictionary<string, List<string>> kwargs)`
	`71`	`+ public async Task<ResultSet> CallProcedureAsync(string graphName, string procedure, IEnumerable<string> args, Dictionary<string, List<string>> kwargs, ProcedureMode procedureMode = ProcedureMode.Write)`
`73`	`72`	`{`
`74`		`- args = args.Select(a => QuoteString(a));`
	`73`	`+ args = args.Select(QuoteString);`
`75`	`74`
`76`	`75`	`var queryBody = new StringBuilder();`
`77`	`76`
`@@ -82,7 +81,9 @@ public async Task<ResultSet> CallProcedureAsync(string graphName, string procedu`
`82`	`81`	`queryBody.Append(string.Join(",", kwargsList));`
`83`	`82`	`}`
`84`	`83`
`85`		`- return await QueryAsync(graphName, queryBody.ToString());`
	`84`	`+ return procedureMode is ProcedureMode.Read`
	`85`	`+ ? await RO_QueryAsync(graphName, queryBody.ToString())`
	`86`	`+ : await QueryAsync(graphName, queryBody.ToString());`
`86`	`87`	`}`
`87`	`88`
`88`	`89`