CTESQLStandard

函数

指定一个表格

格式

<query expression>

       [ <with clause> ] <query expression body>
       [ <order by clause> ] [ <result offset clause> ] [ <fetch first clause> ] 

<query expression>

       [ <with clause> ] <query expression body>
       [ <order by clause> ] [ <result offset clause> ] [ <fetch first clause> ]

<with list>

   <with list element> [ { <comma> <with list element> }... ]

<with list element>

   <query name> [ <left paren> <with column list> <right paren> ]
   AS <table subquery> [ <search or cycle clause> ]

<with column list>

   <column name list>

<query expression body>

   <query term>
   | <query expression body> UNION [ ALL | DISTINCT ]
   [ <corresponding spec> ] <query term>
   | <query expression body> EXCEPT [ ALL | DISTINCT ]
   [ <corresponding spec> ] <query term>

<query term>

   <query primary>
   | <query term> INTERSECT [ ALL | DISTINCT ]
   [ <corresponding spec> ] <query primary>

<query primary>

   <simple table>
   | <left paren> <query expression body>
   [ <order by clause> ] [ <result offset clause> ] [ <fetch first clause> ] <right paren>

<simple table>

   <query specification>
   | <table value constructor>
   | <explicit table>

<explicit table>

   TABLE <table or query name>

<corresponding spec>

   CORRESPONDING [ BY <left paren> <corresponding column list> <right paren> ]

<corresponding column list>

   <column name list>

<order by clause>

   ORDER BY <sort specification list>

<result offset clause>

   OFFSET <offset row count> { ROW | ROWS }

<fetch first clause>

   FETCH { FIRST | NEXT } [ <fetch first row count> ] { ROW | ROWS } ONLY

<offset row count>

   <simple value specification>

<fetch 第一行计数>

   <simple value specification>

语法规则

1. 假设 QE 是 <查询表达式>。
2. 如果指定了 <with 子句>，则
1. 如果一个 <with 子句> WC 紧接着包含 RECURSIVE，则 WC 以及它的 <with 列表> 和 <with 列表元素> 据说具有潜在递归性。否则，它们据说是非递归的。
2. 假设 n 是 <with 列表元素> 的数量。对于每个 i，1（一）≤ i < n，对于每个 j，i < j ≤ n，第 j 个 <with 列表元素> 不应紧接着包含一个<查询名称> 该名称等效于紧接着包含在第 i 个 <with 列表元素> 中的 <查询名称>。
3. 如果 <with 子句> 是非递归的，则对于 1（一）和 n 之间的每个 i，第 i 个 <with 列表元素> WLEi 中紧接着包含的 <查询名称> WQN 的作用域是仅仅包含在每个 <with 列表元素> WLEk 中的 <查询表达式>，其中 k 的范围是从 i+1 到 n，以及 <查询表达式> 中紧接着包含的 <查询表达式主体>。此作用域中包含的并紧接着包含 WQN 的 <表或查询名称> 是作用域内的查询名称。
4. 如果 <with 子句> 具有潜在递归性，则对于 1（一）和 n 之间的每个 i，第 i 个 <with 列表元素> WLEi 中紧接着包含的 <查询名称> WQN 的作用域是仅仅包含在每个 <with 列表元素> WLEk 中的 <查询表达式>，其中 k 的范围是从 1（一）到 n，以及 <查询表达式> 中紧接着包含的 <查询表达式主体>。此作用域中包含的并紧接着包含 WQN 的 <表或查询名称> 是作用域内的查询名称。
5. 对于每个 <with 列表元素> WLE，让 WQE 成为由 WLE 指定的 <查询表达式>，且让 WQT 成为由 WQE 定义的表格。
1. 如果 WQT 的任何两列具有等效的名称，或者如果 WLE 是潜在递归的，则 WLE 应指定一个 <with 列列表>。如果 WLE 指定一个 <with 列列表> WCL，则
1. 等效的 <列名称> 不应在 WCL 中被指定多次。
2. WCL 中 <列名称> 的数量应与 WQT 的度数相同。
2. WQT 中的每个字符类型字符串列都应具有声明的类型排序规则。
6. 潜在递归 <with 列表> WL 的查询名称依赖图 QNDG 是一个有向图
对于从 1（一）到 WL 中仅仅包含的 <查询名称> 数量的 i
1. 每个节点表示一个 <查询名称> WQNi，它紧接着包含在 WL 的一个 <with 列表元素> WLEi 中。
2. 从节点 WQNi 到节点 WQNj 的每条弧线表示这样一个事实：WQNj 被包含在 WLEi 中仅仅包含的 <查询表达式> 中的 <查询名称> 所引用。WQNi 据说立即依赖于 WQNj。
7. 对于具有 n 个元素的潜在递归 <with list> WL，并且对于 i 从 1（一）到 n，设 WLEi 为 WL 的第 i 个 <with list element>，设 WQNi 为 WLEi 中立即包含的 <query name>，设 WQEi 为 WLEi 中简单包含的 <query expression>，设 WQTi 为由 WQEi 定义的表格，设 QNDG 为 WL 的查询名称依赖图。
1. 如果 QNDG 包含至少
一个循环，则 WL 被视为递归。案例
1. 如果 QNDG 包含从 WQNi 到它自己的弧，则 WLEi、WQNi 和 WQTi 被视为递归。WQNi 被视为属于 WQEi 的阶层。
2. 如果 QNDG 包含从 WQNi 到它自己的弧，则 WLEi、WQNi 和 WQTi 被视为递归。WQNi 被视为属于 WQEi 的阶层。
3. 在给定阶层的 WQEi, ..., WQEk 中，至少应有一个 <query expression>，例如 WQEj，使得
1. WQEj 是一个立即包含 UNION 的 <query expression body>。
2. WQEj 具有一个操作数，该操作数不包含引用任何 WQNi, ..., WQNk 的 <query name>。此操作数被称为 WQEj 的非递归操作数。
3. WQEj 被视为锚表达式，WQNj 被视为锚名称。
4. 设 CCCG 为 QNDG 的子图，其中不包含 WQNi, ..., WQNk 之外的任何节点。对于任何锚名称 WQNj，删除那些由 WQEj 中包含的 <query name> 引用的查询名称 WQNl 的弧。剩余的图 SCCGP 不应包含循环。
2. 如果 WLEi 是递归的，则案例
1. 如果 WQEi 最多包含一个属于 WQEi 阶层的 WQNk，则 WLEi 是线性递归的。
2. 否则，设 WQEi 包含任何引用 WQNk 和 WQNl 的两个 <query name>，这两个名称都属于 WQEi 的阶层。案例
1. 如果满足以下每个条件，则 WLEi 是线性递归的
1. WQEi 不包含引用 WQNk 和 WQNl 的 <query name> 的 <table reference list>。
2. WQEi 不包含 TR1 和 TR2 分别是第一个和第二个 <table reference> 或 <table reference> 和 <table factor> 的 <joined table>，并且 TR1 和 TR2 分别包含引用 WQNk 和 WQNl 的 <query name>。
3. WQEi 不包含立即包含包含 WQNk 的 <from clause> 的 <table expression>，并且立即包含一个包含引用 WQNl 的 <query name> 的 <query expression> 的 <where clause>。
2. 否则，WLEi 被视为是非线性递归的。
3. 对于每个 WLEi，对于从 1（一）到 n 的 i，以及对于每个属于 WQEi 阶层的 WQNj
1. WQEi 不应包含包含引用 WQNj 的 <query name> 的 <query expression body>，并且立即包含 EXCEPT，其中 EXCEPT 的右操作数包含 WQNj。
2. WQEi 不应包含具有 <SQL argument list> 的 <routine invocation>，其中包含一个或多个立即包含包含引用 WQNj 的 <query name> 的 <value expression> 的 <SQL argument>。
3. WQEi 不应包含包含引用于 WQNj 的 <query name> 的 <query expression> TSQ，除非 TSQ 仅包含在紧密包含在紧密包含在紧密包含在紧密包含在紧密包含包含 <simple table> 的 <query specification> 中的 <table primary> 中的 <table reference> 中的 <from clause> 中的 <table expression> 中的 <derived table> 中。
4. WQEi 不应包含 <query specification> QS，使得
1. QS 紧密包含包含引用于 WQNj 的 <query name> 的 <table expression> TE，并且
2. QS 紧密包含 <select list> SL 或 TE 紧密包含 <having clause> HC，且 SL 或 TE 包含 <set function specification>。
5. WQEi 不应包含包含引用于 WQNj 的 <query name> 并且仅包含 INTERSECT ALL 或 EXCEPT ALL 的 <query expression body>。
6. WQEi 不应包含 <qualified join> QJ，其中
1. QJ 紧密包含指定 FULL 的 <join type> 和包含引用于 WQNj 的 <query name> 的 <table reference> 或 <table factor>。
2. QJ 紧密包含指定 LEFT 的 <join type> 和紧跟 <join type> 后包含引用于 WQNj 的 <query name> 的 <table factor>。
3. QJ 紧密包含指定 RIGHT 的 <join type> 和紧接在 <join type> 之前包含引用于 WQNj 的 <query name> 的 <table reference>。
7. WQEi 不应包含 <natural join> QJ，其中
1. QJ 紧密包含指定 FULL 的 <join type> 和包含引用于 WQNj 的 <query name> 的 <table reference> 或 <table primary>。
2. QJ 紧密包含指定 LEFT 的 <join type> 和紧跟 <join type> 后包含引用于 WQNj 的 <query name> 的 <table primary>。
3. QJ 紧密包含指定 RIGHT 的 <join type> 和紧接在 <join type> 之前包含引用于 WQNj 的 <query name> 的 <table reference>。iv) 如果 WLEi 是递归的，那么 WLEi 应是线性递归。
4. 如果满足以下所有条件，则称 WLEi 可扩展
1. WLEi 是递归的。
2. WLEi 是线性递归。
3. WQEi 是紧密包含 UNION 或 UNION ALL 的 <query expression body>。让 WQEBi 是紧密包含在 WQEi 中的 <query expression body>。让 QELi 和 QTRi 是紧密包含在 WQEBi 中的 <query expression body> 和 <query term>。WQNi 不应包含在 QELi 中，且 QTRi 应为 <query specification>。
4. WQNi 不是相互递归的。
8. 如果 <with list element> WLE 是不可扩展的，那么它不应紧密包含 <search or cycle clause>。