使用Neo4jClient和Cypher从嵌套对象创建图形

Question

我将一些数据建模为一组简单的嵌套c#对象，我正试图使用。Net Neo4jClient。

我的课程形式如下：

public class Foo {
    public int ID { get; set; }
    public List<Bar> bar { get; set;}
}

public class Bar {
    public int ID { get; set; }
    public List<Baz> baz { get; set;}
}

public class Baz {
    public int ID { get; set; }
}

一旦数据以正确的形式存储在数据库中：

(f:Foo)-[h:HASBAR]->(b:Bar)-[hb:HASBAZ]->(bz:Baz) 

我可以使用collect和optional match，通过以下查询将数据检索到我的类结构中：

List<Foo> foolist = WebApiConfig.GraphClient.Cypher
    .Match("(f:Foo)-[h:HASBAR]->(b:Bar)")
    .OptionalMatch("(b)-[hb:HASBAZ]->(bz:Baz)")
    .With("f, { ID: b.ID, baz: collect(bz) } as Bar")
    .With("{ ID:f.ID, bar:collect(Bar) } as Foo")
    .Return<Foo>("Foo")
    .Results
    .ToList();

这一切都非常有效，数据被正确地序列化到适当的类中。

我的问题是我应该如何执行相反的操作？

在给定的一个Foo类中，包含多个嵌套的bar和baz类，我可以在一个查询中在数据库中创建上述数据结构吗？

或者我必须为每个嵌套级别编写一个查询？

我知道在创建时可能必须列出属性，就像我给客户机一个Foo类，它将创建一个以“bar”作为属性的节点一样。

我的问题主要来自第三层嵌套，如果我将第二层（bar）视为数组（传入Foo.bar）作为变量，我可以创建多个[： HASBAR]关系。但是在同一个查询中，我没有找到将正确的Baz节点与Bar节点相关联的方法。

我是否以正确的方式处理了这件事？

感谢任何回复，提前感谢...

Answer 1

嗯，在一个查询中完成是可能的——不幸的是，我不认为你可以使用美味的UNWIND或FOREACH，因为有辅助嵌套，你需要对类做一些时髦的事情，但是，这里有：

首先，我们需要定义类，这样我们就可以反序列化属性，而不是序列化它们

public class Foo
{
    public int ID { get; set; }

    [JsonIgnore]
    public List<Bar> bar { get; set; }

    [JsonProperty("bar")]
    private List<Bar> barSetter { set { bar = value;} }
}

public class Bar
{
    public int ID { get; set; }

    [JsonIgnore]
    public List<Baz> baz { get; set; }

    [JsonProperty("baz")]
    private List<Baz> bazSetter { set { baz = value; } }
}

public class Baz
{
    public int ID { get; set; }
}

这是什么疯狂？？！？！好吧——通过使用[JsonIgnore]，我们告诉Json不要序列化或反序列化给定的属性——但是我们想反序列化，这样你的检索查询就可以工作——所以使用JsonProperties的私有设置器可以让我们实现这一点。

这种方法的额外好处是，您不需要在Cypher生成位中指定要序列化的属性。这是它的荣耀：

var query = gc.Cypher
    .Create("(f:Foo {fooParam})")
    .WithParam("fooParam", foo);

for (int barIndex = 0; barIndex < foo.bar.Count; barIndex++)
{
    var barIdentifier = $"bar{barIndex}";
    var barParam = $"{barIdentifier}Param";
    query = query
        .With("f")
        .Create($"(f)-[:HASBAR]->({barIdentifier}:Bar {{{barParam}}})")
        .WithParam(barParam, foo.bar[barIndex]);

    for (int bazIndex = 0; bazIndex < foo.bar[barIndex].baz.Count; bazIndex++)
    {
        var bazIdentifier = $"baz{barIndex}{bazIndex}";
        var bazParam = $"{bazIdentifier}Param";
        query = query
            .With($"f, {barIdentifier}")
            .Create($"({barIdentifier})-[:HASBAZ]->({bazIdentifier}:Baz {{{bazParam}}})")
            .WithParam(bazParam, foo.bar[barIndex].baz[bazIndex]);
    }
}

f： Foo位是正常的，随后的for循环允许您定义每个标识符并设置参数。

我不认为这是一个理想的解决方案，但它会工作，并将在1个查询中执行。Obvs，如果有很多嵌套的值，这可能会变得很笨拙。