CUBRID学习笔记 42 Hierarchical QuerySQL层级查询
cubrid的中sql查询语法Hierarchical QuerySQL层级查询
------ 官方文档是英文的,看不明白可以参看ocracle的同类函数说明.很多都是一样的.
ORACLE中CONNECT BY...START WITH
和ocracle的差不多 ,下面的说明就直接抄袭过来
http://www.iwwenbo.com/oracle-start-with-connect-by/
其中，[where 条件1] 可以不需要，[where 条件1]是对根据[start with 条件2 connect by 条件3]选择出来的记录进行过滤，是针对单条记录的过滤，不会考虑树形查询的树结构；
[start with 条件2 ]限定作为搜索起始点的条件，表示从满足什么条件的记录开始查询；[connect by 条件3]表示查询的连接条件，树形菜单的查询常常是因为记录与记录之间存在某种关系，这种关系通常就作为连接条件。
补充：connect by子句，通常跟关键字“PRIOR”一起使用，“PRIOR”关键字的位置通常有两种，”CONNECT BY PRIOR ID = PID”和”CONNECT BY ID = PRIOR PID”，关键字位置的不同，相应的会导致查询结果的不同。
示例：
--创建表
create table tb_menu(
id number(10) not null,--主键ID
pid number(10) not null,--父菜单ID
title varchar2(50),--菜单名称
);
--添加数据
--父菜单
insert into tb_menu(id, pid,title ) values(1,父菜单1',0);
insert into tb_menu(id, pid,title ) values(2,父菜单2',0);
insert into tb_menu(id, pid,title ) values(3,父菜单3',0);
insert into tb_menu(id, pid,title ) values(4,父菜单4',0);
insert into tb_menu(id, pid,title ) values(5,父菜单5',0);
--一级菜单
insert into tb_menu(id, pid,title) values(6,1,'一级菜单6');
insert into tb_menu(id, pid,title) values(7,1,'一级菜单7');
insert into tb_menu(id, pid,title) values(8,1,'一级菜单8');
insert into tb_menu(id, pid,title) values(9,2,'一级菜单9');
insert into tb_menu(id, pid,title) values(10, 2, '一级菜单10');
insert into tb_menu(id, pid,title) values(11, 2, '一级菜单11');
insert into tb_menu(id, pid,title) values(12, 3,'一级菜单12');
insert into tb_menu(id, pid,title) values(13, 3,'一级菜单13');
insert into tb_menu(id, pid,title) values(14, 3,'一级菜单14');
insert into tb_menu(id, pid,title) values(15, 4,'一级菜单15');
insert into tb_menu(id, pid,title) values(16, 4,'一级菜单16');
insert into tb_menu(id, pid,title) values(17, 4,'一级菜单17');
insert into tb_menu(id, pid,title) values(18, 5,'一级菜单18');
insert into tb_menu(id, pid,title) values(19, 5,'一级菜单19');
insert into tb_menu(id, pid,title) values(20, 5,'一级菜单20');
--二级菜单
insert into tb_menu(id, title, pid) values(21, '二级菜单21',6);
insert into tb_menu(id, title, pid) values(22, '二级菜单22',6);
insert into tb_menu(id, title, pid) values(23, '二级菜单23',7);
insert into tb_menu(id, title, pid) values(24, '二级菜单24',7);
insert into tb_menu(id, title, pid) values(25, '二级菜单25',8);
insert into tb_menu(id, title, pid) values(26, '二级菜单26',9);
insert into tb_menu(id, title, pid) values(27, '二级菜单27',10);
insert into tb_menu(id, title, pid) values(28, '二级菜单28',11);
insert into tb_menu(id, title, pid) values(29, '二级菜单29',12);
insert into tb_menu(id, title, pid) values(30, '二级菜单30',13);
insert into tb_menu(id, title, pid) values(31, '二级菜单31',14);
insert into tb_menu(id, title, pid) values(32, '二级菜单32',15);
insert into tb_menu(id, title, pid) values(33, '二级菜单33',16);
insert into tb_menu(id, title, pid) values(34, '二级菜单34',17);
insert into tb_menu(id, title, pid) values(35, '二级菜单35',18);
insert into tb_menu(id, title, pid) values(36, '二级菜单36',19);
insert into tb_menu(id, title, pid) values(37, '二级菜单37',20);
--三级菜单
insert into tb_menu(id, title, pid) values(38, '三级菜单38',21);
insert into tb_menu(id, title, pid) values(39, '三级菜单39',22);
insert into tb_menu(id, title, pid) values(40, '三级菜单40',23);
insert into tb_menu(id, title, pid) values(41, '三级菜单41',24);
insert into tb_menu(id, title, pid) values(42, '三级菜单42',25);
insert into tb_menu(id, title, pid) values(43, '三级菜单43',26);
insert into tb_menu(id, title, pid) values(44, '三级菜单44',27);
insert into tb_menu(id, title, pid) values(45, '三级菜单45',28);
insert into tb_menu(id, title, pid) values(46, '三级菜单46',28);
insert into tb_menu(id, title, pid) values(47, '三级菜单47',29);
insert into tb_menu(id, title, pid) values(48, '三级菜单48',30);
insert into tb_menu(id, title, pid) values(49, '三级菜单49',31);
insert into tb_menu(id, title, pid) values(50, '三级菜单50',31);
commit;
说明：pid字段存储的是当前菜单节点的上级id，如果菜单节点是顶级节点，该菜单没有上级菜单，则pid应为null，然而在表中记录最好不要为null，建议使用0代替，因为null记录会引起全文扫描。
2.语法说明
oracle中递归查询（树形查询）主要依托于：
select * from table_name [where 条件1] start with 条件2 connect by 条件3;
其中，[where 条件1] 可以不需要，[where 条件1]是对根据[start with 条件2 connect by 条件3]选择出来的记录进行过滤，是针对单条记录的过滤，不会考虑树形查询的树结构；
[start with 条件2 ]限定作为搜索起始点的条件，表示从满足什么条件的记录开始查询；[connect by 条件3]表示查询的连接条件，树形菜单的查询常常是因为记录与记录之间存在某种关系，这种关系通常就作为连接条件。
补充：connect by子句，通常跟关键字“PRIOR”一起使用，“PRIOR”关键字的位置通常有两种，”CONNECT BY PRIOR ID = PID”和”CONNECT BY ID = PRIOR PID”，关键字位置的不同，相应的会导致查询结果的不同。
3.递归查询（树形查询）实践
只有上面的文字说明可能还是搞不清楚树形查询，不过动手来操作一遍就清楚了。
我们从最基本的操作，逐步列出常见的树查询操作，所有的查询以家族中的辈分作比方。
1）查询树中的所有顶级父节点（家族中辈分最大的那一代人）。假如这个树是个目录结构，那么第一个操作总是找出所有的顶级节点，然后再逐个根据顶级节点找到其子节点。
select * from tb_menu m where m.pid = 0;
以上查询得到的就是树的所有顶级节点，也就是家族中辈分最大的那一代人。
2）查找一个节点的直属子节点（家族中某个长辈的所有儿子），此时查找的是直属的子类节点，也是用不到树形查询的。
select * from tb_menu m where m.pid=1;
3）查找一个节点的所有直属子节点（家族中某个长辈的所有直系子孙）。
select * from tb_menu m start with m.id=1 connect by m.pid=prior m.id;
4）查找一个节点的直属父节点（家族中的父亲），此时查找的是节点的直属父节点，也是用不到树形查询的
select c.id, c.title, p.id parent_id, p.title parent_title
from tb_menu c, tb_menu p
where c.pid=p.id and c.id=6
5）查找一个节点的所有直属父节点（家族中一个孩子的所有直系长辈祖先，比如父亲，祖父，……）
select * from tb_menu m start with m.id=38 connect by prior m.pid=m.id;
说明：
上面的3）和5），这两条查询都是树形查询，区别在于”prior”关键字的位置不同，所以决定了查询方式的不同，查询结果也不同。当 pid = prior id时，数据库会根据当前的id迭代出pid与该id相同的记录，所以查询的结果是迭代出了所有的子类记录；而prior pid = id时，数据库会跟据当前的pid来迭代出与当前的pid相同的id的记录，所以查询出来的结果就是所有的父类结果。
仔细看一下数据库的查询结果，可以发现，其实3）和5）的查询顺序也是不同的，3）是自上向下检索，5）是自下向上检索。
以下是一系列针对树结构的更深层次的查询，这里的查询不一定是最优的查询方式，或许只是其中的一种实现而已。
6)查询一个节点的兄弟节点（亲兄弟）
--m.parent=m2.parent-->同一个父亲
select * from tb_menu m
where exists (select * from tb_menu m2 where m.pid=m2.pid and m2.id=6)
7)查询与一个节点同级的节点（族兄弟）。 如果在表中设置了级别的字段，那么在做这类查询时会很轻松，同一级别的就是与那个节点同级的，在这里列出不使用该字段时的实现!
with tmp as
(select a., level leaf
from tb_menu a
start with a.pid = 0
connect by a.pid = prior a.id)
select from tmp where leaf = (select leaf from tmp where id = 50);
这里使用两个技巧，一个是使用了level来标识每个节点在表中的级别，还有就是使用with语法模拟出了一张带有级别的临时表。
8)查询一个节点的父节点的的兄弟节点（伯父与叔父）
with tmp as(
select tb_menu.*, level lev
from tb_menu
start with pid=0
connect by pid = prior id)
select b.
from tmp b,(select
from tmp
where id = 21 and lev = 2) a
where b.lev = 1
union all
select
from tmp
where pid = (select distinct x.id
from tmp x, --祖父
tmp y, --父亲
(select
from tmp
where id = 21 and lev > 2) z --儿子
where y.id = z.pid and x.id = y.pid);
这里查询分成以下几步。
首先，和第7个一样，将全表都使用临时表加上级别；
其次，根据级别来判断有几种类型，以上文中举的例子来说，有三种情况：
（1）当前节点为顶级节点，即查询出来的lev值为1，那么它没有上级节点，不予考虑。
（2）当前节点为2级节点，查询出来的lev值为2，那么就只要保证lev级别为1的就是其上级节点的兄弟节点。
（3）其它情况就是3以及以上级别，那么就要选查询出来其上级的上级节点（祖父），再来判断祖父的下级节点都是属于该节点的上级节点的兄弟节点。
最后，就是使用union将查询出来的结果进行结合起来，形成结果集。
**来看看官方的**
CREATE TABLE tree(ID INT, MgrID INT, Name VARCHAR(32), BirthYear INT);INSERT INTO tree VALUES (1,NULL,'Kim', 1963);
INSERT INTO tree VALUES (2,NULL,'Moy', 1958);
INSERT INTO tree VALUES (3,1,'Jonas', 1976);
INSERT INTO tree VALUES (4,1,'Smith', 1974);
INSERT INTO tree VALUES (5,2,'Verma', 1973);
INSERT INTO tree VALUES (6,2,'Foster', 1972);
INSERT INTO tree VALUES (7,6,'Brown', 1981);
CREATE TABLE tree2(id int, treeid int, job varchar(32));
INSERT INTO tree2 VALUES(1,1,'Partner');
INSERT INTO tree2 VALUES(2,2,'Partner');
INSERT INTO tree2 VALUES(3,3,'Developer');
INSERT INTO tree2 VALUES(4,4,'Developer');
INSERT INTO tree2 VALUES(5,5,'Sales Exec.');
INSERT INTO tree2 VALUES(6,6,'Sales Exec.');
INSERT INTO tree2 VALUES(7,7,'Assistant');
INSERT INTO tree2 VALUES(8,null,'Secretary');
SELECT t.id,t.name,t2.job,level
FROM tree t INNER JOIN tree2 t2 ON t.id=t2.treeid
START WITH t.mgrid is null
CONNECT BY prior t.id=t.mgrid
ORDER BY t.id;
结果 能看到层次
id name job level
==============================================================
1 'Kim' 'Partner' 1
2 'Moy' 'Partner' 1
3 'Jonas' 'Developer' 2
4 'Smith' 'Developer' 2
5 'Verma' 'Sales Exec.' 2
6 'Foster' 'Sales Exec.' 2
7 'Brown' 'Assistant' 3
Ordering Data with the Hierarchical Query
SELECT id, mgrid, name, birthyear, levelFROM tree
START WITH mgrid IS NULL
CONNECT BY PRIOR id=mgrid
ORDER SIBLINGS BY birthyear;
id mgrid name birthyear level
2 NULL 'Moy' 1958 1
6 2 'Foster' 1972 2
7 6 'Brown' 1981 3
5 2 'Verma' 1973 2
1 NULL 'Kim' 1963 1
4 1 'Smith' 1974 2
3 1 'Jonas' 1976 2SELECT id, mgrid, name, birthyear, level
FROM tree
START WITH mgrid IS NULL
CONNECT BY PRIOR id=mgrid
ORDER SIBLINGS BY birthyear;
level关键字
理解上面的,就理解下面的了
SELECT id, mgrid, name, LEVEL
FROM tree
WHERE LEVEL=2
START WITH mgrid IS NULL
CONNECT BY PRIOR id=mgrid
ORDER BY id;
还可以加条件
SELECT LEVEL FROM db_root CONNECT BY LEVEL <= 10;
CONNECT_BY_ISLEAF 关键字
connect_by_isleaf是叶节点1 不是0
SELECT id, mgrid, name, CONNECT_BY_ISLEAF
FROM tree
START WITH mgrid IS NULL
CONNECT BY PRIOR id=mgrid
ORDER BY id;
CONNECT_BY_ISCYCLE关键字
这个伪列功能是揪出那些“违反伦理道德”的人。
例如发现一个人既是另外一个人的孙子又是他的爸爸，这显然是不合伦理的，需要尽快发现并进行拨乱反正.
CREATE TABLE tree_cycle(ID INT, MgrID INT, Name VARCHAR(32));
INSERT INTO tree_cycle VALUES (1,NULL,'Kim');
INSERT INTO tree_cycle VALUES (2,11,'Moy');
INSERT INTO tree_cycle VALUES (3,1,'Jonas');
INSERT INTO tree_cycle VALUES (4,1,'Smith');
INSERT INTO tree_cycle VALUES (5,3,'Verma');
INSERT INTO tree_cycle VALUES (6,3,'Foster');
INSERT INTO tree_cycle VALUES (7,4,'Brown');
INSERT INTO tree_cycle VALUES (8,4,'Lin');
INSERT INTO tree_cycle VALUES (9,2,'Edwin');
INSERT INTO tree_cycle VALUES (10,9,'Audrey');
INSERT INTO tree_cycle VALUES (11,10,'Stone');
-- Checking a CONNECT_BY_ISCYCLE value
SELECT id, mgrid, name, CONNECT_BY_ISCYCLE
FROM tree_cycle
START WITH name in ('Kim', 'Moy')
CONNECT BY NOCYCLE PRIOR id=mgrid
ORDER BY id;
id mgrid name connect_by_iscycle
==================================================
1 NULL 'Kim' 0
2 11 'Moy' 0
3 1 'Jonas' 0
4 1 'Smith' 0
5 3 'Verma' 0
6 3 'Foster' 0
7 4 'Brown' 0
8 4 'Lin' 0
9 2 'Edwin' 0
10 9 'Audrey' 0
11 10 'Stone' 1
CONNECT_BY_ROOT 关键字
同一个节点下的节点的connect_by_root是一样的
SELECT id, mgrid, name, CONNECT_BY_ROOT id
FROM tree
START WITH mgrid IS NULL
CONNECT BY PRIOR id=mgrid
ORDER BY id;
PRIOR关键字
下面的说明来自oracle
运算符PRIOR被放置于等号前后的位置，决定着查询时的检索顺序。
PRIOR被置于CONNECT BY子句中等号的前面时，则强制从根节点到叶节点的顺序检索，即由父节点向子节点方向通过树结构，我们称之为自顶向下的方式。如：
CONNECT BY PRIOR EMPNO=MGR
PIROR运算符被置于CONNECT BY 子句中等号的后面时，则强制从叶节点到根节点的顺序检索，即由子节点向父节点方向通过树结构，我们称之为自底向上的方式。例如：
CONNECT BY EMPNO=PRIOR MGR
在这种方式中也应指定一个开始的节点。
官方例子
SELECT id, mgrid, name, PRIOR id as "prior_id"
FROM tree
START WITH mgrid IS NULL
CONNECT BY PRIOR id=mgrid
ORDER BY id;
id mgrid name prior_id
=====================================================
1 NULL 'Kim' NULL
2 NULL 'Moy' NULL
3 1 'Jonas' 1
4 1 'Smith' 1
5 2 'Verma' 2
6 2 'Foster' 2
7 6 'Brown' 6
SYS_CONNECT_BY_PATH
SYS_CONNECT_BY_PATH (column_name, separator_char)
主要用于树查询(层次查询) 以及 多列转行
SELECT id, mgrid, name, SYS_CONNECT_BY_PATH(name,'/') as [hierarchy]FROM tree
START WITH mgrid IS NULL
CONNECT BY PRIOR id=mgrid
ORDER BY id;
id mgrid name hierarchy
==============================================================
1 NULL 'Kim' '/Kim'
2 NULL 'Moy' '/Moy'
3 1 'Jonas' '/Kim/Jonas'
4 1 'Smith' '/Kim/Smith'
5 2 'Verma' '/Moy/Verma'
6 2 'Foster' '/Moy/Foster'
7 6 'Brown' '/Moy/Foster/Brown'
单元练习例子
CREATE TABLE tbl(seq INT, id VARCHAR(10), parent VARCHAR(10));INSERT INTO tbl VALUES (1, 'a', null);
INSERT INTO tbl VALUES (2, 'b', 'a');
INSERT INTO tbl VALUES (3, 'b', 'c');
INSERT INTO tbl VALUES (4, 'c', 'b');
INSERT INTO tbl VALUES (5, 'c', 'b');
SELECT seq, id, parent, LEVEL,
CONNECT_BY_ISCYCLE AS iscycle,
CAST(SYS_CONNECT_BY_PATH(id,'/') AS VARCHAR(10)) AS idpath
FROM tbl
START WITH PARENT is NULL
CONNECT BY NOCYCLE PARENT = PRIOR id;
seq id parent level iscycle idpath
=============================================================================
1 'a' NULL 1 0 '/a'
2 'b' 'a' 2 0 '/a/b'
4 'c' 'b' 3 0 '/a/b/c'
3 'b' 'c' 4 1 '/a/b/c/b'
5 'c' 'b' 5 1 '/a/b/c/b/c'
5 'c' 'b' 3 0 '/a/b/c'
3 'b' 'c' 4 1 '/a/b/c/b'
4 'c' 'b' 5 1 '/a/b/c/b/c'
今天之后是明天,明天之后是后天,后天之后是大后天
SELECT TO_CHAR(base_month + lvl -1, 'YYYYMMDD') h_dateFROM (
SELECT LEVEL lvl, base_month
FROM (
SELECT TO_DATE('201303', 'YYYYMM') base_month FROM db_root
)
CONNECT BY LEVEL <= LAST_DAY(base_month) - base_month + 1
);
h_date
======================
'20130301'
'20130302'
'20130303'
'20130304'
'20130305'
'20130306'
'20130307'
'20130308'
'20130309'
'20130310'
'20130311'
'20130312'
'20130313'
'20130314'
'20130315'
'20130316'
'20130317'
'20130318'
'20130319'
'20130320'
'20130321'
'20130322'
'20130323'
'20130324'
'20130325'
'20130326'
'20130327'
'20130328'
'20130329'
'20130330'
'20130331'