Java 直接邻居关系提高了查询性能

这个问题类似于这两个：

更新：下面是一个例子

在包含190K个节点和727K个关系（以及128MB的数据库磁盘使用量）的数据库中，我希望运行以下操作：

我不明白为什么会这么慢，反正大部分东西都应该在内存中。是否有可能在100ms内达到此要求，或者neo4j达不到此要求？如果有帮助的话，我可以把整个数据库放在某个地方

最大的难题是，相同的查询在重写为使用不同的节点符号时运行较慢：）

前者总是在+4.2秒内运行，而后者在3.8秒以下运行，不管我一次又一次运行多少次（交错）

软件/硬件详细信息：（高级）Neo4j v1.9.RC2，JDK 1.7.0.10，一款带有SSD磁盘的macbook pro，8GBRAM，2核i7，具有以下Neo4j配置：

neostore.nodestore.db.mapped_memory=550M
neostore.relationshipstore.db.mapped_memory=540M
neostore.propertystore.db.mapped_memory=690M
neostore.propertystore.db.strings.mapped_memory=430M
neostore.propertystore.db.arrays.mapped_memory=230M
neostore.propertystore.db.index.keys.mapped_memory=150M
neostore.propertystore.db.index.mapped_memory=140M

wrapper.java.initmemory=4092 
wrapper.java.maxmemory=4092

---

将您的查询更改为下面的查询。在我的笔记本电脑上，它的规格比你的低得多，执行时间减半

START start_node=node(36) 
MATCH (start_node)-[r:COOCCURS_WITH]-(partner)
WITH start_node, partner
MATCH (partner)-[s:COOCCURS_WITH]-(another_partner)-[:COOCCURS_WITH]-(start_node)
RETURN COUNT(DISTINCT s) AS num_partner_partner_links;

此外，与默认设置相比，使用您的设置对性能影响不大。恐怕您无法获得所需的性能，但此查询是朝着正确方向迈出的一步

通常，遍历API将比Cypher更快，因为您显式地控制遍历。我模拟了如下查询：

public class NeoTraversal {

public static void main(final String[] args) {
    final GraphDatabaseService db = new GraphDatabaseFactory()
            .newEmbeddedDatabaseBuilder("/neo4j")
            .loadPropertiesFromURL(NeoTraversal.class.getClassLoader().getResource("neo4j.properties"))
            .newGraphDatabase();
    final Set<Long> uniquePartnerRels = new HashSet<Long>();
    long startTime = System.currentTimeMillis();
    final Node start = db.getNodeById(36);
    for (final Path path : Traversal.description()
            .breadthFirst()
            .relationships(Rel.COOCCURS_WITH, Direction.BOTH)
            .uniqueness(Uniqueness.NODE_GLOBAL)
            .evaluator(Evaluators.atDepth(1))
            .traverse(start)) {
        Node partner = start.equals(path.startNode()) ? path.endNode() : path.startNode();
        for (final Path partnerPath : Traversal.description()
                .depthFirst()
                .relationships(Rel.COOCCURS_WITH, Direction.BOTH)
                .uniqueness(Uniqueness.RELATIONSHIP_PATH)
                .evaluator(Evaluators.atDepth(2))
                .evaluator(Evaluators.includeWhereEndNodeIs(start))
                .traverse(partner)) {
            uniquePartnerRels.add(partnerPath.relationships().iterator().next().getId());
        }
    }
    System.out.println("Execution time: " + (System.currentTimeMillis() - startTime));
    System.out.println(uniquePartnerRels.size());
}

static enum Rel implements RelationshipType {
    COOCCURS_WITH
}

}

公共类遍历{
公共静态void main（最终字符串[]args）{
final GraphDatabaseService db=新GraphDatabaseFactory（）
.newEmbeddedDatabaseBuilder（“/neo4j”）
.loadPropertiesFromURL（NeoTraversal.class.getClassLoader（）.getResource（“neo4j.properties”））
.newGraphDatabase（）；
final Set uniquePartnerRels=新HashSet（）；
long startTime=System.currentTimeMillis（）；
最终节点开始=db.getNodeById（36）；
for（最终路径：Traversal.description（）
.breadthFirst（）
.关系（关系、方向、两者）
.唯一性（唯一性.节点\全局）
.评估员（评估员atDepth（1））
（开始）{
节点伙伴=start.equals（path.startNode（））？path.endNode（）：path.startNode（）；
for（最终路径partnerPath:Traversal.description（）
.depthFirst（）
.关系（关系、方向、两者）
.唯一性（唯一性.关系\路径）
.评估员（评估员atDepth（2））
.evaluator（evaluator.includeWhereEndNodeIs（开始））
（合伙人）{
添加（partnerPath.relationships（）.iterator（）.next（）.getId（））；
}
}
System.out.println（“执行时间：+（System.currentTimeMillis（）-startTime））；
System.out.println（uniquePartnerRels.size（））；
}
静态枚举Rel实现RelationshipType{
合作
}
}

---

这显然优于密码查询，因此这可能是一个很好的选择。优化仍然是可能的。

对于深度/广度优先遍历之外的任何东西来说，neo4j都不是那么“快速”。我通过预计算所有网络并将它们存储到MongoDB中解决了这个问题。描述网络的节点文档如下所示：

{
    node_id : long, 
    partners : long[],
    partner_partner_links : long[]
}

Partners和partner_partner_链接是描述EGDE的文档ID。获取整个网络需要两个查询：一个用于此文档，另一个用于边缘属性（也包含节点属性）：

---

这两方面你都是对的，你的密码查询要快一些，遍历查询至少要快2倍！但它仍然不在我需要的地方：/10K结果需要1秒，最大节点需要20秒。。另外，在你的遍历查询中有2个错误，希望我可以编辑你的答案。你可以通过在集合中添加关系标识符来提高速度。我又编辑了代码。你会再次获得一些时间，但这当然不会创造奇迹。最大的瓶颈是你需要在两个方向上穿越。你的数据不能被建模为只指向一个方向吗？在这种情况下，你会怎么做？这些数据中的方向真的没有多大意义（数据基本上代表了两个生物体生活在一起的时间，就像facebook上的朋友一样，总是对称的），但可以肯定的是，如果有一个技巧可以利用它们来获得绩效，我就不会有问题。你似乎对你的关系有方向，但是，在遍历过程中，您确实不能逻辑地使用它们。也许这是让你们的关系更有意义的一个选择？例如，你是爸爸、老板还是什么的。在这种情况下，方向是有意义的，您可以使用它们更明智地穿越。

START start_node=node(36) 
MATCH (start_node)-[r:COOCCURS_WITH]-(partner)
WITH start_node, partner
MATCH (partner)-[s:COOCCURS_WITH]-(another_partner)-[:COOCCURS_WITH]-(start_node)
RETURN COUNT(DISTINCT s) AS num_partner_partner_links;

public class NeoTraversal {

public static void main(final String[] args) {
    final GraphDatabaseService db = new GraphDatabaseFactory()
            .newEmbeddedDatabaseBuilder("/neo4j")
            .loadPropertiesFromURL(NeoTraversal.class.getClassLoader().getResource("neo4j.properties"))
            .newGraphDatabase();
    final Set<Long> uniquePartnerRels = new HashSet<Long>();
    long startTime = System.currentTimeMillis();
    final Node start = db.getNodeById(36);
    for (final Path path : Traversal.description()
            .breadthFirst()
            .relationships(Rel.COOCCURS_WITH, Direction.BOTH)
            .uniqueness(Uniqueness.NODE_GLOBAL)
            .evaluator(Evaluators.atDepth(1))
            .traverse(start)) {
        Node partner = start.equals(path.startNode()) ? path.endNode() : path.startNode();
        for (final Path partnerPath : Traversal.description()
                .depthFirst()
                .relationships(Rel.COOCCURS_WITH, Direction.BOTH)
                .uniqueness(Uniqueness.RELATIONSHIP_PATH)
                .evaluator(Evaluators.atDepth(2))
                .evaluator(Evaluators.includeWhereEndNodeIs(start))
                .traverse(partner)) {
            uniquePartnerRels.add(partnerPath.relationships().iterator().next().getId());
        }
    }
    System.out.println("Execution time: " + (System.currentTimeMillis() - startTime));
    System.out.println(uniquePartnerRels.size());
}

static enum Rel implements RelationshipType {
    COOCCURS_WITH
}

}

{
    node_id : long, 
    partners : long[],
    partner_partner_links : long[]
}

db.edge.find({"_id" : {"$in" : network.partner_partner_links}});