列表

列表（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时，返回为空。

Note

  • 越界的下标返回为空，未越界的可以正常返回。
  • M≥N时，返回为空。
  • 查询单个元素时，如果M为null，返回报错BAD_TYPE；范围查询时，M或N为null，返回为null。

示例

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

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]。

最后更新: August 19, 2021