Драйвер Neo4j не получает записи драйвера обратной связи

Question

Я пытаюсь получить все отношения, связанные с узлом, используя драйвер Neo4j C #, я хочу получить все входящие и исходящие отношения.

Но проблема в том, что я получаю только исходящие отношения от узла, используядрайвер C # Neo4j, а не входящие отношения, но в окне запросов я могу выполнить оба моих запроса.

Это данные моего графика:

Как видите, я хочу, чтобы все отчетливые отношения, поступающие на узел Group1, для которого я написал этот запрос Cypher.

MATCH path=(e1)-[*]->(`GROUP1`: TRAVEL_PLAN { name: 'GROUP1' })
UNWIND [relationship in relationships(path) | type(relationship)] as pathRelationship
WITH DISTINCT pathRelationship
ORDER BY pathRelationship
RETURN pathRelationship as relationships

, который работает нормальнов браузере и в результате правильно, но проблема в том, что я использую драйвер .NET для Neo4j, который дает мне пустой массив.

Я также создал Neo4j sandbox editor online для всех, кто попытается решить эту проблему.Пароль: installation-fishes-evidence

Это пример данных, которые нужно создать, если кто-то может их решить:

MERGE (T4: COMPETENCY { name: 'T4' })
ON CREATE SET
    T4.id = randomUUID(),
    T4.type = 'COMPETENCY',
    T4.created = timestamp()
ON MATCH SET
    T4.lastUpdated = timestamp()

MERGE (C1: COMPETENCY { name: 'C1' })
ON CREATE SET
    C1.id = randomUUID(),
    C1.type = 'COMPETENCY',
    C1.created = timestamp()
ON MATCH SET
    C1.lastUpdated = timestamp()

MERGE (C2: COMPETENCY { name: 'C2' })
ON CREATE SET
    C2.id = randomUUID(),
    C2.type = 'COMPETENCY',
    C2.created = timestamp()
ON MATCH SET
    C2.lastUpdated = timestamp()

MERGE (C3: COMPETENCY { name: 'C3' })
ON CREATE SET
    C3.id = randomUUID(),
    C3.type = 'COMPETENCY',
    C3.created = timestamp()
ON MATCH SET
    C3.lastUpdated = timestamp()

MERGE (C4: COMPETENCY { name: 'C4' })
ON CREATE SET
    C4.id = randomUUID(),
    C4.type = 'COMPETENCY',
    C4.created = timestamp()
ON MATCH SET
    C4.lastUpdated = timestamp()

MERGE (GROUP1: TRAVEL_PLAN { name: 'GROUP1' })
ON CREATE SET
    GROUP1.id = randomUUID(),
    GROUP1.type = 'TRAVEL_PLAN',
    GROUP1.created = timestamp()
ON MATCH SET
    GROUP1.lastUpdated = timestamp()

---------------------------------------------------------------------------------------------------

MATCH (GROUP1: TRAVEL_PLAN {name:'GROUP1'})

MATCH (T4: COMPETENCY {name:'T4'}) 
MATCH (C1: COMPETENCY {name:'C1'})
MATCH (C2: COMPETENCY {name:'C2'})
MATCH (C3: COMPETENCY {name:'C3'})
MATCH (C4: COMPETENCY {name:'C4'})

CREATE (T4)-[:BELONG_TO]->(GROUP1)
CREATE (C1)-[:BELONG_TO]->(GROUP1)
CREATE (C2)-[:BELONG_TO]->(GROUP1)
CREATE (C3)-[:BELONG_TO]->(GROUP1)
CREATE (C4)-[:BELONG_TO]->(GROUP1)

---------------------------------------------------------------------------------------------------
CREATE INDEX ON :COMPETENCY(name)
----------------------------------------------------------------------------------------------------
CREATE INDEX ON :TRAVEL_PLAN(name)
----------------------------------------------------------------------------------------------------

Это программа на C #, которую я пытаюсь (DotNetFiddle here):

using Neo4j.Driver.V1;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace GraphDemo
{
    public class Program
    {
        public static void Main()
        {
            IDriver driver = GraphDatabase.Driver("bolt://100.26.232.160:35027", AuthTokens.Basic("neo4j", "installation-fishes-evidence"));



            string forwardRelationStatement = new StringBuilder()
                                          .AppendLine(string.Format("MATCH path=(e1)<-[*]-(`{0}`: {1} {{ name: '{0}' }})", "GROUP1", "TRAVEL_PLAN"))
                                          .AppendLine("UNWIND [relationship in relationships(path) | type(relationship)] as pathRelationship")
                                          .AppendLine("WITH DISTINCT pathRelationship")
                                          .AppendLine("ORDER BY pathRelationship")
                                          .AppendLine("RETURN pathRelationship as relationships")
                                          .ToString();

            string backwardRelationStatement = new StringBuilder()
                                          .AppendLine(string.Format("MATCH path=(e1)-[*]->(`{0}`: {1} {{ name: '{0}' }})", "GROUP1", "TRAVEL_PLAN" ))
                                          .AppendLine("UNWIND [relationship in relationships(path) | type(relationship)] as pathRelationship")
                                          .AppendLine("WITH DISTINCT pathRelationship")
                                          .AppendLine("ORDER BY pathRelationship")
                                          .AppendLine("RETURN pathRelationship as relationships")
                                          .ToString();

            using (ISession session = driver.Session())
            {
                var resultCursor = session.Run(backwardRelationStatement);
                var res = resultCursor.SelectMany(x => x.Values.Values);

                var s = Newtonsoft.Json.JsonConvert.SerializeObject(res, Formatting.Indented);

                IEnumerable<string> relations = JsonConvert.DeserializeObject<IEnumerable<string>>(s);

                foreach (string relation in relations)
                    Console.WriteLine(relation);
            }
        }
    }
}

Это было бы большой помощью, если вы дадите какие-либо подсказки.Почесываю голову около 4 часов.