6

我在 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 做到这一点？

4

3 回答 3

10

很抱歉答案很晚，但我想我找到了一个优雅的解决方案，可以成为这个问题的公认答案。

基于@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上测试；）

于 2017-05-11T13:36:04.810 回答
8

您不能使用通常的递归 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类型化的lvlJSON 属性。

http://rextester.com/YNU7932

于 2014-09-05T09:52:24.473 回答
0

进一步开发了 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;
于 2017-06-29T09:39:57.260 回答