使用 row_to_json 進行 Postgres 遞歸查詢

Question

我在 postgres 9.3.5 中有一張表，如下所示：

CREATE TABLE customer_area_node
(
  id bigserial NOT NULL,
  customer_id integer NOT NULL,
  parent_id bigint,
  name text,
  description text,

  CONSTRAINT customer_area_node_pkey PRIMARY KEY (id)
)

我查詢：

WITH RECURSIVE c AS (
       SELECT *, 0 as level, name as path FROM customer_area_node WHERE customer_id = 2 and parent_id is null
       UNION ALL
       SELECT customer_area_node.*, 
       c.level + 1 as level, 
       c.path || '/' || customer_area_node.name as path
  FROM customer_area_node 
  join c ON customer_area_node.parent_id = c.id
)
SELECT * FROM c ORDER BY path;

這似乎適用於構建諸如 building1/floor1/room1、building1/floor1/room2 等路徑。

我希望能夠輕松地將其轉換為表示樹結構的 json，我被告知我可以使用 row_to_json 來完成。

作為一種合理的替代方法，我可以通過任何其他方式將數據格式化為更有效的機制，這樣我實際上可以輕松地將其轉換為實際的樹結構，而無需在 / 上使用大量 string.splits。

有沒有一種相當簡單的方法可以用 row_to_json 做到這一點？

Answer 1

您不能使用通常的遞歸 CTE 來做到這一點，因為幾乎不可能在其層次結構的深處設置 json 值。 但是你可以反過來做：從葉子開始構建樹，直到它的根：

-- calculate node levels
WITH RECURSIVE c AS (
    SELECT *, 0 as lvl
    FROM customer_area_node
    -- use parameters here, to select the root first
    WHERE customer_id = 2 AND parent_id IS NULL
  UNION ALL
    SELECT customer_area_node.*, c.lvl + 1 as lvl
    FROM customer_area_node 
    JOIN c ON customer_area_node.parent_id = c.id
),
-- select max level
maxlvl AS (
  SELECT max(lvl) maxlvl FROM c
),
-- accumulate children
j AS (
    SELECT c.*, json '[]' children -- at max level, there are only leaves
    FROM c, maxlvl
    WHERE lvl = maxlvl
  UNION ALL
    -- a little hack, because PostgreSQL doesn't like aggregated recursive terms
    SELECT (c).*, array_to_json(array_agg(j)) children
    FROM (
      SELECT c, j
      FROM j
      JOIN c ON j.parent_id = c.id
    ) v
    GROUP BY v.c
)
-- select only root
SELECT row_to_json(j) json_tree
FROM j
WHERE lvl = 0;

這甚至適用於 PostgreSQL 9.2+

SQLFiddle

更新：一個變體，它也應該處理流氓葉節點（位於 1 和max-level之間的級別）：

WITH RECURSIVE c AS (
    SELECT *, 0 as lvl
    FROM   customer_area_node
    WHERE  customer_id = 1 AND parent_id IS NULL
  UNION ALL
    SELECT customer_area_node.*, c.lvl + 1
    FROM   customer_area_node 
    JOIN   c ON customer_area_node.parent_id = c.id
),
maxlvl AS (
  SELECT max(lvl) maxlvl FROM c
),
j AS (
    SELECT c.*, json '[]' children
    FROM   c, maxlvl
    WHERE  lvl = maxlvl
  UNION ALL
    SELECT   (c).*, array_to_json(array_agg(j) || array(SELECT r
                                                        FROM   (SELECT l.*, json '[]' children
                                                                FROM   c l, maxlvl
                                                                WHERE  l.parent_id = (c).id
                                                                AND    l.lvl < maxlvl
                                                                AND    NOT EXISTS (SELECT 1
                                                                                   FROM   c lp
                                                                                   WHERE  lp.parent_id = l.id)) r)) children
    FROM     (SELECT c, j
              FROM   c
              JOIN   j ON j.parent_id = c.id) v
    GROUP BY v.c
)
SELECT row_to_json(j) json_tree
FROM   j
WHERE  lvl = 0;

這應該也適用於 PostgreSQL 9.2+，但是，我無法測試。 （我現在只能在 9.5+ 上測試）。

這些解決方案可以處理任何分層表中的任何列，但總是會在其輸出中附加一個int類型的lvl JSON 屬性。

http://rextester.com/YNU7932

Answer 2

很抱歉回答太晚了，但我想我找到了一個優雅的解決方案，可以成為這個問題的公認答案。

基於@pozs 發現的令人敬畏的“小技巧”，我想出了一個解決方案：

• 用很少的代碼解決“流氓葉子”的情況（利用NOT EXISTS謂詞）
• 避免整個級別的計算/條件的東西

WITH RECURSIVE customer_area_tree("id", "customer_id", "parent_id", "name", "description", "children") AS (
  -- tree leaves (no matching children)
  SELECT c.*, json '[]'
  FROM customer_area_node c
  WHERE NOT EXISTS(SELECT * FROM customer_area_node AS hypothetic_child WHERE hypothetic_child.parent_id = c.id)

  UNION ALL

  -- pozs's awesome "little hack"
  SELECT (parent).*, json_agg(child) AS "children"
  FROM (
    SELECT parent, child
    FROM customer_area_tree AS child
    JOIN customer_area_node parent ON parent.id = child.parent_id
  ) branch
  GROUP BY branch.parent
)
SELECT json_agg(t)
FROM customer_area_tree t
LEFT JOIN customer_area_node AS hypothetic_parent ON(hypothetic_parent.id = t.parent_id)
WHERE hypothetic_parent.id IS NULL

更新：

使用非常簡單的數據進行測試，它確實有效，但正如 posz 在評論中指出的那樣，使用他的示例數據，一些流氓葉節點被遺忘了。 但是，我發現對於更復雜的數據，之前的答案也不起作用，因為只有具有“最大級別”葉節點的共同祖先的流氓葉節點才會被捕獲（當“1.2.5.8”不存在時，“ 1.2.4" 和 "1.2.5" 不存在，因為它們沒有具有任何“最大級別”葉節點的共同祖先）。

所以這是一個新的提議，通過提取NOT EXISTS子請求並使其成為內部UNION ，利用UNION重復數據刪除能力（利用 jsonb 比較能力）將 posz 的工作與我的工作混合：

<!-- language: sql -->
WITH RECURSIVE
c_with_level AS (

    SELECT *, 0 as lvl
    FROM   customer_area_node
    WHERE  parent_id IS NULL

    UNION ALL

    SELECT child.*, parent.lvl + 1
    FROM   customer_area_node child
    JOIN   c_with_level parent ON parent.id = child.parent_id
),
maxlvl AS (
  SELECT max(lvl) maxlvl FROM c_with_level
),
c_tree AS (
    SELECT c_with_level.*, jsonb '[]' children
    FROM   c_with_level, maxlvl
    WHERE  lvl = maxlvl

    UNION 
    (
        SELECT (branch_parent).*, jsonb_agg(branch_child)
        FROM (
            SELECT branch_parent, branch_child
            FROM c_with_level branch_parent
            JOIN c_tree branch_child ON branch_child.parent_id = branch_parent.id
        ) branch
        GROUP BY branch.branch_parent

        UNION

        SELECT c.*, jsonb '[]' children
        FROM   c_with_level c
        WHERE  NOT EXISTS (SELECT 1 FROM c_with_level hypothetical_child WHERE hypothetical_child.parent_id = c.id)
    )
)
SELECT jsonb_pretty(row_to_json(c_tree)::jsonb)
FROM c_tree
WHERE lvl = 0;

在http://rextester.com/SMM38494 上測試；)

Answer 3

進一步開發了 pozs 的答案，以獲得帶有子樹的遞歸葉子。 所以這個答案真的返回了完整的樹。

CREATE OR REPLACE FUNCTION pg_temp.getTree(bigint) 
    RETURNS TABLE( 
            id bigint,
            customer_id integer,
            parent_id bigint,
            name text,
            description text,
            children json
        ) 
        AS $$   

        WITH RECURSIVE relations AS ( 
            SELECT 
                can.id,
                can.customer_id,
                can.parent_id,
                can.name, 
                can.description,
                0 AS depth 
                FROM customer_area_node can 
                WHERE can.id = $1 
            UNION ALL 
            SELECT 
                can.id,
                can.customer_id,
                can.parent_id,
                can.name, 
                can.description,
                relations.depth + 1 
                FROM customer_area_node can
                JOIN relations ON can.parent_id = relations.id AND can.id != can.parent_id
        ),     

        maxdepth AS ( 
            SELECT max(depth) maxdepth FROM relations 
        ), 

        rootTree as ( 
            SELECT r.* FROM 
                relations r, maxdepth 
                WHERE depth = maxdepth 
            UNION ALL 
            SELECT r.* FROM 
                relations r, rootTree 
                WHERE r.id = rootTree.parent_id AND rootTree.id != rootTree.parent_id 
        ), 

        mainTree AS ( 
            SELECT 
                c.id,
                c.customer_id,
                c.parent_id,
                c.name, 
                c.description,
                c.depth, 
                json_build_array() children 
                FROM relations c, maxdepth 
                WHERE c.depth = maxdepth 
            UNION ALL 
            SELECT 
                (relations).*, 
                array_to_json( 
                    array_agg(mainTree) 
                    || 
                    array( 
                        SELECT t 
                            FROM ( 
                                SELECT 
                                    l.*, 
                                    json_build_array() children 
                                FROM relations l, maxdepth 
                                    WHERE l.parent_id = (relations).id 
                                    AND l.depth < maxdepth 
                                    AND l.id  NOT IN ( 
                                        SELECT id FROM rootTree 
                                    ) 
                            ) r 
                           JOIN pg_temp.getTree(r.id) t 
                            ON r.id = t.id 
                        )) 
                children 
    FROM ( 
        SELECT relations, mainTree 
            FROM relations 
        JOIN mainTree 
            ON ( 
                mainTree.parent_id = relations.id 
                AND mainTree.parent_id != mainTree.id 
            ) 
    ) v 
    GROUP BY v.relations 
    ) 

        SELECT 
            id,
            customer_id,
            parent_id,
            name, 
            description,
            children 
        FROM mainTree WHERE id = $1 
    $$ 
    LANGUAGE SQL; 

    SELECT * 
    FROM 
        customer_area_node can 
        JOIN pg_temp.getTree(can.id) t ON t.id = can.id 
    WHERE can.parent_id IS NULL;