【发布时间】：2012-05-10 16:15:00
【问题描述】：
我有以下问题：我正在尝试发现从源节点 (node_s) 到目标节点 (node_t) 的所有可能路径。
带有图边的原始表格的格式很简单：|节点_x |节点_y | strength | ，其中 "node_x" -> "node_y" 是直接边，边的强度为 "weight"。
我们的想法是，如果在探索路径期间的任何时候，我们发现其子节点中的一个节点具有目标 node_t，我们记录该路径并停止从该节点探索路径，否则继续探索.
简单的解决方案是使用 PostgreSQL 的递归 CTE 构造图的传递闭包：
WITH RECURSIVE transitive_closure (source, target, weight, path_string) AS
(
--non-recurive term
SELECT b.node_x, b.node_y, b.strength, b.node_x || '.' || b.node_y || '.' AS path_string
FROM best_path b
WHERE b.node_x = node_s --source_node
UNION
--recurive term
SELECT tc.source, b.node_y, least(tc.weight,b.strength), tc.path_string || b.node_y || '.' AS path_string
FROM best_path AS b JOIN transitive_closure AS tc ON b.node_x = tc.target
WHERE tc.path_string NOT LIKE '%' || b.node_y || '.%'
)
SELECT *
FROM transitive_closure tc
WHERE tc.target = node_t --target_node
上面的代码将从源节点node_s发现所有可能的路径。只有在传递闭包构造之后，我才能选择从源节点到目标节点所需的路径行（参见最后一个 SELECT 语句）。
例子：
best_path 表有以下数据：
node_x | node_y | strength
--------+--------+----------
1 | 2 | 1
1 | 3 | 1
2 | 4 | 1
2 | 5 | 1
3 | 6 | 1
3 | 7 | 1
4 | 8 | 1
4 | 9 | 1
5 | 10 | 1
5 | 11 | 1
查询：
找到从源节点 = 1 到目标节点 = 4 的路径
结果：
source | target | strength | path_string
--------+--------+----------+------------
1 | 2 | 1 | 1.2.
1 | 3 | 1 | 1.3.
1 | 4 | 1 | 1.2.4.
1 | 5 | 1 | 1.2.5.
1 | 6 | 1 | 1.3.6.
1 | 7 | 1 | 1.3.7.
1 | 8 | 1 | 1.2.4.8.
1 | 9 | 1 | 1.2.4.9.
1 | 10 | 1 | 1.2.5.10.
1 | 11 | 1 | 1.2.5.11.
这不是我需要的。由于已经有从节点 2 到节点 4（目标）的直接边，我不需要路径 1.2.5.、1.2.4.8.、1.2.4.9.、1.2.5.10.、1.2.5.11.，路径探索对于节点 2，应该在发现从 2 到 4 的路径时停止。
总而言之，如果节点已经有到目标节点的直接边，我不想发现它的路径。这意味着在 CTE 的递归术语中，我希望有一些条件会说如下，伪代码如下：
WITH RECURSIVE transitive_closure (source, target, weight, path_string) AS
(
--non-recurive term (as before)
SELECT b.node_x, b.node_y, b.strength, b.node_x || '.' || b.node_y || '.' AS path_string
FROM best_path b
WHERE b.node_x = node_s --source_node
UNION
--recurive term
SELECT tc.source, b.node_y, least(tc.weight,b.strength), tc.path_string || b.node_y || '.' AS path_string
FROM best_path AS b JOIN transitive_closure AS tc ON b.node_x = tc.target
WHERE tc.path_string NOT LIKE '%' || b.node_y || '.%'
AND b.node_y = node_t
--will select only rows with direct edge to target
UNION (second union is not allowed in CTE)
SELECT those rows which do not have direct edge to target
AND which parents did not contribute to constructing the query above.
i.e. b.node_x = tc.target where there is no direct edge between b.node_x to node_t
)
作为查找从源节点 = 1 到目标节点 = 4 的路径的查询结果，我想要以下内容：
source | target | strength | path_string
--------+--------+----------+------------
1 | 2 | 1 | 1.2.
1 | 3 | 1 | 1.3.
1 | 4 | 1 | 1.2.4.
1 | 6 | 1 | 1.3.6.
1 | 7 | 1 | 1.3.7.
提前感谢您的帮助！
我已经尝试了很多方法：例如FROM/WHERE 子句中的条件，试图将 CTE 传递给函数，但没有成功。
任何建议将不胜感激。
我有自己的递归函数，可以实现我想要的，但是，它在大量数据上非常慢；并且 PostgreSQL 的 CTE 显然优化得很好，所以我想深入研究一下。
【问题讨论】：
-
如果 Source = 2 和 Target = 5，结果是什么？请将其附加到您的问题中。我正在尝试完善这个查询：stackoverflow.com/a/10395130
-
第一个CTE会输出不想要的结果：2->4 (2.4.), 2->5 (2.5.), 2->8 (2.4.8.), 2->9 (2.4.9.)、2->10 (2.5.10.)、2->11 (2.5.11.)。期望的输出是：2->5 (2.5.)
-
我已经修改了我的答案stackoverflow.com/a/10395130 现在只产生 2->5 个
-
@MichaelBuen 谢谢您，目前正在测试，将返回测试结果！
-
另一种查询优化方法，虽然不能移植到其他数据库，但仅适用于 Postgresql，它使用 DISTINCT ON：stackoverflow.com/a/10401572
标签： postgresql graph transitive-closure-table recursive-cte