Neo4j -嵌套FOREACH查询失败

Question

问题: Neo4j浏览器锁定Executing query...或返回Unknown error。原因是我下面的查询中的第三个FOREACH，只有FOREACH定义而不是MERGE/CREATE子句。

我试着创建一个Cypher查询，该查询将以年份集合作为整数，并创建年份/月/日节点。我试图通过使用集合/映射(先使用集合/映射)，然后使用嵌套的FOREACH子句来减少行数，这些子句在创建天数的FOREACH之前工作得很好。

问题似乎来自于使用映射的整数，如果我用一个普通整数替换m.num，它将处理天数很好，但只处理一个月(多次)。

该查询基于Kenny Bastani的以下查询：

https://gist.github.com/kbastani/8519557

我还将CREATE更改为CREATE UNIQUE，这将防止类似于MERGE的重复关系/节点

我应该以不同的方式编写查询吗？我确实有一个旧版本的查询工作一次，但是在localhost和grapheneDB上都锁定了执行查询。当初始测试查询(年份：1999,2000,2004,2010,2400)在grapheneDB上工作时，它返回：

Added 1755 labels, created 1755 nodes, set 5195 properties, created 1800 relationships, returned 0 rows in 20049 ms

这是合理的时间吗？它会因为使用GrapheneDB和256 it内存而慢吗？或者，通过将Cypher简化为嵌套查询和集合/映射，我是否使查询的性能变得效率低下？

以下是我的疑问：

//Date ranges in a month
WITH 
    range(1, 28) as Days_28, 
    range(1, 29) as Days_29, 
    range(1, 30) as Days_30, 
    range(1, 31) as Days_31

//Assign months date ranges
WITH 
    Days_31 as January, 
    Days_28 as February, 
    Days_29 as Leap_February, 
    Days_31 as March, 
    Days_30 as April, 
    Days_31 as May, 
    Days_30 as June,
    Days_31 as July, 
    Days_31 as August, 
    Days_30 as September, 
    Days_31 as October, 
    Days_30 as November, 
    Days_31 as December

//Mapping months to days keys - num key could be avoided by changing FOREACH to: 'FOREACH(m IN range(1,length(year.months)) |' or 'FOREACH(m IN range(1, 12) |'
WITH [
    {num: 1, days: January}, 
    {num: 2, days: February}, 
    {num: 3, days: March}, 
    {num: 4, days: April}, 
    {num: 5, days: May}, 
    {num: 6, days: June}, 
    {num: 7, days: July}, 
    {num: 8, days: August}, 
    {num: 9, days: September}, 
    {num: 10, days: October}, 
    {num: 11, days: November}, 
    {num: 12, days: December}
    ] as regular_year, Leap_February

//Create leap year
WITH [regular_year[0] , {num: 2, days: Leap_February} , regular_year[2..11]] AS leap_year, regular_year

//Years to create are stored in years collection - anyway to move this to the top without having to add it to the end of every WITH clause prior?
WITH [1996] as years,leap_year,regular_year
//Check if year is a leap year, if so map to leap_year, if not map regular_year
WITH [year IN years | CASE WHEN (year%4=0 AND NOT year%100=0) THEN {year:year, months:leap_year} WHEN (year%4=0 AND year%100=0 AND year%400=0) THEN {year:year, months:leap_year} ELSE {year:year, months:regular_year} END] AS yearMap

//Create nodes/relationships for years/months/days
FOREACH(year IN yearMap |
    MERGE (thisYear: Year {year: year.year})

    FOREACH(m IN year.months |
        MERGE (thisMonth :Month { month: m.num, year: year.year })
        CREATE UNIQUE (thisYear)-[:HAS_MONTH]->(thisMonth)

        MERGE (firstDay :Day { day: 1, month: m.num, year: year.year })
        CREATE UNIQUE (thisMonth)-[:FIRST]->(firstDay)

        //This FOREACH line is causing a problem, if replace m.num with an integer value it works, but then only processes that month
        FOREACH (d IN TAIL((year.months[m.num]).days) |
            MERGE (thisDay: Day { day: d, month: m.num, year: year.year })
            MERGE (lastDay: Day { day: d - 1, month: m.num, year: year.year })
            CREATE UNIQUE(lastDay)-[:NEXT]->(thisDay)
        )

    MERGE (lastDay: Day { day: last((year.months[m.num]).days), month: m.num, year: year.year })
    CREATE UNIQUE (thisMonth)-[:LAST]->(lastDay)
    )
)

更新：我发现了一些错误。由于查询的第一个版本，我改变了创建leap_year集合的方式。规则年与查询工作很好，它只是打破了闰年。这是因为误解了regular_year2..11，我原以为它会切分2-11，但是第二个整数是上限吗？将其改为12个月将增加剩余的所有月份。该方法还导致leap_year的长度为3而不是12，通过将行更改为：

WITH [regular_year[0], {num: 2, days: Leap_February}] + filter(month in regular_year WHERE month.num>2) AS leap_year, regular_year

我发现的第二个问题是在第三个FOREACH中，我使用的是(year.months[m.num]).days，在这里我应该让m.num-1正确地访问集合，并再次访问最后一个MERGE。但是，对于闰年，查询仍然中断。

更新2: --我想我在编辑中列出的修复程序已经成功了。在我所有年份的localhostDB中，除了我测试的那一年(2000年)，我用一个类似的闰年(2400)进行了检查，这很有效。

我尝试对grapheneDB中的数据库进行查询，得到了以下错误：

The pattern (thisMonth)-[1469:FIRST]->(firstDay) produced multiple possible paths, and that is not allowed

它所指的代码片段是：

FOREACH(m IN year.months |
 MERGE (thisMonth:Month { month: m.num, year: year.year })
 CREATE UNIQUE (thisYear)-[:HAS_MONTH]->(thisMonth)

 MERGE (firstDay:Day { day: 1, month: m.num, year: year.year })
 CREATE UNIQUE (thisMonth)-[:FIRST]->(firstDay)

我一直在grapheneDB的那个数据库中处理这个查询，创建了一个新的数据库，并且使用这个查询--一切都很好，即使是2000年。大约花费了4000 of，然后我尝试了这个查询，它混合了一个共6年的规则/闰年。它无法完成查询，尽管存在大量的节点。在单个年份(现有或不存在)上再次使用该查询失败。我的查询一定是以某种方式破坏了数据库？

Answer 1

我和石墨线人谈过：

一个是空闲的沙箱实例，内存、cpu和执行时间都有一定的资源限制。如果其中一个数据库超出了进一步的限制而无法恢复，它将被重新启动。

他们还说，如果你遇到有关石墨烯的问题，你应该联系他们的支持。或者，如果您通过heroku支持系统使用heroku外接程序。