To specify common table expressions, use a WITH clause that has one or more comma-separated subclauses. 要指定公共表表达式，请使用具有一个或多个逗号分隔子类的WITH子句。Each subclause provides a subquery that produces a result set, and associates a name with the subquery. 每个子类都提供一个子查询来生成结果集，并将名称与子查询相关联。The following example defines CTEs named cte1 and cte2 in the WITH clause, and refers to them in the top-level SELECT that follows the WITH clause:以下示例在WITH子句中定义名为cte1和cte2的CTE，并在WITH子句后面的顶级SELECT中引用它们：

WITH
  cte1 AS (SELECT a, b FROM table1),
  cte2 AS (SELECT c, d FROM table2)
SELECT b, d FROM cte1 JOIN cte2
WHERE cte1.a = cte2.c;

In the statement containing the WITH clause, each CTE name can be referenced to access the corresponding CTE result set.在包含WITH子句的语句中，可以引用每个CTE名称来访问相应的CTE结果集。

A CTE name can be referenced in other CTEs, enabling CTEs to be defined based on other CTEs.CTE名称可以在其他CTE中引用，从而可以基于其他CTE定义CTE。

A CTE can refer to itself to define a recursive CTE. CTE可以引用自身来定义递归CTE。Common applications of recursive CTEs include series generation and traversal of hierarchical or tree-structured data.递归CTE的常见应用包括层次或树结构数据的序列生成和遍历。

Common table expressions are an optional part of the syntax for DML statements. 公共表表达式是DML语句语法的可选部分。They are defined using a WITH clause:它们使用WITH子句定义：

with_clause:
    WITH [RECURSIVE]
cte_name [(col_name [, col_name] ...)] AS (subquery)
        [, cte_name [(col_name [, col_name] ...)] AS (subquery)] ...

cte_name names a single common table expression and can be used as a table reference in the statement containing the WITH clause.cte_name命名一个公共表表达式，可以在包含WITH子句的语句中用作表引用。

The subquery part of AS (subquery) is called the “subquery of the CTE” and is what produces the CTE result set. AS (subquery)的子查询部分称为“CTE的子查询”，是生成CTE结果集的部分。The parentheses following AS are required.AS后面的括号是必需的。

A common table expression is recursive if its subquery refers to its own name. 如果公共表表达式的子查询引用自己的名称，则该表达式是递归的。The RECURSIVE keyword must be included if any CTE in the WITH clause is recursive. 如果WITH子句中的任何CTE是递归的，则必须包含RECURSIVE关键字。For more information, see Recursive Common Table Expressions.有关详细信息，请参见递归公共表表达式。

Determination of column names for a given CTE occurs as follows:确定给定CTE的列名如下：

A WITH clause is permitted in these contexts:在下列情况下允许使用WITH子句：

Only one WITH clause is permitted at the same level. 同一级别只允许一个WITH子句。WITH followed by WITH at the same level is not permitted, so this is illegal:不允许在同一级别WITH后跟WITH，因此这是非法的：

WITH cte1 AS (...) WITH cte2 AS (...) SELECT ...

To make the statement legal, use a single WITH clause that separates the subclauses by a comma:要使语句合法，请使用一个WITH子句，该子句用逗号分隔子类：

WITH cte1 AS (...), cte2 AS (...) SELECT ...

However, a statement can contain multiple WITH clauses if they occur at different levels:但是，如果语句出现在不同的级别，则语句可以包含多个WITH子句：

WITH cte1 AS (SELECT 1)
SELECT * FROM (WITH cte2 AS (SELECT 2) SELECT * FROM cte2 JOIN cte1) AS dt;

A WITH clause can define one or more common table expressions, but each CTE name must be unique to the clause. WITH子句可以定义一个或多个公共表表达式，但每个CTE名称对于该子句都必须是唯一的。This is illegal:这是非法的：

WITH cte1 AS (...), cte1 AS (...) SELECT ...

To make the statement legal, define the CTEs with unique names:要使语句合法，请使用唯一名称定义CTE：

WITH cte1 AS (...), cte2 AS (...) SELECT ...

A CTE can refer to itself or to other CTEs:CTE可指自身或其他CTE：

For resolving references to objects with the same names, derived tables hide CTEs; and CTEs hide base tables, TEMPORARY tables, and views. 为了解析对同名对象的引用，派生表隐藏CTE；CTE隐藏基表、临时表和视图。Name resolution occurs by searching for objects in the same query block, then proceeding to outer blocks in turn while no object with the name is found.名称解析是通过搜索同一查询块中的对象，然后依次转到外部块，而找不到具有名称的对象。

Like derived tables, a CTE cannot contain outer references prior to MySQL 8.0.14. 与派生表一样，CTE不能包含MySQL8.0.14之前的外部引用。This is a MySQL restriction that is lifted in MySQL 8.0.14, not a restriction of the SQL standard. 这是MySQL8.0.14中取消的MySQL限制，不是SQL标准的限制。For additional syntax considerations specific to recursive CTEs, see Recursive Common Table Expressions.有关特定于递归CTE的其他语法注意事项，请参阅递归公共表表达式。

A recursive common table expression is one having a subquery that refers to its own name. 递归公共表表达式具有引用其自身名称的子查询。For example:例如：

WITH RECURSIVE cte (n) AS
(
  SELECT 1
  UNION ALL
  SELECT n + 1 FROM cte WHERE n < 5
)
SELECT * FROM cte;

When executed, the statement produces this result, a single column containing a simple linear sequence:执行时，该语句将生成以下结果，即包含简单线性序列的单个列：

+------+
| n    |
+------+
|    1 |
|    2 |
|    3 |
|    4 |
|    5 |
+------+

A recursive CTE has this structure:递归CTE具有以下结构：

The recursive CTE subquery shown earlier has this nonrecursive part that retrieves a single row to produce the initial row set:前面显示的递归CTE子查询有一个非递归部分，它检索一行以生成初始行集：

SELECT 1

The CTE subquery also has this recursive part:CTE子查询还有这个递归部分：

SELECT n + 1 FROM cte WHERE n < 5

At each iteration, that SELECT produces a row with a new value one greater than the value of n from the previous row set. 在每次迭代中，该SELECT将生成一个新值大于上一行集中n值的行。The first iteration operates on the initial row set (1) and produces 1+1=2; the second iteration operates on the first iteration's row set (2) and produces 2+1=3; and so forth. 第一次迭代对初始行集（1）进行运算，产生1+1=2；第二次迭代对第一次迭代的行集（2）进行运算，产生2+1=3；依此类推。This continues until recursion ends, which occurs when n is no longer less than 5.这种情况一直持续到递归结束，当n不再小于5时发生。

If the recursive part of a CTE produces wider values for a column than the nonrecursive part, it may be necessary to widen the column in the nonrecursive part to avoid data truncation. 如果CTE的递归部分为列生成比非递归部分更宽的值，则可能需要在非递归部分加宽列以避免数据截断。Consider this statement:考虑一下这个说法：

WITH RECURSIVE cte AS
(
  SELECT 1 AS n, 'abc' AS str
  UNION ALL
  SELECT n + 1, CONCAT(str, str) FROM cte WHERE n < 3
)
SELECT * FROM cte;

In nonstrict SQL mode, the statement produces this output:在非严格SQL模式下，该语句生成以下输出：

+------+------+
| n    | str  |
+------+------+
|    1 | abc  |
|    2 | abc  |
|    3 | abc  |
+------+------+

The str column values are all 'abc' because the nonrecursive SELECT determines the column widths. str列值都是'abc'，因为非递归SELECT决定列宽。Consequently, the wider str values produced by the recursive SELECT are truncated.因此，递归SELECT生成的更宽的str值被截断。

In strict SQL mode, the statement produces an error:在严格SQL模式下，该语句会产生错误：

ERROR 1406 (22001): Data too long for column 'str' at row 1

To address this issue, so that the statement does not produce truncation or errors, use CAST() in the nonrecursive SELECT to make the str column wider:要解决此问题，以便语句不会产生截断或错误，请在非递归SELECT中使用CAST()使str列更宽：

WITH RECURSIVE cte AS
(
  SELECT 1 AS n, CAST('abc' AS CHAR(20)) AS str
  UNION ALL
  SELECT n + 1, CONCAT(str, str) FROM cte WHERE n < 3
)
SELECT * FROM cte;

Now the statement produces this result, without truncation:现在，语句将生成以下结果，而不进行截断：

+------+--------------+
| n    | str          |
+------+--------------+
|    1 | abc          |
|    2 | abcabc       |
|    3 | abcabcabcabc |
+------+--------------+

Columns are accessed by name, not position, which means that columns in the recursive part can access columns in the nonrecursive part that have a different position, as this CTE illustrates:列是按名称而不是位置访问的，这意味着递归部分中的列可以访问非递归部分中具有不同位置的列，如此CTE所示：

WITH RECURSIVE cte AS
(
  SELECT 1 AS n, 1 AS p, -1 AS q
  UNION ALL
  SELECT n + 1, q * 2, p * 2 FROM cte WHERE n < 5
)
SELECT * FROM cte;

Because p in one row is derived from q in the previous row, and vice versa, the positive and negative values swap positions in each successive row of the output:因为一行中的p来自前一行中的q，反之亦然，所以正负值在输出的每个连续行中交换位置：

+------+------+------+
| n    | p    | q    |
+------+------+------+
|    1 |    1 |   -1 |
|    2 |   -2 |    2 |
|    3 |    4 |   -4 |
|    4 |   -8 |    8 |
|    5 |   16 |  -16 |
+------+------+------+

Some syntax constraints apply within recursive CTE subqueries:一些语法约束适用于递归CTE子查询：

These constraints come from the SQL standard, other than the MySQL-specific exclusions of ORDER BY, LIMIT (MySQL 8.0.18 and earlier), and DISTINCT.这些约束来自SQL标准，而不是特定于MySQL的ORDER BY、LIMIT(MySQL 8.0.18及更早版本）和DISTINCT排除。

For recursive CTEs, EXPLAIN output rows for recursive SELECT parts display Recursive in the Extra column.对于递归CTE，EXPLAIN递归SELECT部分的输出行在Extra列中显示Recursive。

Cost estimates displayed by EXPLAIN represent cost per iteration, which might differ considerably from total cost. EXPLAIN显示的成本估算表示每次迭代的成本，这可能与总成本有很大的不同。The optimizer cannot predict the number of iterations because it cannot predict at what point the WHERE clause becomes false.优化器无法预测迭代次数，因为它无法预测WHERE子句在什么时候变为false。

CTE actual cost may also be affected by result set size. CTE实际成本也可能受到结果集大小的影响。A CTE that produces many rows may require an internal temporary table large enough to be converted from in-memory to on-disk format and may suffer a performance penalty. 产生许多行的CTE可能需要一个足够大的内部临时表，以便从内存格式转换为磁盘格式，并且可能会受到性能损失。If so, increasing the permitted in-memory temporary table size may improve performance; see Section 8.4.4, “Internal Temporary Table Use in MySQL”.如果是这样，增加内存中允许的临时表大小可以提高性能；请参阅第8.4.4节，“MySQL中的内部临时表使用”。

It is important for recursive CTEs that the recursive SELECT part include a condition to terminate recursion. 对于递归CTE来说，递归SELECT部分包含终止递归的条件是很重要的。As a development technique to guard against a runaway recursive CTE, you can force termination by placing a limit on execution time:作为一种防止失控的递归CTE的开发技术，您可以通过限制执行时间来强制终止：

Suppose that a recursive CTE is mistakenly written with no recursion execution termination condition:假设在没有递归执行终止条件的情况下错误地编写了递归CTE：

WITH RECURSIVE cte (n) AS
(
  SELECT 1
  UNION ALL
  SELECT n + 1 FROM cte
)
SELECT * FROM cte;

By default, cte_max_recursion_depth has a value of 1000, causing the CTE to terminate when it recurses past 1000 levels. 默认情况下，cte_max_recursion_depth的值为1000，当它递归超过1000级时，导致cte终止。Applications can change the session value to adjust for their requirements:应用程序可以更改会话值以适应其需求：

SET SESSION cte_max_recursion_depth = 10;      -- permit only shallow recursion
SET SESSION cte_max_recursion_depth = 1000000; -- permit deeper recursion

You can also set the global cte_max_recursion_depth value to affect all sessions that begin subsequently.您还可以设置全局cte_max_recursion_depth值以影响随后开始的所有会话。

For queries that execute and thus recurse slowly or in contexts for which there is reason to set the cte_max_recursion_depth value very high, another way to guard against deep recursion is to set a per-session timeout. 对于执行缓慢从而递归的查询，或者在有理由将cte_max_recursion_depth值设置得非常高的上下文中，另一种防止深度递归的方法是设置每个会话超时。To do so, execute a statement like this prior to executing the CTE statement:为此，请在执行CTE语句之前执行如下语句：

SET max_execution_time = 1000; -- impose one second timeout

Alternatively, include an optimizer hint within the CTE statement itself:或者，在CTE语句本身中包含优化器提示：

WITH RECURSIVE cte (n) AS
(
  SELECT 1
  UNION ALL
  SELECT n + 1 FROM cte
)
SELECT /*+ SET_VAR(cte_max_recursion_depth = 1M) */ * FROM cte;

WITH RECURSIVE cte (n) AS
(
  SELECT 1
  UNION ALL
  SELECT n + 1 FROM cte
)
SELECT /*+ MAX_EXECUTION_TIME(1000) */ * FROM cte;

Beginning with MySQL 8.0.19, you can also use LIMIT within the recursive query to impose a maximum nuber of rows to be returned to the outermost SELECT, for example:从MySQL8.0.19开始，您还可以在递归查询中使用LIMIT来设置要返回到最外层SELECT的最大行数，例如：

WITH RECURSIVE cte (n) AS
(
  SELECT 1
  UNION ALL
  SELECT n + 1 FROM cte LIMIT 10000
)
SELECT * FROM cte;

You can do this in addition to or instead of setting a time limit. 除了设置时间限制之外，您还可以这样做，也可以不设置时间限制。Thus, the following CTE terminates after returning ten thousand rows or running for one thousand seconds, whichever occurs first:因此，以下CTE在返回一万行或运行一千秒后终止，以先发生的为准：

WITH RECURSIVE cte (n) AS
(
  SELECT 1
  UNION ALL
  SELECT n + 1 FROM cte LIMIT 10000
)
SELECT /*+ MAX_EXECUTION_TIME(1000) */ * FROM cte;

If a recursive query without an execution time limit enters an infinite loop, you can terminate it from another session using KILL QUERY. 如果没有执行时间限制的递归查询进入无限循环，可以使用KILL QUERY从另一个会话终止它。Within the session itself, the client program used to run the query might provide a way to kill the query. 在会话本身中，用于运行查询的客户机程序可能会提供终止查询的方法。For example, in mysql, typing Control+C interrupts the current statement.例如，在mysql中，键入Control+C会中断当前语句。

As mentioned previously, recursive common table expressions (CTEs) are frequently used for series generation and traversing hierarchical or tree-structured data. 如前所述，递归公共表表达式（cte）经常用于序列生成和遍历层次结构或树结构的数据。This section shows some simple examples of these techniques.本节展示了这些技术的一些简单示例。

Fibonacci Series Generation斐波那契级数生成

A Fibonacci series begins with the two numbers 0 and 1 (or 1 and 1) and each number after that is the sum of the previous two numbers. 斐波那契级数从两个数字0和1（或1和1）开始，之后的每个数字是前两个数字的和。A recursive common table expression can generate a Fibonacci series if each row produced by the recursive SELECT has access to the two previous numbers from the series. 如果递归SELECT生成的每一行都可以访问序列中的前两个数字，则递归公共表表达式可以生成斐波那契序列。The following CTE generates a 10-number series using 0 and 1 as the first two numbers:以下CTE使用0和1作为前两个数字生成10数字系列：

WITH RECURSIVE fibonacci (n, fib_n, next_fib_n) AS
(
  SELECT 1, 0, 1
  UNION ALL
  SELECT n + 1, next_fib_n, fib_n + next_fib_n
    FROM fibonacci WHERE n < 10
)
SELECT * FROM fibonacci;

The CTE produces this result:CTE产生以下结果：

+------+-------+------------+
| n    | fib_n | next_fib_n |
+------+-------+------------+
|    1 |     0 |          1 |
|    2 |     1 |          1 |
|    3 |     1 |          2 |
|    4 |     2 |          3 |
|    5 |     3 |          5 |
|    6 |     5 |          8 |
|    7 |     8 |         13 |
|    8 |    13 |         21 |
|    9 |    21 |         34 |
|   10 |    34 |         55 |
+------+-------+------------+

How the CTE works:CTE的工作原理：

The preceding output shows the entire CTE result. 前面的输出显示了整个CTE结果。To select just part of it, add an appropriate WHERE clause to the top-level SELECT. 要只选择其中的一部分，请在顶层SELECT中添加适当的WHERE子句。For example, to select the 8th Fibonacci number, do this:例如，要选择第8个斐波那契数，请执行以下操作：

mysql> WITH RECURSIVE fibonacci ...
       ...
SELECT fib_n FROM fibonacci WHERE n = 8;
+-------+
| fib_n |
+-------+
|    13 |
+-------+

Date Series Generation日期序列生成

A common table expression can generate a series of successive dates, which is useful for generating summaries that include a row for all dates in the series, including dates not represented in the summarized data.公共表表达式可以生成一系列连续的日期，这对于生成包含序列中所有日期行的摘要（包括摘要数据中未表示的日期）非常有用。

Suppose that a table of sales numbers contains these rows:假设销售编号表包含以下行：

mysql> SELECT * FROM sales ORDER BY date, price;
+------------+--------+
| date       | price  |
+------------+--------+
| 2017-01-03 | 100.00 |
| 2017-01-03 | 200.00 |
| 2017-01-06 |  50.00 |
| 2017-01-08 |  10.00 |
| 2017-01-08 |  20.00 |
| 2017-01-08 | 150.00 |
| 2017-01-10 |   5.00 |
+------------+--------+

This query summarizes the sales per day:此查询汇总了每天的销售额：

mysql> SELECT date, SUM(price) AS sum_price
FROM sales
GROUP BY date
ORDER BY date;
+------------+-----------+
| date       | sum_price |
+------------+-----------+
| 2017-01-03 |    300.00 |
| 2017-01-06 |     50.00 |
| 2017-01-08 |    180.00 |
| 2017-01-10 |      5.00 |
+------------+-----------+

However, that result contains “holes” for dates not represented in the range of dates spanned by the table. 但是，该结果包含表所跨越的日期范围内未表示的日期的“洞”。A result that represents all dates in the range can be produced using a recursive CTE to generate that set of dates, joined with a LEFT JOIN to the sales data.可以使用递归CTE生成表示该范围内所有日期的结果，以生成该日期集，并与销售数据进行LEFT JOIN。

Here is the CTE to generate the date range series:以下是生成日期范围系列的CTE：

WITH RECURSIVE dates (date) AS
(
  SELECT MIN(date) FROM sales
  UNION ALL
  SELECT date + INTERVAL 1 DAY FROM dates
  WHERE date + INTERVAL 1 DAY <= (SELECT MAX(date) FROM sales)
)
SELECT * FROM dates;

The CTE produces this result:CTE产生以下结果：

+------------+
| date       |
+------------+
| 2017-01-03 |
| 2017-01-04 |
| 2017-01-05 |
| 2017-01-06 |
| 2017-01-07 |
| 2017-01-08 |
| 2017-01-09 |
| 2017-01-10 |
+------------+

How the CTE works:CTE的工作原理：

Joining the CTE with a LEFT JOIN against the sales table produces the sales summary with a row for each date in the range:将CTE与sales表的LEFT JOIN连接起来，生成销售汇总，其中包含范围内每个日期的行：

WITH RECURSIVE dates (date) AS
(
  SELECT MIN(date) FROM sales
  UNION ALL
  SELECT date + INTERVAL 1 DAY FROM dates
  WHERE date + INTERVAL 1 DAY <= (SELECT MAX(date) FROM sales)
)
SELECT dates.date, COALESCE(SUM(price), 0) AS sum_price
FROM dates LEFT JOIN sales ON dates.date = sales.date
GROUP BY dates.date
ORDER BY dates.date;

The output looks like this:输出如下所示：

+------------+-----------+
| date       | sum_price |
+------------+-----------+
| 2017-01-03 |    300.00 |
| 2017-01-04 |      0.00 |
| 2017-01-05 |      0.00 |
| 2017-01-06 |     50.00 |
| 2017-01-07 |      0.00 |
| 2017-01-08 |    180.00 |
| 2017-01-09 |      0.00 |
| 2017-01-10 |      5.00 |
+------------+-----------+

Some points to note:需要注意的几点：

Hierarchical Data Traversal分层数据遍历

Recursive common table expressions are useful for traversing data that forms a hierarchy. 递归公共表表达式对于遍历形成层次结构的数据非常有用。Consider these statements that create a small data set that shows, for each employee in a company, the employee name and ID number, and the ID of the employee's manager. 考虑这些语句，创建一个小数据集，显示一个公司的每个雇员的雇员姓名和ID号，以及雇员经理的ID。The top-level employee (the CEO), has a manager ID of NULL (no manager).顶级员工（CEO）的经理ID为NULL（无经理）。

CREATE TABLE employees (
  id         INT PRIMARY KEY NOT NULL,
  name       VARCHAR(100) NOT NULL,
  manager_id INT NULL,
  INDEX (manager_id),
FOREIGN KEY (manager_id) REFERENCES employees (id)
);
INSERT INTO employees VALUES
(333, "Yasmina", NULL),  # Yasmina is the CEO (manager_id is NULL)
(198, "John", 333),      # John has ID 198 and reports to 333 (Yasmina)
(692, "Tarek", 333),
(29, "Pedro", 198),
(4610, "Sarah", 29),
(72, "Pierre", 29),
(123, "Adil", 692);

The resulting data set looks like this:结果数据集如下所示：

mysql> SELECT * FROM employees ORDER BY id;
+------+---------+------------+
| id   | name    | manager_id |
+------+---------+------------+
|   29 | Pedro   |        198 |
|   72 | Pierre  |         29 |
|  123 | Adil    |        692 |
|  198 | John    |        333 |
|  333 | Yasmina |       NULL |
|  692 | Tarek   |        333 |
| 4610 | Sarah   |         29 |
+------+---------+------------+

To produce the organizational chart with the management chain for each employee (that is, the path from CEO to employee), use a recursive CTE:要使用每个员工的管理链（即从CEO到员工的路径）生成组织结构图，请使用递归CTE：

WITH RECURSIVE employee_paths (id, name, path) AS
(
  SELECT id, name, CAST(id AS CHAR(200))
    FROM employees
    WHERE manager_id IS NULL
  UNION ALL
  SELECT e.id, e.name, CONCAT(ep.path, ',', e.id)
    FROM employee_paths AS ep JOIN employees AS e
      ON ep.id = e.manager_id
)
SELECT * FROM employee_paths ORDER BY path;

The CTE produces this output:CTE产生以下输出：

+------+---------+-----------------+
| id   | name    | path            |
+------+---------+-----------------+
|  333 | Yasmina | 333             |
|  198 | John    | 333,198         |
|   29 | Pedro   | 333,198,29      |
| 4610 | Sarah   | 333,198,29,4610 |
|   72 | Pierre  | 333,198,29,72   |
|  692 | Tarek   | 333,692         |
|  123 | Adil    | 333,692,123     |
+------+---------+-----------------+

How the CTE works:CTE的工作原理：

To find the path for a specific employee or employees, add a WHERE clause to the top-level SELECT. 要查找特定雇员的路径，请在顶层SELECT中添加WHERE子句。For example, to display the results for Tarek and Sarah, modify that SELECT like this:例如，要显示Tarek和Sarah的结果，请修改SELECT如下：

mysql> WITH RECURSIVE ...
       ...
SELECT * FROM employees_extended
WHERE id IN (692, 4610)
ORDER BY path;
+------+-------+-----------------+
| id   | name  | path            |
+------+-------+-----------------+
| 4610 | Sarah | 333,198,29,4610 |
|  692 | Tarek | 333,692         |
+------+-------+-----------------+

Common table expressions (CTEs) are similar to derived tables in some ways:公共表表达式（CTE）在某些方面与派生表类似：

Because of these similarities, CTEs and derived tables often can be used interchangeably. 由于这些相似性，CTE和派生表通常可以互换使用。As a trivial example, these statements are equivalent:举个简单的例子，这些语句是等价的：

WITH cte AS (SELECT 1) SELECT * FROM cte;
SELECT * FROM (SELECT 1) AS dt;

However, CTEs have some advantages over derived tables:但是，与派生表相比，CTE有一些优势：

CTEs are similar to tables created with CREATE [TEMPORARY] TABLE but need not be defined or dropped explicitly. CTE类似于用CREATE [TEMPORARY] TABLE创建的表，但不需要显式定义或删除。For a CTE, you need no privileges to create tables.对于CTE，创建表不需要任何权限。