22章分区

已分区表的分区范围是以这样一种方式，每个分区包含的行为分区表达式的值是一个给定的范围内。范围应连续但不重叠，和定义使用VALUES LESS THAN算子。在接下来的几个例子，假设你正在创建一个表，如以下为20家连锁音像店举行的人事档案，编号为1到20：

创建员工信息表（ID为不空，名为varchar（30），lname VARCHAR（30），聘用日期不为空的默认“1970-01-01，分离的日期无效的默认9999-12-31 '，job_code int不空，不空store_id int）；

这张桌子可以按范围分区的多种方式，根据你的需要。一种方法是使用store_id专栏例如，你可能决定分区表的方式加入按范围分区条款如下所示：

CREATE TABLE employees (
    id INT NOT NULL,
    fname VARCHAR(30),
    lname VARCHAR(30),
    hired DATE NOT NULL DEFAULT '1970-01-01',
    separated DATE NOT NULL DEFAULT '9999-12-31',
    job_code INT NOT NULL,
    store_id INT NOT NULL
)
PARTITION BY RANGE (store_id) (
    PARTITION p0 VALUES LESS THAN (6),
    PARTITION p1 VALUES LESS THAN (11),
    PARTITION p2 VALUES LESS THAN (16),
    PARTITION p3 VALUES LESS THAN (21)
);

在这个分区方案，所有行相应的员工工作在商店1-5都存储在分区p0，那些在商店通过10 6存储分区P1，等等。每个分区被定义为，从最低到最高。这是一个要求PARTITION BY RANGE语法；你可以认为它是类似于一个系列如果…“…在这方面，C和java报表。

这是很容易确定一个新的行包含数据(72, 'Mitchell', 'Wilson', '1998-06-25', NULL, 13)插入分区P2但当你的外链，增加了21^ST商店根据这项计划，没有规则，涵盖了一个排的store_id大于20，所以错误的结果因为服务器不知道哪里的地方。你可以把这个利用了从发生“包罗万象的“VALUES LESS THAN子句中CREATE TABLE声明，提供所有值大于最高值显式命名：

创建员工信息表（ID为不空，名为varchar（30），lname VARCHAR（30），聘用日期不为空的默认“1970-01-01，分离的日期无效的默认9999-12-31 '，job_code int不空，不空store_id int）按范围分区（分区store_id）（P0值小于（6），分区P1值小于（11），分区P2的值小于（16），p3分区值小于最大）；

（如在这一章中，其他的例子，我们假设默认存储引擎InnoDB。）

MAXVALUE代表一个整数的值总是大于整数值最大（数学语言，它作为一个最小上界）。现在，任何行的store_id列的值大于或等于16（最高值定义）都存储在分区P3。在未来的某一时刻，当门店数量增加到了25，30，或您可以使用ALTER TABLE语句添加新分区存储21-25，26-30，等等（见第22，“分区管理”，细节如何做到这一点）。

以同样的方式，你可以根据员工的工作守则，是表分区，基于范围job_code列的值。例如，假设两位数的工作代码用于正则（店内）的工人，三位码是用于办公和支持人员，和四位数字码用于管理职位，你可以使用下面的语句创建分区表：

创建员工信息表（ID为不空，名为varchar（30），lname VARCHAR（30），聘用日期不为空的默认“1970-01-01，分离的日期无效的默认9999-12-31 '，job_code int不空，不空store_id int）按范围分区（分区job_code）（P0值小于（100），分区P1值小于（1000），分区P2的值小于（10000））；

在这种情况下，所有行有关商店的工人将被存储在分区p0，与办公室和支持人员P1，和那些有关管理分区p2

它也可以使用的表达VALUES LESS THAN条款.然而，MySQL必须能够评估表达式的返回值的一部分小于（<比较）

而不是分裂的表数据根据商店的数量，你可以使用基于一个表达式DATE柱代替。例如，让我们假设你希望分区基于年每个员工离开公司；即价值YEAR(separated)。一例CREATE TABLE声明说，实施这样的分区方案如下所示：

创建员工信息表（ID为不空，名为varchar（30），lname VARCHAR（30），聘用日期不为空的默认“1970-01-01，分离的日期无效的默认9999-12-31 '，job_code int，int store_id）按范围分区（年（分离）（分区）P0值小于（1991），分区P1值小于（1996），分区P2的值小于（2001），分区P3值小于最大值）；

在这个方案中，所有的员工离开之前，1991年的行存储在分区p0；对于那些留在年1991至1995，在P1；对于那些留在年1996至2000，在p2；和谁离开了2000年后的任何人员，在P3

也有可能是分区表RANGE，基于一个价值TIMESTAMP柱，使用UNIX_TIMESTAMP()功能，如本例所示：

创建表quarterly_report_status（report_id int不空，report_status varchar（20）不空，不空report_updated时间戳默认current_timestamp更新current_timestamp）按范围分区（unix_timestamp（report_updated））（分区P0值小于（unix_timestamp（'2008-01-01 00:00:00”）），分区P1值小于（unix_timestamp（'2008-04-01 00:00:00”）），分区P2的值小于（unix_timestamp（'2008-07-01 00:00:00”）），分区P3值小于（unix_timestamp（'2008-10-01 00:00:00”）），分区P4值小于（unix_timestamp（'2009-01-01 00:00:00”）），分区P5值小于（unix_timestamp（'2009-04-01 00:00:00”）），分区P6值小于（unix_timestamp（'2009-07-01 00:00:00”）），分区P7值小于（unix_timestamp（'2009-10-01 00:00:00”）），分区P8值小于（unix_timestamp（'2010-01-01 00:00:00”）），分区P9值小于（次））；

其他表达式TIMESTAMP价值观是不允许的。（见虫# 42849。）

范围分区是特别有用的以下一个或多个条件为真时：

在这类划分的一个变种是RANGE COLUMNS分配。分配的村庄范围列可以使用多个列定义划分范围，既适用于排在分区布局和确定包含或排除特定的分区进行分区修剪时。看到第22.2.3.1，范围列分区”为更多的信息

基于时间间隔的分区方案。如果你想实现一个分区方案基于MySQL的8时间范围或时间，你有两个选择：

列表分区在MySQL是类似于在许多方面划分范围。在分区RANGE，每个分区必须被明确定义。这两种类型的分区之间的主要差别是，在列表分区，每个分区的定义和基于列值的会员在一组值的列表中选择，而不是一组值的连续范围。这是通过使用列表分区（expr）哪里expr是一个列值或基于列的值并返回一个整型值的表达式，然后确定每个分区的值（value_list），在那里value_list是一个用逗号分隔的整数。

与定义的范围分区列表分区的情况下，不需要任何特定的顺序声明。更详细的语法信息，看第13.1.18，“创建表的语法

在下面的例子中，我们假设的表进行分区的基本定义是由CREATE TABLE表所示：

创建员工信息表（ID为不空，名为varchar（30），lname VARCHAR（30），聘用日期不为空的默认“1970-01-01，分离的日期无效的默认9999-12-31 '，job_code store_id int，int）；

（这是作为一个基础的实例在同一台第22.2.1，”范围划分”。与其他分区的例子，我们假设default_storage_engine是InnoDB。）

假定有20个音像店分布在4的专营权，如下表所示。

在这样一种方式，行店属于同一地区存储在同一个分区表的分区，你可以使用CREATE TABLE表所示：

创建员工信息表（ID为不空，名varchar（30）、lname VARCHAR（30），雇用日期不为空的默认“1970-01-01，分离的日期无效的默认9999-12-31 '，job_code store_id int，int）列表分区（store_id）（分区pnorth值（3,5,6,9,17），分区peast值（1,2,10,11,19,20），分区pwest值（4,12,13,14,18），分区pcentral值（7,8,15,16））；

这使得它很容易添加或删除员工记录有关特定地区或从表。例如，假设在西部地区的所有商店都出售给另一家公司。MySQL中的所有行为，涉及员工在该地区的商店工作可以删除与查询ALTER TABLE employees TRUNCATE PARTITION pWest，可以执行比更有效DELETE陈述从员工那里store_id删除（4,12,13,14,18）；。（使用ALTER TABLE employees DROP PARTITION pWest还将删除所有这些行，但也将删除的分区pwest从表的定义；你将需要使用一个ALTER TABLE ... ADD PARTITION声明恢复表的分区方案。）

与RANGE分区，它是可能的结合列表通过散列或关键生产复合分区分区的分区（分区）。看到第22.2.6，“subpartitioning”

与案例RANGE分区，没有“抓住所有“如MAXVALUE；所有预期值为分区表达应覆盖分区…在values（…）条款.一个INSERT含有一个无与伦比的分区列的值不能用一个错误的声明，如本例所示：

MySQL的>CREATE TABLE h2 (->c1 INT,->c2 INT->)->PARTITION BY LIST(c1) (->PARTITION p0 VALUES IN (1, 4, 7),->PARTITION p1 VALUES IN (2, 5, 8)->);查询行，0行受影响（0.11秒）MySQL >INSERT INTO h2 VALUES (3, 5);错误1525（hy000）：表没有分区的价值

当插入多行，使用一个单一的INSERT声明为一个单一的InnoDB表，InnoDB考虑语句的一单交易，所以任何无与伦比的价值的存在导致语句完全失败，所以没有行插入。

你能使这类错误被忽略的利用IGNORE关键词如果你这样做，含有无与伦比的分区列值的行不插入任何行，但与匹配值是插入，并没有报告错误：

mysql> TRUNCATE h2;
Query OK, 1 row affected (0.00 sec)

mysql> SELECT * FROM h2;
Empty set (0.00 sec)

mysql> INSERT IGNORE INTO h2 VALUES (2, 5), (6, 10), (7, 5), (3, 1), (1, 9);
Query OK, 3 rows affected (0.00 sec)
Records: 5  Duplicates: 2  Warnings: 0

mysql> SELECT * FROM h2;
+------+------+
| c1   | c2   |
+------+------+
|    7 |    5 |
|    1 |    9 |
|    2 |    5 |
+------+------+
3 rows in set (0.00 sec)

MySQL 8还提供了支持LIST COLUMNS分区，变体列表分区可以使用比其他分区列的整数类型的列，并使用多个列作为分区键。有关更多信息，参见第22.2.3.2，”名单列分区”

接下来的两节中讨论COLUMNS分区，这是变异范围和LIST分区专栏用户可以使用多个分区键列。所有这些列都考虑到将排在分区的目的和决心，分区进行分区修剪的匹配行。

此外，两RANGE COLUMNS分区和表列分区支持非整数列的使用定义值的范围或列表成员。允许的数据类型如下表所示：

讨论RANGE COLUMNS和表列在接下来的两个章节划分假定你已经熟悉基于范围和列表支持MySQL 5.1及以后的划分；关于这些的更多信息，参见第22.2.1，”范围划分”，和22.2.2节，“列表分区”，分别

创建表table_name通过范围分区（列column_list（partition）partition_name不太多的价值value_list）[，分区partition_name不太多的价值value_list）] […]）column_list：column_name【，column_name] […]value_list：value【，value] […]

MySQL的>CREATE TABLE rcx (->a INT,->b INT,->c CHAR(3),->d INT->)->PARTITION BY RANGE COLUMNS(a,d,c) (->PARTITION p0 VALUES LESS THAN (5,10,'ggg'),->PARTITION p1 VALUES LESS THAN (10,20,'mmm'),->PARTITION p2 VALUES LESS THAN (15,30,'sss'),->PARTITION p3 VALUES LESS THAN (MAXVALUE,MAXVALUE,MAXVALUE)->);查询行，0行受影响（0.15秒）

创建表格R1（一个int，int b）按范围分区（一）（分区P0值小于（5），分区P1值小于（次））；

MySQL的>INSERT INTO r1 VALUES (5,10), (5,11), (5,12);查询行，3行受影响（0秒）记录：3份：0警告：0mysql >SELECT PARTITION_NAME,TABLE_ROWS->FROM INFORMATION_SCHEMA.PARTITIONS->WHERE TABLE_NAME = 'r1';---------------- ------------ | partition_name | table_rows | ---------------- ------------ | P0 | 0 | | P1 |三| ---------------- ------------ 2行集（0.001秒）

创建表的RC1（一个int，int b）的范围（A，B）列分区（分区P0值小于（5, 12），分区P3值小于（最大值，最大值））；

mysql> INSERT INTO rc1 VALUES (5,10), (5,11), (5,12);
Query OK, 3 rows affected (0.00 sec)
Records: 3  Duplicates: 0  Warnings: 0

mysql> SELECT PARTITION_NAME,TABLE_ROWS
    ->     FROM INFORMATION_SCHEMA.PARTITIONS
    ->     WHERE TABLE_NAME = 'rc1';
+--------------+----------------+------------+
| TABLE_SCHEMA | PARTITION_NAME | TABLE_ROWS |
+--------------+----------------+------------+
| p            | p0             |          2 |
| p            | p1             |          1 |
+--------------+----------------+------------+
2 rows in set (0.00 sec)

MySQL的&#62;SELECT (5,10) < (5,12), (5,11) < (5,12), (5,12) < (5,12);+-----------------+-----------------+-----------------+| (5,10) < (5,12) | (5,11) < (5,12) | (5,12) < (5,12) |+-----------------+-----------------+-----------------+|               1 |               1 |               0 |+-----------------+-----------------+-----------------+1 row in set (0.00 sec)

SELECT ROW(5,10) < ROW(5,12), ROW(5,11) < ROW(5,12), ROW(5,12) < ROW(5,12);

CREATE TABLE rx (
    a INT,
    b INT
)
PARTITION BY RANGE COLUMNS (a)  (
    PARTITION p0 VALUES LESS THAN (5),
    PARTITION p1 VALUES LESS THAN (MAXVALUE)
);

mysql> INSERT INTO rx VALUES (5,10), (5,11), (5,12);
Query OK, 3 rows affected (0.00 sec)
Records: 3  Duplicates: 0  Warnings: 0

mysql> SELECT PARTITION_NAME,TABLE_ROWS
    ->     FROM INFORMATION_SCHEMA.PARTITIONS
    ->     WHERE TABLE_NAME = 'rx';
+--------------+----------------+------------+
| TABLE_SCHEMA | PARTITION_NAME | TABLE_ROWS |
+--------------+----------------+------------+
| p            | p0             |          0 |
| p            | p1             |          3 |
+--------------+----------------+------------+
2 rows in set (0.00 sec)

创建表的RC2（一个int，int b）的范围（A，B）列分区（分区P0值小于（0），分区P1值小于（10,20），分区P2的值小于（10,30），分区P3值小于（最大值，最大值）；创建表RC3（一）int，int）B的范围列分区（A，B）（分区P0值小于（0），分区P1值小于（10,20），分区P2的值小于（10,30），分区P3值小于（10,35），分区P4值小于（40），分区P5值小于比（MaxValue最大））；

CREATE TABLE rc4 (
    a INT,
    b INT,
    c INT
)
PARTITION BY RANGE COLUMNS(a,b,c) (
    PARTITION p0 VALUES LESS THAN (0,25,50),
    PARTITION p1 VALUES LESS THAN (10,20,100),
    PARTITION p2 VALUES LESS THAN (10,30,50)
    PARTITION p3 VALUES LESS THAN (MAXVALUE,MAXVALUE,MAXVALUE)
 );

mysql> SELECT (0,25,50) < (10,20,100), (10,20,100) < (10,30,50);
+-------------------------+--------------------------+
| (0,25,50) < (10,20,100) | (10,20,100) < (10,30,50) |
+-------------------------+--------------------------+
|                       1 |                        1 |
+-------------------------+--------------------------+
1 row in set (0.00 sec)

MySQL的>CREATE TABLE rcf (->a INT,->b INT,->c INT->)->PARTITION BY RANGE COLUMNS(a,b,c) (->PARTITION p0 VALUES LESS THAN (0,25,50),->PARTITION p1 VALUES LESS THAN (20,20,100),->PARTITION p2 VALUES LESS THAN (10,30,50),->PARTITION p3 VALUES LESS THAN (MAXVALUE,MAXVALUE,MAXVALUE)->);错误1493（hy000）：值小于值必须为每个分区严格递增

mysql> SELECT (0,25,50) < (20,20,100), (20,20,100) < (10,30,50);
+-------------------------+--------------------------+
| (0,25,50) < (20,20,100) | (20,20,100) < (10,30,50) |
+-------------------------+--------------------------+
|                       1 |                        0 |
+-------------------------+--------------------------+
1 row in set (0.00 sec)

创建员工信息表（ID为不空，名为varchar（30），lname VARCHAR（30），聘用日期不为空的默认“1970-01-01，分离的日期无效的默认9999-12-31 '，job_code int不空，不空store_id int）；

创建表employees_by_lname（ID为不空，名varchar（30）、lname VARCHAR（30），雇用日期不为空的默认“1970-01-01，分离的日期无效的默认9999-12-31 '，job_code int不空，不空store_id int）的范围列分区（模型）（分区P0值小于（G’），分区P1值小于（是的），分区P2的值小于（不），分区P3值小于（次））；

通过改变范围列雇员表分区（模型）（分区P0值小于（G’），分区P1值小于（是的），分区P2的值小于（不），分区P3值小于（次））；

通过范围列表（聘用）员工分区（分区P0值小于（'1970-01-01 '），分区P1值小于（'1980-01-01 '），分区P2的值小于（'1990-01-01 '），分区P3值小于（'2000-01-01 '），分区P4值小于（'2010-01-01 '），分区P5值小于（次））；

CREATE TABLE customers_1 (    first_name VARCHAR(25),    last_name VARCHAR(25),    street_1 VARCHAR(30),    street_2 VARCHAR(30),    city VARCHAR(15),    renewal DATE)PARTITION BY LIST COLUMNS(city) (    PARTITION pRegion_1 VALUES IN('Oskarshamn', 'H?gsby', 'M?nster?s'),    PARTITION pRegion_2 VALUES IN('Vimmerby', 'Hultsfred', 'V?stervik'),    PARTITION pRegion_3 VALUES IN('N?ssj?', 'Eksj?', 'Vetlanda'),    PARTITION pRegion_4 VALUES IN('Uppvidinge', 'Alvesta', 'V?xjo'));

CREATE TABLE customers_2 (
    first_name VARCHAR(25),
    last_name VARCHAR(25),
    street_1 VARCHAR(30),
    street_2 VARCHAR(30),
    city VARCHAR(15),
    renewal DATE
)
PARTITION BY LIST COLUMNS(renewal) (
    PARTITION pWeek_1 VALUES IN('2010-02-01', '2010-02-02', '2010-02-03',
        '2010-02-04', '2010-02-05', '2010-02-06', '2010-02-07'),
    PARTITION pWeek_2 VALUES IN('2010-02-08', '2010-02-09', '2010-02-10',
        '2010-02-11', '2010-02-12', '2010-02-13', '2010-02-14'),
    PARTITION pWeek_3 VALUES IN('2010-02-15', '2010-02-16', '2010-02-17',
        '2010-02-18', '2010-02-19', '2010-02-20', '2010-02-21'),
    PARTITION pWeek_4 VALUES IN('2010-02-22', '2010-02-23', '2010-02-24',
        '2010-02-25', '2010-02-26', '2010-02-27', '2010-02-28')
);

CREATE TABLE customers_3 (
    first_name VARCHAR(25),
    last_name VARCHAR(25),
    street_1 VARCHAR(30),
    street_2 VARCHAR(30),
    city VARCHAR(15),
    renewal DATE
)
PARTITION BY RANGE COLUMNS(renewal) (
    PARTITION pWeek_1 VALUES LESS THAN('2010-02-09'),
    PARTITION pWeek_2 VALUES LESS THAN('2010-02-15'),
    PARTITION pWeek_3 VALUES LESS THAN('2010-02-22'),
    PARTITION pWeek_4 VALUES LESS THAN('2010-03-01')
);

分区HASH主要用于保证预定数量的分区中的数据均匀分布。的范围或列表分区，您必须明确指定哪个分区给定列的值或者设置列值应存放在；与哈希分区，这一决定是照顾你，你只需要指定一个列值或表达式基于散列列值和分区数为分区表是可分的。

分区表的使用HASH划分，有必要追加到CREATE TABLE声明一个散列分区法（expr）条款，在expr是返回一个整型表达式。这仅仅是一个列的类型的名称是一个MySQL的整数类型。此外，你可能想跟随分区num，在那里num是一个正整数表示分区的数量，桌子是可分。

下面的语句创建一个表，使用哈希算法对store_id柱分为4个分区：

创建员工信息表（ID为不空，名为varchar（30），lname VARCHAR（30），聘用日期不为空的默认“1970-01-01，分离的日期无效的默认9999-12-31 '，job_code int，int store_id）散列分区法（store_id）分区4；

如果不包括PARTITIONS条款，分区的默认数量一；使用PARTITIONS关键词无数量后，结果在一个语法错误。

你也可以使用一个SQL表达式，返回一个整数expr。例如，你可能想划分这一年的员工被雇用。这可以通过如下所示：

创建员工信息表（ID为不空，名为varchar（30），lname VARCHAR（30），聘用日期不为空的默认“1970-01-01，分离的日期无效的默认9999-12-31 '，job_code int，int store_id）散列分区法（年（雇））分区4；

expr必须返回一个数，随机整数（换句话说，它应该是不同的但确定性），并且必须不包含任何禁止的结构描述22.6节，“分区”的约束和限制。你也应该记住，这种表达是每次插入一行或更新的评价（或删除）；这意味着非常复杂的表达式可能会导致性能问题，尤其是当执行操作（如批量插入）影响许多排在同一时间。

最高效的哈希函数是一个运行在一个单一的表列的值增加或减少持续的列的值，因为这可以“修剪“范围分区。这是更密切的表达与它所基于的列的值的变化，更有效地使用MySQL可以表达为哈希分区。

例如，在date_col是一列式DATE，然后表达TO_DAYS(date_col)据说与价值成正比日期，因为在每一个变化的价值date_col，在一致的方式表达的变化值。表达的差异YEAR(date_col)相对于日期不完全是那样直接TO_DAYS(date_col)，因为不是每个可能的变化日期产生一个等效的变化YEAR(date_col)。即使如此，YEAR(date_col)是一个散列函数的很好的候选人，因为它直接随一部分日期有没有可能改变date_col产生不成比例的变化YEAR(date_col)

相反，假设你有一个叫作int_col其类型INT。现在考虑的表达POW(5-int_col,3) + 6。这是一个好的选择因为散列函数值的变化在_ int不保证产品在该表达式的值成比例的变化。改变的价值int_col通过一个给定的量可以产生各种不同的表达式的值的变化。例如，改变在_ int从5到六产生一个变化的-1在该表达式的值，但变化的价值在_ int从6到七产生一个变化的-7在表达式的值

换句话说，越密切的列的值与表达式的值图如下直线的方程追踪y=cx哪里c是某个非零常数，更好的表达是适合散列。这是因为更多的非线性表达式，该分区也容易产生数据之间的分布越不均匀。

在理论上，对于涉及多个列值表达式的修剪也是可以的，但确定的这种表达是合适的可以是相当困难和费时。为此，哈希表达涉及多个列的使用不是特别推荐。

什么时候PARTITION BY HASH是用于存储引擎确定哪个分区num分区使用基于表达式的结果的模。换句话说，对于一个给定的表达expr，其中分区存储记录号分区N，在那里N= MOD(expr，num）。假设表T1定义如下，以便它有4个分区：

CREATE TABLE t1 (col1 INT, col2 CHAR(5), col3 DATE)
    PARTITION BY HASH( YEAR(col3) )
    PARTITIONS 4;

如果你插入一条记录到t1谁的col3值'2005-09-15'，然后分配其存储决定如下：

MOD(YEAR('2005-09-01'),4)=  MOD(2005,4)=  1

MySQL 8还支持一个变种HASH分区被称为线性散列采用更复杂的算法来确定新的行插入到分区表的位置。看到第22.2.4.1，线性散列分区”，为描述这个算法

用户提供的表达是每一次记录的插入或更新评估。它还可以根据不同的情况进行评估，当记录被删除。

CREATE TABLE employees (
    id INT NOT NULL,
    fname VARCHAR(30),
    lname VARCHAR(30),
    hired DATE NOT NULL DEFAULT '1970-01-01',
    separated DATE NOT NULL DEFAULT '9999-12-31',
    job_code INT,
    store_id INT
)
PARTITION BY LINEAR HASH( YEAR(hired) )
PARTITIONS 4;

创建表T1（col1 int，char（五），col2 col3日期）通过线性哈希分区（分区六年（COL3））；

V = POWER(2, CEILING( LOG(2,6) )) = 8
N = YEAR('2003-04-14') & (8 - 1)
   = 2003 & 7
   = 3

(3 >= 6 is FALSE: record stored in partition #3)

V = 8
N = YEAR('1998-10-19') & (8 - 1)
  = 1998 & 7
  = 6

(6 >= 6 is TRUE: additional step required)

N = 6 & ((8 / 2) - 1)
  = 6 & 3
  = 2

(2 >= 6 is FALSE: record stored in partition #2)

划分的关键是类似的哈希分区，除了在哈希分区使用一个自定义的表情，散列函数为重点的划分是由MySQL服务器提供。

语法规则CREATE TABLE ... PARTITION BY KEY类似于创建一个表，按哈希分区。主要的区别如下：

也可以通过线性关键分区表。这里是一个简单的例子：

CREATE TABLE tk (
    col1 INT NOT NULL,
    col2 CHAR(5),
    col3 DATE
)
PARTITION BY LINEAR KEY (col1)
PARTITIONS 3;

这个LINEAR关键词具有相同的效果钥匙分割它HASH分区的分区号，使用权两算法而不是模算术推导。看到第22.2.4.1，线性散列分区”，为描述这个算法及其启示。

分区也被称为复合分区-在一个分区表的每个分区的进一步划分。考虑以下CREATE TABLE声明：

创建表的TS（ID int，购买日期）按范围分区（年（购买））子分区哈希（to_days（购买）2）子分区（分区P0值小于（1990），分区P1值小于（2000），分区P2值小于最大值）；

表ts有3个范围走吧这些部分的每一部分p0，P1，和p2-进一步分为2个子。实际上，整个表分3 * 2 = 6走吧但是，由于我们的行动PARTITION BY RANGE条款，前2个店只有那些记录一个值小于1990的购买专栏

这是可能的，分区的子分区表RANGE或列表。。。。。。。subpartitions可能使用。HASH或钥匙分区。这也被称为复合分区

它也可以定义不会显式使用SUBPARTITION子句指定单个的子分区选项。例如，一个更复杂的方式创建相同的表TS如前一个例子所示将：

CREATE TABLE ts (id INT, purchased DATE)
    PARTITION BY RANGE( YEAR(purchased) )
    SUBPARTITION BY HASH( TO_DAYS(purchased) ) (
        PARTITION p0 VALUES LESS THAN (1990) (
            SUBPARTITION s0,
            SUBPARTITION s1
        ),
        PARTITION p1 VALUES LESS THAN (2000) (
            SUBPARTITION s2,
            SUBPARTITION s3
        ),
        PARTITION p2 VALUES LESS THAN MAXVALUE (
            SUBPARTITION s4,
            SUBPARTITION s5
        )
    );

注意一些语法项目如下：

分区在MySQL不允许NULL作为一个分区表达式的值，它是否是一个列值或用户提供的表达式的值。即使是允许使用无效的作为一个表达式，否则必须产生一个整数的值，记住这一点是重要的NULL是不是一个数字。MySQL的分区实施治疗无效的是比任何非—NULL价值，正如顺序做.

这意味着治疗NULL不同类型的分区之间的变化，以及可能产生的行为，你不如果你不准备期待。在这种情况下，我们在本节讨论如何处理MySQL分区类型无效的确定在这一行应该存放的分区时的价值，并提供例子每。

处理空与范围划分如果你插入一行到一个表分区RANGE这样，用来确定分区列的值无效的，行插入到最低的分区。数据库中名为考虑一下这两个表p，创建如下：

MySQL的>CREATE TABLE t1 (->c1 INT,->c2 VARCHAR(20)->)->PARTITION BY RANGE(c1) (->PARTITION p0 VALUES LESS THAN (0),->PARTITION p1 VALUES LESS THAN (10),->PARTITION p2 VALUES LESS THAN MAXVALUE->);查询行，0行受影响（0.09秒）MySQL >CREATE TABLE t2 (->c1 INT,->c2 VARCHAR(20)->)->PARTITION BY RANGE(c1) (->PARTITION p0 VALUES LESS THAN (-5),->PARTITION p1 VALUES LESS THAN (0),->PARTITION p2 VALUES LESS THAN (10),->PARTITION p3 VALUES LESS THAN MAXVALUE->);查询行，0行受影响（0.09秒）

你可以看到创建的分区，这两CREATE TABLE使用下面的查询语句PARTITIONS表中information_schema数据库：

mysql> SELECT TABLE_NAME, PARTITION_NAME, TABLE_ROWS, AVG_ROW_LENGTH, DATA_LENGTH
     >   FROM INFORMATION_SCHEMA.PARTITIONS
     >   WHERE TABLE_SCHEMA = 'p' AND TABLE_NAME LIKE 't_';
+------------+----------------+------------+----------------+-------------+
| TABLE_NAME | PARTITION_NAME | TABLE_ROWS | AVG_ROW_LENGTH | DATA_LENGTH |
+------------+----------------+------------+----------------+-------------+
| t1         | p0             |          0 |              0 |           0 |
| t1         | p1             |          0 |              0 |           0 |
| t1         | p2             |          0 |              0 |           0 |
| t2         | p0             |          0 |              0 |           0 |
| t2         | p1             |          0 |              0 |           0 |
| t2         | p2             |          0 |              0 |           0 |
| t2         | p3             |          0 |              0 |           0 |
+------------+----------------+------------+----------------+-------------+
7 rows in set (0.00 sec)

（有关此表的更多信息见24.14节，“information_schema分区表”。）现在让我们填充这些表包含一个单排NULL在列作为分区键，并验证该行被插入使用一对SELECT声明:

MySQL的>INSERT INTO t1 VALUES (NULL, 'mothra');查询行，1行的影响（0秒）MySQL >INSERT INTO t2 VALUES (NULL, 'mothra');查询行，1行的影响（0秒）MySQL >SELECT * FROM t1;------ -------- | ID |名字| ------ -------- |空| Mothra | ------ -------- 1行集（0秒）MySQL >SELECT * FROM t2;第二次会议（第三次会议）

你可以看到，采用分区通过重新运行以前的查询与存储插入行INFORMATION_SCHEMA.PARTITIONS检查输出：

MySQL的>SELECT TABLE_NAME, PARTITION_NAME, TABLE_ROWS, AVG_ROW_LENGTH, DATA_LENGTH>FROM INFORMATION_SCHEMA.PARTITIONS>WHERE TABLE_SCHEMA = 'p' AND TABLE_NAME LIKE 't_';------------ ---------------- ------------ ---------------- ------------- | table_name | partition_name | table_rows | avg_row_length | data_length | ------------ ---------------- ------------ ---------------- -------------| T1 | P0 | 1 | 20 | 20 || T1 | | P1 0 0 0 | | | | T1 | | P2 0 0 0 | | || T2 | P0 | 1 | 20 | 20 || T2 | | P1 0 0 0 | | | | T2 | | P2 0 0 0 | | | | T2 | | P3 0 0 0 | | | ------------ ---------------- ------------ ---------------- ------------- 7 rows在设定（0.01秒）

你也可以证明这些行删除这些分区存储在最低编号的分区的每个表，然后重新运行SELECT声明:

MySQL的>ALTER TABLE t1 DROP PARTITION p0;查询行，0行受影响（0.16秒）MySQL >ALTER TABLE t2 DROP PARTITION p0;查询行，0行受影响（0.16秒）MySQL >SELECT * FROM t1;空集合（0秒）MySQL >SELECT * FROM t2;空集（0.001秒）

（更多信息ALTER TABLE ... DROP PARTITION，看到第13.1.8，“ALTER TABLE语法”。）

NULL也以这种方式处理的分区，使用SQL函数的表达式。假设我们定义一个表使用CREATE TABLE如这一声明：

创建表tndate（ID int，DT日期）按范围分区（年（DT））（分区P0值小于（1990年），分区P1值小于（2000年），分区P2值小于最大值）；

与其他MySQL功能，YEAR(NULL)退货无效的。一行dt列值无效的作为虽然分区表达式的值小于其他任何值，所以插入分区p0

处理空列表分区已分区表的LIST承认无效的值，当且仅当它的一个分区是使用包含定义的值列表NULL。反之，一个表分区列表不明确使用NULL值列表中的拒绝导致行无效的对于分区表达式的值，如图所示：

mysql> CREATE TABLE ts1 (
    ->     c1 INT,
    ->     c2 VARCHAR(20)
    -> )
    -> PARTITION BY LIST(c1) (
    ->     PARTITION p0 VALUES IN (0, 3, 6),
    ->     PARTITION p1 VALUES IN (1, 4, 7),
    ->     PARTITION p2 VALUES IN (2, 5, 8)
    -> );
Query OK, 0 rows affected (0.01 sec)

mysql> INSERT INTO ts1 VALUES (9, 'mothra');
ERROR 1504 (HY000): Table has no partition for value 9

mysql> INSERT INTO ts1 VALUES (NULL, 'mothra');
ERROR 1504 (HY000): Table has no partition for value NULL

只有行具有c1价值之间零和8包括可插入TS1NULL超出这个范围，就像数九。我们可以创建表ts2和TS3在值列表包含NULL，如下所示：

MySQL的>CREATE TABLE ts2 (->c1 INT,->c2 VARCHAR(20)->)->PARTITION BY LIST(c1) (->PARTITION p0 VALUES IN (0, 3, 6),->PARTITION p1 VALUES IN (1, 4, 7),->PARTITION p2 VALUES IN (2, 5, 8),->PARTITION p3 VALUES IN (NULL)->);查询好，为受影响的行（0.01秒）MySQL >CREATE TABLE ts3 (->c1 INT,->c2 VARCHAR(20)->)->PARTITION BY LIST(c1) (->PARTITION p0 VALUES IN (0, 3, 6),->PARTITION p1 VALUES IN (1, 4, 7, NULL),->PARTITION p2 VALUES IN (2, 5, 8)->);查询好，为受影响的行（0.01秒）

定义分区值列表时，你可以（也应该）治疗NULL就像任何其他的价值。例如，两值（null）和VALUES IN (1, 4, 7, NULL)是有效的，如（null值在1，4，7），VALUES IN (NULL, 1, 4, 7)，等等。你可以插入一行无效的柱c1为每个表TS2和ts3：

MySQL的>INSERT INTO ts2 VALUES (NULL, 'mothra');查询行，1行的影响（0秒）MySQL >INSERT INTO ts3 VALUES (NULL, 'mothra');查询行，1行的影响（0秒）

通过发行相应的查询INFORMATION_SCHEMA.PARTITIONS，你可以确定哪些分区用来存放刚才插入的行（我们假设，在前面的例子中，这个分区表中创建P数据库）：

mysql> SELECT TABLE_NAME, PARTITION_NAME, TABLE_ROWS, AVG_ROW_LENGTH, DATA_LENGTH
     >   FROM INFORMATION_SCHEMA.PARTITIONS
     >   WHERE TABLE_SCHEMA = 'p' AND TABLE_NAME LIKE 'ts_';
+------------+----------------+------------+----------------+-------------+
| TABLE_NAME | PARTITION_NAME | TABLE_ROWS | AVG_ROW_LENGTH | DATA_LENGTH |
+------------+----------------+------------+----------------+-------------+
| ts2        | p0             |          0 |              0 |           0 |
| ts2        | p1             |          0 |              0 |           0 |
| ts2        | p2             |          0 |              0 |           0 |
| ts2        | p3             |          1 |             20 |          20 |
| ts3        | p0             |          0 |              0 |           0 |
| ts3        | p1             |          1 |             20 |          20 |
| ts3        | p2             |          0 |              0 |           0 |
+------------+----------------+------------+----------------+-------------+
7 rows in set (0.01 sec)

如本节前面，你也可以验证分区是用于存储行删除这些分区，然后执行SELECT

空哈希分区处理的关键。NULL是分区表的不同处理搞砸或KEY。在这种情况下，任何分区表达式无效的值作为返回值为零，但其。我们可以通过在创建一个表的分区的文件系统的影响，验证了这种行为HASH和填充它与记录包含适当的值。假设你有一个表TH（也在p使用下面的语句创建数据库）：

MySQL的>CREATE TABLE th (->c1 INT,->c2 VARCHAR(20)->)->PARTITION BY HASH(c1)->PARTITIONS 2;查询行，0行受影响（0秒）

分区属于这个表格可以被用在这里显示的查询：

mysql> SELECT TABLE_NAME,PARTITION_NAME,TABLE_ROWS,AVG_ROW_LENGTH,DATA_LENGTH
     >   FROM INFORMATION_SCHEMA.PARTITIONS
     >   WHERE TABLE_SCHEMA = 'p' AND TABLE_NAME ='th';
+------------+----------------+------------+----------------+-------------+
| TABLE_NAME | PARTITION_NAME | TABLE_ROWS | AVG_ROW_LENGTH | DATA_LENGTH |
+------------+----------------+------------+----------------+-------------+
| th         | p0             |          0 |              0 |           0 |
| th         | p1             |          0 |              0 |           0 |
+------------+----------------+------------+----------------+-------------+
2 rows in set (0.00 sec)

TABLE_ROWS每个分区0。现在插入两排成TH谁的c1列的值无效的0，确认这些行被插入，如图所示：

mysql> INSERT INTO th VALUES (NULL, 'mothra'), (0, 'gigan');
Query OK, 1 row affected (0.00 sec)

mysql> SELECT * FROM th;
+------+---------+
| c1   | c2      |
+------+---------+
| NULL | mothra  |
+------+---------+
|    0 | gigan   |
+------+---------+
2 rows in set (0.01 sec)

回想一下，对于任意整数N，价值零模N总是无效的。partitioned by that are for表HASH或钥匙，这个结果是确定正确的分区处理0。检查INFORMATION_SCHEMA.PARTITIONS表一次又一次，我们可以看到，一排排被插入到分区P0：

mysql> SELECT TABLE_NAME, PARTITION_NAME, TABLE_ROWS, AVG_ROW_LENGTH, DATA_LENGTH
     >   FROM INFORMATION_SCHEMA.PARTITIONS
     >   WHERE TABLE_SCHEMA = 'p' AND TABLE_NAME ='th';
+------------+----------------+------------+----------------+-------------+
| TABLE_NAME | PARTITION_NAME | TABLE_ROWS | AVG_ROW_LENGTH | DATA_LENGTH |
+------------+----------------+------------+----------------+-------------+
| th         | p0             |          2 |             20 |          20 |
| th         | p1             |          0 |              0 |           0 |
+------------+----------------+------------+----------------+-------------+
2 rows in set (0.00 sec)

通过重复最后一个示例使用PARTITION BY KEY在的地方散列分区法在表的定义，您可以验证NULL也像对待0这种类型的划分。

添加范围和列表分区滴以类似的方式处理，所以我们讨论在本节划分这两类管理。有关用表，哈希分区工作或关键信息，看第22.3.2，“管理散列分区”

a partition from table落水partitioned by that is或者RANGE或由列表可以通过使用ALTER TABLE声明与删除分区选项假设你已经创建了一个表，按范围分区，然后填入10记录使用以下CREATE TABLE和INSERT声明:

MySQL的>CREATE TABLE tr (id INT, name VARCHAR(50), purchased DATE)->PARTITION BY RANGE( YEAR(purchased) ) (->PARTITION p0 VALUES LESS THAN (1990),->PARTITION p1 VALUES LESS THAN (1995),->PARTITION p2 VALUES LESS THAN (2000),->PARTITION p3 VALUES LESS THAN (2005),->PARTITION p4 VALUES LESS THAN (2010),->PARTITION p5 VALUES LESS THAN (2015)->);查询行，0行受影响（0.28秒）MySQL >INSERT INTO tr VALUES->(1, 'desk organiser', '2003-10-15'),->(2, 'alarm clock', '1997-11-05'),->(3, 'chair', '2009-03-10'),->(4, 'bookcase', '1989-01-10'),->(5, 'exercise bike', '2014-05-09'),->(6, 'sofa', '1987-06-05'),->(7, 'espresso maker', '2011-11-22'),->(8, 'aquarium', '1992-08-04'),->(9, 'study desk', '2006-09-16'),->(10, 'lava lamp', '1998-12-25');查询行，10行受影响（0.05秒）记录：10份：0警告：0

你可以看到哪些项目应该被插入到分区p2如图所示：

MySQL的>SELECT * FROM tr->WHERE purchased BETWEEN '1995-01-01' AND '1999-12-31';------ ------------- ------------ | ID |名字|购买| ------ ------------- ------------ | 2 |闹钟| 1997-11-05 | | 10 |熔岩灯| 1998-12-25 | ------ ------------- ------------ 2行集（0秒）

你也可以使用分区选择得到这个信息，如下所示：

mysql> SELECT * FROM tr PARTITION (p2);
+------+-------------+------------+
| id   | name        | purchased  |
+------+-------------+------------+
|    2 | alarm clock | 1997-11-05 |
|   10 | lava lamp   | 1998-12-25 |
+------+-------------+------------+
2 rows in set (0.00 sec)

看到第22，“分区选择”为更多的信息

把分区命名p2，执行以下命令：

MySQL的>ALTER TABLE tr DROP PARTITION p2;查询好，为受影响的行（0秒）

它是要记住很重要，当你删除一个分区，你也删除所有的数据被存储在该分区。你可以看到，这是通过重新运行以前的案例SELECTPERERY：

MySQL的>SELECT * FROM tr WHERE purchased->BETWEEN '1995-01-01' AND '1999-12-31';空集（0.001秒）

因此，你必须有DROP一个表的权限才能执行修改表…删除分区在那张桌子上

如果你想删除所有数据，同时保留所有分区表定义和划分方案，使用TRUNCATE TABLE声明。（见第13.1.34”truncate table语法”。）

如果你想改变一个表的分区没有丢失数据，使用ALTER TABLE ... REORGANIZE PARTITION相反。看下面或第13.1.8，“ALTER TABLE语法”，有关REORGANIZE PARTITION

如果你现在执行SHOW CREATE TABLE声明中，你可以看到分区表结构已经改变：

MySQL的>SHOW CREATE TABLE tr\G*************************** 1. row ***************************       Table: trCreate Table: CREATE TABLE `tr` (  `id` int(11) DEFAULT NULL,  `name` varchar(50) DEFAULT NULL,  `purchased` date DEFAULT NULL) ENGINE=InnoDB DEFAULT CHARSET=latin1/*!50100 PARTITION BY RANGE ( YEAR(purchased))(PARTITION p0 VALUES LESS THAN (1990) ENGINE = InnoDB, PARTITION p1 VALUES LESS THAN (1995) ENGINE = InnoDB, PARTITION p3 VALUES LESS THAN (2005) ENGINE = InnoDB, PARTITION p4 VALUES LESS THAN (2010) ENGINE = InnoDB, PARTITION p5 VALUES LESS THAN (2015) ENGINE = InnoDB) */1 row in set (0.00 sec)

当你插入新的行为变化表purchased列值之间“1995-01-01”和'2004-12-31'包容，那些行将存储在分区P3。你可以验证这个如下：

mysql> INSERT INTO tr VALUES (11, 'pencil holder', '1995-07-12');
Query OK, 1 row affected (0.00 sec)

mysql> SELECT * FROM tr WHERE purchased
    -> BETWEEN '1995-01-01' AND '2004-12-31';
+------+----------------+------------+
| id   | name           | purchased  |
+------+----------------+------------+
|    1 | desk organiser | 2003-10-15 |
|   11 | pencil holder  | 1995-07-12 |
+------+----------------+------------+
2 rows in set (0.00 sec)

mysql> ALTER TABLE tr DROP PARTITION p3;
Query OK, 0 rows affected (0.03 sec)

mysql> SELECT * FROM tr WHERE purchased
    -> BETWEEN '1995-01-01' AND '2004-12-31';
Empty set (0.00 sec)

行数从表中删除的结果ALTER TABLE ... DROP PARTITION不报告的服务器会用等效DELETE查询

滴水LIST从相同的角度出发修改表…删除分区语法用于坠RANGE分区。然而，有一个重要的分歧的影响，这对您使用本表之后：你不能再插入表中的任何行有任何被列入名单的价值定义删除分区的值。（见22.2.2节，“列表分区”，即为一例。）

添加一个新的范围或列表分区以前的分区表，使用ALTER TABLE ... ADD PARTITION声明。为表分区的范围，这可以用来添加一个新的范围，对现有的分区列表的末尾。假设你有一个分区表为您的组织含会员资料，它的定义如下：

CREATE TABLE members (
    id INT,
    fname VARCHAR(25),
    lname VARCHAR(25),
    dob DATE
)
PARTITION BY RANGE( YEAR(dob) ) (
    PARTITION p0 VALUES LESS THAN (1980),
    PARTITION p1 VALUES LESS THAN (1990),
    PARTITION p2 VALUES LESS THAN (2000)
);

进一步假设为成员的最低年龄是16岁。当日历的方法，2015年底，你意识到你将很快被承认的成员谁出生在2000（及以后）。你可以修改members表以容纳新成员出生在年2000至2010如下所示：

修改表的成员添加分区（分区P3值小于（2010））；

表是按范围分区，您可以使用ADD PARTITION添加新的分区，分区的高端列表。试图添加在现有的分区之间或导致错误如下所示的一个新的分区，以这种方式：

MySQL的>ALTER TABLE members>ADD PARTITION (>PARTITION n VALUES LESS THAN (1970));错误1463（hy000）：值小于值必须严格?每个分区的增加

你可以解决这个问题，第一个分区为两个新的分裂，它们之间的范围，像这样：

ALTER TABLE members
    REORGANIZE PARTITION p0 INTO (
        PARTITION n0 VALUES LESS THAN (1970),
        PARTITION n1 VALUES LESS THAN (1980)
);

使用SHOW CREATE TABLE你可以看到，修改表声明已经达到期望的效果：

mysql> SHOW CREATE TABLE members\G
*************************** 1. row ***************************
       Table: members
Create Table: CREATE TABLE `members` (
  `id` int(11) DEFAULT NULL,
  `fname` varchar(25) DEFAULT NULL,
  `lname` varchar(25) DEFAULT NULL,
  `dob` date DEFAULT NULL
) ENGINE=InnoDB DEFAULT CHARSET=latin1
/*!50100 PARTITION BY RANGE ( YEAR(dob))
(PARTITION n0 VALUES LESS THAN (1970) ENGINE = InnoDB,
 PARTITION n1 VALUES LESS THAN (1980) ENGINE = InnoDB,
 PARTITION p1 VALUES LESS THAN (1990) ENGINE = InnoDB,
 PARTITION p2 VALUES LESS THAN (2000) ENGINE = InnoDB,
 PARTITION p3 VALUES LESS THAN (2010) ENGINE = InnoDB) */
1 row in set (0.00 sec)

参见第13.1.8.1，“修改表分区操作”

你也可以使用ALTER TABLE ... ADD PARTITION添加新的分区表，分区的列表。假设一个表tt使用以下定义CREATE TABLE声明：

TT（create table id的数据，国际城市战略）分区（partition（数据）的P值（5，10，15），P1值的分区（6，12，18）；

你可以在其中添加一个新分区存储行有data列的值七，14，和二十一如图所示：

ALTER TABLE tt ADD PARTITION (PARTITION p2 VALUES IN (7, 14, 21));

记住你不能添加一个新的LIST分区包含任何值，都已经包含在现有分区的值列表。如果你试图这样做，将导致一个错误：

MySQL的>ALTER TABLE tt ADD PARTITION >(PARTITION np VALUES IN (4, 8, 12));错误1465（hy000）：多个定义在相同?列表分区

因为在任何行data列值十二已分配的分区p1，你不能创建一个新的分区表TT这包括12在值列表。要做到这一点，你可以把P1，并添加np然后一个新的P1用改性的定义。然而，正如前面所讨论的，这会导致所有数据存储在损失p1-这是通常情况下，这是不是你真正想做的事情。另一个解决方案可能会出现与新的分区表的副本进行复制数据到使用CREATE TABLE ... SELECT ...，然后把旧桌子和重命名新的，但是这可能是非常耗时，在处理大量数据。这也可能不在高可用性要求的情况下是可行的。

你可以在一个单一的添加多个分区ALTER TABLE ... ADD PARTITION声明如下所示：

创建员工信息表（ID为不空，名为varchar（50）不为空，varchar（50）模型不空，雇用日期不为空）按范围分区（年（雇））（分区P1值小于（1991），分区P2的值小于（1996），分区P3值小于（2001）、分区P4值小于（2005））；改变表员工添加分区（分区P5值小于（2010），分区P6值小于最大值）；

幸运的是，MySQL的实现提供了重新划分分区无数据丢失的方法。让我们先看几个简单的例子RANGE分区。回忆会员表现定义如下所示：

mysql> SHOW CREATE TABLE members\G
*************************** 1. row ***************************
       Table: members
Create Table: CREATE TABLE `members` (
  `id` int(11) DEFAULT NULL,
  `fname` varchar(25) DEFAULT NULL,
  `lname` varchar(25) DEFAULT NULL,
  `dob` date DEFAULT NULL
) ENGINE=InnoDB DEFAULT CHARSET=latin1
/*!50100 PARTITION BY RANGE ( YEAR(dob))
(PARTITION n0 VALUES LESS THAN (1970) ENGINE = InnoDB,
 PARTITION n1 VALUES LESS THAN (1980) ENGINE = InnoDB,
 PARTITION p1 VALUES LESS THAN (1990) ENGINE = InnoDB,
 PARTITION p2 VALUES LESS THAN (2000) ENGINE = InnoDB,
 PARTITION p3 VALUES LESS THAN (2010) ENGINE = InnoDB) */
1 row in set (0.00 sec)

假设你想将所有成员行代表出生前1960到一个单独的分区。正如我们已经看到的，不能使用ALTER TABLE ... ADD PARTITION。然而，你可以使用另一个分区相关的扩展ALTER TABLE要做到这一：

修改表的成员重新分区（分区N0为S0值小于（1960），分区S1值小于（1970））；

实际上，这个命令将分区p0为两个新的分区S0和s1。它也将被存储在数据P0根据主要体现在两个规则到新的分区PARTITION ... VALUES ...条款，使S0只包含那些记录，YEAR(dob)小于1960，S1包含在这些行YEAR(dob)大于或等于1960但小于1970。

一REORGANIZE PARTITION条款也可用于合并相邻的分区。你可以反在前面陈述的影响会员表如下所示：

ALTER TABLE members REORGANIZE PARTITION s0,s1 INTO (
    PARTITION p0 VALUES LESS THAN (1970)
);

没有数据丢失在分裂或合并的分区使用REORGANIZE PARTITION。在执行上面的语句，mysql的动作都被存储在分区的记录S0和s1为分区P0

对于一般的语法是REORGANIZE PARTITION这里展示的是：

修改表tbl_namereorganize partitionpartition_list为（partition_definitions）；

在这里,tbl_name是分区表的名称，和partition_list是一个以逗号分隔的一个或多个现有的分区被改变名称列表。partition_definitions是一个逗号分隔的新的分区定义列表，它遵循相同的规则为partition_definitions列表中使用CREATE TABLE。你不限于合并成一个或几个分区，一个分区分裂成许多，使用时reorganize partition。例如，你可以整理所有四个分区的members表格一分为二，像这样：

修改表的成员重新划分P0，P1，P2，P3（划分为M0值小于（1980），分区M1值小于（2000））；

你也可以使用REORGANIZE PARTITION与表分区的列表。我们再添加一个新的分区列表分区的问题tt因为新的分区表和失败有价值，已经在一个现有的分区的值列表。我们可以通过添加一个分区只包含不冲突的值处理，然后将新的分区和现有的一个，这是存储在现有的价值现在是新搬来的人：

改变表格添加分区（分区NP值（4，8））；改变表格整理划分为P1，NP（分区P1值（6、18），分区NP值（4、8、12））；

这里是要牢记使用时的一些关键点ALTER TABLE ... REORGANIZE PARTITIONpartitioned that are to repartition表模式范围或LIST：

表格是由哈希或关键的划分非常相似，另一方面在一个分区设置的变化，以及不同数量的已分区表的范围或列表方式。为此，本节讨论的重点是通过哈希或分区表的修改。用于添加和表的范围或列表分区的分区滴讨论，看第22.3.1，”管理的范围和列表分区”

你不能删除分区表，分区HASH或钥匙以同样的方式，你可以从表分区的RANGE或列表。然而，你可以合并HASH或钥匙分区使用ALTER TABLE ... COALESCE PARTITION。假设一个客户数据表包含客户分为十二分区，创建如下所示：

CREATE TABLE clients (
    id INT,
    fname VARCHAR(30),
    lname VARCHAR(30),
    signed DATE
)
PARTITION BY HASH( MONTH(signed) )
PARTITIONS 12;

减少分区的数量从12到8，执行以下ALTER TABLE声明：

MySQL的>ALTER TABLE clients COALESCE PARTITION 4;查询行，0行受影响（0.02秒）

COALESCE同样适用于表分区的搞砸，KEY，线性散列，或LINEAR KEY。这里有一个例子与前一个类似，只是在不同的表分区的线性键：

mysql> CREATE TABLE clients_lk (
    ->     id INT,
    ->     fname VARCHAR(30),
    ->     lname VARCHAR(30),
    ->     signed DATE
    -> )
    -> PARTITION BY LINEAR KEY(signed)
    -> PARTITIONS 12;
Query OK, 0 rows affected (0.03 sec)

mysql> ALTER TABLE clients_lk COALESCE PARTITION 4;
Query OK, 0 rows affected (0.06 sec)
Records: 0  Duplicates: 0  Warnings: 0

following the numberCOALESCE PARTITION是合并，换句话说，在其余分区的数量，这是从表中删除分区的数量。

试图删除多个分区比在一个错误的这样的结果：

mysql> ALTER TABLE clients COALESCE PARTITION 18;
ERROR 1478 (HY000): Cannot remove all partitions, use DROP TABLE instead

为增加分区数clients从12到18台，使用修改表…添加分区如图所示：

ALTER TABLE clients ADD PARTITION PARTITIONS 6;

在MySQL 8中，它是可以用表使用表分区或子分区交换ALTER TABLE pt EXCHANGE PARTITION p WITH TABLE nt，在那里pt是分区表和p是分区和子分区的pt有未分区的表交换nt，提供下列陈述是真的：

除了对ALTER，INSERT，和CREATE特权通常需要ALTER TABLE报表，您必须DROP特权执行ALTER TABLE ... EXCHANGE PARTITION

你也应该注意以下影响ALTER TABLE ... EXCHANGE PARTITION：

语法ALTER TABLE ... EXCHANGE PARTITION这里展示的是，在ptpartitioned is the table，p是分区（或子分区）进行交换，并nt是交换与非分区表p：

修改表pt交换分区p表nt；

或者，你可以添加WITH VALIDATION或没有验证。什么时候WITHOUT VALIDATION指定的ALTER TABLE ... EXCHANGE PARTITION操作不执行任何排排验证当交换分区无分区表，允许数据库管理员承担确保行内的分区定义边界的责任。与验证是默认的

有且只有一个分区或子分区可能是唯一的非分区表在一个单一的交换ALTER TABLE EXCHANGE PARTITION声明。交换多个分区或子分区，使用多个ALTER TABLE EXCHANGE PARTITION声明.交换分区不得与其他ALTER TABLE选项分区及（如适用）分区的分区表可以是任何类型或类型在MySQL 8的支持。

与非分区表交换分区

假设一个分区表e已创建并填充使用下面的SQL语句：

E（create table id不空，fname varchar（30），lname varchar（30）的城市范围分区（partition（ID），P值小于（50），P1值小于分区（partition），P2的值小于（150分），P3值小于（MaxValue））插入到；E值（1669年，“吉姆”，“史密斯”（337），“玛丽”，“琼斯”（16），“弗兰克”、“白”（2005年），“琳达”，“黑”）；

现在我们创建在已分区copy ofe命名E2。这可以使用MySQL客户如下图所示：

mysql> CREATE TABLE e2 LIKE e;
Query OK, 0 rows affected (0.04 sec)

mysql> ALTER TABLE e2 REMOVE PARTITIONING;
Query OK, 0 rows affected (0.07 sec)
Records: 0  Duplicates: 0  Warnings: 0

你可以看到它的分区表e包含行通过查询INFORMATION_SCHEMA.PARTITIONS表，这样：

MySQL的>SELECT PARTITION_NAME, TABLE_ROWSFROM INFORMATION_SCHEMA.PARTITIONSWHERE TABLE_NAME = 'e';---------------- ------------ | partition_name | table_rows | ---------------- ------------ | P0 | 1 | | P1 | 0 | | P2 | 0 | | P3 | 3 | ---------------- ------------ 2行集（0秒）

交换分区p0表E表e2，你可以使用ALTER TABLE，如下所示：

MySQL的>ALTER TABLE e EXCHANGE PARTITION p0 WITH TABLE e2;查询行，0行受影响（0.04秒）

更确切地说，只是发表的声明使分区中发现任何行是与那些在桌上发现了。你可以看到这是怎么发生的通过查询INFORMATION_SCHEMA.PARTITIONS表，如前。表行，以前发现的分区P0不再存在：

mysql> SELECT PARTITION_NAME, TABLE_ROWS
           FROM INFORMATION_SCHEMA.PARTITIONS
           WHERE TABLE_NAME = 'e';
+----------------+------------+
| PARTITION_NAME | TABLE_ROWS |
+----------------+------------+
| p0             |          0 |
| p1             |          0 |
| p2             |          0 |
| p3             |          3 |
+----------------+------------+
4 rows in set (0.00 sec)

如果你查询表e2，你可以看到“丢失的“行现在可以发现：

mysql> SELECT * FROM e2;
+----+-------+-------+
| id | fname | lname |
+----+-------+-------+
| 16 | Frank | White |
+----+-------+-------+
1 row in set (0.00 sec)

表与分区交换不一定是空的。为了证明这一点，我们首先将新行插入表e，确保该行存储在分区P0通过选择一个id列的值小于50，验证这后来通过查询PARTITIONS表

MySQL的>INSERT INTO e VALUES (41, "Michael", "Green");查询行，一行受到影响（0秒）MySQL >SELECT PARTITION_NAME, TABLE_ROWSFROM INFORMATION_SCHEMA.PARTITIONSWHERE TABLE_NAME = 'e';            ---------------- ------------ | partition_name | table_rows | ---------------- ------------ | P0 | 1 | | P1 | 0 | | P2 | 0 | | P3 | 3 | ---------------- ------------ 4行集（0秒）

现在我们再次交换分区p0表E2使用相同的ALTER TABLE声明之前：

MySQL的>ALTER TABLE e EXCHANGE PARTITION p0 WITH TABLE e2;查询行，0行受影响（0.28秒）

以下查询输出显示的表行存储在分区p0和表行存储在表E2发行前，ALTER TABLE声明，现在换了个地方：

MySQL的>SELECT * FROM e;------ ------- ------- | ID |名| LName | ------ ------- ------- | 16 |弗兰克|白| | 1669 |吉姆|史米斯| | 337 |玛丽|琼斯| | 2005 |琳达|黑| ------ ------- ------- 4行集（0秒）MySQL >SELECT PARTITION_NAME, TABLE_ROWSFROM INFORMATION_SCHEMA.PARTITIONSWHERE TABLE_NAME = 'e';---------------- ------------ | partition_name | table_rows | ---------------- ------------ | P0 | 1 | | P1 | 0 | | P2 | 0 | | P3 | 3 | ---------------- ------------ 4行集（0秒）MySQL >SELECT * FROM e2;---- --------- ------- | ID |名| LName | ---- --------- ------- | 41 |米迦勒|绿色| ---- --------- ------- 1行集（0秒）

不匹配的行

你应该记住，任何行中发现的未分区表发行前ALTER TABLE ... EXCHANGE PARTITION语句必须满足他们被存储在目标分区的必要条件；否则，该语句将失败。看到这是如何发生的，先插入一行插入E2这是在分区的分区定义的界限p0表E。例如，插入一行一个id列的值太大；然后，试着交换表分区了：

MySQL的>INSERT INTO e2 VALUES (51, "Ellen", "McDonald");查询行，1行的影响（0.08秒）MySQL >ALTER TABLE e EXCHANGE PARTITION p0 WITH TABLE e2;错误1707（hy000）：发现行不匹配的分区

只有WITHOUT VALIDATION选择是否允许此操作成功：

MySQL的>ALTER TABLE e EXCHANGE PARTITION p0 WITH TABLE e2 WITHOUT VALIDATION;查询行，0行受影响（0.02秒）

当一个分区是一个表包含不匹配的行的分区定义的交换，它是数据库管理员的责任来解决不匹配的行，可以使用REPAIR TABLE或ALTER TABLE ... REPAIR PARTITION

交换分区没有逐行验证

为了避免耗时的验证时，交换分区表有很多行，它可以通过行验证步骤添加跳过行WITHOUT VALIDATION到ALTER TABLE ... EXCHANGE PARTITION声明

下面的示例将在执行的时候，交换分区和非分区表的差异，并没有验证。分区表（表e）包含两个分区100万排每。在P0表的行被移除，P0是1万行非分区表交换。这个与验证操作需要0.74秒。通过比较，该WITHOUT VALIDATION操作需要0.01秒

# Create a partitioned table with 1 million rows in each partitionCREATE TABLE e (    id INT NOT NULL,    fname VARCHAR(30),    lname VARCHAR(30))    PARTITION BY RANGE (id) (        PARTITION p0 VALUES LESS THAN (1000001),        PARTITION p1 VALUES LESS THAN (2000001),);mysql> SELECT COUNT(*) FROM e;                                             | COUNT(*) |+----------+|  2000000 |+----------+1 row in set (0.27 sec)# View the rows in each partitionSELECT PARTITION_NAME, TABLE_ROWS FROM INFORMATION_SCHEMA.PARTITIONS WHERE TABLE_NAME = 'e';+----------------+-------------+| PARTITION_NAME | TABLE_ROWS  |+----------------+-------------+| p0             |     1000000 || p1             |     1000000 |+----------------+-------------+2 rows in set (0.00 sec)# Create a nonpartitioned table of the same structure and populate it with 1 million rowsCREATE TABLE e2 (    id INT NOT NULL,    fname VARCHAR(30),    lname VARCHAR(30));mysql> SELECT COUNT(*) FROM e2;+----------+| COUNT(*) |+----------+|  1000000 |+----------+1 row in set (0.24 sec)# Create another nonpartitioned table of the same structure and populate it with 1 million rowsCREATE TABLE e3 (    id INT NOT NULL,    fname VARCHAR(30),    lname VARCHAR(30));    mysql> SELECT COUNT(*) FROM e3;+----------+| COUNT(*) |+----------+|  1000000 |+----------+1 row in set (0.25 sec)# Drop the rows from p0 of table emysql> DELETE FROM e WHERE id < 1000001;Query OK, 1000000 rows affected (5.55 sec)# Confirm that there are no rows in partition p0mysql> SELECT PARTITION_NAME, TABLE_ROWS FROM INFORMATION_SCHEMA.PARTITIONS WHERE TABLE_NAME = 'e';+----------------+------------+| PARTITION_NAME | TABLE_ROWS |+----------------+------------+| p0             |          0 || p1             |    1000000 |+----------------+------------+2 rows in set (0.00 sec)    # Exchange partition p0 of table e with the table e2 'WITH VALIDATION'mysql> ALTER TABLE e EXCHANGE PARTITION p0 WITH TABLE e2 WITH VALIDATION;Query OK, 0 rows affected (0.74 sec)# Confirm that the partition was exchanged with table e2mysql> SELECT PARTITION_NAME, TABLE_ROWS FROM INFORMATION_SCHEMA.PARTITIONS WHERE TABLE_NAME = 'e';+----------------+------------+| PARTITION_NAME | TABLE_ROWS |+----------------+------------+| p0             |    1000000 || p1             |    1000000 |+----------------+------------+2 rows in set (0.00 sec)# Once again, drop the rows from p0 of table emysql> DELETE FROM e WHERE id < 1000001;Query OK, 1000000 rows affected (5.55 sec)# Confirm that there are no rows in partition p0mysql> SELECT PARTITION_NAME, TABLE_ROWS FROM INFORMATION_SCHEMA.PARTITIONS WHERE TABLE_NAME = 'e';+----------------+------------+| PARTITION_NAME | TABLE_ROWS |+----------------+------------+| p0             |          0 || p1             |    1000000 |+----------------+------------+2 rows in set (0.00 sec)# Exchange partition p0 of table e with the table e3 'WITHOUT VALIDATION'mysql> ALTER TABLE e EXCHANGE PARTITION p0 WITH TABLE e3 WITHOUT VALIDATION;Query OK, 0 rows affected (0.01 sec)# Confirm that the partition was exchanged with table e3mysql> SELECT PARTITION_NAME, TABLE_ROWS FROM INFORMATION_SCHEMA.PARTITIONS WHERE TABLE_NAME = 'e';+----------------+------------+| PARTITION_NAME | TABLE_ROWS |+----------------+------------+| p0             |    1000000 || p1             |    1000000 |+----------------+------------+2 rows in set (0.00 sec)

如果一个分区是一个表包含不匹配的行的分区定义的交换，它是数据库管理员的责任来解决不匹配的行，可以使用REPAIR TABLE或ALTER TABLE ... REPAIR PARTITION

与非分区表交换子

你也可以换一个subpartitioned子表（见第22.2.6，“subpartitioning”）与非分区表使用ALTER TABLE ... EXCHANGE PARTITION声明。在下面的示例中，我们先创建一个表锿这是分区的RANGE通过与subpartitioned钥匙，填充此表为我们做表e，然后创建一个空的，未分区的复制沙二段的表，如下所示：

mysql> CREATE TABLE es (
    ->     id INT NOT NULL,
    ->     fname VARCHAR(30),
    ->     lname VARCHAR(30)
    -> )
    ->     PARTITION BY RANGE (id)
    ->     SUBPARTITION BY KEY (lname)
    ->     SUBPARTITIONS 2 (
    ->         PARTITION p0 VALUES LESS THAN (50),
    ->         PARTITION p1 VALUES LESS THAN (100),
    ->         PARTITION p2 VALUES LESS THAN (150),
    ->         PARTITION p3 VALUES LESS THAN (MAXVALUE)
    ->     );
Query OK, 0 rows affected (2.76 sec)

mysql> INSERT INTO es VALUES
    ->     (1669, "Jim", "Smith"),
    ->     (337, "Mary", "Jones"),
    ->     (16, "Frank", "White"),
    ->     (2005, "Linda", "Black");
Query OK, 4 rows affected (0.04 sec)
Records: 4  Duplicates: 0  Warnings: 0

mysql> CREATE TABLE es2 LIKE es;
Query OK, 0 rows affected (1.27 sec)

mysql> ALTER TABLE es2 REMOVE PARTITIONING;
Query OK, 0 rows affected (0.70 sec)
Records: 0  Duplicates: 0  Warnings: 0

虽然我们没有明确的名字，任何关于创建表时es，我们可以获得产生这些包括名字subpartition _名称列的PARTITIONS表information_schema当选择从表，如下所示：

mysql> SELECT PARTITION_NAME, SUBPARTITION_NAME, TABLE_ROWS
    ->     FROM INFORMATION_SCHEMA.PARTITIONS
    ->     WHERE TABLE_NAME = 'es';
+----------------+-------------------+------------+
| PARTITION_NAME | SUBPARTITION_NAME | TABLE_ROWS |
+----------------+-------------------+------------+
| p0             | p0sp0             |          1 |
| p0             | p0sp1             |          0 |
| p1             | p1sp0             |          0 |
| p1             | p1sp1             |          0 |
| p2             | p2sp0             |          0 |
| p2             | p2sp1             |          0 |
| p3             | p3sp0             |          3 |
| p3             | p3sp1             |          0 |
+----------------+-------------------+------------+
8 rows in set (0.00 sec)

以下ALTER TABLE隐含分区表p3sp0表es与非分区表沙二段：

mysql> ALTER TABLE es EXCHANGE PARTITION p3sp0 WITH TABLE es2;
Query OK, 0 rows affected (0.29 sec)

您可以验证该行发出以下查询交换：

mysql> SELECT PARTITION_NAME, SUBPARTITION_NAME, TABLE_ROWS
    ->     FROM INFORMATION_SCHEMA.PARTITIONS
    ->     WHERE TABLE_NAME = 'es';
+----------------+-------------------+------------+
| PARTITION_NAME | SUBPARTITION_NAME | TABLE_ROWS |
+----------------+-------------------+------------+
| p0             | p0sp0             |          1 |
| p0             | p0sp1             |          0 |
| p1             | p1sp0             |          0 |
| p1             | p1sp1             |          0 |
| p2             | p2sp0             |          0 |
| p2             | p2sp1             |          0 |
| p3             | p3sp0             |          0 |
| p3             | p3sp1             |          0 |
+----------------+-------------------+------------+
8 rows in set (0.00 sec)

mysql> SELECT * FROM es2;
+------+-------+-------+
| id   | fname | lname |
+------+-------+-------+
| 1669 | Jim   | Smith |
|  337 | Mary  | Jones |
| 2005 | Linda | Black |
+------+-------+-------+
3 rows in set (0.00 sec)

如果一个表subpartitioned，你可以交换只有一子分区表的分区表不是一整个分区，如下所示：

mysql> ALTER TABLE es EXCHANGE PARTITION p3 WITH TABLE es2;
ERROR 1704 (HY000): Subpartitioned table, use subpartition instead of partition

在一个严格的方式比较表结构；数量，顺序，名字，和列和分区表的索引和非分区表类型必须精确匹配。此外，这两个表都必须使用相同的存储引擎：

mysql> CREATE TABLE es3 LIKE e;
Query OK, 0 rows affected (1.31 sec)

mysql> ALTER TABLE es3 REMOVE PARTITIONING;
Query OK, 0 rows affected (0.53 sec)
Records: 0  Duplicates: 0  Warnings: 0

mysql> SHOW CREATE TABLE es3\G
*************************** 1. row ***************************
       Table: es3
Create Table: CREATE TABLE `es3` (
  `id` int(11) NOT NULL,
  `fname` varchar(30) DEFAULT NULL,
  `lname` varchar(30) DEFAULT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4
1 row in set (0.00 sec)

mysql> ALTER TABLE es3 ENGINE = MyISAM;
Query OK, 0 rows affected (0.15 sec)
Records: 0  Duplicates: 0  Warnings: 0

mysql> ALTER TABLE es EXCHANGE PARTITION p3sp0 WITH TABLE es3;
ERROR 1497 (HY000): The mix of handlers in the partitions is not allowed in this version of MySQL

多个表和分区的维护任务可以对分区使用SQL语句用于这种目的表进行。

表分区表维护可以使用语句完成CHECK TABLE，OPTIMIZE TABLE，ANALYZE TABLE，和REPAIR TABLEpartitioned，which are for表支持。

你可以使用一些扩展ALTER TABLE这种类型的一个或多个分区进行操作，如下所示：

每个报表列表中只显示也支持关键字ALL在分配名单的地方。使用全部导致语句作用于表中的所有分区。

你也可以使用TRUNCATE分区ALTER TABLE ... TRUNCATE PARTITION。这句话可以用来删除所有记录从一个或多个分区在大致相同的方式，TRUNCATE TABLE从表中删除所有行

ALTER TABLE ... TRUNCATE PARTITION ALL将表中的所有分区

本节讨论获取现有的分区信息，可以在许多方面做了。获取这些信息的方法，包括以下：

在本章中其他地方讨论，SHOW CREATE TABLE包括在其输出分区用于创建一个分区表条款。例如:

mysql> SHOW CREATE TABLE trb3\G
*************************** 1. row ***************************
       Table: trb3
Create Table: CREATE TABLE `trb3` (
  `id` int(11) DEFAULT NULL,
  `name` varchar(50) DEFAULT NULL,
  `purchased` date DEFAULT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4
/*!50100 PARTITION BY RANGE (YEAR(purchased))
(PARTITION p0 VALUES LESS THAN (1990) ENGINE = InnoDB,
 PARTITION p1 VALUES LESS THAN (1995) ENGINE = InnoDB,
 PARTITION p2 VALUES LESS THAN (2000) ENGINE = InnoDB,
 PARTITION p3 VALUES LESS THAN (2005) ENGINE = InnoDB) */
0 row in set (0.00 sec)

从输出SHOW TABLE STATUS对于分区表是一样的，非分区表，除了那创造性的选择列包含的字符串partitioned。这个引擎列包含所有分区的表使用的存储引擎的名称。（见第13.7.6.36，“显示表状态语法”，有关此声明的更多信息。）

你也可以获取分区信息INFORMATION_SCHEMA，其中包含一个PARTITIONS表看到24.14节，“information_schema分区表”

可以确定分区的分区表中给定的SELECT查询使用EXPLAIN。这个分区列在EXPLAIN输出列表分区的记录将被查询匹配。

假设一个表trb1创建并填充如下：

以创建表（ID int，NAME varchar（50），购买日期）按范围分区（ID）（分区P0值小于（3），分区P1值小于（7），分区P2的值小于（9），分区P3值小于（11））；插入以价值（1台组织者'，' 2003-10-15”），（2，“CD播放器”、“1993-11-05”），（3，“电视机”、“1996-03-10”），（4，“书架”、“1982-01-10”），（5，“自行车运动”，“2004-05-09”），（6，“沙发”、“1987-06-05”），（7，“爆米花机”、“2001-11-22”），（8，“水族馆”、“1992-08-04”），（9，“书桌”、“1984-09-16”），（10，“熔岩灯”、“1998-12-25”）；

你可以看到哪些分区是用于查询等SELECT * FROM trb1;，如下所示：

MySQL的>EXPLAIN SELECT * FROM trb1\G*************************** 1。行***************************编号：1 select_type：简单表：以P0，P1，P2分区，P3型：allpossible_keys：空键：空key_len：零号：空10行：额外的：使用filesort

在这种情况下，所有四个分区进行搜索。然而，当一个限制条件使用分区键添加到查询中，你可以看到，只有那些分区包含匹配值进行扫描，如图所示：

mysql> EXPLAIN SELECT * FROM trb1 WHERE id < 5\G
*************************** 1. row ***************************
           id: 1
  select_type: SIMPLE
        table: trb1
   partitions: p0,p1
         type: ALL
possible_keys: NULL
          key: NULL
      key_len: NULL
          ref: NULL
         rows: 10
        Extra: Using where

EXPLAIN 还提供了使用和可能的密钥密钥的信息：

MySQL的&#62;ALTER TABLE trb1 ADD PRIMARY KEY (id);查询行，10行受影响（0.03秒）记录：10份：0警告：0mysql &#62;EXPLAIN SELECT * FROM trb1 WHERE id < 5\G*************************** 1。行***************************编号：1 select_type：简单表：以分区：P0、P1型：rangepossible_keys：主键：主要key_len：4编号：空7行：额外使用的地方：

如果EXPLAIN用于检查对未分区表的查询，不产生误差，但价值的分区柱总是NULL

这个rows柱EXPLAIN输出显示表中的行的总数。

参见第13.8.2，”解释语法”

本节讨论与主键和唯一键的分区键的关系。的规律，这种关系可以表示如下：用于划分表达对于分区表的所有列必须是每一个独特的关键，表可能有部分。

换句话说，桌上的每一个独特的钥匙必须在表的分区表达式中使用的每一列。（这也包括表的主键，因为它是通过定义一个独特的关键。这种特殊的情况下是在后面讨论。）例如，以下各表的创建语句是无效的：

CREATE TABLE t1 (
    col1 INT NOT NULL,
    col2 DATE NOT NULL,
    col3 INT NOT NULL,
    col4 INT NOT NULL,
    UNIQUE KEY (col1, col2)
)
PARTITION BY HASH(col3)
PARTITIONS 4;

CREATE TABLE t2 (
    col1 INT NOT NULL,
    col2 DATE NOT NULL,
    col3 INT NOT NULL,
    col4 INT NOT NULL,
    UNIQUE KEY (col1),
    UNIQUE KEY (col3)
)
PARTITION BY HASH(col1 + col3)
PARTITIONS 4;

在每一种情况下，该表将至少有一个独特的关键，不包括用于划分表达所有列。

下面的语句是有效的，并代表一种相应的无效创建表的语句可以工作：

CREATE TABLE t1 (
    col1 INT NOT NULL,
    col2 DATE NOT NULL,
    col3 INT NOT NULL,
    col4 INT NOT NULL,
    UNIQUE KEY (col1, col2, col3)
)
PARTITION BY HASH(col3)
PARTITIONS 4;

CREATE TABLE t2 (
    col1 INT NOT NULL,
    col2 DATE NOT NULL,
    col3 INT NOT NULL,
    col4 INT NOT NULL,
    UNIQUE KEY (col1, col3)
)
PARTITION BY HASH(col1 + col3)
PARTITIONS 4;

这个例子表明，在这种情况下产生的误差：

mysql> CREATE TABLE t3 (
    ->     col1 INT NOT NULL,
    ->     col2 DATE NOT NULL,
    ->     col3 INT NOT NULL,
    ->     col4 INT NOT NULL,
    ->     UNIQUE KEY (col1, col2),
    ->     UNIQUE KEY (col3)
    -> )
    -> PARTITION BY HASH(col1 + col3)
    -> PARTITIONS 4;
ERROR 1491 (HY000): A PRIMARY KEY must include all columns in the table's partitioning function

这个CREATE TABLE语句失败，因为2和col3包括在建议的分区键列，但这些都是餐桌上的两个唯一键的一部分。这表明无效表定义一个可能的修复：

MySQL的>CREATE TABLE t3 (->col1 INT NOT NULL,->col2 DATE NOT NULL,->col3 INT NOT NULL,->col4 INT NOT NULL,->UNIQUE KEY (col1, col2, col3),->UNIQUE KEY (col3)->)->PARTITION BY HASH(col3)->PARTITIONS 4;查询行，0行受影响（0.05秒）

在这种情况下，该分区键col3是一个独特的关键部分，和表的创建语句成功。

下表不能被分区的所有，因为没有办法包括在分区键的任何列，属于独特的钥匙：

CREATE TABLE t4 (
    col1 INT NOT NULL,
    col2 INT NOT NULL,
    col3 INT NOT NULL,
    col4 INT NOT NULL,
    UNIQUE KEY (col1, col3),
    UNIQUE KEY (col2, col4)
);

因为每一个主键是通过定义一个独特的关键，这个限制也包括表的主键，如果它有一个。例如，下面两个语句是无效的：

CREATE TABLE t5 (
    col1 INT NOT NULL,
    col2 DATE NOT NULL,
    col3 INT NOT NULL,
    col4 INT NOT NULL,
    PRIMARY KEY(col1, col2)
)
PARTITION BY HASH(col3)
PARTITIONS 4;

CREATE TABLE t6 (
    col1 INT NOT NULL,
    col2 DATE NOT NULL,
    col3 INT NOT NULL,
    col4 INT NOT NULL,
    PRIMARY KEY(col1, col3),
    UNIQUE KEY(col2)
)
PARTITION BY HASH( YEAR(col2) )
PARTITIONS 4;

在这两种情况下，主键不包括所有列在分区表达式引用。然而，这两个陈述是有效的：

CREATE TABLE t7 (
    col1 INT NOT NULL,
    col2 DATE NOT NULL,
    col3 INT NOT NULL,
    col4 INT NOT NULL,
    PRIMARY KEY(col1, col2)
)
PARTITION BY HASH(col1 + YEAR(col2))
PARTITIONS 4;

CREATE TABLE t8 (
    col1 INT NOT NULL,
    col2 DATE NOT NULL,
    col3 INT NOT NULL,
    col4 INT NOT NULL,
    PRIMARY KEY(col1, col2, col4),
    UNIQUE KEY(col2, col1)
)
PARTITION BY HASH(col1 + YEAR(col2))
PARTITIONS 4;

如果表没有唯一键，这包括没有主键则不在此限，你可以使用分区表达的任何列只要列式与分区类型兼容。

出于同样的原因，你不能在以后添加一个独特的关键分区表除非主要包括表的分区表达式中使用的所有列。考虑分区表创建如下所示：

mysql> CREATE TABLE t_no_pk (c1 INT, c2 INT)
    ->     PARTITION BY RANGE(c1) (
    ->         PARTITION p0 VALUES LESS THAN (10),
    ->         PARTITION p1 VALUES LESS THAN (20),
    ->         PARTITION p2 VALUES LESS THAN (30),
    ->         PARTITION p3 VALUES LESS THAN (40)
    ->     );
Query OK, 0 rows affected (0.12 sec)

它可以添加一个主键t_no_pk使用这些ALTER TABLE声明:

可能的ALTER TABLE t_no_pk ADD PRIMARY KEY(c1);查询行，0行受影响（0.13秒）记录：0份：0警告：0 #降本pkmysql >ALTER TABLE t_no_pk DROP PRIMARY KEY;查询行，0行受影响（0.10秒）记录：0份：0警告：0 #使用另一个可能的pkmysql >ALTER TABLE t_no_pk ADD PRIMARY KEY(c1, c2);查询行，0行受影响（0.12秒）记录：0份：0警告：0 #降本pkmysql >ALTER TABLE t_no_pk DROP PRIMARY KEY;查询行，0行受影响（0.09秒）记录：0份：0警告：0

然而，接下来的语句失败，因为c1是分区键的一部分，但不是该主键的一部分：

#失败与错误1503mysql >ALTER TABLE t_no_pk ADD PRIMARY KEY(c2);错误1503（hy000）：主键必须包括表中的所有列的分区函数

自t_no_pk只有C1在其划分的表达，试图添加一个独特的关键c2一个人失败。然而，你可以添加一个独特的关键，同时使用C1和c2

这些规则也适用于现有的非分区表，你希望的分区使用ALTER TABLE ... PARTITION BY。考虑一个表np_pk创建如下所示：

mysql> CREATE TABLE np_pk (
    ->     id INT NOT NULL AUTO_INCREMENT,
    ->     name VARCHAR(50),
    ->     added DATE,
    ->     PRIMARY KEY (id)
    -> );
Query OK, 0 rows affected (0.08 sec)

以下ALTER TABLE语句失败与错误，因为补充柱不是表中的任何独特的关键部分：

mysql> ALTER TABLE np_pk
    ->     PARTITION BY HASH( TO_DAYS(added) )
    ->     PARTITIONS 4;
ERROR 1503 (HY000): A PRIMARY KEY must include all columns in the table's partitioning function

然而，这一声明中使用id为分区列列是有效的，如下所示：

MySQL的>ALTER TABLE np_pk->PARTITION BY HASH(id)->PARTITIONS 4;查询行，0行受影响（0.11秒）记录：0份：0警告：0

在的情况下np_pk，只有柱可作为分区表达式的一部分身份证件；如果你希望进行分区表使用的任何其他列在分区表达式，你必须先修改表，通过添加所需的列或列的主键，或删除主键共。

在MySQL 5.0，分区的支持是不实际的MySQL服务器提供的，而是由一个表存储引擎自身或本地分区处理。在MySQL 8中，只有InnoDB存储引擎提供了本地分区处理。这意味着分区表不能使用任何其他存储引擎创建的。

ALTER TABLE ... OPTIMIZE PARTITION没有分区表，使用正确的工作InnoDB。使用ALTER TABLE ... REBUILD PARTITION和修改表…分析分区，相反，这样的表。有关更多信息，参见第13.1.8.1，“修改表分区操作”

partitioned表1。执行升级时，表分区的KEY必须抛弃和重装上阵。分区使用存储引擎的表以外的InnoDB不能从MySQL 5.7或更早版本升级到MySQL 8或更高版本；必须删除该分区表ALTER TABLE ... REMOVE PARTITIONING或将其转换为InnoDB使用ALTER TABLE ... ENGINE=INNODB在升级之前

有关转换MyISAM表InnoDB，看到第15.8.1.4”转换表，从MyISAM到InnoDB”

本节讨论MySQL分区专门用于划分表达功能的局限性。

只有MySQL功能显示在以下列表中的表达式允许分区：

在MySQL 8中，分区修剪是支持的TO_DAYS()，TO_SECONDS()，YEAR()，和UNIX_TIMESTAMP()功能.看到22.4节，“分区修剪”为更多的信息

ceiling()和floor()。这些函数返回一个整数，如果它是通过一个精确数字类型的参数，如其中的一个INT类型或DECIMAL。这意味着，例如，如下CREATE TABLE语句失败与错误，如下所示：

MySQL的>CREATE TABLE t (c FLOAT) PARTITION BY LIST( FLOOR(c) )(->PARTITION p0 VALUES IN (1,3,5),->PARTITION p1 VALUES IN (2,4,6)->);错误1490（hy000）：分区函数返回类型错误

与周extract()函数说明符。通过返回的值EXTRACT()功能，使用时EXTRACT(WEEK FROM col)，取决于你的价值default_week_format系统变量。for this reason，EXTRACT()是不允许一个分区函数时指定单位周。（错误# 54483）

看到部分可以声明为任意类型，“数学函数”，关于这些函数的返回类型的更多信息，以及11.2节，“数字类型”