PostgreSQL将数据从递归CTE传递到函数

问题描述

我遇到以下问题：我试图发现从源节点（ node_s ）到目标节点（ node_t ）的所有可能路径。

带图边的原始表的格式很简单： | node_x | node_y |强度| ，其中node_x - >node_y是边缘强度为weight的直接边缘。 p 在探索路径的任何一点，我们发现其子节点中的一个节点的目标是 node_t ，我们记录此路径并停止探索来自此节点的路径，否则继续探索。 b

简单的解决方案是使用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_p AS 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 |强度
 -------- + -------- + ---------- 
 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 |目标|强度| 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 
 
  - 经过期限
 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 
  - 将只选择直接指向目标的行
 
 UNION（CTE中不允许使用第二个联合）
 
选择那些不行的行有直接的优势t 
以及哪个父母没有参与构建上述查询。 
 iebnode_x = tc.target b.node_x和node_t之间没有直接的边界b 
 
 
 
 
 
作为查询从源节点= 1到目标节点= 4的查询的结果，我希望得到以下结果： 
 
 
 来源|目标|强度| 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显然是非常优化的，所以我想深入挖掘它。 解决方案