Adds support for runtime= (#481)

Author: cskardon

Neo4jClient.Tests/Cypher/CypherFluentQueryPlannerTests.cs

@@ -54,4 +54,68 @@ public void ThrowsInvalidOperationException_WhenNeo4jVersionIsLessThan22()
             });
         }
     }
+
+    public class CypherFluentQueryRuntimeTests : IClassFixture<CultureInfoSetupFixture>
+    {
+        //Tests:
+        // 2 - must be first in the list 
+
+        [Fact]
+        public void MustBeFirst()
+        {
+            var client = Substitute.For<IRawGraphClient>();
+            client.CypherCapabilities.Returns(CypherCapabilities.Cypher35);
+
+            Assert.Throws<InvalidOperationException>(() =>
+            {
+                var _ = new CypherFluentQuery(client)
+                    .Match("(n)")
+                    .Runtime("Free")
+                    .Query;
+            });
+        }
+
+        [Fact]
+        public void TestRuntimeWithFreeTextConstruction()
+        {
+            var client = Substitute.For<IRawGraphClient>();
+            client.CypherCapabilities.Returns(CypherCapabilities.Cypher35);
+
+            var query = new CypherFluentQuery(client)
+                .Runtime("Free")
+                .Query;
+
+            Assert.Equal("CYPHER runtime=Free", query.QueryText);
+        }
+
+        [Theory]
+        [InlineData(CypherRuntime.Slotted, "slotted")]
+        [InlineData(CypherRuntime.Pipelined, "pipelined")]
+        [InlineData(CypherRuntime.Parallel, "parallel")]
+        public void TestPlannerWithCypherPlannerVariant(CypherRuntime input, string expected)
+        {
+            var client = Substitute.For<IRawGraphClient>();
+            client.CypherCapabilities.Returns(CypherCapabilities.Cypher35);
+
+            var query = new CypherFluentQuery(client)
+                .Runtime(input)
+                .Query;
+
+            Assert.Equal($"CYPHER runtime={expected}", query.QueryText);
+        }
+
+        [Fact]
+        public void ThrowsInvalidOperationException_WhenNeo4jVersionIsLessThan35()
+        {
+            var client = Substitute.For<IRawGraphClient>();
+            client.CypherCapabilities.Returns(CypherCapabilities.Cypher30);
+
+            Assert.Throws<InvalidOperationException>(() =>
+            {
+                var _ = new CypherFluentQuery(client)
+                    .Runtime("Free")
+                    .Query;
+            });
+        }
+    }
 }

Neo4jClient/BoltGraphClient.cs

@@ -295,6 +295,8 @@ public async Task ConnectAsync(NeoServerConfiguration configuration = null)
 
                 if (ServerVersion >= new Version(3, 0))
                     CypherCapabilities = CypherCapabilities.Cypher30;
+                if (ServerVersion >= new Version(3, 5))
+                    CypherCapabilities = CypherCapabilities.Cypher35;
                 if(ServerVersion >= new Version(4,0))
                     CypherCapabilities = CypherCapabilities.Cypher40;
                 if(ServerVersion >= new Version(4,4))

Neo4jClient/Cypher/CypherCapabilities.cs

@@ -35,9 +35,10 @@ public CypherCapabilities(CypherCapabilities cypherCapabilities)
         public static readonly CypherCapabilities Cypher226 = new CypherCapabilities(Cypher22) { AutoRollsBackOnError = true };
         public static readonly CypherCapabilities Cypher23 = new CypherCapabilities(Cypher226) {SupportsStartsWith = true};
         public static readonly CypherCapabilities Cypher30 = new CypherCapabilities(Cypher23) { SupportsStoredProcedures = true, SupportsHasFunction = false };
-        public static readonly CypherCapabilities Cypher40 = new CypherCapabilities(Cypher30) { SupportsMultipleTenancy = true, SupportsShow = true };
+        public static readonly CypherCapabilities Cypher35 = new CypherCapabilities(Cypher30) { SupportsRuntime = true };
+        public static readonly CypherCapabilities Cypher40 = new CypherCapabilities(Cypher35) { SupportsMultipleTenancy = true, SupportsShow = true };
         public static readonly CypherCapabilities Cypher44 = new CypherCapabilities(Cypher40) { SupportsStoredProceduresWithTransactionalBatching = true };
-        
+       
         public static readonly CypherCapabilities Default = Cypher20;
 
         /// <summary>
@@ -50,6 +51,11 @@ public CypherCapabilities(CypherCapabilities cypherCapabilities)
         public bool SupportsNullComparisonsWithIsOperator { get; set; }
         public bool SupportsStartsWith { get; set; }
         public bool SupportsStoredProceduresWithTransactionalBatching { get; set; }
+        
+        /// <summary>
+        /// Runtime is available to be set in 3.5 onwards.
+        /// </summary>
+        public bool SupportsRuntime { get; set; }
 
         /// <summary>
         /// Cypher 3.0 provides support for Stored Procedures via the CALL keyword.

Neo4jClient/Cypher/CypherFluentQuery.cs

@@ -505,6 +505,33 @@ public ICypherFluentQuery ParserVersion(int major, int minor)
             return ParserVersion(new Version(major, minor));
         }
 
+        public ICypherFluentQuery Runtime(string runtime)
+        {
+            if(!Client.CypherCapabilities.SupportsRuntime)
+                throw new InvalidOperationException("'runtime=' not supported in Neo4j versions older than 3.5");
+
+            if (!string.IsNullOrWhiteSpace(this.Query.QueryText))
+                throw new InvalidOperationException("Runtime needs to be defined first.");
+
+            return Mutate(w => w.AppendClause($"CYPHER runtime={runtime}"));
+        }
+
+        public ICypherFluentQuery Runtime(CypherRuntime runtime)
+        {
+            switch (runtime)
+            {
+                case CypherRuntime.Slotted:
+                    return Runtime("slotted");
+                case CypherRuntime.Pipelined:
+                    return Runtime("pipelined");
+                case CypherRuntime.Parallel:
+                    return Runtime("parallel");
+                default:
+                    throw new ArgumentOutOfRangeException(nameof(runtime), runtime, null);
+            }
+            
+        }
+
         public ICypherFluentQuery Planner(string planner)
         {
             if(!Client.CypherCapabilities.SupportsPlanner)

Neo4jClient/Cypher/CypherRuntime.cs

@@ -0,0 +1,13 @@
+namespace Neo4jClient.Cypher
+{
+    public enum CypherRuntime
+    {
+        /// <summary>The default for the Community Edition of Neo4j</summary>
+        Slotted,
+        /// <summary>The default for the Enterprise Edition of Neo4j</summary>
+        Pipelined,
+        /// <summary>Allows for multi-threaded execution of queries.</summary>
+        /// <remarks>This does not always result in increased performance.</remarks>
+        Parallel,
+    }
+}

Neo4jClient/Cypher/ICypherFluentQuery.cs

@@ -49,6 +49,9 @@ public partial interface ICypherFluentQuery
 
         ICypherFluentQuery Planner(string planner);
         ICypherFluentQuery Planner(CypherPlanner planner);
+
+        ICypherFluentQuery Runtime(string runtime);
+        ICypherFluentQuery Runtime(CypherRuntime runtime);
 
         ICypherFluentQuery Match(params string[] matchText);
         ICypherFluentQuery UsingIndex(string index);

Neo4jClient/GraphClient.cs

@@ -122,6 +122,9 @@ void StopTimerAndNotifyCompleted()
                 if (version >= new Version(3, 0))
                     CypherCapabilities = CypherCapabilities.Cypher30;
 
+                if (version >= new Version(3, 5))
+                    CypherCapabilities = CypherCapabilities.Cypher35;
+
                 if (version >= new Version(4, 0))
                     CypherCapabilities = CypherCapabilities.Cypher40;
                 if(ServerVersion >= new Version(4,4))