列表

列表（List）是复合数据类型，一个列表是一组元素的序列，可以通过元素在序列中的位置访问列表中的元素。

列表用左方括号（[）和右方括号（]）包裹多个元素，各个元素之间用英文逗号（,）隔开。元素前后的空格在列表中被忽略，因此可以使用换行符、制表符和空格调整格式。

示例

  1. # 返回列表[1,2,3]
  2. nebula> RETURN [1, 2, 3] AS List;
  3. +-----------+
  4. | List      |
  5. +-----------+
  6. | [1, 2, 3] |
  7. +-----------+
  9. # 返回列表[1,2,3,4,5]中位置下标为3的元素。列表的位置下标是从0开始，因此返回的元素为4。
  10. nebula> RETURN range(1,5)[3];
  11. +---------------+
  12. | range(1,5)[3] |
  13. +---------------+
  14. | 4             |
  15. +---------------+
  17. # 返回列表[1,2,3,4,5]中位置下标为-2的元素。列表的最后一个元素的位置下标是-1，因此-2是指倒数第二个元素，即4。
  18. nebula> RETURN range(1,5)[-2];
  19. +------------------+
  20. | range(1,5)[-(2)] |
  21. +------------------+
  22. | 4                |
  23. +------------------+
  25. # 返回列表[1,2,3,4,5]中位置下标大于2的元素。
  26. nebula> RETURN [n IN range(1,5) WHERE n > 2] AS a;
  27. +-----------+
  28. | a         |
  29. +-----------+
  30. | [3, 4, 5] |
  31. +-----------+
  33. # 筛选列表[1,2,3,4,5]中位置下标大于2的元素，将这些元素分别做运算并返回。
  34. nebula> RETURN [n IN range(1,5) WHERE n > 2 | n + 10] AS a;
  35. +--------------+
  36. | a            |
  37. +--------------+
  38. | [13, 14, 15] |
  39. +--------------+
  41. # 将列表[1,2,3,4,5]中的元素分别做运算，然后返回。
  42. nebula> RETURN [n IN range(1,5) | n + 10] AS a;
  43. +----------------------+
  44. | a                    |
  45. +----------------------+
  46. | [11, 12, 13, 14, 15] |
  47. +----------------------+
  49. # 将列表[1,2,3,4,5]中的元素分别做运算，然后将列表去掉表头并返回。
  50. nebula> RETURN tail([n IN range(1, 5) | 2 * n - 10]) AS a;
  51. +-----------------+
  52. | a               |
  53. +-----------------+
  54. | [-6, -4, -2, 0] |
  55. +-----------------+
  57. # 将列表[1,2,3]中的元素判断为真，然后返回。
  58. nebula> RETURN [n IN range(1, 3) WHERE true | n] AS r;
  59. +-----------+
  60. | r         |
  61. +-----------+
  62. | [1, 2, 3] |
  63. +-----------+
  65. # 返回列表[1,2,3]的长度。
  66. nebula> RETURN size([1,2,3]);
  67. +---------------+
  68. | size([1,2,3]) |
  69. +---------------+
  70. | 3             |
  71. +---------------+
  73. # 将列表[92,90]中的元素做运算，然后在where子句中进行条件判断。
  74. nebula> GO FROM "player100" OVER follow WHERE follow.degree NOT IN [x IN [92, 90] | x + $$.player.age] \
  75.         YIELD follow._dst AS id, follow.degree AS degree;
  76. +-------------+--------+
  77. | id          | degree |
  78. +-------------+--------+
  79. | "player101" | 95     |
  80. +-------------+--------+
  81. | "player102" | 90     |
  82. +-------------+--------+
  84. # 将MATCH语句的查询结果作为列表中的元素进行运算并返回。
  85. nebula> MATCH p = (n:player{name:"Tim Duncan"})-[:follow]->(m) \
  86.         RETURN [n IN nodes(p) | n.age + 100] AS r;
  87. +------------+
  88. | r          |
  89. +------------+
  90. | [142, 136] |
  91. +------------+
  92. | [142, 133] |
  93. +------------+

OpenCypher兼容性

  • 复合数据类型（例如set、map、list）不能存储为点或边的属性。

  • 不支持使用range()函数返回一个列表的部分元素。

    1. nebula> RETURN range(0,5)[0..3];
    2. [ERROR (-7)]: SyntaxError: syntax error near `3]'

  • 在openCypher中，查询越界元素时返回null，而在nGQL中，查询越界元素时返回OUT_OF_RANGE。

    1. nebula> RETURN range(0,5)[-12];
    2. +-------------------+
    3. | range(0,5)[-(12)] |
    4. +-------------------+
    5. | OUT_OF_RANGE      |
    6. +-------------------+