ROWNUM用法

ORACLE 中ROWNUM用法总结!
对于 Oracle 的 rownum 问题，很多资料都说不支持>,>=,=,between...and，只能用以上符号(<、<=、!=)，并非说用>,& gt;=,=,between..and 时会提示SQL语法错误，而是经常是查不出一条记录来，还会出现似乎是莫名其妙的结果来，其实您只要理解好了这个 rownum 伪列的意义就不应该感到惊奇，同样是伪列，rownum 与 rowid 可有些不一样，下面以例子说明假设某个表 t1(c1) 有 20 条记录如果用 select rownum,c1 from t1 where rownum < 10, 只要是用小于号，查出来的结果很容易地与一般理解在概念上能达成一致，应该不会有任何疑问的。可如果用 select rownum,c1 from t1 where rownum > 10 (如果写下这样的查询语句，这时候在您的头脑中应该是想得到表中后面10条记录)，你就会发现，显示出来的结果要让您失望了，也许您还会怀疑是不谁删了一 些记录，然后查看记录数，仍然是 20 条啊？那问题是出在哪呢？先好好理解 rownum 的意义吧。因为ROWNUM是对结果集加的一个伪列，即先查到结果集之后再加上去的一个列 (强调：先要有结果集)。简单的说 rownum 是对符合条件结果的序列号。它总是从1开始排起的。所以你选出的结果不可能没有1，而有其他大于1的值。所以您没办法期望得到下面的结果集：11 aaaaaaaa
12 bbbbbbb
13 ccccccc
.................rownum >10 没有记录，因为第一条不满足去掉的话，第二条的ROWNUM又成了1，所以永远没有满足条件的记录。或者可以这样理解：ROWNUM是一个序列，是oracle数据库从数据文件或缓冲区中读取数据的顺序。它取得第一条记录则rownum值为1，第二条为2，依次类 推。如果你用>,>=,=,between...and这些条件，因为从缓冲区或数据文件中得到的第一条记录的rownum为1，则被删除， 接着取下条，可是它的rownum还是1，又被删除，依次类推，便没有了数据。有了以上从不同方面建立起来的对 rownum 的概念，那我们可以来认识使用 rownum 的几种现像1. select rownum,c1 from t1 where rownum != 10 为何是返回前9条数据呢？它与 select rownum,c1 from tablename where rownum < 10 返回的结果集是一样的呢？
因为是在查询到结果集后，显示完第 9 条记录后，之后的记录也都是 != 10,或者 >=10,所以只显示前面9条记录。也可以这样理解，rownum 为9后的记录的 rownum为10，因条件为 !=10，所以去掉，其后记录补上，rownum又是10，也去掉，如果下去也就只会显示前面9条记录了2. 为什么 rownum >1 时查不到一条记录，而 rownum >0 或 rownum >=1 却总显示所以的记录
因为 rownum 是在查询到的结果集后加上去的，它总是从1开始3. 为什么 between 1 and 10 或者 between 0 and 10 能查到结果，而用 between 2 and 10 却得不到结果
原因同上一样，因为 rownum 总是从 1 开始从上可以看出，任何时候想把 rownum = 1 这条记录抛弃是不对的，它在结果集中是不可或缺的，少了rownum=1 就像空中楼阁一般不能存在，所以你的 rownum 条件要包含到 1但如果就是想要用 rownum > 10 这种条件的话话就要用嵌套语句,把 rownum 先生成，然后对他进行查询。
select *
from (selet rownum as rn，t1.* from a where ...)
where rn >10一般代码中对结果集进行分页就是这么干的。另外：rowid 与 rownum 虽都被称为伪列，但它们的存在方式是不一样的，rowid 可以说是物理存在的，表示记录在表空间中的唯一位置ID，在DB中唯一。只要记录没被搬动过，rowid是不变的。rowid 相对于表来说又像表中的一般列，所以以 rowid 为条件就不会有 rownum那些情况发生。
另外还要注意：rownum不能以任何基表的名称作为前缀。
---------------------------------------------------------------------Oracle中rownum的基本用法
对于rownum来说它是oracle系统顺序分配为从查询返回的行的编号，返回的第一行分配的是1，第二行是2，依此类推，这个伪字段可以用于限制查询返回的总行数，且rownum不能以任何表的名称作为前缀。(1) rownum 对于等于某值的查询条件
如果希望找到学生表中第一条学生的信息，可以使用rownum=1作为条件。但是想找到学生表中第二条学生的信息，使用rownum=2结果查不到数据。因为rownum都是从1开始，但是1以上的自然数在rownum做等于判断是时认为都是false条件，所以无法查到rownum = n（n>1的自然数）。
SQL> select rownum,id,name from student where rownum=1;（可以用在限制返回记录条数的地方，保证不出错，如：隐式游标）
SQL> select rownum,id,name from student where rownum =2; ROWNUM ID     NAME
---------- ------ ---------------------------------------------------（2）rownum对于大于某值的查询条件如果想找到从第二行记录以后的记录，当使用rownum>2是查不出记录的，原因是由于rownum是一个总是从1开始的伪列，Oracle 认为rownum> n(n>1的自然数)这种条件依旧不成立，所以查不到记录。查找到第二行以后的记录可使用以下的子查询方法来解决。注意子查询中的rownum必须要有别名，否则还是不会查出记录来，这是因为rownum不是某个表的列，如果不起别名的话，无法知道rownum是子查询的列还是主查询的列。
SQL>select * from(select rownum no ,id,name from student) where no>2;NO ID     NAME
---------- ------ ---------------------------------------------------3 200003 李三4 200004 赵四（3）rownum对于小于某值的查询条件
rownum对于rownum<n（(n>1的自然数）的条件认为是成立的，所以可以找到记录。
SQL> select rownum,id,name from student where rownum <3;ROWNUM ID     NAME
---------- ------ ---------------------------------------------------1 200001 张一2 200002 王二查询rownum在某区间的数据，必须使用子查询。例如要查询rownum在第二行到第三行之间的数据，包括第二行和第三行数据，那么我们只能写以下语句，先让它返回小于等于三的记录行，然后在主查询中判断新的rownum的别名列大于等于二的记录行。但是这样的操作会在大数据集中影响速度。
SQL> select * from (select rownum no,id,name from student where rownum<=3 ) where no >=2;NO ID     NAME
---------- ------ ---------------------------------------------------2 200002 王二3 200003 李三（4）rownum和排序
Oracle中的rownum的是在取数据的时候产生的序号，所以想对指定排序的数据去指定的rowmun行数据就必须注意了。
SQL> select rownum ,id,name from student order by name;ROWNUM ID     NAME
---------- ------ ---------------------------------------------------3 200003 李三2 200002 王二1 200001 张一4 200004 赵四
可以看出，rownum并不是按照name列来生成的序号。系统是按照记录插入时的顺序给记录排的号，rowid也是顺序分配的。为了解决这个问题，必须使用子查询；
SQL> select rownum ,id,name from (select * from student order by name);ROWNUM ID     NAME
---------- ------ ---------------------------------------------------1 200003 李三2 200002 王二3 200001 张一4 200004 赵四
这样就成了按name排序，并且用rownum标出正确序号（有小到大）
笔者在工作中有一上百万条记录的表，在jsp页面中需对该表进行分页显示，便考虑用rownum来作，下面是具体方法(每页显示20条)：
“select * from tabname where rownum<20 order by name" 但却发现oracle却不能按自己的意愿来执行，而是先随便取20条记录，然后再order by，后经咨询oracle,说rownum确实就这样，想用的话，只能用子查询来实现先排序，后rownum，方法如下：
"select * from (select * from tabname order by name) where rownum<20",但这样一来，效率会低很多。
后经笔者试验，只需在order by 的字段上加主键或索引即可让oracle先按该字段排序，然后再rownum；方法不变：    “select * from tabname where rownum<20 order by name"取得某列中第N大的行select column_name from
(select table_name.*,dense_rank() over (order by column desc) rank from table_name)
where rank = &N； 假如要返回前5条记录：select * from tablename where rownum<6;(或是rownum <= 5 或是rownum != 6)
假如要返回第5-9条记录：select * from tablename
where …
and rownum<10
minus
select * from tablename
where …
and rownum<5
order by name
选出结果后用name排序显示结果。(先选再排序)注意：只能用以上符号(<、<=、!=)。select * from tablename where rownum != 10;返回的是前９条记录。
不能用：>,>=,=,Between...and。由于rownum是一个总是从1开始的伪列，Oracle 认为这种条件不成立。另外，这个方法更快：select * from (
select rownum r,a from yourtable
where rownum <= 20
order by name )
where r > 10
这样取出第11-20条记录!(先选再排序再选)要先排序再选则须用select嵌套：内层排序外层选。
rownum是随着结果集生成的，一旦生成，就不会变化了；同时,生成的结果是依次递加的，没有1就永远不会有2!
rownum 是在查询集合产生的过程中产生的伪列，并且如果where条件中存在 rownum 条件的话，则:1： 假如判定条件是常量，则：
只能 rownum = 1, <= 大于1 的自然数， = 大于1 的数是没有结果的；大于一个数也是没有结果的
即 当出现一个 rownum 不满足条件的时候则 查询结束 this is stop key（一个不满足，系统将该记录过滤掉，则下一条记录的rownum还是这个，所以后面的就不再有满足记录，this is stop key）；2： 假如判定值不是常量，则：若条件是 = var , 则只有当 var 为1 的时候才满足条件，这个时候不存在 stop key ,必须进行full scan ,对每个满足其他where条件的数据进行判定，选出一行后才能去选rownum=2的行……分页查询语句：
1：单表查询SELECT * FROM (SELECT t.*,ROWNUM r FROM TABLE t WHERE ROWNUM <= pageNumber*pageSize) WHERE r >(pageNumber)*pageSize2：两张表联查SELECT * FROM (SELECT ROWNUM RN,XX.* FROM (SELECT 表名.字段名, 表名.字段名, 表名.字段名... FROM TABLE1  t1, TABLE2   t2 WHERE t1.字段=t2.字段) XX WHERE ROWNUM<=pageSize*pageNumber) WHERE RN >(pageNumber-1)*pageSize

select into与insert into区别

我们经常会遇到需要表复制的情况，如将一个table1的数据的部分字段复制到table2中，或者将整个table1复制到table2中，这时候我们就要使用SELECT INTO 和 INSERT INTO SELECT 表复制语句了。1.INSERT INTO SELECT语句语句形式为：Insert into Table2(field1,field2,...) select value1,value2,... from Table1注意：（1）要求目标表Table2必须存在，并且字段field,field2...也必须存在（2）注意Table2的主键约束，如果Table2有主键而且不为空，则 field1， field2...中必须包括主键（3）注意语法，不要加values，和插入一条数据的sql混了，不要写成:Insert into Table2(field1,field2,...) values (select value1,value2,... from Table1)由于目标表Table2已经存在，所以我们除了插入源表Table1的字段外，还可以插入常量。示例如下：+ expand sourceview plaincopy to clipboardprint--1.创建测试表  create TABLE Table1  (  a varchar(10),  b varchar(10),  c varchar(10))create TABLE Table2  (  a varchar(10),  c varchar(10),  d int)--2.创建测试数据  Insert into Table1 values('赵','asds','90')  Insert into Table1 values('钱','asds','100')  Insert into Table1 values('孙','asds','80')  Insert into Table1 values('李','asds',null)  select * from Table2--3.INSERT INTO SELECT语句复制表数据  Insert into Table2(a, c, d) select a,c,5 from Table1--4.显示更新后的结果  select * from Table2  --5.删除测试表  drop TABLE Table1  drop TABLE Table22.SELECT INTO FROM语句语句形式为：SELECT vale1, value2 into Table2 from Table1要求目标表Table2不存在，因为在插入时会自动创建表Table2，并将Table1中指定字段数据复制到Table2中。示例如下：view plaincopy to clipboardprint?--1.创建测试表  create TABLE Table1  (  a varchar(10),  b varchar(10),  c varchar(10))--2.创建测试数据  Insert into Table1 values('赵','asds','90')  Insert into Table1 values('钱','asds','100')  Insert into Table1 values('孙','asds','80')  Insert into Table1 values('李','asds',null)  --3.SELECT INTO FROM语句创建表Table2并复制数据  select a,c INTO Table2 from Table1  --4.显示更新后的结果  select * from Table2  --5.删除测试表  drop TABLE Table1  drop TABLE Table2 注意：如果在sql/plus或者PL/SQL执行这条语句，会报"ORA-00905:缺失关键字"错误，原因是PL/Sql与T-SQL的区别。
T-SQL中该句正常，但PL/SQL中解释是:
select..into is part of PL/SQL language which means you have to use it inside a PL/SQL block. You can not use it in a SQL statement outside of PL/SQL.
即不能单独作为一条sql语句执行，一般在PL/SQL程序块(block)中使用。如果想在PL/SQL中实现该功能，可使用Create table newTable as select * from ...：
如： create table NewTable as select * from ATable;NewTable 除了没有键，其他的和ATable一样---------SQL SELECT INTO语法介绍
SQL SELECT INTO 语句可用于创建表的备份复件。
SELECT INTO 语句
SELECT INTO 语句从一个表中选取数据，然后把数据插入另一个表中。
SELECT INTO 语句常用于创建表的备份复件或者用于对记录进行存档。
SQL SELECT INTO 语法
您可以把所有的列插入新表：
SELECT * INTO new_table_name [IN externaldatabase] FROM old_tablename
或者只把希望的列插入新表：
SELECT column_name(s) INTO new_table_name [IN externaldatabase] FROM old_tablename
SQL SELECT INTO 实例 - 制作备份复件
下面的例子会制作 "Persons" 表的备份复件：
SELECT * INTO Persons_backup FROM Persons
IN 子句可用于向另一个数据库中拷贝表：
SELECT * INTO Persons IN 'Backup.mdb' FROM Persons
如果我们希望拷贝某些域，可以在 SELECT 语句后列出这些域：
SELECT LastName,FirstName
INTO Persons_backup
FROM Persons
SQL SELECT INTO 实例 - 带有 WHERE 子句
我们也可以添加 WHERE 子句。
下面的例子通过从 "Persons" 表中提取居住在 "Beijing" 的人的信息，创建了一个带有两个列的名为 "Persons_backup" 的表：
SELECT LastName,Firstname INTO Persons_backup FROM Persons WHERE City='Beijing'
SQL SELECT INTO 实例 - 被连接的表
从一个以上的表中选取数据也是可以做到的。
下面的例子会创建一个名为 "Persons_Order_Backup" 的新表，其中包含了从 Persons 和 Orders 两个表中取得的信息：
SELECT Persons.LastName,Orders.OrderNo
INTO Persons_Order_Backup
FROM Persons
INNER JOIN Orders
ON Persons.Id_P=Orders.Id_P
-------------------------------------------
select into from 和 insert into select都是用来复制表，两者的主要区别为： select into from 要求目标表不存在，因为在插入时会自动创建。insert into select from 要求目标表存在。下面分别介绍两者语法一、INSERT INTO SELECT语句(见下)1、语句形式insert into Table1(field1,field2...) select value1,value2... from Table22、注意（1）要求Table1存在，且字段field1,field2...也存在（2）注意Table2的主键约束，若Table2中有主键且不为空，则字段field1，field2...中也必须包含主键（3）注意语法，不要加values，和插入一条数据的sql混了，不要写成:Insert into Table2(field1,field2,...) values (select value1,value2,... from Table1)
（4）由于目标表Table2已经存在，所以我们除了插入源表Table1的字段外，还可以插入常量。3、完整实例：
SQL 代码   复制--1.创建测试表create TABLE Table1(a varchar(10),b varchar(10),c varchar(10),
CONSTRAINT [PK_Table1] PRIMARY KEY CLUSTERED(a ASC)) ON [PRIMARY]
create TABLE Table2(a varchar(10),c varchar(10),d int,
CONSTRAINT [PK_Table2] PRIMARY KEY CLUSTERED(a ASC)) ON [PRIMARY]
GO
--2.创建测试数据Insert into Table1 values('赵','asds','90')
Insert into Table1 values('钱','asds','100')
Insert into Table1 values('孙','asds','80')
Insert into Table1 values('李','asds',null)
GO
select * from Table2
--3.INSERT INTO SELECT语句复制表数据Insert into Table2(a, c, d) select a,c,5 from Table1
GO
--4.显示更新后的结果select * from Table2
GO
--5.删除测试表drop TABLE Table1
drop TABLE Table2二、SELECT INTO FROM语句
语句形式为：SELECT vale1, value2 into Table2 from Table1
要求目标表Table2不存在，因为在插入时会自动创建表Table2，并将Table1中指定字段数据复制到Table2中 。完整实例：
SQL 代码   复制--1.创建测试表create TABLE Table1(a varchar(10),b varchar(10),c varchar(10),
CONSTRAINT [PK_Table1] PRIMARY KEY CLUSTERED(a ASC)) ON [PRIMARY]
GO
--2.创建测试数据Insert into Table1 values('赵','asds','90')
Insert into Table1 values('钱','asds','100')
Insert into Table1 values('孙','asds','80')
Insert into Table1 values('李','asds',null)
GO
--3.SELECT INTO FROM语句创建表Table2并复制数据select a,c INTO Table2 from Table1
GO
--4.显示更新后的结果select * from Table2
GO
--5.删除测试表drop TABLE Table1
drop TABLE Table2不幸的是，我用select into没有成功，因为时间问题，还是用了复制表的基本语句(从oldTable复制到newTable)：
1、create table newTable as select * from oldTabel; 既复制表结构，也复制表内容；
2、create table newTable as select * from oldTable where 1=2; 只复制表结构，不复制表内容；
3、insert into newTable select * form oldTable; 不复制表结构，只复制表内容
或者 select value1,value2 into newTable form oldTable;

merge into的使用

我们操作数据库的时候，有时候会遇到insertOrUpdate这种需求。如果数据库中存在数据就update，如果不存在就insert。以前的时候，需要额外select查询一下，如果有数据就update，如果没有数据就insert。而现在Orcale数据库都提供了 MERGE 方法来处理这种需求。MERGE 命令使用一条语句从一个或者多个数据源中完成对表的更新和插入数据。MERGE 语法：MERGE INTO [your table-name] [rename your table here]
USING ( [write your query here] )[rename your query-sql and using just like a table]
ON ([conditional expression here] AND [...]...)
WHEN MATHED THEN [here you can execute some update sql or something else ]
WHEN NOT MATHED THEN [execute something else here ! ] 使用例子：create table TEST (ID INTEGER,VALUE VARCHAR2(255) );
insert into TEST values (1, 'test1');
insert into TEST values (2, 'test2');   我们想插入一条数据  {ID=2,NAME='newtest2'}  那么可以这么写MERGE INTO  TEST T1
USING (SELECT '2' as A FROM dual) T2 on (T1.ID=T2.ID)
WHEN MATCHED THEN UPDATE SET T1.NAME='newtest2'
WHEN NOT MATCHED THEN  INSERT (T1.ID, T1.NAME) VALUES ('1', 'newtest2');
如果ID为2的数据存在那么 UPDATE，如果不存在INSERT注意事项：Merge Into的原理是，从using 搜出来的结果逐条与on条件匹配，然后决定是update还是Insert。 当USING后面的sql没有查询到数据的时候，Merge Into语句是不会执行update和Insert操作的。所以要想让Merge Into正常运行，要保证USING 后面的SELECT有数据，个人喜欢使用DUAL表作为USING后的表，方便自己控制。
------------------------------------------oracle merge into 用法详解
1.    MERGE INTO 的用途MERGE INTO 是Oracle 9i以后才出现的新的功能。那这个功能 是什么呢？简单来说，就是：“有则更新，无则插入”从这句话里，应该可以理解到，merge into 操作一个对象'A'的时候，要有另外一个结果集做为源数据 'B'.‘merge into’  将B中的数据与A中的数据按照一定条件'C'进行对比，如果 A中数据满足C条件，则进行update操作，如果不满足条件 'C'，则进行insert操作。（请注意这种对应关系）2、 语法结构MERGE [INTO] [schema.]table [alias]USING {[schema.]table|views|query} [alias]ON {condition}WHEN MATCHED THEN UPDATE SET {clause}WHEN NOT MATCHED THEN INSERT VALUES {clause}我们可以用于单条数据的处理，也可以用于数据的批处理。对于merge into来说，那都是张飞吃豆芽儿，小菜一碟儿。而且效率要比单独执行update+insert 操作效率要高。但是请注意，using语句中的结果集 B不可以与merge into 的对象A相同，否则，会因为结果集A,B恒等。当 on() 进行等值判断时，只可以进行update操作，不能进行insert 操作，当 on() 进行不等值判断时，只可以进行insert操作，不能进行update操作。首先创建示例表：
create table PRODUCTS(PRODUCT_ID INTEGER,PRODUCT_NAME VARCHAR2(60),CATEGORY VARCHAR2(60));insert into PRODUCTS values (1501, 'VIVITAR 35MM', 'ELECTRNCS');insert into PRODUCTS values (1502, 'OLYMPUS IS50', 'ELECTRNCS');insert into PRODUCTS values (1600, 'PLAY GYM', 'TOYS');insert into PRODUCTS values (1601, 'LAMAZE', 'TOYS');insert into PRODUCTS values (1666, 'HARRY POTTER', 'DVD');commit;create table NEWPRODUCTS(PRODUCT_ID INTEGER,PRODUCT_NAME VARCHAR2(60),CATEGORY VARCHAR2(60));insert into NEWPRODUCTS values (1502, 'OLYMPUS CAMERA', 'ELECTRNCS');insert into NEWPRODUCTS values (1601, 'LAMAZE', 'TOYS');insert into NEWPRODUCTS values (1666, 'HARRY POTTER', 'TOYS');insert into NEWPRODUCTS values (1700, 'WAIT INTERFACE', 'BOOKS');commit;1.可省略的UPDATE或INSERT子句update使用，省略insert：MERGE INTO products pUSING newproducts npON (p.product_id = np.product_id)WHEN MATCHED THENUPDATESET p.product_name = np.product_name,p.category = np.category;insert使用，省略update：MERGE INTO products pUSING newproducts npON (p.product_id = np.product_id)WHEN NOT MATCHED THENINSERTVALUES (np.product_id, np.product_name,np.category);2、带条件的Updates和Inserts子句你能够添加WHERE子句到UPDATE或INSERT子句中去, 来跳过update或insert操作对某些行的处理.下面例子根据表NEWPRODUCTS来更新表PRODUCTS数据，根据条件category进行更新：MERGE INTO products pUSING newproducts npON (p.product_id = np.product_id)WHEN MATCHED THENUPDATESET p.product_name = np.product_nameWHERE p.category = np.category;MERGE INTO products pUSING newproducts npON (p.product_id = np.product_id)WHEN MATCHED THENUPDATESET p.product_name = np.product_name,p.category = np.category
WHERE p.category = 'DVD'
WHEN NOT MATCHED THEN
INSERT
VALUES (np.product_id, np.product_name, np.category)
WHERE np.category != 'BOOKS'3.两表连接无条件的Inserts
你能够不用连接源表和目标表就把源表的数据插入到目标表中. 这对于你想插入所有行到目标表时是非常有用的. Oracle 10g现在支持在ON条件中使用常量过滤谓词. 举个常量过滤谓词例子ON (1=0). 下面例子从源表插入行到表PRODUCTS, 不检查这些行是否在表PRODUCTS中存在:SQL> MERGE INTO products pUSING newproducts npON (1=0)WHEN NOT MATCHED THENINSERTVALUES (np.product_id, np.product_name, np.category)WHERE np.category = 'BOOKS'
-----------------------------------------------------------

树操作递归查询

---- 向上递归 id 最小级别
select distinct text,typefrom t_test_plan_ganttmodels t start with id = '0d143095102e4e39b52defbaf1e3c993' connect by prior parent = id ---- 向下递归 id 最大级别
select distinct text ,typefrom t_test_plan_ganttmodels t start with t.id = '0d143095102e4e39b52defbaf1e3c993'
connect by prior id = parent
---------------------------------------------------------------
Oracle 树操作、递归查询(select…start with…connect by…prior)
一、Oracle中start with…connect by prior子句用法connect by 是结构化查询中用到的，其基本语法是：
select … from tablename
start with 条件1
connect by 条件2
where 条件3;
例：
select * from table
start with org_id = ‘HBHqfWGWPy’
connect by prior org_id = parent_id;简单说来是将一个树状结构存储在一张表里，比如一个表中存在两个字段:
org_id，parent_id那么通过表示每一条记录的parent是谁，就可以形成一个树状结构。用上述语法的查询可以取得这棵树的所有记录。其中：条件1 是根结点的限定语句，当然可以放宽限定条件，以取得多个根结点，实际就是多棵树。条件2 是连接条件，其中用PRIOR表示上一条记录，比如 CONNECT BY PRIOR org_id = parent_id；就是说上一条记录的org_id 是本条记录的parent_id，即本记录的父亲是上一条记录。条件3 是过滤条件，用于对返回的所有记录进行过滤。简单介绍如下：在扫描树结构表时，需要依此访问树结构的每个节点，一个节点只能访问一次，其访问的步骤如下：第一步：从根节点开始；第二步：访问该节点；第三步：判断该节点有无未被访问的子节点，若有，则转向它最左侧的未被访问的子节，并执行第二步，否则执行第四步；第四步：若该节点为根节点，则访问完毕，否则执行第五步；第五步：返回到该节点的父节点，并执行第三步骤。总之：扫描整个树结构的过程也即是中序遍历树的过程。1．树结构的描述树结构的数据存放在表中，数据之间的层次关系即父子关系，通过表中的列与列间的关系来描述，如EMP表中的EMPNO和MGR。EMPNO表示该雇员的编号，MGR表示领导该雇员的人的编号，即子节点的MGR值等于父节点的EMPNO值。在表的每一行中都有一个表示父节点的MGR（除根节点外），通过每个节点的父节点，就可以确定整个树结构。在SELECT命令中使用CONNECT BY 和START WITH 子句可以查询表中的树型结构关系。其命令格式如下：
SELECT . . .
CONNECT BY {PRIOR 列名1=列名2|列名1=PRIOR 裂名2}
[START WITH]；其中：CONNECT BY子句说明每行数据将是按层次顺序检索，并规定将表中的数据连入树型结构的关系中。PRIOR运算符必须放置在连接关系的两列中某一个的前面。对于节点间的父子关系，PRIOR运算符在一侧表示父节点，在另一侧表示子节点，从而确定查找树结构是的顺序是自顶向下还是自底向上。在连接关系中，除了可以使用列名外，还允许使用列表达式。START WITH 子句为可选项，用来标识哪个节点作为查找树型结构的根节点。若该子句被省略，则表示所有满足查询条件的行作为根节点。START WITH：不但可以指定一个根节点，还可以指定多个根节点。2．关于PRIOR运算符PRIOR被放置于等号前后的位置，决定着查询时的检索顺序。PRIOR被置于CONNECT BY子句中等号的前面时，则强制从根节点到叶节点的顺序检索，即由父节点向子节点方向通过树结构，我们称之为自顶向下的方式。如：CONNECT BY PRIOR EMPNO=MGRPIROR运算符被置于CONNECT BY 子句中等号的后面时，则强制从叶节点到根节点的顺序检索，即由子节点向父节点方向通过树结构，我们称之为自底向上的方式。例如：CONNECT BY EMPNO=PRIOR MGR在这种方式中也应指定一个开始的节点。3．定义查找起始节点在自顶向下查询树结构时，不但可以从根节点开始，还可以定义任何节点为起始节点，以此开始向下查找。这样查找的结果就是以该节点为开始的结构树的一枝。4．使用LEVEL在具有树结构的表中，每一行数据都是树结构中的一个节点，由于节点所处的层次位置不同，所以每行记录都可以有一个层号。层号根据节点与根节点的距离确定。不论从哪个节点开始，该起始根节点的层号始终为1，根节点的子节点为2， 依此类推。图1.2就表示了树结构的层次。5．节点和分支的裁剪在对树结构进行查询时，可以去掉表中的某些行，也可以剪掉树中的一个分支，使用WHERE子句来限定树型结构中的单个节点，以去掉树中的单个节点，但它却不影响其后代节点（自顶向下检索时）或前辈节点（自底向顶检索时）。6．排序显示象在其它查询中一样，在树结构查询中也可以使用ORDER BY 子句，改变查询结果的显示顺序，而不必按照遍历树结构的顺序。二、例子1、准备测试表和测试数据1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
--菜单目录结构表
create table tb_menu(
&nbsp;&nbsp; id&nbsp;&nbsp;&nbsp;&nbsp; number(10) not null, --主键id
&nbsp;&nbsp; title&nbsp; varchar2(50), --标题
&nbsp;&nbsp; parent number(10) --parent id
)--父菜单
insert into tb_menu(id, title, parent) values(1, '父菜单1',null);
insert into tb_menu(id, title, parent) values(2, '父菜单2',null);
insert into tb_menu(id, title, parent) values(3, '父菜单3',null);
insert into tb_menu(id, title, parent) values(4, '父菜单4',null);
insert into tb_menu(id, title, parent) values(5, '父菜单5',null);
--一级菜单
insert into tb_menu(id, title, parent) values(6, '一级菜单6',1);
insert into tb_menu(id, title, parent) values(7, '一级菜单7',1);
insert into tb_menu(id, title, parent) values(8, '一级菜单8',1);
insert into tb_menu(id, title, parent) values(9, '一级菜单9',2);
insert into tb_menu(id, title, parent) values(10, '一级菜单10',2);
insert into tb_menu(id, title, parent) values(11, '一级菜单11',2);
insert into tb_menu(id, title, parent) values(12, '一级菜单12',3);
insert into tb_menu(id, title, parent) values(13, '一级菜单13',3);
insert into tb_menu(id, title, parent) values(14, '一级菜单14',3);
insert into tb_menu(id, title, parent) values(15, '一级菜单15',4);
insert into tb_menu(id, title, parent) values(16, '一级菜单16',4);
insert into tb_menu(id, title, parent) values(17, '一级菜单17',4);
insert into tb_menu(id, title, parent) values(18, '一级菜单18',5);
insert into tb_menu(id, title, parent) values(19, '一级菜单19',5);
insert into tb_menu(id, title, parent) values(20, '一级菜单20',5);
--二级菜单
insert into tb_menu(id, title, parent) values(21, '二级菜单21',6);
insert into tb_menu(id, title, parent) values(22, '二级菜单22',6);
insert into tb_menu(id, title, parent) values(23, '二级菜单23',7);
insert into tb_menu(id, title, parent) values(24, '二级菜单24',7);
insert into tb_menu(id, title, parent) values(25, '二级菜单25',8);
insert into tb_menu(id, title, parent) values(26, '二级菜单26',9);
insert into tb_menu(id, title, parent) values(27, '二级菜单27',10);
insert into tb_menu(id, title, parent) values(28, '二级菜单28',11);
insert into tb_menu(id, title, parent) values(29, '二级菜单29',12);
insert into tb_menu(id, title, parent) values(30, '二级菜单30',13);
insert into tb_menu(id, title, parent) values(31, '二级菜单31',14);
insert into tb_menu(id, title, parent) values(32, '二级菜单32',15);
insert into tb_menu(id, title, parent) values(33, '二级菜单33',16);
insert into tb_menu(id, title, parent) values(34, '二级菜单34',17);
insert into tb_menu(id, title, parent) values(35, '二级菜单35',18);
insert into tb_menu(id, title, parent) values(36, '二级菜单36',19);
insert into tb_menu(id, title, parent) values(37, '二级菜单37',20);
--三级菜单
insert into tb_menu(id, title, parent) values(38, '三级菜单38',21);
insert into tb_menu(id, title, parent) values(39, '三级菜单39',22);
insert into tb_menu(id, title, parent) values(40, '三级菜单40',23);
insert into tb_menu(id, title, parent) values(41, '三级菜单41',24);
insert into tb_menu(id, title, parent) values(42, '三级菜单42',25);
insert into tb_menu(id, title, parent) values(43, '三级菜单43',26);
insert into tb_menu(id, title, parent) values(44, '三级菜单44',27);
insert into tb_menu(id, title, parent) values(45, '三级菜单45',28);
insert into tb_menu(id, title, parent) values(46, '三级菜单46',28);
insert into tb_menu(id, title, parent) values(47, '三级菜单47',29);
insert into tb_menu(id, title, parent) values(48, '三级菜单48',30);
insert into tb_menu(id, title, parent) values(49, '三级菜单49',31);
insert into tb_menu(id, title, parent) values(50, '三级菜单50',31);
commit;select * from tb_menu;
parent字段存储的是上级id，如果是顶级父节点，该parent为null(得补充一句，当初的确是这样设计的，不过现在知道，表中最好别有null记录，这会引起全文扫描，建议改成0代替)。2、树操作
我们从最基本的操作，逐步列出树查询中常见的操作，所有查询出来的节点以家族中的辈份作比方。1)、查找树中的所有顶级父节点（辈份最长的人）。 假设这个树是个目录结构，那么第一个操作总是找出所有的顶级节点，再根据该节点找到其下属节点。1
select * from tb_menu m where m.parent is null;
2)、查找一个节点的直属子节点（所有儿子）。 如果查找的是直属子类节点，也是不用用到树型查询的。1
select * from tb_menu m where m.parent=1;
3)、查找一个节点的所有直属子节点（所有后代）。1
select * from tb_menu m start with m.id=1 connect by m.parent=prior m.id;
这个查找的是id为1的节点下的所有直属子类节点，包括子辈的和孙子辈的所有直属节点。4)、查找一个节点的直属父节点（父亲）。 如果查找的是节点的直属父节点，也是不用用到树型查询的。1
2
3
4
--c-->child, p->parent
select c.id, c.title, p.id parent_id, p.title parent_title
from tb_menu c, tb_menu p
where c.parent=p.id and c.id=6
5)、查找一个节点的所有直属父节点（祖宗）。1
select * from tb_menu m start with m.id=38 connect by prior m.parent=m.id;
这里查找的就是id为1的所有直属父节点，打个比方就是找到一个人的父亲、祖父等。但是值得注意的是这个查询出来的结果的顺序是先列出子类节点再列出父类节点，姑且认为是个倒序吧。上面列出两个树型查询方式，第3条语句和第5条语句，这两条语句之间的区别在于prior关键字的位置不同，所以决定了查询的方式不同。 当parent = prior id时，数据库会根据当前的id迭代出parent与该id相同的记录，所以查询的结果是迭代出了所有的子类记录；而prior parent = id时，数据库会跟据当前的parent来迭代出与当前的parent相同的id的记录，所以查询出来的结果就是所有的父类结果。以下是一系列针对树结构的更深层次的查询，这里的查询不一定是最优的查询方式，或许只是其中的一种实现而已。6)、查询一个节点的兄弟节点（亲兄弟）。1
2
3
--m.parent=m2.parent-->同一个父亲
select * from tb_menu m
where exists (select * from tb_menu m2 where m.parent=m2.parent and m2.id=6)
7)、查询与一个节点同级的节点（族兄弟）。 如果在表中设置了级别的字段，那么在做这类查询时会很轻松，同一级别的就是与那个节点同级的，在这里列出不使用该字段时的实现!1
2
3
4
5
6
7
8
with tmp as(select a.*, level leaf        from tb_menu a                start with a.parent is null     connect by a.parent = prior a.id)
select *
from tmp
where leaf = (select leaf from tmp where id = 50);
这里使用两个技巧，一个是使用了level来标识每个节点在表中的级别，还有就是使用with语法模拟出了一张带有级别的临时表。8)、查询一个节点的父节点的的兄弟节点（伯父与叔父）。          1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
with tmp as(select tb_menu.*, level levfrom tb_menustart with parent is nullconnect by parent = prior id)select b.*
from tmp b,(select *from tmpwhere id = 21 and lev = 2) a
where b.lev = 1union allselect *
from tmp
where parent = (select distinct x.idfrom tmp x, --祖父tmp y, --父亲(select *from tmpwhere id = 21 and lev > 2) z --儿子where y.id = z.parent and x.id = y.parent);
这里查询分成以下几步。
首先，将第7个一样，将全表都使用临时表加上级别；
其次，根据级别来判断有几种类型，以上文中举的例子来说，有三种情况：
（1）当前节点为顶级节点，即查询出来的lev值为1，那么它没有上级节点，不予考虑。
（2）当前节点为2级节点，查询出来的lev值为2，那么就只要保证lev级别为1的就是其上级节点的兄弟节点。
（3）其它情况就是3以及以上级别，那么就要选查询出来其上级的上级节点（祖父），再来判断祖父的下级节点都是属于该节点的上级节点的兄弟节点。
最后，就是使用union将查询出来的结果进行结合起来，形成结果集。9)、查询一个节点的父节点的同级节点（族叔）。
这个其实跟第7种情况是相同的。1
2
3
4
5
6
7
8
with tmp as(select a.*, level leaf        from tb_menu a                start with a.parent is null     connect by a.parent = prior a.id)
select *
from tmp
where leaf = (select leaf from tmp where id = 6) - 1;
基本上，常见的查询在里面了，不常见的也有部分了。其中，查询的内容都是节点的基本信息，都是数据表中的基本字段，但是在树查询中还有些特殊需求，是对查询数据进行了处理的，常见的包括列出树路径等。补充一个概念，对于数据库来说，根节点并不一定是在数据库中设计的顶级节点，对于数据库来说，根节点就是start with开始的地方。下面列出的是一些与树相关的特殊需求。10)、名称要列出名称全部路径。
这里常见的有两种情况，一种是从顶级列出，直到当前节点的名称（或者其它属性）；一种是从当前节点列出，直到顶级节点的名称（或其它属性）。举地址为例：国内的习惯是从省开始、到市、到县、到居委会的，而国外的习惯正好相反（老师说的，还没接过国外的邮件，谁能寄个瞅瞅  ）。
从顶部开始：1
2
3
4
5
select sys_connect_by_path (title, '/')
from tb_menu
where id = 50
start with parent is null
connect by parent = prior id;
从当前节点开始：1
2
3
4
select sys_connect_by_path (title, '/')
from tb_menu
start with id = 50
connect by prior parent = id;
在这里我又不得不放个牢骚了。oracle只提供了一个sys_connect_by_path函数，却忘了字符串的连接的顺序。在上面的例子中，第一个sql是从根节点开始遍历，而第二个sql是直接找到当前节点，从效率上来说已经是千差万别，更关键的是第一个sql只能选择一个节点，而第二个sql却是遍历出了一颗树来。再次ps一下。sys_connect_by_path函数就是从start with开始的地方开始遍历，并记下其遍历到的节点，start with开始的地方被视为根节点，将遍历到的路径根据函数中的分隔符，组成一个新的字符串，这个功能还是很强大的。11)、列出当前节点的根节点。
在前面说过，根节点就是start with开始的地方。1
2
3
4
select connect_by_root title, tb_menu.*
from tb_menu
start with id = 50
connect by prior parent = id;
connect_by_root函数用来列的前面，记录的是当前节点的根节点的内容。12)、列出当前节点是否为叶子。
这个比较常见，尤其在动态目录中，在查出的内容是否还有下级节点时，这个函数是很适用的。1
2
3
4
select connect_by_isleaf, tb_menu.*
from tb_menu
start with parent is null
connect by parent = prior id;
connect_by_isleaf函数用来判断当前节点是否包含下级节点，如果包含的话，说明不是叶子节点，这里返回0；反之，如果不包含下级节点，这里返回1。至此，oracle树型查询基本上讲完了，以上的例子中的数据是使用到做过的项目中的数据，因为里面的内容可能不好理解，所以就全部用一些新的例子来进行阐述。以上所有sql都在本机上测试通过，也都能实现相应的功能，但是并不能保证是解决这类问题的最优方案（如第8条明显写成存储过程会更好）.
----------------------------------------------------------------oracle递归查询也有叫树查询的,语法结构为: select  * from  tb  start with id=1 connect by prior id=id2 (prior也可以放在等号后面:id=prior id2 ,这样查询的结果等同于交换变量的位置:prior id2=id).之所以叫递归查询是因为后一次的查询条件是依赖前一次的记录进行的,如prior id2=id  意思就是当前要查询的id等于前一条记录的id2  即以此类推进行递归查询connect  by  是递归查询的标志    若省去prior 则仅查询满足start with 条件的记录 .

ORACLE ROWNUM用法、select into与insert into区别、merge into的使用、递归查询相关推荐

  1. oracle的rownum的用法,Oracle Rownum用法

    Oracle Rownum用法 Oracle提供了rownum,rownum是一个隐含的(查询结果集)字段,rownum是一个行号,从1开始. rownum隐含字段 select rownum, a. ...

  2. ROWNUM用法--SELECT * FROM T WHERE ROWNUM=1

    对于不熟悉ROWNUM用法的人可以好好的看看了. 为什么SELECT * FROM T WHERE ROWNUM=1 可以查询出来数据, 而SELECT * FROM T WHERE ROWNUM=2 ...

  3. oracle rownum用法排序,利用rownum分组排序去重

    需求:SQL> select fyear,fseason,fsale from t_test order by fyear,fseason; FYEAR    FSEASON      FSAL ...

  4. Oracle rownum 用法

    对于rownum来说它是oracle系统顺序分配为从查询返回的行的编号,返回的第一行分配的是1,第二行是2,依此类推,这个伪字段可以用于限制查询返回的总行数,且rownum不能以任何表的名称作为前缀. ...

  5. Oracle rownum 用法 --使用rownum 实现获取记录

    实现以下查询: (1)获取前两条的记录: (2)获取第三条到第六条的记录: 表 student ,记录数8条 (1)获取前两条的记录 直接生成 select * from student where ...

  6. oracle+rownum(),Oracle rownum用法

    rownum是什么 rownum是一种伪列,它会根据返回记录生成一个序列化的数字. 对rownum进行>.>=.=操作 不能对rownum使用>(大于1的数值).>=(大于或等 ...

  7. oracle rownum用法

    在 Oracle 数据库中,ROWNUM 是一个只读的伪列,它能够返回每一行的行号.ROWNUM 的值是在 SELECT 语句中检索到的行被返回之前为每一行分配的值.这意味着,ROWNUM 的值是与行 ...

  8. oracle rownum用法排序,oracle rownum对排序的影响

    select * from (select c.*, rownum rn from content c) where rn >= 1 and rn <= 5 2. 但是如果, 加上orde ...

  9. 【软件测试】Oracle中的rownum用法

    一.对rownum的说明 查看全文 http://www.taodudu.cc/news/show-3538609.html 相关文章: Oracle rownum 用法 Oracle rownum ...

最新文章

  1. 微型计算机有什么电路组成,第二章 微型计算机的基本电路组成
  2. 这个机器狗引起网友争议，「持枪机器狗」射程达1200米
  3. Python学习笔记（三）——条件语句、循环语句
  4. 对照片进行边缘化处理，并将边缘化处理后的结果保存
  5. 树视图的属性与方法 c# 1614262746
  6. 上新啦 | 火山翻译新增38个语种！
  7. 洛谷2678跳石头----二分答案入门
  8. 【回眸】LDA算法（数据处理与智能决策）
  9. 云端卫士助力运营商实现DDoS安全业务的统一运营
  10. 计算机视觉领域最高奖,数据挖掘研究领域最高奖项公布 优必选AI首席科学家陶大程博士获IEEE ICDM研究贡献奖...
  11. python 按行读取_python按行读取
  12. ZYNQ sd卡启动失败，mmc0: error -84 whilst initialising SD card， SD卡只读，mmcblk0: mmc0:0001 SD 8 GiB (ro)
  13. 新形势下安全风险评估实践
  14. 第八次作业——MPEG音频编码
  15. 为什么用了这么多社交软件，你还是要回家相亲
  16. 端到端OCR-ABCNet论文笔记
  17. 基于gmssl SM2 签名验签测试程序
  18. f2fs学习笔记 - 5. f2fs基本类图
  19. Flutter3引用原生播放器-Android篇
  20. Go语言通用代码生成器仙童已发布Beta5版，发布最新介绍视频，彻底修复弹性登录模块

热门文章

  1. java实现多线程断点续传,上传下载 分享
  2. 【Hibernate】Hibernate实体关系映射——主键相同的一对一关系
  3. Java Scala 混合编程导致 编译失败 ，【找不到符号】问题解决
  4. Confluence 6 索引支持的语言并进行修改
  5. C#关于电脑DPI改动显示的问题
  6. c语言sin函数近似值,用泰勒公式求sin(x)的近似值
  7. python实现合并链表_python：16.合并两个排序的链表
  8. 台式电脑计算机硬盘清理,台式电脑重装系统win7清理磁盘碎片的方法
  9. android 360状态栏显示,如何从Android应用程序显示360全景(How to display a 360 panorama from android application)...
  10. c语言实现结构体变量private,C语言中结构体变量私有化详解