oracle中with递归的用法

oracle 多段with as用法-回复Oracle是一个广泛使用的关系型数据库管理系统，它支持使用SQL语言进行数据操作和查询。

其中，多段WITH子句是Oracle SQL的一个重要特性，它允许我们在一个查询中定义多个临时表，以简化复杂查询的编写。

本文将介绍多段WITH子句的用法，并逐步解释其实现原理和使用方法。

一、什么是多段WITH子句多段WITH子句是Oracle SQL中的一种高级查询语法，它允许我们在一个查询中定义多个临时表，以供后续查询使用。

它的基本语法如下所示：WITH第一段子查询AS (SELECT ...),第二段子查询AS (SELECT ...),...第N段子查询AS (SELECT ...)SELECT ...FROM ...在这个语法中，第一段子查询可以引用后续任意一段子查询定义的临时表，而后续每一段子查询只可以引用前面定义的临时表。

这样，我们就可以在一个查询中建立多个关联的临时表，以实现更复杂的数据查询和分析。

二、多段WITH子句的实现原理在理解多段WITH子句的用法之前，我们需要了解它的实现原理。

Oracle在执行一个多段WITH子句的查询时，实际上会将每个子查询定义的临时表展开为对应的视图，并将这些视图嵌套在主查询中。

这个过程称为“视图展开”或“视图合并”。

展开后的查询会被优化器进行优化和执行。

三、多段WITH子句的使用方法在实际使用中，多段WITH子句可以帮助我们简化复杂查询的编写，并改善查询的可读性和维护性。

下面将详细介绍多段WITH子句的使用方法。

1. 基本用法多段WITH子句的基本用法已经在前面的语法中介绍过了。

我们可以在WITH子句中定义多个子查询，并在后续的主查询中引用这些子查询定义的临时表。

例如，我们可以使用多段WITH子句统计某个销售订单的销售额和利润：WITH订单明细AS (SELECT ...),销售额AS (SELECT ...),利润AS (SELECT ...)SELECT 销售额, 利润FROM 订单明细通过将复杂的查询逻辑划分为多个临时表的定义，我们可以更清晰地表达查询的意图，并提高查询的可读性。

oracle递归写法Oracle是一种强大的关系型数据库管理系统，递归在Oracle中也是一个非常重要的功能。

递归是一种能够在算法或程序中重复执行某个过程的方法。

我们知道，在关系型数据库管理系统中，数据是以表的形式存储的。

当我们需要从表中查询某些特定的数据时，可以使用递归来实现这个目标。

以下是Oracle递归的写法：1. 使用WITH子句来定义递归的初始条件；2. 在WITH子句中定义递归的部分，并使用UNION ALL语句将其连接；3. 在递归的最后一部分中使用SELECT语句来选择结果。

Oracle的递归实现方式可以使用PL/SQL语句实现，也可以使用SQL 语句实现。

不同的实现方式会有一些细微的差异，在具体实践中需要按照具体情况选择。

下面是一个Oracle递归实现的示例：WITH RECURSIVE 表名称（字段1，字段2，……，字段n） AS (SELECT 初始查询结果UNION ALLSELECT 递归查询结果FROM 表名WHERE 递归查询条件)SELECT 结果FROM 表名;其中，表名称是递归表的名称，字段1、字段2、……、字段n是递归表中的字段，初始查询结果是递归的初始条件，递归查询结果是递归的中间部分，递归查询条件是递归的退出条件，结果是递归查询的结果集，表名是递归查询的表名。

递归查询在Oracle中有很多实际应用场景，比如查询组织架构图中某个节点的所有下级节点、查询登录用户有哪些权限等等。

递归查询方法简单，但是需要对数据结构有深入的了解和掌握。

综上所述，Oracle递归写法是一种非常重要的技能，能够大大提高数据处理和查询的效率，是每个Oracle数据库开发人员必须掌握的能力之一。

oracle的with简书Oracle的WITH语句是一种非常常用的SQL语法。

它可以在查询中创建临时表，以在同一查询中使用。

在本文中，我们将介绍Oracle的WITH语句及其用法。

WITH语句，也被称为公共表表达式（Common Table Expression，CTE），是一种允许用户为一个查询创建临时表的方法。

这些临时表只在查询中有效，并且可以在同一查询中多次引用。

WITH语句极大地提高了查询的可读性和可维护性。

使用WITH语句，我们可以将复杂的查询分解为多个简单的查询，并使用这些简单的查询创建临时表。

然后，我们可以在同一查询中使用这些临时表，使查询的逻辑更加清晰和简洁。

WITH语句使用以下语法：```WITH alias_name AS (SELECT column1, column2, ...FROM table_nameWHERE condition)SELECT column1, column2, ...FROM alias_nameWHERE condition;```在这个语法中，我们首先使用WITH关键字声明一个临时表的别名。

然后，在AS子句中，我们使用SELECT语句来定义这个临时表的内容。

接下来，在主查询中，我们使用这个临时表的别名来引用这个临时表。

以下是一个使用WITH语句的示例：```WITH employees AS (SELECT employee_id, first_name, last_name, salaryFROM employeesWHERE salary > 5000)SELECT first_name, last_name, salaryFROM employeesWHERE salary > 10000;```在这个示例中，我们首先创建了一个临时表employees，该表包含了工资大于5000的雇员的信息。

然后，在主查询中，我们进一步筛选工资大于10000的雇员，并显示他们的姓名和工资。

oracle中with的用法及用处========WITH========用于一个语句中某些中间结果放在临时表空间的SQL语句如WITH channel_summary AS (SELECT channels.channel_desc, SUM(amount_sold) AS channel_totalFROM sales, channelsWHERE sales.channel_id = channels.channel_idGROUP BY channels.channel_desc)SELECT channel_desc, channel_totalFROM channel_summaryWHERE channel_total > (SELECT SUM(channel_total) * 1/3FROM channel_summary);CHANNEL_DESC CHANNEL_TOTAL-------------------- -------------Direct Sales 312829530channel_summary表就是WITH生成的中间表1：这个临时表空间channel_summary 什么时候清除呢？是一个会话结束自动消失嘛？临时表在会话结束就自动被PGA清除2：就这一功能来说，子查询就可以达到啊，为什么要用with呢？用with有什么好处，不会仅仅是 ...都能写，但执行计划不同的。

当有多个相似子查询的时候，用with写公共部分，因为子查询结果在内存临时表中，执行效率当然就高啦。

如果你后面需要不止一次地引用这个结果，那么WITH就会大大提高效率。

代码的可读性好。

oracle递归查询start with connect by prior的用法在Oracle数据库中，"START WITH"和"CONNECT BY PRIOR"是用于执行递归查询的关键字。

这些关键字与"SELECT"语句一起使用，用于在以层次结构组织的数据中进行深度优先搜索。

具体用法如下所示：1. 使用"START WITH"关键字指定递归查询的起始条件。

例如，如果要从员工表中查询所有直接报告给经理ID为100的员工，可以这样写：```SELECT employee_id, employee_nameFROM employeeSTART WITH manager_id = 100;```2. 使用"CONNECT BY PRIOR"关键字指定递归查询的连接条件。

它指定了当前行与上一行之间的关系。

例如，可以将上述查询修改为查询经过多层级关系的员工：```SELECT employee_id, employee_nameFROM employeeSTART WITH manager_id = 100CONNECT BY PRIOR employee_id = manager_id;```在这个例子中，"PRIOR employee_id = manager_id"指定了下一层级的员工与上一层级的经理之间的连接关系。

3. 使用其他"WHERE"子句对查询结果进行筛选。

例如，可以添加"WHERE"子句限制只返回特定层级的员工：```SELECT employee_id, employee_nameFROM employeeSTART WITH manager_id = 100CONNECT BY PRIOR employee_id = manager_idWHERE LEVEL <= 3;```在这个例子中，"LEVEL"是递归查询中的一个伪列，表示当前行的层级。

oracle 递归查询语句
Oracle 中的递归查询通常使用Common Table Expression（CTE）来实现。

以下是一个简单的Oracle 递归查询语句示例：
```sql
WITH RECURSIVE cte (id, level, parent_id) AS (
--基本情况：选取起始节点
SELECT id, 1 AS level, NULL AS parent_id
FROM your_table
WHERE id = YOUR_START_ID
UNION ALL
--递归情况：选取子节点
SELECT c.id, c.level + 1 AS level, c.parent_id
FROM your_table c
JOIN cte ON c.parent_id = cte.id
)
SELECT * FROM cte;
```
在这个示例中，我们首先选择起始节点（YOUR_START_ID 对应的具体节点），然后递归地选择子节点。

最后，查询结果将包含所有节点及
其层次结构。

请将`your_table` 替换为实际的数据表名，并根据需要调整查询条件。

此外，这个示例适用于Oracle 12c 及更高版本。

需要注意的是，Oracle 递归查询语句的性能取决于表结构和数据量。

在实际应用中，为了避免性能问题，请确保表具有合适的索引，并限制查询的层级深度。

oracle 递归查询优化的方法Oracle数据库是一种常用的关系型数据库管理系统，具有强大的查询功能。

在实际开发中，我们经常会遇到需要递归查询的情况，即查询某个节点的所有子节点或祖先节点。

然而，递归查询往往会涉及到大量的数据和复杂的逻辑，导致查询效率低下。

因此，本文将介绍一些优化递归查询的方法，以提高查询效率。

1. 使用CONNECT BY子句进行递归查询Oracle提供了CONNECT BY子句来支持递归查询。

通过使用CONNECT BY子句，我们可以轻松地实现递归查询，例如查询某个员工及其所有下属员工的信息。

CONNECT BY子句的基本语法如下：```SELECT 列名FROM 表名START WITH 条件CONNECT BY PRIOR 列名 = 列名;```其中，START WITH子句用于指定递归查询的起始节点，CONNECT BY PRIOR子句用于指定递归查询的连接条件。

通过合理设置起始节点和连接条件，我们可以实现不同类型的递归查询。

2. 使用层次查询优化递归查询在递归查询中，我们经常会遇到多层递归查询的情况，即查询某个节点的所有子节点及其子节点的子节点。

这时，可以使用层次查询来优化递归查询。

层次查询是一种特殊的递归查询，通过使用LEVEL伪列可以获取每个节点的层次信息。

例如，我们可以使用以下语句查询某个员工及其所有下属员工的信息及其层次信息：```SELECT 列名, LEVELFROM 表名START WITH 条件CONNECT BY PRIOR 列名 = 列名;```通过使用LEVEL伪列，我们可以方便地获取每个节点的层次信息，从而更好地理解查询结果。

3. 使用递归子查询优化递归查询在某些情况下，使用CONNECT BY子句可能会导致查询效率低下，特别是在处理大量数据时。

这时，可以考虑使用递归子查询来优化递归查询。

递归子查询是一种特殊的子查询，通过使用WITH子句和递归关键字来实现递归查询。

一、概述Oracle数据库提供了存储过程来帮助用户封装一系列SQL语句，以便于简化数据库操作和提高性能。

在存储过程中，常常会使用到WITH 子句来创建临时的查询结果集，以便在存储过程的后续语句中使用。

本文将重点介绍在Oracle存储过程中的WITH用法及注意事项。

二、WITH子句概述1、WITH子句是一种通用表表达式（CTE，Common Table Expression），用于创建临时的命名查询结果集。

WITH子句通常由关键字WITH和一个或多个子查询组成，可以在后续的SQL语句中像使用表一样引用这些临时结果集。

2、在存储过程中使用WITH子句能够提高可读性和维护性，同时还可以优化查询性能。

三、在Oracle存储过程中使用WITH子句的示例在存储过程中使用WITH子句的一般语法如下：```sqlCREATE OR REPLACE PROCEDURE procedure_nameASBEGINWITH temp_table (column1, column2, ...)AS(SELECT column1, column2, ...FROM table_nameWHERE ...)-- 后续的SQL语句可以引用temp_tableEND;```下面是一个具体的示例，假设我们有一个存储过程，需要根据员工的工资水平来进行统计和分析。

```sqlCREATE OR REPLACE PROCEDURE calculate_salary_statistics ASBEGINWITH high_salary_employees (employee_id, employee_name, salary)AS(SELECT employee_id, employee_name, salaryFROM employeesWHERE salary > xxx)SELECT COUNT(*)INTO high_salary_employee_countFROM high_salary_employees;-- 后续可以继续使用high_salary_employees来编写其他逻辑END;```四、在存储过程中使用WITH子句的注意事项1、WITH子句内的查询结果集只在当前的SQL语句中有效，后续的SQL语句需要继续引用它的话，必须在相同的语句块中。

oracle 递归查询逻辑Oracle是一种关系型数据库管理系统，它提供了一种强大的递归查询功能，可以在查询语句中使用递归查询逻辑来实现复杂的数据查询和处理操作。

本文将详细介绍Oracle中递归查询的原理和使用方法。

递归查询是一种通过重复应用查询语句来解决复杂问题的方法。

在Oracle中，递归查询可以通过使用WITH语句和CONNECT BY子句来实现。

WITH语句用于定义一个或多个临时表，而CONNECT BY子句则用于指定递归查询的条件和连接关系。

我们先来了解一下WITH语句的使用方法。

WITH语句可以将一个或多个查询块定义为一个临时表，这些查询块可以在后续的查询语句中引用。

使用WITH语句可以提高查询语句的可读性和维护性，同时还可以避免重复执行相同的子查询。

WITH语句的语法如下：```WITH 表名 (列名1, 列名2, ...) AS (查询语句1UNION ALL查询语句2UNION ALL...查询语句n)```其中，表名是临时表的名称，列名1、列名2等是临时表的列名，查询语句1、查询语句2等是定义临时表的查询语句。

接下来，我们来看一下CONNECT BY子句的使用方法。

CONNECT BY 子句用于指定递归查询的条件和连接关系。

在递归查询中，每个查询块都必须包含一个起始条件和一个递归条件，起始条件用于指定递归查询的起始节点，而递归条件则用于指定递归查询的连接关系。

CONNECT BY子句的语法如下：```SELECT 列名1, 列名2, ...FROM 表名START WITH 起始条件CONNECT BY 递归条件```其中，列名1、列名2等是要查询的列名，表名是要查询的表名，起始条件用于指定递归查询的起始节点，递归条件用于指定递归查询的连接关系。

在使用递归查询时，我们需要注意一些重要的事项。

首先，递归查询必须包含一个终止条件，以避免无限递归。

其次，递归查询可能会导致性能问题，特别是在处理大量数据时。

Oracle11GR2的递归WITH⼦查询⽅法下⾯给⼤家详细介绍Oracle 11GR2的递归WITH⼦查询⽅法，具体内容如下所⽰：SQL> with emp_data(ename,empno,mgr,l)as(select ename, empno, mgr, 1 lvl from emp where mgr is nullunion allselect emp.ename, emp.empno, emp.mgr, ed.l+1from emp, emp_data edwhere emp.mgr = ed.empno)SEARCH DEPTH FIRST BY ename SET order_byselect l,lpad('*' ,2*l, '*')||ename nmfrom emp_dataorder by order_by/L NM---- ---------------1 **KING2 ****BLAKE3 ******ALLEN3 ******JAMES3 ******MARTIN3 ******TURNER3 ******WARD2 ****CLARK3 ******MILLER2 ****JONES3 ******FORD4 ********SMITH3 ******SCOTT4 ********ADAMS14 rows selected.不知道真⽤起来怎么样，按我的想象可以⽐原来的SYS_CONNECT_BY_PATH多玩出很多新花样，⽐如按路径累加，更灵活的剪枝条件，WITH⼦查询也称为CTE (Common Table Expression)，是ANSI SQL-99标准的⼀部分。

ORACLE从9i开始引⼊WITH⼦查询，把它被称作SUBQUERY FACTORING(分解⼦查询)。

WITH⼦查询的作⽤类似于内联视图(INLINE VIEW)。

oraclesql递归查询讲解Oracle SQL递归查询Oracle SQL递归查询是在Oracle数据库中使用递归查询的一种形式。

它可以对表中的记录进行查询，从而得出一组有用的结果。

递归查询允许我们使用某个表中的一个记录，查询另一个表，然后再查询另一个表，以此类推，这种查询模式称为递归查询。

要创建递归查询，我们必须使用Oracle SQL的WITH子句，这是一个可以指定一个查询的名称，然后定义一个查询的结果集的SQL子句。

每次迭代时，通过这种方式获取到的结果集会被作为参数传入下一次查询。

递归查询条件必须指定条件，以便在查询结果准备就绪时终止整个查询过程。

此外，我们还可以使用UNION ALL子句来对递归查询生成的多个结果集进行合并，以便更好地查看数据。

另外，为了简化结果，我们也可以使用GROUP BY子句来将结果集中的行分组。

下面是一个示例，演示如何使用Oracle SQL递归查询从表中检索数据。

假设我们想要查询出表products中的所有商品，其中每个商品都属于某个特定的类别，并且每个类别可以有其自身的父类别：WITH all_productsAS (SELECT p.*FROM products pWHERE p.category_id = 0UNION ALLSELECT p.*FROM products pJOIN all_products apON p.category_id = ap.id)SELECT *FROM all_products;在这个例子中，我们使用WITH子句定义了一个名为“all_products”的查询，用于查询属于类别“0”的所有商品。

然后，我们将查询用作参数，按照类别id（category_id）将每个类别下的商品查询出来。

最后，我们使用SELECT子句从递归查询中检索商品。

oracle with的用法oracle with语句，也叫做“共享子查询”，是oracle 9i引入的新特性。

可以用在创建视图、临时表、索引等。

一、oracle with语句的定义oracle with语句是一种独立的查询结构，用来从数据库中检索数据。

它在语句的前面采用with子句定义共享结果集，可以在后续的查询中作为临时的视图使用。

oracle的with语句被称为子查询（subquery），用select语句将一个查询放置在一个仅能由oracle解析的语句块中，它可以重复使用，而普通的子查询不可以重复使用。

二、oracle with语句语法WITH 子查询别名 (列表)AS(select语句1union allselect语句2...)select * from 子查询别名;三、oracle with语句应用1、识别重复行在某些情况下，我们需要识别出重复行，并从结果集中删除这些重复行，这时可以使用with语句，with语句可以提取最新的记录：with vw_empas(select emp_no, emp_name, dept_id, ROW_NUMBER()OVER(partition by emp_no order by dept_id desc) as seq_nofrom emp)select emp_no, emp_name, dept_idfrom vw_empwhere seq_no=1;2、使用分组函数使用oracle的分组函数时，如果需要过滤掉重复行，可以考虑使用with语句，而不是在查询中使用group by子句。

with vw_emp as(select emp_no, dept_no, sum(salary) over(partition by emp_no) as total_salaryfrom emp)select * from vw_empwhere total_salary>10000;3、加入计算的逻辑行有时候，我们可以用with语句将一些比较复杂的逻辑以语句的形式写出来，并将它们加入到查询中，以便使查询更加清晰。

connect by和with recursive语句的用法Connect by和with recursive语句是两种在关系数据库中用于处理层次关系数据的语句。

它们分别被用于不同的数据库系统，一个用于Oracle数据库，另一个用于PostgreSQL和MySQL数据库。

在本篇文章中，我们将一步一步回答关于这两种语句的用法。

第一部分：Connect by语句一、Connect by语句是Oracle数据库中用于处理层次关系数据的语句。

它使用了递归查询的方式来遍历一个表中的层次结构数据。

Connect by语句的基本语法如下：SELECT 列名FROM 表名[WHERE 条件]CONNECT BY PRIOR 列名= 列名;其中，列名是要查询的列名，表名是要查询的表名，条件是一个可选的条件表达式，CONNECT BY是关键字，PRIOR是关键字，用于指定上层和下层之间的连接条件。

二、Connect by语句的用法1. 连接条件：通过使用CONNECT BY ... PRIOR ...语法，Connect by语句可以指定上层和下层之间的连接条件。

这个连接条件类似于JOIN条件，可以使用等于操作符或其他操作符来指定条件。

2. 递归查询：Connect by语句使用递归查询的方式来遍历层次结构数据。

它从根节点开始，逐级遍历每个节点，并按照指定的连接条件找到下一级子节点，直到找不到为止。

3. 增加层次：Connect by语句还可以使用CONNECT BY ... LEVEL <= n语法来限制层次的数量。

这样可以控制递归查询的深度，只返回指定层次以下的数据。

第二部分：With recursive语句一、With recursive语句是PostgreSQL和MySQL数据库中用于处理层次关系数据的语句。

它与Connect by语句类似，也使用递归查询的方式来遍历一个表中的层次结构数据。

With recursive语句的基本语法如下：WITH RECURSIVE 递归表名(列名)AS (初始查询UNION ALL递归查询)SELECT 列名FROM 递归表名;其中，递归表名是一个临时表名，用于存储递归查询的结果，列名是要查询的列名，初始查询是第一次查询，递归查询是对递归表进行迭代查询的子查询，UNION ALL关键字用于将初始查询和递归查询的结果合并。

"WITH" 是在SQL 查询中使用的关键字，用于创建临时表达式（也称为子查询）或者为查询结果集提供别名。

而"Oracle" 是一种流行的关系数据库管理系统（RDBMS），常用于存储和管理大量数据。

结合在一起，"WITH Oracle" 可以表示在Oracle 数据库中使用"WITH" 关键字的用法。

在Oracle 中，"WITH" 关键字通常用于以下两个方面：1. 公共表表达式（Common Table Expression，CTE）：使用"WITH" 关键字可以定义一个临时的命名查询块，该查询块可以在后续查询中引用。

这被称为公共表表达式（CTE）。

使用CTE 可以提高查询的可读性和可维护性。

例如，下面是使用"WITH" 创建一个名为"my_cte" 的CTE 的示例：WITH my_cte AS (SELECT column1, column2FROM table1WHERE condition)SELECT *FROM my_cteWHERE column1 = 'value';2. 递归查询（Recursive Queries）：在Oracle 中，"WITH" 还可以用于创建递归查询，即查询可以自引用并在自身上执行迭代操作。

递归查询通常用于处理具有层次结构或递归关系的数据。

例如，下面是使用"WITH" 创建递归查询的示例：WITH recursive_query (column1, column2) AS (SELECT root_column1, root_column2FROM tableWHERE conditionUNION ALLSELECT child_column1, child_column2FROM tableJOIN recursive_query ON table.parent_id = recursive_query.column1)SELECT *FROM recursive_query;需要注意的是，"WITH" 关键字的用法可以根据具体的查询和数据模型而有所不同。

with关键字实现递归查询通常⽤来实现树形结构⾸先来看⼀下表数据以下代码是递归查询北京市的树结构WITH org AS (SELECT Code, name, parentCode, 1 AS levelFROM TestCityWHERE code = '01'UNION ALLSELECT t1.Code, , t1.parentCode, t2.level + 1 AS levelFROM TestCity t1 INNER JOIN org t2ON t1.parentCode = t2.Code)SELECT*FROM org注意：如果要在with表达式中计算，需要保证两边的type⼀致，如WITH org AS (SELECT Code, name, parentCode, 1 AS level, tname = CAST('' as nvarchar(20))FROM TestCityWHERE code = '01'UNION ALLSELECT t1.Code, , t1.parentCode, t2.level + 1 AS level, tanme = CAST(N'|--' + t2.tname as nvarchar(20)) FROM TestCity t1 INNER JOIN org t2ON t1.parentCode = t2.Code)SELECT code ,parentCode, tname + name as nameFROM org再⽐较以下两段从StackOverFolw中摘来的代码--报错 Types don't match between the anchor and the recursive part in column "nm" of recursive query "cte". WITH cte AS (SELECT1 as rn,'name1' as nmUNION ALLSELECTrn + 1,nm = 'name' + CAST((rn + 1) as varchar(255))FROM cte a WHERE rn < 10)SELECT *FROM cte--正解with cte as(select 1 as rn,CAST('name1' AS VARCHAR(255)) as nmunion allselect rn+1,nm = CAST('name' + CAST((rn+1) as varchar(255)) AS VARCHAR(255))from cte a where rn<10)select * from cte。

Oracle递归的写法（startwith）以及where条件作⽤域先转⼀个讲Oracle递归讲得⾮常透彻的⽂章：前⾔：嗯，这也是⼀个前⼈挖坑，后⼈来填的故事。

数据库⾥有⼀个关于地域信息的表，可以叫它tableA，此表⾥有三个字段分别是 parent_area_code、area_code、isvalid，有⼀段sql的功能是查找指定地域code的所有⽗类地域，sql如下，这是⼀个典型的递归的写法：select area_codefrom tableAwhere isvalid=1start with area_code =5002002753connect by prior parent_area_code = area_code注意这个isvalid，起初这个表⾥没有⽆效的数据，因此这个写法还没有造成什么杀伤⼒。

某⼀天这个语句执⾏时报错：ORA-01436⽤户数据中的CONNECT BY循环（个⼈理解是tableA本⾝是个树状图，如果这个树状图的数据⾥出现了死循环，例如 a的⽗类为b，b的⽗类为a，就会报这个异常）⼀开始从数据⼊⼿，发现有确实有会造成死循环的数据出现，可是它们的isvalid字段的值都为0，可是上⾯的sql⾥⾯明明过滤掉了isvalid=0的数据，怎么可能呢？于是⼜跑去看了⼀遍oracle递归语句的⽤法，看到了这⼀段：5.还可以加where条件我上⾯说了可以把start with ,connect 假装看成where 条件⼀样.所以在这个sql语句其他地⽅还可以加其他where 语句,可以看成与递归查询⽆关.只是对整个结果起过滤作⽤真相⼤⽩，我⾃⼰把where条件的作⽤域搞错了，它并不是作⽤于递归查询中，⽽是在递归结束之后才起作⽤，⽽那些isvalid=0的有问题的数据，已经在递归中造成了死循环，所以这个where条件显然写的位置不对。

这是我最后修改后的sql语句，⾄此，问题解决。

oracle中递归函数的用法
递归函数是指在函数体中调用自身的函数。

Oracle中支持递归函数的使用，它可以用来解决一些复杂的问题，比如树形结构数据的查询等。

在Oracle中，递归函数使用WITH RECURSIVE语句实现。

该语句使用递归子查询来实现递归函数功能。

下面是一个示例代码：
WITH RECURSIVE cte (id, name, parent_id, level) AS (
SELECT id, name, parent_id, 1
FROM my_table
WHERE parent_id IS NULL
UNION ALL
SELECT child.id, , child.parent_id,
parent.level + 1
FROM my_table child
INNER JOIN cte parent ON child.parent_id = parent.id
)
SELECT id, name, level
FROM cte;
在上面的代码中，cte是递归子查询的别名，id、name、parent_id、level是查询结果中的列名。

第一条SELECT语句查询表中parent_id 为NULL的记录，并设置level为1。

第二条SELECT语句查询所有parent_id不为NULL的记录，并将其与cte匹配，并将level设置
为parent的level加1。

递归函数的优点是可以在一次查询中获取复杂的数据。

但是，递归函数也有一些缺点，比如性能较差、容易产生死循环等问题。

因此，在使用递归函数时，需要谨慎考虑其适用性。

利⽤递归WITH⼦查询进⾏优化的实例利⽤递归WITH⼦查询进⾏优化的实例递归WITH⼦查询我已经⽤过不少了，不过都是当作玩具，没有在实践中⽤过。

昨天碰到了⼀个实⽤例⼦。

在⼀个OLTP中有⼀张表，主键是随着创建时间递增的。

每天产⽣⼤约1万条记录，全表⼤约有⼏百万，没有分区，创建时间没有索引。

现在要求取出最近两天的数据并且从中过滤出部分记录。

过滤条件上也没有索引。

原来的查询为全表扫描，效率太低，有没有办法改善？前提：因为原表索引够多了，不能新增索引；原查询来⾃JAVA程序，修改之后必须还是⼀个SQL, 交由JAVA程序执⾏。

测试数据：CREATE TABLE items ASSELECT 3000000 - LEVEL AS item_id,SYSDATE-LEVEL/10000 AS created_date,TRUNC(DBMS_RANDOM.VALUE(1,101)) AS item_type,SYS_GUID() AS DESCRIPTIONFROM DUALCONNECT BY LEVEL<=1000000;ALTER TABLE items ADD CONSTRAINT items_pk PRIMARY KEY (item_id) USING INDEX;EXEC DBMS_STATS.GATHER_TABLE_STATS(USER,'ITEMS');原表要复杂得多，现在简化为100万的⼀张表。

查询⼤约相当于：SELECT * FROM items WHERE created_date >= TRUNC(SYSDATE)-2 AND item_type=14;294 rows selected.Elapsed: 00:00:00.90Execution Plan----------------------------------------------------------Plan hash value: 446380563---------------------------------------------------------------------------| Id | Operation | Name | Rows | Bytes | Cost (%CPU)| Time |---------------------------------------------------------------------------| 0 | SELECT STATEMENT | | 258 | 8772 | 1501 (1)| 00:00:19 ||* 1 | TABLE ACCESS FULL| ITEMS | 258 | 8772 | 1501 (1)| 00:00:19 |---------------------------------------------------------------------------Predicate Information (identified by operation id):---------------------------------------------------1 - filter("ITEM_TYPE"=14 AND "CREATED_DATE">=TRUNC(SYSDATE@!)-2)Statistics----------------------------------------------------------0 recursive calls0 db block gets5429 consistent gets5406 physical reads0 redo size13636 bytes sent via SQL*Net to client625 bytes received via SQL*Net from client21 SQL*Net roundtrips to/from client0 sorts (memory)0 sorts (disk)294 rows processed例⼦表简化了很多, 所以只花了0.9秒，5429个⼀致读。