标签: recursive-query

我有一个包含事件范围的表，如下所示：

id | title | start      | end
1  | Lorem | 2019-11-02 | 2019-11-03
2  | Ipsum | 2019-11-02 | 2019-11-02
3  | Dolor | 2019-11-08 | 2019-11-10
4  | Amet  | 2019-11-02 | 2019-11-04

我想选择所有行，但加入范围内的日期，这样我就可以为范围内每天的每个事件设置 X 行。结果应该来自我的示例表：

date        | id | title | start      | end
2019-11-02  | 1  | Lorem | 2019-11-02 | 2019-11-03
2019-11-02  | 2  | Ipsum | 2019-11-02 | 2019-11-02
2019-11-02  | 4  | Amet  | 2019-11-02 | 2019-11-04
2019-11-03  | 1  | Lorem …

我需要获取直接或间接依赖某人的所有员工的姓名。使用本示例中的查询（来自https://rextester.com/WGVRGJ67798），

create table employee(
id int not null,
employee varchar(10) not null,
boss int null    
)

insert into employee values
(1,'Anna',null),
(2,'Bob',1),
(3,'Louis',1),
(4,'Sara',2),
(5,'Sophie',2),
(6,'John',4);

with boss as (
     select id, employee, boss, cast(null as varchar(10)) as name
     from employee 
     where boss is null
    
     union all 
    
     select e.id, e.employee, b.id, b.employee
     from employee e 
     join boss b on b.id = e.boss
 )

select * from boss

我可以得到这个结果：

但是，我需要看到这个：

这就像显示一个人与他或她“下面”的所有员工之间所有可能的关系。

我正在尝试在 SQL Server 中进行递归查询，以分层方式显示数据。这是表的结构

    [id] [int] IDENTITY(1,1) NOT NULL,
    [name] [varchar(100)] NOT NULL,
    [Parent_Id] [int] NULL,

每个产品都有一个父产品。Parent_Id 列包含父级的 id。对于根产品，parent_id 为空。

我想做一个 sql 查询来分层显示产品。下图是如何组织产品的示例。

产品可以有产品子项。

对于上图，查询结果应如下所示：

id name      parent_id
1  P1        NULL
2  P2        NULL
3  P2-1      2
4  P2-2      2
5  P2-3      2
6  P2-3-1    5
7  P2-3-2    5
8  P3        NULL
9  P3-1      8

这是我为实现它而写的请求：

with tree as (select * from products
               union all
               select * from tree where parent_id = tree.id
             )
select * from tree;

但我得到类似于以下内容的结果：

1 …

我在Oracle 10g中有一个表MYTYPE表示树结构,如下所示:

ID | PARENTID | DETAIL

我想选择MYTYPE中作为特定ID的后代的所有行,以便我可以在其他地方创建查询,例如:

SELECT * 
  FROM MYDETAIL 
 WHERE MYTYPEID IN [all MYTYPE which are descendants of some ID];

构建后代集的成本效率最高的方法是什么,最好不使用PL/SQL？

我有一个问题是将查询命名为树

WITH UtHierarchy
AS (
    SELECT etabid
        ,ut
        ,utlib
        ,parenteut
        ,0 AS LEVEL
        ,ut AS root
    FROM RUT
    WHERE etabid = 1
        AND parenteut IS NULL

    UNION ALL

    SELECT RUT.etabid
        ,RUT.ut
        ,RUT.utlib
        ,RUT.parenteut
        ,LEVEL + 1 AS LEVEL
        ,RUT.parenteut AS root
    FROM RUT
    INNER JOIN UtHierarchy uh ON uh.ut = rut.parenteut
    WHERE RUT.ETABID = 1
    )
SELECT *
FROM UtHierarchy
ORDER BY root

我需要有以下树:

UT Root
UT Root
-- UT level 1
UT Root
-- UT level 1
-- -- …

我有以下sql让我所有的根forumpost的子孙.

with recursive all_posts (id, parentid, root_id) as
                (
                select t1.id,
                t1.parent_forum_post_id as parentid,
                t1.id as root_id
                from forumposts t1

                union all

                select c1.id,
                c1.parent_forum_post_id as parentid,
                p.root_id
                from forumposts
                c1
                join all_posts p on p.id = c1.parent_forum_post_id
                )

                select fp.id
                from forumposts fp inner join all_posts ap
                on fp.id=ap.id 
                where
                root_id=1349 
                group by fp.id

我想要删除选中的记录.像从forumposts fp中删除的东西,其中fp.id =(最后从上面的代码中选择),但这不起作用(我在"DELETE"或附近得到语法错误).这是我第一次使用递归,我必须遗漏一些东西.任何帮助表示赞赏.

我在postgres数据库中有以下记录。parent_pk与父子关系中的pk相关。

pk名称类型parent_pk
------ ---- ---------
1 hnumber101房子0
2 hnumber201房子0
101道奇充电车1
102野马车1
103公车2
301约翰使用者101
302爱德华用户102
303约翰用户102
304约翰用户103

我想以以下格式从上述内容中生成一个json-

[{
   “ id”：1
   “ name”：“ hnumber101”，
   “类型”：“房屋”
   “孩子”：[{
              “ id”：101，
              “ name”：“道奇充电器”，
              “ type”：“车辆”
              “孩子”：[{
                       “ id”：301，
                       “ name”：“ john”，
                       “ type”：“用户”
                       }]，                            
              }，
              {
              “ id”：102，
              “ name”：“ mustang”，
              “ type”：“车辆”
              “孩子”：[{
                       “ id”：303，
                       “ name”：“ john”，
                       “ type”：“用户”
                       }，
                       {
                       “ id”：302，
                       “ name”：“ edward”，
                       “ type”：“用户”
                       }]，                            
              }]，
  }，
 {
   “ id”：2
   “ name”：“ hnumber201”，
   “类型”：“房屋”
   “孩子”：[{
              “ id”：103，
              “ …

我希望以下内容返回所有元组,将层次结构中的每个父级解析到顶部,但它只返回最低级别(其ID在查询中指定).如何返回给定level_id的整个树？

create table level(
level_id int,
level_name text,
parent_level int);

 insert into level values (197,'child',177), (  177, 'parent', 3 ), (  2, 'grandparent',  null  );

WITH RECURSIVE recursetree(level_id, levelparent) AS (
 SELECT level_id, parent_level 
 FROM level 
 where level_id = 197

UNION ALL
SELECT t.level_id, t.parent_level
FROM level t, recursetree rt 
WHERE rt.level_id = t.parent_level
)

SELECT * FROM recursetree;

我正在尝试并在Oracle 11g数据库中的一个层次查询中搜索从节点获取所有最后一级子项( leafs)的方法.

我有2个表:"节点"(所有节点的列表及其各自的值),以及指定父子关系的"关系":

--NODES--

 ID_NODE    -      VALUE
1       3
2       6
3       9
4       2
5       4
6       5
7       2
8       7
9       8
10      1

- 关系 -

ID_FATHER    -   ID_CHILD
1       2
1       3
1       4
2       5
2       6
4       7
5       8
5       9
7       10  

我已经阅读了CONNECT_BY_ISLEAF,如果它是一个叶子,它返回1,但我不能像Oracle示例一样查询CONNECT_BY_ISLEAF,我也没有得到任何结果.即使我不确切知道如何使用此函数精确地进行查询(例如使用案例条件？)

太谢谢了!

我是PLSQL更高级主题的新手,所以希望有人可以帮助我.

问题: 我有一个表,其中包含管理员和用户之间发送的消息.该表有一个带有FK的message_parent到同一个表message_id字段:如果填充了该字段,则表示该消息是作为对前一个消息的回复发送的.我需要选择属于同一个对话的所有消息并显示它们.这可以通过单个查询完成,还是需要一个程序来处理这种逻辑？据我所知,它需要递归,因为我正在搜索的message_id总是在变化

示例 消息表:

|message_id|parent_id|message_content|
|----------|---------|---------------|
|101       |100      | foo           |
|100       |97       | bar           |
|99        |(null)   | Left out      |
|97        |(null)   | baz           |

所以选择message_content的正确查询应该返回"baz","bar"和"foo"而不是"left out"(因为baz是原始消息).如果只有两个消息可以捆绑在一起,或者例如一个thread_id列,它会链接同一个'线程'中的所有消息,但是随着parent_id的不断变换,我很难解决它.