标签: recursive

我有两张桌子

ID  Task
1   1
2   2
3   3
4   4

Col1  depend
2     3
2     4
3     1
4     2

ID和Col1通过 FK 约束相关。我想找出所有循环引用。这里ID和Col1仅用于组合来自 2 个表的行，例如：

Task 1 can start anytime.
Task 2 can start only after completion of 3, 4 etc

1 –
2 – 3, 4, 1, 2   -- for 2 there is circular dependency
3 – 1
4 – 2, 3, 4      -- also circular dependency

案例2：

Col1  depend
2 …

使用 PostgreSQL 8.4，我试图使用 order by 和两个表的索引列查询两个包含 100 万条记录的表，并且我正在失去性能（1 列需要 30 毫秒，两列需要 5 分钟）。例如：

select r.code, r.test_code, r.sample_code, s.barcode, s.registry_date
from requests r
inner join samples s on (s.code = r.sample_code)
order by s.barcode  asc , r.code asc
limit 21;

表信息：

CREATE TABLE public.samples (
  code BIGINT NOT NULL,
  barcode VARCHAR(40) NOT NULL,
  registry_date TIMESTAMP WITH TIME ZONE NOT NULL,
  CONSTRAINT samples_pkey PRIMARY KEY(code)
);

CREATE INDEX idx_samp_barcode ON public.samples (barcode);
CREATE INDEX idx_samp_barcode_code ON public.samples (barcode, code);
CREATE INDEX …

这是用 PostgreSQL 9.6 测试过的，但这是一个通用的 SQL 问题。

是否可以在递归 CTE (rCTE) 中使用递归表的自联接？

我尝试了以下包含递归项自联接的 rCTE x，

WITH RECURSIVE
x (id) AS (
  SELECT 1 id UNION ALL SELECT x1.id+x2.id FROM x x1, x x2
  WHERE x1.id < 5 AND x2.id < 5 AND x1.id = x2.id
  )
SELECT * FROM x;

，希望应该等同于：

WITH RECURSIVE
x (id) AS (
  SELECT 1 id UNION ALL SELECT id+id FROM x WHERE id < 5
  )
SELECT * FROM x;

但是之前的 rCTE 会产生一个错误：

ERROR:  recursive reference …

我正在尝试创建一个查询来计算库存中所有项目的“可销售”数量。在这种情况下，一个项目可以有当前可用的库存，但也可以是一个套件，它由可以组装以形成成品的原材料组成。因此，可供出售的是当前可用的成品 (FG) 数量加上可以制成 FG 的最少组件。

例子：

假设我们正在销售由笔记本电脑和手提包组成的笔记本电脑套件。如果我们已经制作了 2 个套件，以及 6 台笔记本电脑和 3 个手提袋，那么我们可以出售的这些套件总共是 2 + 3 = 5。在这种情况下，手提袋是限制因素。尽管我们有 6 台笔记本电脑，但由于包包限制了我们，我们只能多制作 3 个套件。

我已经走了这么远，计算从最低级别 2 到级别 1，但级别 0 不正确。因此，在这种情况下，笔记本电脑套件的计算是正确的（手头有 11 个 + 我们可以再制造 4 个 = 15 个可供出售）。但顶级笔记本电脑和包包是不正确的。最高级别（笔记本电脑和包套件）的直接子代的最少可销售量是 15 + 3 现有套件 = 18，而不是 14。

我在想也许我需要添加第二个递归 CTE 而不是我在最终选择中的左连接？

SQL小提琴

CREATE TABLE Item (
  Id INT,
  ParentId INT,
  DisplaySeq INT,  
  DisplayText VARCHAR(30),
  OnHandQty INT
  );

INSERT INTO Item (Id, ParentId, DisplaySeq, DisplayText, OnHandQty) VALUES
(9, NULL, 0, 'Laptop & Bag Kit', 3), …

我很感激我正在努力实现的一些帮助。

我公司制造的零件是由子组件和子组件的子组件构建的。这看起来像：

             1
         /   \  \
        /     |   \
       2      3    7
      / \    / \
     4   5  4   6

4 和 5 组合成 2，4 和 6 组成 3，然后组件 2、3 和 7 组成 1。

我的桌子看起来像这样；

+------+-----+-------+----------+----------------+
| ROOT | SUB | LEVEL | LEADTIME | TOP LEVEL PART |
+------+-----+-------+----------+----------------+
|    1 |   1 |     0 |        4 |              1 |
|    1 |   2 |     1 |        2 |              1 |
|    1 |   3 |     1 |        5 …

我正在尝试进行以下工作：

WITH results(n, string ) AS (
            SELECT 1,'lol'
            UNION ALL
            SELECT n+1, string + ' lol'
            FROM results
            WHERE n<6
            )
            SELECT * FROM results

但是 SQL 似乎无法识别第二列中的字符串连接并返回错误：

递归查询“结果”的“字符串”列中的锚点和递归部分之间的类型不匹配。

我想要的输出是这样的

1、哈哈

2、哈哈哈哈哈

3、哈哈哈哈哈

等等

给定像“ABC”这样的输入，生成一个查询，计算给定字符串的 0 个或多个的所有潜在分割，

期望的输出，

A   B   C
A   BC
AB  C
ABC

给定一个像“ABCD”这样的输入

A    B   C    D
A    BC  D
A    B   CD
AB   C   D
A    BCD
AB   CD
ABC  D
ABCD

并不是所有关心输出如何形成、数组、行、json 等。更多的是寻找分组的所有排列的离散列表。

给定一个特定的起始节点父 id ( pid) ，我需要计算二叉树结构中的左右节点（按 joinDate 分组的输出）。

树存储在下表中：

例如，使用pid = 4您将获得 2 cid(5 和 11 )，然后您将使用它们作为新的pid(5, 11)。当cid为 null 或已遍历完整树时，计算所有placement = Land placement = R。其他位置如“M”应该被忽略。

插图：

选定起始节点 4 的预期输出：

+-----------+-------------+-------+
| placement | joiningDate | Total |
+-----------+-------------+-------+
| L         | 2015-02-02  |     3 |
| R         | 2015-02-02  |     1 |
| L         | 2015-08-21  |     4 |
| L         | 2015-12-12  |     1 |
+-----------+-------------+-------+

具有这种简单的多对多自引用结构。
一个项目通过表拥有其他项目joins：

CREATE TABLE items (
  item_id   serial PRIMARY KEY
, title     text
);

CREATE TABLE joins (
  id        serial PRIMARY KEY
, item_id   int
, child_id  int
);

INSERT INTO items (item_id, title) VALUES
  (1, 'PARENT')
, (2, 'LEVEL 2')
, (3, 'LEVEL 3.1')
, (4, 'LEVEL 4.1')
, (5, 'LEVEL 4.2')
, (6, 'LEVEL 3.2')
;

INSERT INTO joins (item_id, child_id) VALUES
  (1, 2)
, (2, 3)
, (3, 4)
, (3, 5)
, (2, 6) …

我们有这个漂亮的 Postgres 树生成器。然而，它会产生一棵树的切口，而不是一次产生整棵树：

item_id jsonb_pretty
1   {
    "title": "PARENT",
    "item_id": 1,
    "children": {
        "title": "LEVEL 2",
        "item_id": 2,
        "children": {
            "title": "LEVEL 3.2",
            "item_id": 6
        }
    }
}
1   {
    "title": "PARENT",
    "item_id": 1,
    "children": {
        "title": "LEVEL 2",
        "item_id": 2,
        "children": {
            "title": "LEVEL 3.1",
            "item_id": 3,
            "children": {
                "title": "LEVEL 4.1",
                "item_id": 4
            }
        }
    }
}
1   {
    "title": "PARENT",
    "item_id": 1,
    "children": {
        "title": "LEVEL 2",
        "item_id": 2,
        "children": {
            "title": "LEVEL 3.1",
            "item_id": …