列表

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

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

列表操作

对列表进行操作可以使用预设的列表函数,也可以使用下标表达式过滤列表内的元素。

下标表达式语法

  1. [M]
  2. [M..N]
  3. [M..]
  4. [..N]

nGQL的下标支持从前往后查询,从0开始,0表示第一个元素,1表示第二个元素,以此类推;也支持从后往前查询,从-1开始,-1表示最后一个元素,-2表示倒数第二个元素,以此类推。

  • [M]:表示下标为M的元素。
  • [M..N]:表示M ≤ 下标 < N的元素。N为0时,返回为空。
  • [M..]:表示M ≤ 下标的元素。
  • [..N]:表示下标 < N的元素。N为0时,返回为空。

示例

  1. # 返回列表[1,2,3]
  2. nebula> RETURN [1, 2, 3] AS List;
  3. +-----------+
  4. | List |
  5. +-----------+
  6. | [1, 2, 3] |
  7. +-----------+
  8. # 返回列表[1,2,3,4,5]中位置下标为3的元素。列表的位置下标是从0开始,因此返回的元素为4。
  9. nebula> RETURN range(1,5)[3];
  10. +---------------+
  11. | range(1,5)[3] |
  12. +---------------+
  13. | 4 |
  14. +---------------+
  15. # 返回列表[1,2,3,4,5]中位置下标为-2的元素。列表的最后一个元素的位置下标是-1,因此-2是指倒数第二个元素,即4。
  16. nebula> RETURN range(1,5)[-2];
  17. +------------------+
  18. | range(1,5)[-(2)] |
  19. +------------------+
  20. | 4 |
  21. +------------------+
  22. # 返回列表[1,2,3,4,5]中下标位置从0到3(不包括3)的元素。
  23. nebula> RETURN range(1,5)[0..3];
  24. +------------------+
  25. | range(1,5)[0..3] |
  26. +------------------+
  27. | [1, 2, 3] |
  28. +------------------+
  29. # 返回列表[1,2,3,4,5]中位置下标大于2的元素。
  30. nebula> RETURN range(1,5)[3..] AS a;
  31. +--------+
  32. | a |
  33. +--------+
  34. | [4, 5] |
  35. +--------+
  36. # 返回列表内下标小于3的元素。
  37. nebula> WITH [1, 2, 3, 4, 5] AS list \
  38. RETURN list[..3] AS r;
  39. +-----------+
  40. | r |
  41. +-----------+
  42. | [1, 2, 3] |
  43. +-----------+
  44. # 筛选列表[1,2,3,4,5]中大于2的元素,将这些元素分别做运算并返回。
  45. nebula> RETURN [n IN range(1,5) WHERE n > 2 | n + 10] AS a;
  46. +--------------+
  47. | a |
  48. +--------------+
  49. | [13, 14, 15] |
  50. +--------------+
  51. # 返回列表内第一个至倒数第二个(包括)的元素。
  52. nebula> YIELD [1, 2, 3][0..-1] AS a;
  53. +--------+
  54. | a |
  55. +--------+
  56. | [1, 2] |
  57. +--------+
  58. # 返回列表内倒数第三个至倒数第一个(不包括)的元素。
  59. nebula> YIELD [1, 2, 3, 4, 5][-3..-1] AS a;
  60. +--------+
  61. | a |
  62. +--------+
  63. | [3, 4] |
  64. +--------+
  65. # 设置变量,返回列表内下标为1、2的元素。
  66. nebula> $var = YIELD 1 AS f, 3 AS t; \
  67. YIELD [1, 2, 3][$var.f..$var.t] AS a;
  68. +--------+
  69. | a |
  70. +--------+
  71. | [2, 3] |
  72. +--------+
  73. # 越界的下标返回为空,未越界的可以正常返回。
  74. nebula> RETURN [1, 2, 3, 4, 5] [0..10] AS a;
  75. +-----------------+
  76. | a |
  77. +-----------------+
  78. | [1, 2, 3, 4, 5] |
  79. +-----------------+
  80. nebula> RETURN [1, 2, 3] [-5..5] AS a;
  81. +-----------+
  82. | a |
  83. +-----------+
  84. | [1, 2, 3] |
  85. +-----------+
  86. # [0..0]时返回为空。
  87. nebula> RETURN [1, 2, 3, 4, 5] [0..0] AS a;
  88. +----+
  89. | a |
  90. +----+
  91. | [] |
  92. +----+
  93. # M ≥ N时,返回为空。
  94. nebula> RETURN [1, 2, 3, 4, 5] [3..1] AS a;
  95. +----+
  96. | a |
  97. +----+
  98. | [] |
  99. +----+
  100. # 范围查询时,下标有null时,返回为null。
  101. nebula> WITH [1,2,3] AS list \
  102. RETURN list[0..null] as a;
  103. +----------+
  104. | a |
  105. +----------+
  106. | __NULL__ |
  107. +----------+
  108. # 将列表[1,2,3,4,5]中的元素分别做运算,然后将列表去掉表头并返回。
  109. nebula> RETURN tail([n IN range(1, 5) | 2 * n - 10]) AS a;
  110. +-----------------+
  111. | a |
  112. +-----------------+
  113. | [-6, -4, -2, 0] |
  114. +-----------------+
  115. # 将列表[1,2,3]中的元素判断为真,然后返回。
  116. nebula> RETURN [n IN range(1, 3) WHERE true | n] AS r;
  117. +-----------+
  118. | r |
  119. +-----------+
  120. | [1, 2, 3] |
  121. +-----------+
  122. # 返回列表[1,2,3]的长度。
  123. nebula> RETURN size([1,2,3]);
  124. +---------------+
  125. | size([1,2,3]) |
  126. +---------------+
  127. | 3 |
  128. +---------------+
  129. # 将列表[92,90]中的元素做运算,然后在where子句中进行条件判断。
  130. nebula> GO FROM "player100" OVER follow WHERE follow.degree NOT IN [x IN [92, 90] | x + $$.player.age] \
  131. YIELD follow._dst AS id, follow.degree AS degree;
  132. +-------------+--------+
  133. | id | degree |
  134. +-------------+--------+
  135. | "player101" | 95 |
  136. +-------------+--------+
  137. | "player102" | 90 |
  138. +-------------+--------+
  139. # 将MATCH语句的查询结果作为列表中的元素进行运算并返回。
  140. nebula> MATCH p = (n:player{name:"Tim Duncan"})-[:follow]->(m) \
  141. RETURN [n IN nodes(p) | n.age + 100] AS r;
  142. +------------+
  143. | r |
  144. +------------+
  145. | [142, 136] |
  146. +------------+
  147. | [142, 133] |
  148. +------------+

OpenCypher兼容性

  • 在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. +-------------------+
  • 复合数据类型(例如set、map、list)不能存储为点或边的属性。

    • 建议修改图建模方式:将复合数据类型建模为点的邻边,而不是该点的自身属性,每条邻边可以动态增删,并且可以设置邻边的 Rank 值来控制邻边的顺序。
  • List中不支持pattern,例如 [(src)-[]->(m) | m.name]