[英]Using CONNECT BY PRIOR for a hierarchical query - Oracle SQL
我目前正在处理一个需要分层查询的需求，但我似乎无法理解。
要求是：对于给定的一组订单，找出他们的所有需求，以及补充这些需求的原因。 然后，如果补货是MAKE类型（即另一个订单），找出它的所有需求和补货等。
小提琴末尾的结果查询本质上是在说：对于订单 x，这里是它的所有要求。 对于这些需求中的每一个，这里是计划补充它的内容。
我现在需要做的是，对于所有make 类型的补货，我基本上需要通过加入这些表来继续重复这个过程，提取补充这些补货的东西，等等，但这样做的同时要跟踪顶级订单。
我希望把它变成一个看起来像这样的数据集：
| Root Order | Order_Number | Requirement_ID | Replenishment_ID | Replenishment_Type | Replenishment_Detail | Replenishment_Date |
|:----------:|:------------:|:--------------:|:----------------:|:------------------:|:--------------------:|:------------------:|
| 300 | 300 | AA-300 | RO601 | Bought | 963 | 7/15/2018 |
| 300 | 300 | AA-300 | RO111 | Make | 251 | 10/23/2018 |
| 300 | 300 | AA-300 | RO435 | Make | 837 | 3/4/2018 |
| 300 | 300 | AA-300 | RO608 | Make | 850 | 4/27/2018 |
| 300 | 300 | AA-516 | RO734 | Make | 415 | 5/5/2018 |
| 300 | 300 | AA-516 | RO245 | Bought | 130 | 2/6/2018 |
| 300 | 300 | AA-516 | RO754 | Bought | 874 | 6/9/2018 |
| 300 | 300 | AA-468 | RO120 | Make | 333 | 7/28/2018 |
| 300 | 300 | AA-468 | RO96 | Bought | 279 | 6/11/2018 |
| 300 | 300 | AA-744 | RO576 | Make | 452 | 6/9/2018 |
| 300 | 300 | AA-744 | RO592 | Bought | 967 | 1/16/2018 |
| 300 | 300 | AA-744 | RO104 | Make | 232 | 1/30/2019 |
| 300 | 300 | AA-744 | RO169 | Make | 804 | 2/2/2018 |
| 300 | 130 | AA-785 | RO573 | Make | 616 | 4/1/2018 |
| 300 | 130 | AA-785 | RO139 | Make | 698 | 7/16/2018 |
| 300 | 130 | AA-785 | RO252 | Make | 190 | 8/2/2018 |
| 300 | 130 | AA-785 | RO561 | Make | 453 | 5/13/2018 |
| 300 | 130 | AA-785 | RO775 | Make | 974 | 8/7/2018 |
| 300 | 130 | AA-171 | RO92 | Bought | 493 | 4/1/2018 |
| 300 | 493 | AA-400 | RO4 | Make | 591 | 4/17/2018 |
| 300 | 493 | AA-401 | NULL | NULL | NULL | NULL |
| Now | Starting | From | The | Other | | Tables |
| 300 | 591 | AA-999 | RO1 | Bought | 111 | 4/19/2019 |
| 300 | 591 | AA-111 | RO2 | Bought | 123 | 4/1/2019 |
| 300 | 591 | AA-001 | RO400 | Make | 124 | 5/1/2019 |
| 300 | 124 | AA-313 | RO112 | Bought | 102 | 7/8/2019 |
| etc | etc | etc | etc | etc | etc | etc |
在这里你可以看到订单300有 130 的补货，然后有 493 的补货。
如何使用CONNECT_BY_ROOT和CONNECT BY PRIOR来实现这一点？ 我曾尝试递归WITH像下面，但不产生一个层次。
WITH
rec(Root_Order, Order_Number, Requirement_ID, Replenishment_ID, Replenishment_Type, Replenishment_Detail, Replenishment_Date) AS (
SELECT
Orders.Order_Number AS Root_Order,
Orders.Order_Number,
Requirements.Requirement_ID,
Replenishments.Replenishment_ID,
Replenishments.Replenishment_Type,
Replenishments.Replenishment_Detail,
Replenishments.Replenishment_Date
FROM
Orders
LEFT JOIN Requirements ON Orders.Order_Number = Requirements.Order_Number
LEFT JOIN Lookup ON Requirements.Requirement_ID = Lookup.Requirement_ID
LEFT JOIN Replenishments ON Lookup.Replenishment_ID = Replenishments.Replenishment_ID
UNION ALL
SELECT
rec.Order_Number
rec.Replenishment_Details,
Requirements.Requirement_ID,
Replenishments.Replenishment_ID,
Replenishments.Replenishment_Type,
Replenishments.Replenishment_Detail,
Replenishments.Replenishment_Date
FROM
rec
LEFT JOIN Requirements ON Orders.Order_Number = Requirements.Order_Number
LEFT JOIN Lookup ON Requirements.Requirement_ID = Lookup.Requirement_ID
LEFT JOIN Replenishments ON Lookup.Replenishment_ID = Replenishments.Replenishment_ID
)
CYCLE Root_Order, Order_Number, Requirement_ID, Replenishment_ID, Replenishment_Type, Replenishment_Detail, Replenishment_Date SET CYCLE TO 1 DEFAULT 0
SELECT DISTINCT * FROM rec
谢谢
从您的输入开始：
with data (
Order_Number , Requirement_ID , Replenishment_ID ,
Replenishment_Type , Replenishment_Detail , Replenishment_Date
) as (
select 300,'AA-300','RO601' ,'Bought', 963, to_date('15-Jul-18','dd-Mon-rr') from dual union all
select 300,'AA-300','RO111' ,'Make', 251, to_date('23-Oct-18','dd-Mon-rr') from dual union all
select 300,'AA-300','RO435' ,'Make', 837, to_date('4-Mar-18','dd-Mon-rr') from dual union all
select 300,'AA-300','RO608' ,'Make', 850, to_date('27-Apr-18','dd-Mon-rr') from dual union all
select 300,'AA-516','RO734' ,'Make', 415, to_date('5-May-18','dd-Mon-rr') from dual union all
select 300,'AA-516','RO245' ,'Bought', 130, to_date('6-Feb-18','dd-Mon-rr') from dual union all
select 300,'AA-516','RO754' ,'Bought', 874, to_date('9-Jun-18','dd-Mon-rr') from dual union all
select 300,'AA-468','RO120' ,'Make', 333, to_date('28-Jul-18','dd-Mon-rr') from dual union all
select 300,'AA-468','RO96' ,'Bought', 279, to_date('11-Jun-18','dd-Mon-rr') from dual union all
select 300,'AA-744','RO576' ,'Make', 452, to_date('9-Jun-18','dd-Mon-rr') from dual union all
select 300,'AA-744','RO592' ,'Bought', 967, to_date('16-Jan-18','dd-Mon-rr') from dual union all
select 300,'AA-744','RO104' ,'Make', 232, to_date('30-Jan-19','dd-Mon-rr') from dual union all
select 300,'AA-744','RO169' ,'Make', 804, to_date('2-Feb-18','dd-Mon-rr') from dual union all
select 500,'AA-100','RO567' ,'Make', 725, to_date('22-Mar-18','dd-Mon-rr') from dual union all
select 500,'AA-100','RO90' ,'Bought', 240, to_date('14-Mar-18','dd-Mon-rr') from dual union all
select 500,'AA-100','RO202' ,'Bought', 185, to_date('26-Feb-18','dd-Mon-rr') from dual union all
select 500,'AA-823','RO764' ,'Bought', 629, to_date('15-Oct-18','dd-Mon-rr') from dual union all
select 500,'AA-823','RO434' ,'Make', 314, to_date('27-Jun-18','dd-Mon-rr') from dual union all
select 500,'AA-823','RO752' ,'Bought', 504, to_date('25-Apr-18','dd-Mon-rr') from dual union all
select 500,'AA-823','RO204' ,'Make', 847, to_date('9-Jul-18','dd-Mon-rr') from dual union all
select 500,'AA-239','RO367' ,'Bought', 652, to_date('14-Feb-18','dd-Mon-rr') from dual union all
select 500,'AA-239','RO732' ,'Bought', 561, to_date('3-Oct-18','dd-Mon-rr') from dual union all
select 130,'AA-785','RO573' ,'Make', 616, to_date('1-Apr-18','dd-Mon-rr') from dual union all
select 130,'AA-785','RO139' ,'Make', 698, to_date('16-Jul-18','dd-Mon-rr') from dual union all
select 130,'AA-785','RO252' ,'Make', 190, to_date('2-Aug-18','dd-Mon-rr') from dual union all
select 130,'AA-785','RO561' ,'Make', 453, to_date('13-May-18','dd-Mon-rr') from dual union all
select 130,'AA-785','RO775' ,'Make', 974, to_date('7-Aug-18','dd-Mon-rr') from dual union all
select 130,'AA-171','RO92' ,'Bought', 493, to_date('1-Apr-18','dd-Mon-rr') from dual union all
select 200,'AA-171','RO532' ,'Make', 727, to_date('17-May-18','dd-Mon-rr') from dual union all
select 200,'AA-337','RO29' ,'Make', 402, to_date('1-Jun-18','dd-Mon-rr') from dual union all
select 200,'AA-337','RO725' ,'Make', 892, to_date('9-Mar-18','dd-Mon-rr') from dual union all
select 200,'AA-533','RO216' ,'Bought', 637, to_date('1-Jun-18','dd-Mon-rr') from dual union all
select 100,'AA-100', NULL , NULL, NULL, NULL from dual union all
select 100,'AA-100','RO438' ,'Make', 125, to_date('19-Mar-18','dd-Mon-rr') from dual union all
select 493,'AA-400','RO4', 'Bought', 591, to_date('17-Apr-18','dd-Mon-rr') from dual union all
select 493,'AA-401', NULL , NULL, NULL, NULL from dual
)
select connect_by_root(order_number) root_order, data.*, level lvl
from data
start with order_number not in (
select replenishment_detail from data where replenishment_detail is not null
)
connect by order_number = prior replenishment_detail
order siblings by order_number, replenishment_detail;
ROOT_ORDER ORDER_NUMBER REQUIR REPLE REPLEN REPLENISHMENT_DETAIL REPLENISHMENT_DATE LVL
---------- ------------ ------ ----- ------ -------------------- ------------------- ----------
100 100 AA-100 RO438 Make 125 2018-03-19 00:00:00 1
100 100 AA-100 1
200 200 AA-337 RO29 Make 402 2018-06-01 00:00:00 1
200 200 AA-533 RO216 Bought 637 2018-06-01 00:00:00 1
200 200 AA-171 RO532 Make 727 2018-05-17 00:00:00 1
200 200 AA-337 RO725 Make 892 2018-03-09 00:00:00 1
300 300 AA-516 RO245 Bought 130 2018-02-06 00:00:00 1
300 130 AA-785 RO252 Make 190 2018-08-02 00:00:00 2
300 130 AA-785 RO561 Make 453 2018-05-13 00:00:00 2
300 130 AA-171 RO92 Bought 493 2018-04-01 00:00:00 2
300 493 AA-400 RO4 Bought 591 2018-04-17 00:00:00 3
300 493 AA-401 3
300 130 AA-785 RO573 Make 616 2018-04-01 00:00:00 2
300 130 AA-785 RO139 Make 698 2018-07-16 00:00:00 2
300 130 AA-785 RO775 Make 974 2018-08-07 00:00:00 2
300 300 AA-744 RO104 Make 232 2019-01-30 00:00:00 1
300 300 AA-300 RO111 Make 251 2018-10-23 00:00:00 1
300 300 AA-468 RO96 Bought 279 2018-06-11 00:00:00 1
300 300 AA-468 RO120 Make 333 2018-07-28 00:00:00 1
300 300 AA-516 RO734 Make 415 2018-05-05 00:00:00 1
300 300 AA-744 RO576 Make 452 2018-06-09 00:00:00 1
300 300 AA-744 RO169 Make 804 2018-02-02 00:00:00 1
300 300 AA-300 RO435 Make 837 2018-03-04 00:00:00 1
300 300 AA-300 RO608 Make 850 2018-04-27 00:00:00 1
300 300 AA-516 RO754 Bought 874 2018-06-09 00:00:00 1
300 300 AA-300 RO601 Bought 963 2018-07-15 00:00:00 1
300 300 AA-744 RO592 Bought 967 2018-01-16 00:00:00 1
500 500 AA-100 RO202 Bought 185 2018-02-26 00:00:00 1
500 500 AA-100 RO90 Bought 240 2018-03-14 00:00:00 1
500 500 AA-823 RO434 Make 314 2018-06-27 00:00:00 1
500 500 AA-823 RO752 Bought 504 2018-04-25 00:00:00 1
500 500 AA-239 RO732 Bought 561 2018-10-03 00:00:00 1
500 500 AA-823 RO764 Bought 629 2018-10-15 00:00:00 1
500 500 AA-239 RO367 Bought 652 2018-02-14 00:00:00 1
500 500 AA-100 RO567 Make 725 2018-03-22 00:00:00 1
500 500 AA-823 RO204 Make 847 2018-07-09 00:00:00 1
在 WITH DATA 子句中，替换您的连接。 排序会将每个“根”顺序的所有行放在一起，但在每个“根”内，层次结构将“深度优先”，因此您可以看到级别之间的直接关系。
最好的问候， 炖阿什顿
我认为你正在寻找类似的东西：
with rec(root_order, order_number, requirement_id, replenishment_id, replenishment_type,
replenishment_detail, replenishment_date)
as (
-- anchor member
select
orders.order_number as root_order,
orders.order_number,
requirements.requirement_id,
replenishments.replenishment_id,
replenishments.replenishment_type,
replenishments.replenishment_detail,
replenishments.replenishment_date
from orders
join requirements on orders.order_number = requirements.order_number
left join lookup on requirements.requirement_id = lookup.requirement_id
left join replenishments on lookup.replenishment_id = replenishments.replenishment_id
union all
-- recursive member
select rec.root_order,
requirements.order_number,
requirements.requirement_id,
replenishments.replenishment_id,
replenishments.replenishment_type,
replenishments.replenishment_detail,
replenishments.replenishment_date
from rec
join requirements on rec.replenishment_detail = requirements.order_number
left join lookup on requirements.requirement_id = lookup.requirement_id
left join replenishments on lookup.replenishment_id = replenishments.replenishment_id
)
select *
from rec
order by root_order, order_number, requirement_id;
锚成员本质上是您的原始查询，除了它添加了root_order并且我将第一个 join 加入了内部以稍微减少噪音（原始的 87 行中的很多只有order_number其他所有内容为空）。
然后递归成员将rec.replenishment_detail （子订单号）连接到requirements.order_number以沿着层次结构向下走。 它不需要再次引用实际的订单表（除非你真的想要其他一些字段，在这种情况下包含它是微不足道的）。
使用生成 65 行输出的示例数据，包括：
ROOT_ORDER ORDER_NUMBER REQUIR REPLE REPLEN REPLENISHMENT_DETAIL REPLENISHM
---------- ------------ ------ ----- ------ -------------------- ----------
...
300 130 AA-171 RO532 Make 727 2018-05-17
300 130 AA-171 RO92 Bought 493 2018-04-01
300 130 AA-785 RO573 Make 616 2018-04-01
300 130 AA-785 RO561 Make 453 2018-05-13
300 130 AA-785 RO775 Make 974 2018-08-07
300 130 AA-785 RO139 Make 698 2018-07-16
300 130 AA-785 RO252 Make 190 2018-08-02
300 300 AA-300 RO601 Bought 963 2018-07-15
300 300 AA-300 RO111 Make 251 2018-10-23
300 300 AA-300 RO435 Make 837 2018-03-04
300 300 AA-300 RO608 Make 850 2018-04-27
300 300 AA-468 RO96 Bought 279 2018-06-11
300 300 AA-468 RO120 Make 333 2018-07-28
300 300 AA-516 RO754 Bought 874 2018-06-09
300 300 AA-516 RO245 Bought 130 2018-02-06
300 300 AA-516 RO734 Make 415 2018-05-05
300 300 AA-744 RO169 Make 804 2018-02-02
300 300 AA-744 RO576 Make 452 2018-06-09
300 300 AA-744 RO592 Bought 967 2018-01-16
300 300 AA-744 RO104 Make 232 2019-01-30
300 493 AA-400 RO4 Bought 591 2018-04-17
300 493 AA-401
...
db<>fiddle基于你的原件。
请注意，它还包括独立的“子”订单：
...
130 130 AA-171 RO92 Bought 493 2018-04-01
130 130 AA-171 RO532 Make 727 2018-05-17
130 130 AA-785 RO775 Make 974 2018-08-07
130 130 AA-785 RO561 Make 453 2018-05-13
130 130 AA-785 RO252 Make 190 2018-08-02
130 130 AA-785 RO573 Make 616 2018-04-01
130 130 AA-785 RO139 Make 698 2018-07-16
130 493 AA-400 RO4 Bought 591 2018-04-17
130 493 AA-401
...
493 493 AA-400 RO4 Bought 591 2018-04-17
493 493 AA-401
...
等等。你可以从一个特定的目标订单开始（即让锚成员有where orders.order_number = 300 ），但不清楚这是否是你想要的。 如果不是，并且您也不希望自己看到较低的订单，那么您需要一种方法来识别顶级订单。 一种方法可能是通过添加not exists(...)过滤器来排除任何显示为任何replenishment_detail值的订单：
with rec(root_order, order_number, requirement_id, replenishment_id, replenishment_type,
replenishment_detail, replenishment_date)
as (
-- anchor member
select
orders.order_number as root_order,
orders.order_number,
requirements.requirement_id,
replenishments.replenishment_id,
replenishments.replenishment_type,
replenishments.replenishment_detail,
replenishments.replenishment_date
from orders
join requirements on orders.order_number = requirements.order_number
left join lookup on requirements.requirement_id = lookup.requirement_id
left join replenishments on lookup.replenishment_id = replenishments.replenishment_id
where not exists (
select *
from replenishments
where replenishment_detail = orders.order_number
)
union all
-- recursive member
select rec.root_order,
requirements.order_number,
requirements.requirement_id,
replenishments.replenishment_id,
replenishments.replenishment_type,
replenishments.replenishment_detail,
replenishments.replenishment_date
from rec
join requirements on rec.replenishment_detail = requirements.order_number
left join lookup on requirements.requirement_id = lookup.requirement_id
left join replenishments on lookup.replenishment_id = replenishments.replenishment_id
)
select *
from rec
order by root_order, order_number, requirement_id;
现在只有 54 行，不包括 130/493/等。 上面的根顺序行。
由于您实际上询问的是分层查询而不是递归查询，因此您可以这样做：
with cte (order_number, requirement_id, replenishment_id, replenishment_type,
replenishment_detail, replenishment_date, is_root_order)
as (
select
orders.order_number,
requirements.requirement_id,
replenishments.replenishment_id,
replenishments.replenishment_type,
replenishments.replenishment_detail,
replenishments.replenishment_date,
case when exists (
select *
from replenishments
where replenishment_detail = orders.order_number
) then 'N' else 'Y' end
from orders
join requirements on orders.order_number = requirements.order_number
left join lookup on requirements.requirement_id = lookup.requirement_id
left join replenishments on lookup.replenishment_id = replenishments.replenishment_id
)
select connect_by_root(order_number) as root_order,
order_number, requirement_id, replenishment_id, replenishment_type,
replenishment_detail, replenishment_date
from cte
start with is_root_order = 'Y'
connect by order_number = prior replenishment_detail;
CTE 再次几乎是您的原始查询，使用 case 表达式和exists 子句来确定每个订单是否是“根”订单，就像以前一样 - 但现在作为标志而不是过滤器。 分层查询相当简单，在它的starts with子句中使用该标志。
另一个db<>fiddle 。
（我刚刚意识到这几乎就是@StewAshton 所说的；我的 CTE 本质上是他的“替换您的连接”步骤。唯一的另一个真正区别是他将标志计算直接移到了starts with子句中，其中实际上可能会稍微更有效率，因为它不必再次点击replenishments表......）
我通常更喜欢递归 CTE 方法，但分层方法在这里很有吸引力，只是因为它的简洁性。 不过，您可能希望将两种方法的性能与您的真实数据进行比较。
将ORACLE层次结构START WITH / CONNECT BY PRIOR转换为SQL Server CTE
[英]Converting ORACLE hierarchical START WITH / CONNECT BY PRIOR to SQL Server CTE
Oracle - 在分层查询中使用先连接并将它们放入行中
[英]Oracle - using connect by prior in Hierarchical Queries and put them into rows
是否可以仅使用连接而不是使用 connect by 子句在 Oracle SQL 中编写分层查询
[英]Is it possible to write a hierarchical query in Oracle SQL using only joins instead of using connect by clause
声明:本站的技术帖子网页，遵循CC BY-SA 4.0协议，如果您需要转载，请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.