ORDER BY

ORDER BY 是一个子句，它决定 RETURN 或 WITH 子句的结果如何排序。从 Neo4j 5.24 开始，它也可以作为一个独立子句使用，无论是单独使用还是与 SKIP/OFFSET 或 LIMIT 结合使用。

ORDER BY 默认按升序对结果进行排序，但可以修改为按降序对结果进行排序。

ORDER BY 依靠比较来对输出进行排序（有关详细信息，请参阅值类型的相等性、排序和比较）。您可以根据不同的值进行排序，例如节点或关系的属性、ID 或表达式的结果。

除非使用 ORDER BY，否则 Neo4j 不保证查询结果的行顺序。

示例图

以下示例使用具有以下模式的图

要重新创建它，请对空 Neo4j 数据库运行以下查询

CREATE (o1:Order {id: 'ORD-001', orderDate: datetime('2024-05-01T10:00:00'), total: 550, status: 'shipped'}),
       (o2:Order {id: 'ORD-002', orderDate: datetime('2024-05-02T14:30:00'), total: 1000, status: 'pending'}),
       (o3:Order {id: 'ORD-003', orderDate: datetime('2024-05-03T09:15:00'), total: 550, status: 'pending'}),
       (o4:Order {id: 'ORD-004', orderDate: datetime('2024-05-04T12:45:00'), total: 200}),
       (o5:Order {id: 'ORD-005', orderDate: datetime('2024-05-05T15:00:00'), total: 800, status: 'shipped'}),

       (i1:Item {name: 'Phone', price: 500}),
       (i2:Item {name: 'Laptop', price: 1000}),
       (i3:Item {name: 'Headphones', price: 250}),
       (i4:Item {name: 'Charger', price: 50}),
       (i5:Item {name: 'Keyboard', price: 200}),

       (o1)-[:CONTAINS]->(i1),
       (o1)-[:CONTAINS]->(i4),
       (o2)-[:CONTAINS]->(i2),
       (o3)-[:CONTAINS]->(i1),
       (o3)-[:CONTAINS]->(i4),
       (o4)-[:CONTAINS]->(i5),
       (o5)-[:CONTAINS]->(i1),
       (o5)-[:CONTAINS]->(i3),
       (o5)-[:CONTAINS]->(i4)

基本示例

示例 1. 按属性值排序

ORDER BY 可用于按属性值对结果进行排序。

按节点属性排序

MATCH (o:Order)
RETURN o.id AS order,
       o.total AS total
  ORDER BY total

返回节点，按 total 属性的值升序排序。

结果
订单	总计
`"ORD-004"`	`200`
`"ORD-001"`	`550`
`"ORD-003"`	`550`
`"ORD-005"`	`800`
`"ORD-002"`	`1000`
行数：5

示例 2. 按多个属性值排序

通过在 ORDER BY 子句中列出两个或多个属性来按多个属性值排序。Cypher^® 首先按第一个属性排序，如果值相等，则移动到下一个属性，依此类推。

按多个属性排序

MATCH (o:Order)
RETURN o.id AS order,
       o.total AS total,
       o.orderDate AS orderDate
  ORDER BY total,
           orderDate

这将返回节点，首先按其 total 属性排序，然后对于相等的值，按其 orderDate 属性排序。

结果
订单	总计	订单日期
`"ORD-004"`	`200`	`2024-05-04T12:45Z`
`"ORD-001"`	`550`	`2024-05-01T10:00Z`
`"ORD-003"`	`550`	`2024-05-03T09:15Z`
`"ORD-005"`	`800`	`2024-05-05T15:00Z`
`"ORD-002"`	`1000`	`2024-05-02T14:30Z`
行数：5

示例 3. 按 ID 排序

ORDER BY 可用于按节点或关系的 ID 进行排序（通过 elementId() 或 id() 函数检索）。

按元素 ID 排序

MATCH (o:Order)
RETURN o.id AS order,
       elementId(o) AS elementId
  ORDER BY elementId

结果
订单	元素 ID
`"ORD-001"`	`"4:9350eddd-5a35-413d-8684-708b1da35d23:0"`
`"ORD-002"`	`"4:9350eddd-5a35-413d-8684-708b1da35d23:1"`
`"ORD-003"`	`"4:9350eddd-5a35-413d-8684-708b1da35d23:2"`
`"ORD-004"`	`"4:9350eddd-5a35-413d-8684-708b1da35d23:3"`
`"ORD-005"`	`"4:9350eddd-5a35-413d-8684-708b1da35d23:4"`
行数：5

当节点和关系被删除时，Neo4j 会重用其内部 ID。因此，依赖内部 Neo4j ID 的应用程序是不稳定的，并且可能不准确。建议使用应用程序生成的 ID。

示例 4. 按表达式排序

ORDER BY 可用于根据表达式的结果进行排序。以下查询计算每个订单 total 属性值的 10% 折扣，然后按折扣后的总额对结果进行排序。

按表达式结果排序

MATCH (o:Order)
RETURN o.id AS order,
       o.total * 0.9 AS discountedTotal
  ORDER BY discountedTotal

结果
订单	折扣后总额
`"ORD-004"`	`180.0`
`"ORD-001"`	`495.0`
`"ORD-003"`	`495.0`
`"ORD-005"`	`720.0`
`"ORD-002"`	`900.0`
行数：5

下一个查询计算每个订单中包含的商品数量，然后按商品数量对结果进行排序。

按表达式结果排序

MATCH (o:Order)
RETURN o.id AS order,
      COUNT { (o)-[:CONTAINS]->(:Item) } AS itemCount
  ORDER BY itemCount

结果
订单	商品数量
`"ORD-002"`	`1`
`"ORD-004"`	`1`
`"ORD-001"`	`2`
`"ORD-003"`	`2`
`"ORD-005"`	`3`
行数：5

按不在结果中的值排序

ORDER BY 可以按不包含在结果集中的值进行排序。也就是说，排序键不需要是前面的 RETURN 或 WITH 子句的一部分。例如，下面的查询根据订单中包含的商品数量对订单进行排序，即使该计数未返回。

按未返回结果中的值排序

MATCH (o:Order)
RETURN o.id AS order
  ORDER BY COUNT { (o)-[:CONTAINS]->(:Item) }

结果
订单
`"ORD-002"`
`"ORD-004"`
`"ORD-001"`
`"ORD-003"`
`"ORD-005"`
行数：5

升序和降序

ORDER BY 默认按升序对结果进行排序。要显式按升序对结果进行排序，请附加 ASC[ENDING]。

显式按升序排序结果

MATCH (o:Order)
RETURN o.id AS order,
       o.total AS total
  ORDER BY total ASC

结果
订单	总计
`"ORD-004"`	`200`
`"ORD-001"`	`550`
`"ORD-003"`	`550`
`"ORD-005"`	`800`
`"ORD-002"`	`1000`
行数：5

要按降序对结果进行排序，请附加 DESC[ENDING]。

按降序排序结果

MATCH (o:Order)
RETURN o.id AS order,
       o.total AS total
  ORDER BY total DESC

结果
订单	总计
`"ORD-002"`	`1000`
`"ORD-005"`	`800`
`"ORD-001"`	`550`
`"ORD-003"`	`550`
`"ORD-004"`	`200`
行数：5

ORDER BY 可以结合升序和降序排序。在下面的示例中，结果首先按 total 值降序排序，然后按 orderDate 值升序排序。

组合升序和降序结果排序

MATCH (o:Order)
RETURN o.id AS order,
       o.total AS total,
       o.orderDate AS orderDate
  ORDER BY total DESC,
           orderDate ASC

结果
订单	总计	订单日期
`"ORD-002"`	`1000`	`2024-05-02T14:30Z`
`"ORD-005"`	`800`	`2024-05-05T15:00Z`
`"ORD-001"`	`550`	`2024-05-01T10:00Z`
`"ORD-003"`	`550`	`2024-05-03T09:15Z`
`"ORD-004"`	`200`	`2024-05-04T12:45Z`
行数：5

ORDER BY 和模式匹配

ORDER BY 可用于在继续进行其他模式匹配之前对结果进行排序。在下面的示例中，它与 LIMIT 结合使用，首先按 Order 节点的 orderDate 属性值进行排序，将结果限制为最近的 Order，然后匹配任何连接的 Item 节点。另请注意，在此示例中，ORDER BY 和 LIMIT 用作独立子句，而不是子子句。

查找最近下的订单中包含的商品

MATCH (o:Order)
ORDER BY o.orderDate DESC
LIMIT 1
MATCH (o)-[:CONTAINS]->(i:Item)
RETURN o.id AS order,
       o.total,
       collect(i.name) AS items

结果
订单	总计	商品
`"ORD-005"`	`800`	`["Phone", "Headphones", "Charger"]`
行数：1

空值

排序时，null 值在升序中出现在最后，在降序中出现在最前面。

按空属性排序

MATCH (o:Order)
RETURN o.id AS order,
       o.status AS status
  ORDER BY status DESC

结果
订单	状态
`"ORD-004"`	`null`
`"ORD-001"`	`"shipped"`
`"ORD-005"`	`"shipped"`
`"ORD-002"`	`"pending"`
`"ORD-003"`	`"pending"`
行数：5

ORDER BY 和 WITH 子句

当 ORDER BY 出现在 WITH 子句上时，紧随其后的子句将按指定顺序接收记录。这种保证的顺序对于依赖于值处理顺序的操作非常有用。例如，将 ORDER BY 附加到 WITH 子句可以用于控制由 collect() 聚合函数生成的列表中项的顺序。MERGE 和 SET 子句也具有排序依赖性，可以通过这种方式进行控制。

以下示例使用 WITH 和 ORDER BY 按 Item 节点的 price 属性对其进行排序，然后后续 RETURN 子句中的 collect() 根据该排序为每个订单构建一个有序列表。

WITH、ORDER BY 和 collect()

MATCH (o:Order)-[:CONTAINS]->(i:Item)
WITH o, i
  ORDER BY i.price DESC
RETURN o.id AS order,
       collect(i.name || " ($" || toString(i.price) || ")") AS orderedListOfItems

结果
订单	有序商品列表
`"ORD-002"`	`["Laptop ($1000)"]`
`"ORD-001"`	`["Phone ($500)", "Charger ($50)"]`
`"ORD-003"`	`["Phone ($500)", "Charger ($50)"]`
`"ORD-005"`	`["Phone ($500)", "Headphones ($250)", "Charger ($50)"]`
`"ORD-004"`	`["Keyboard ($200)"]`
行数：5

聚合或 DISTINCT 结果的排序

ORDER BY 可用的变量取决于前面的 RETURN 或 WITH 子句是否执行聚合以组合结果或使用 DISTINCT 删除重复项。

如果 RETURN 或 WITH 未聚合值或未使用 DISTINCT，则 ORDER BY 可以引用前面 RETURN 或 WITH 子句中引用的任何变量。

WITH 子句（不包括聚合或 DISTINCT）后的 ORDER BY

MATCH (o:Order)-[:CONTAINS]->(i:Item)
WITH o.id AS order,
     i.name AS item
  ORDER BY o.orderDate
RETURN order, item

如果 RETURN 或 WITH 执行聚合或使用 DISTINCT，则只有来自任一操作的投影变量才可用于 ORDER BY。这是因为这些操作会改变子句生成的行数，并且任何未明确投影的变量都将被丢弃。

WITH 子句投影聚合值后的 ORDER BY

MATCH (o:Order)-[:CONTAINS]->(i:Item)
WITH collect(o.id) AS orders,
     i.name AS items
  ORDER BY o.orderDate
RETURN orders, items

错误消息

In a WITH/RETURN with DISTINCT or an aggregation, it is not possible to access variables declared before the WITH/RETURN: o

ORDER BY 和索引

使用 ORDER BY 对节点属性进行排序的 Cypher 查询的性能可能会受到查找节点的索引的存在和使用的影响。如果索引可以按查询中请求的顺序提供节点，Cypher 可以避免使用昂贵的 Sort 操作。有关此功能的更多信息，请参阅范围索引支持的 ORDER BY。

将 `ORDER BY` 用作独立子句

ORDER BY 可以作为独立子句使用，也可以与 SKIP/OFFSET 或 LIMIT 结合使用。

ORDER BY 的独立使用

MATCH (i:Item)
ORDER BY i.price
RETURN collect(i.name || " ($" || toString(i.price) || ")") AS orderedPriceList

结果
有序价格列表
`["Charger ($50)", "Keyboard ($200)", "Headphones ($250)", "Phone ($500)", "Laptop ($1000)"]`
行数：1

ORDER BY 与 SKIP 和 LIMIT 结合使用

MATCH (i:Item)
ORDER BY i.price DESC
SKIP 1
LIMIT 1
RETURN i.name AS secondMostExpensiveItem,
       i.price AS price

结果
第二昂贵的商品	价格
`"Phone"`	`500`
行数：1