按范围分区的表的分区方式是每个分区包含分区表达式值位于给定范围内的行。 范围应该是连续的但不重叠，并使用 VALUES LESS THAN 运算符 定义 。 对于接下来的几个示例，假设您要创建一个表，如下所示，以保存20个视频商店链的人事记录，编号为1到20：

CREATE TABLE员工（
    id INT NOT NULL，
    fname VARCHAR（30），
    lname VARCHAR（30），
    雇用DATE NOT NULL DEFAULT'1970-01-01'，
    分隔DATE NOT NULL DEFAULT'9999-12-31'，
    job_code INT NOT NULL，
    store_id INT NOT NULL
）;

根据您的需要，可以通过多种方式按范围对此表进行分区。 一种方法是使用该 store_id 列。 例如，您可能决定通过添加 PARTITION BY RANGE 如下所示 的 子句 来对表4进行分区 ：

CREATE TABLE员工（
    id INT NOT NULL，
    fname VARCHAR（30），
    lname VARCHAR（30），
    雇用DATE NOT NULL DEFAULT'1970-01-01'，
    分隔DATE NOT NULL DEFAULT'9999-12-31'，
    job_code INT NOT NULL，
    store_id INT NOT NULL
）
PAR BY BY RANGE（store_id）（
    分区p0值小于（6），
    分区p1值小于（11），
    分区p2值小于（16），
    分区p3值低于（21）
）;

在该分区方案中，对应于在商店1到5工作的雇员的所有行存储在分区中 p0 ，对于在商店6到10中使用的那些行存储在分区中 p1 ，等等。 每个分区按从低到高的顺序定义。 这是 PARTITION BY RANGE 语法 的要求 ; if ... elseif ... 在这方面， 你可以认为它类似于 C或Java中 的一系列 语句。

这是很容易确定包含数据的新行 (72, 'Mitchell', 'Wilson', '1998-06-25', NULL, 13) 插入分区 p2 ，但是当你的链增加了21会发生什么 ^ST 店？ 在此方案下，没有规则覆盖 store_id 大于20 的行 ，因此导致错误，因为服务器不知道将其放置在何处。 您可以通过 在 语句中 使用 “ catchall ” VALUES LESS THAN 子句 来防止这种情况发生 ，该 CREATE TABLE 语句提供的所有值都大于显式命名的最高值：

CREATE TABLE员工（
    id INT NOT NULL，
    fname VARCHAR（30），
    lname VARCHAR（30），
    雇用DATE NOT NULL DEFAULT'1970-01-01'，
    分隔DATE NOT NULL DEFAULT'9999-12-31'，
    job_code INT NOT NULL，
    store_id INT NOT NULL
）
PAR BY BY RANGE（store_id）（
    分区p0值小于（6），
    分区p1值小于（11），
    分区p2值小于（16），
    PARTITION p3值比MAXVALUE低
）;

（与本章中的其他示例一样，我们假设默认存储引擎是 InnoDB 。）

MAXVALUE 表示一个整数值，该值始终大于最大可能的整数值（在数学语言中，它用作 最小上限 ）。 现在， store_id 列值大于或等于16（定义的最高值）的 任何行都 存储在分区中 p3 。 在未来的某个时刻 - 当商店数量增加到25个，30个或更多时 - 您可以使用 ALTER TABLE 语句为商店21-25,26-30等添加新分区（参见 第23.3节， “分区管理” ，有关如何执行此操作的详细信息。

以同样的方式，您可以根据员工职务代码对表进行分区 - 即基于 job_code 列值的 范围 。 例如 - 假设两位数的工作代码用于常规（店内）工作人员，三位数代码用于办公室和支持人员，四位数代码用于管理职位 - 您可以创建分区表使用以下声明：

CREATE TABLE员工（
    id INT NOT NULL，
    fname VARCHAR（30），
    lname VARCHAR（30），
    雇用DATE NOT NULL DEFAULT'1970-01-01'，
    分隔DATE NOT NULL DEFAULT'9999-12-31'，
    job_code INT NOT NULL，
    store_id INT NOT NULL
）
按范围划分（job_code）（
    分区p0值小于（100），
    分区p1值小于（1000），
    分区p2值小于（10000）
）;

在这种情况下，与店内工人相关的所有行都将存储在分区中 p0 ，与办公室和支持人员 p1 相关的行以及与分区中的管理人员相关的行 p2 。

也可以在 VALUES LESS THAN 子句中 使用表达式 。 但是，MySQL必须能够将表达式的返回值作为 LESS THAN （ < ）比较的 一部分进行评估 。

您可以使用基于两 DATE 列 中的一 列 的表达式，而不是根据商店编号拆分表数据 。 例如，假设您希望根据每个员工离开公司的年份进行分区; 也就是说，的价值 YEAR(separated) 。 CREATE TABLE 此处显示了实现此类分区方案 的 语句 示例 ：

CREATE TABLE员工（
    id INT NOT NULL，
    fname VARCHAR（30），
    lname VARCHAR（30），
    雇用DATE NOT NULL DEFAULT'1970-01-01'，
    分隔DATE NOT NULL DEFAULT'9999-12-31'，
    job_code INT，
    store_id INT
）
按比例分区（年份（分开））（
    分数p0值低于（1991），
    分区p1值低于（1996），
    分区p2值低于（2001），
    PARTITION p3值比MAXVALUE低
）;

在这个方案中，对于1991年之前离开的所有员工，行存储在分区中 p0 ; 对于那些谁留在1991年至1995年，在 p1 ; 对于那些谁留在1996年年内至2000年，在 p2 ; 以及在2000年之后离开的任何工人 p3 。

也可以 使用 函数根据 列 RANGE 的值对 表进行分区 ，如下例所示： TIMESTAMP UNIX_TIMESTAMP()

CREATE TABLE quarterly_report_status（
    report_id INT NOT NULL，
    report_status VARCHAR（20）NOT NULL，
    report_updated TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
）
PARTITION BY RANGE（UNIX_TIMESTAMP（report_updated））（
    PARTITION p0 VALUE少于（UNIX_TIMESTAMP（'2008-01-01 00:00:00'）），
    PARTITION p1 VALUE少于（UNIX_TIMESTAMP（'2008-04-01 00:00:00'）），
    PARTITION p2 VALUE少于（UNIX_TIMESTAMP（'2008-07-01 00:00:00'）），
    PARTITION p3 VALUES比（UNIX_TIMESTAMP（'2008-10-01 00:00:00'）），
    PARTITION p4 VALUES少于（UNIX_TIMESTAMP（'2009-01-01 00:00:00'）），
    PARTITION p5 VALUES比（UNIX_TIMESTAMP（'2009-04-01 00:00:00'）），
    PARTITION p6 VALUES（UNIX_TIMESTAMP（'2009-07-01 00:00:00'）），
    PARTITION p7 VALUES少于（UNIX_TIMESTAMP（'2009-10-01 00:00:00'）），
    PARTITION p8 VALUE少于（UNIX_TIMESTAMP（'2010-01-01 00:00:00'）），
    分区p9值小于（MAXVALUE）
）;

TIMESTAMP 不允许 涉及 值的 任何其他表达式 。 （参见Bug＃42849。）

当满足以下一个或多个条件时，范围分区特别有用：

这种分区的一种变体是 RANGE COLUMNS 分区。 通过分区， RANGE COLUMNS 可以使用多列来定义分区范围，这些分区范围既适用于分区中行的放置，也适用于在执行分区修剪时确定包含或排除特定分区。 有关 更多信息 ， 请参见 第23.2.3.1节“RANGE COLUMNS分区” 。

基于时间间隔的分区方案。  如果您希望在MySQL 8.0中基于时间范围或时间间隔实现分区方案，您有两种选择：

MySQL中的列表分区在很多方面类似于范围分区。 与分区依据一样 RANGE ，必须明确定义每个分区。 两种类型的分区之间的主要区别在于，在列表分区中，每个分区是根据一组值列表中的一个列值中的列值的成员资格来定义和选择的，而不是在一组连续范围中的一个中定义和选择的。值。 这是通过使用 where 值是列值或基于列值的表达式并返回整数值，然后通过a定义每个分区来完成的 ，其中 是逗号分隔的整数列表。 PARTITION BY LIST(expr) expr VALUES IN (value_list) value_list

与范围定义的分区的情况不同，列表分区不需要以任何特定顺序声明。 有关更详细的语法信息，请参见 第13.1.20节“CREATE TABLE语法” 。

对于下面的示例，我们假设要分区的表的基本定义由 CREATE TABLE 此处显示 的 语句 提供 ：

CREATE TABLE员工（
    id INT NOT NULL，
    fname VARCHAR（30），
    lname VARCHAR（30），
    雇用DATE NOT NULL DEFAULT'1970-01-01'，
    分隔DATE NOT NULL DEFAULT'9999-12-31'，
    job_code INT，
    store_id INT
）;

（这是用作 第23.2.1节“RANGE分区”中 示例的基础的表 。与其他分区示例一样，我们假设 default_storage_engine 是 InnoDB 。）

假设在4个特许经营店中分布有20个视频商店，如下表所示。

要对属于同一区域的存储的行存储在同一分区中的方式对此表进行分区，可以使用 CREATE TABLE 此处显示 的 语句：

CREATE TABLE员工（
    id INT NOT NULL，
    fname VARCHAR（30），
    lname VARCHAR（30），
    雇用DATE NOT NULL DEFAULT'1970-01-01'，
    分隔DATE NOT NULL DEFAULT'9999-12-31'，
    job_code INT，
    store_id INT
）
PARISTION BY LIST（store_id）（
    （3,5,6,9,17）中的分区值，
    （1,2,10,11,19,20）中的分区值，
    （4,12,13,14,18）中的分区值（PYest VALUES）
    分配中心价值（7,8,15,16）
）;

这样可以轻松地将与特定区域相关的员工记录添加到表中或从表中删除。 例如，假设西部地区的所有商店都出售给另一家公司。 在MySQL 8.0中，可以使用查询删除与在该区域中的商店工作的员工相关的所有行，该查询 ALTER TABLE employees TRUNCATE PARTITION pWest 可以比等效 DELETE 语句 更有效地执行 DELETE FROM employees WHERE store_id IN (4,12,13,14,18); 。 （使用 ALTER TABLE employees DROP PARTITION pWest 也会删除所有这些行，但也会 pWest 从表的定义中 删除分区 ;您需要使用 ALTER TABLE ... ADD PARTITION 语句来恢复表的原始分区方案。）

与 RANGE 分区一样，可以将 LIST 分区与散列或密钥分区 相结合 ，以产生复合分区（子分区）。 请参见 第23.2.6节“子分区” 。

与 RANGE 分区 的情况不同 ，没有 “ 全能 ”， 例如 MAXVALUE ; 分区表达式的所有期望值都应包含在 PARTITION ... VALUES IN (...) 子句中。 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)
    - >);
查询OK，0行受影响（0.11秒）

mysql> ERROR 1525（HY000）：表没有值为3的分区INSERT INTO h2 VALUES (3, 5);

当使用单个 INSERT 语句 将多个行插入 单个 InnoDB 表时，请 InnoDB 将该语句视为单个事务，以便存在任何不匹配的值会导致语句完全失败，因此不会插入任何行。

您可以使用 IGNORE 关键字 忽略此类错误 。 如果这样做，则不会插入包含不匹配的分区列值的行，但 会 插入 具有匹配值的任何行 ，并且不会报告任何错误：

MySQL的> TRUNCATE h2;
查询正常，1行受影响（0.00秒）

MySQL的> SELECT * FROM h2;
空集（0.00秒）

MySQL的> INSERT IGNORE INTO h2 VALUES (2, 5), (6, 10), (7, 5), (3, 1), (1, 9);
查询OK，3行受影响（0.00秒）
记录：5个重复：2个警告：0

MySQL的> SELECT * FROM h2;
+ ------ + ------ +
| c1 | c2 |
+ ------ + ------ +
| 7 | 5 |
| 1 | 9 |
| 2 | 5 |
+ ------ + ------ +
3组（0.00秒）

MySQL 8.0还提供对 LIST COLUMNS 分区的 支持， 分区是一种 LIST 分区 变体， 它允许您使用除整数类型之外的类型列来分区列，并使用多个列作为分区键。 有关更多信息，请参见 第23.2.3.2节“列表列分区” 。

接下来的两节讨论 COLUMNS 分区 ，它们是变体 RANGE 和 LIST 分区。 COLUMNS 分区允许在分区键中使用多个列。 所有这些列都被考虑在内，以便在分区中放置行，以及确定在分区修剪中检查哪些分区的匹配行。

此外， RANGE COLUMNS 分区和 LIST COLUMNS 分区都支持使用非整数列来定义值范围或列表成员。 允许的数据类型显示在以下列表中：

在接下来的两节中 讨论 RANGE COLUMNS 和 LIST COLUMNS 分区假设您已经熟悉MySQL 5.1及更高版本支持的基于范围和列表的分区; 有关这些的更多信息，请分别参见 第23.2.1节“RANGE分区” 和 第23.2.2节“LIST分区” 。

table_name
由RANGE COLUMNS（column_list）划分的创建表（）
    分区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)
    - >);
查询OK，0行受影响（0.15秒）

CREATE TABLE r1（
    一个INT，
    b INT
）
按范围划分（a）（
    分区p0值小于（5），
    分区p1值小于（MAXVALUE）
）;

MySQL的> INSERT INTO r1 VALUES (5,10), (5,11), (5,12);
查询OK，3行受影响（0.00秒）
记录：3个重复：0个警告：0

mysql> SELECT PARTITION_NAME,TABLE_ROWS
    - >      FROM INFORMATION_SCHEMA.PARTITIONS
    - >     WHERE TABLE_NAME = 'r1';
+ ---------------- + ------------ +
| PARTITION_NAME | TABLE_ROWS |
+ ---------------- + ------------ +
| p0 | 0 |
| p1 | 3 |
+ ---------------- + ------------ +
2行（0.00秒）

CREATE TABLE rc1（
    一个INT，
    b INT
）
按范围栏划分（a，b）（
    分区p0值小于（5,12），
    PARTITION p3值小于（MAXVALUE，MAXVALUE）
）;

MySQL的> INSERT INTO rc1 VALUES (5,10), (5,11), (5,12);
查询OK，3行受影响（0.00秒）
记录：3个重复：0个警告：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行（0.00秒）

MySQL的> 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排（0.00秒）

选择行（5,10）<行（5,12），行（5,11）<行（5,12），行（5,12）<行（5,12）;

CREATE TABLE rx（
    一个INT，
    b INT
）
按范围栏划分（a）（
    分区p0值小于（5），
    分区p1值小于（MAXVALUE）
）;

MySQL的> INSERT INTO rx VALUES (5,10), (5,11), (5,12);
查询OK，3行受影响（0.00秒）
记录：3个重复：0个警告：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行（0.00秒）

CREATE TABLE rc2（
    一个INT，
    b INT
）
按范围栏划分（a，b）（
    分区p0值小于（0,10），
    分区p1值小于（10,20），
    分区p2值小于（10,30），
    PARTITION p3值小于（MAXVALUE，MAXVALUE）
 ）;

CREATE TABLE rc3（
    一个INT，
    b INT
）
按范围栏划分（a，b）（
    分区p0值小于（0,10），
    分区p1值小于（10,20），
    分区p2值小于（10,30），
    分区p3值低于（10,35），
    分区p4值不到（20,40），
    PARTITION p5值小于（MAXVALUE，MAXVALUE）
 ）;

CREATE TABLE rc4（
    一个INT，
    b INT，
    c INT
）
按范围栏划分（a，b，c）（
    分区p0值小于（0,25,50），
    分区p1值小于（10,20,100），
    分区p2值小于（10,30,50）
    PARTITION p3值小于（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排（0.00秒）

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)
    - >   ERROR 1493（HY000）：VALUES值必须严格增加每个分区的值);

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排（0.00秒）

CREATE TABLE员工（
    id INT NOT NULL，
    fname VARCHAR（30），
    lname VARCHAR（30），
    雇用DATE NOT NULL DEFAULT'1970-01-01'，
    分隔DATE NOT NULL DEFAULT'9999-12-31'，
    job_code INT NOT NULL，
    store_id INT NOT NULL
）;

CREATE TABLE employees_by_lname（
    id INT NOT NULL，
    fname VARCHAR（30），
    lname VARCHAR（30），
    雇用DATE NOT NULL DEFAULT'1970-01-01'，
    分隔DATE NOT NULL DEFAULT'9999-12-31'，
    job_code INT NOT NULL，
    store_id INT NOT NULL
）
按栏分区（lname）（
    分区p0值小于（'g'），
    分区p1值小于（'m'），
    分区p2值小于（'t'），
    分区p3值小于（MAXVALUE）
）;

ALTER TABLE员工按范围列分区（lname）（
    分区p0值小于（'g'），
    分区p1值小于（'m'），
    分区p2值小于（'t'），
    分区p3值小于（MAXVALUE）
）;

ALTER TABLE员工按范围列分区（租用）（
    分区p0值不到（'1970-01-01'），
    分区p1值低于（'1980-01-01'），
    分区p2值低于（'1990-01-01'），
    分区p3价值低于（'2000-01-01'），
    分区p4价值低于（'2010-01-01'），
    分区p5值小于（MAXVALUE）
）;

CREATE TABLE customers_1（
    first_name VARCHAR（25），
    last_name VARCHAR（25），
    street_1 VARCHAR（30），
    street_2 VARCHAR（30），
    city VARCHAR（15），
    更新日期
）
列表栏（城市）划分（
    PARAGETION 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），
    更新日期
）
列表栏划分（续期）（
    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），
    更新日期
）
按范围栏划分（续期）（
    分数pWeek_1的价值低于（'2010-02-09'），
    分数pWeek_2的价值低于（'2010-02-15'），
    分数pWeek_3价值低于（'2010-02-22'），
    分数pWeek_4价值低于（'2010-03-01'）
）;

分区 HASH 主要用于确保在预定数量的分区之间均匀分布数据。 使用范围或列表分区时，必须明确指定应存储给定列值或列值的哪个分区; 通过散列分区，您可以自行决定此决策，并且只需要根据要散列的列值和分区表要分区的分区数指定列值或表达式。

要使用分区对表进行 HASH 分区，必须在 CREATE TABLE 语句后 附加 一个 子句，其中 是一个返回整数的表达式。 这可以只是列的名称，其类型是MySQL的整数类型之一。 此外，您最有可能想要使用 ，其中 是一个正整数，表示要将表分成的分区数。 PARTITION BY HASH (expr) expr PARTITIONS num num

以下语句创建一个在 store_id 列 上使用散列的表， 并分为4个分区：

CREATE TABLE员工（
    id INT NOT NULL，
    fname VARCHAR（30），
    lname VARCHAR（30），
    雇用DATE NOT NULL DEFAULT'1970-01-01'，
    分隔DATE NOT NULL DEFAULT'9999-12-31'，
    job_code INT，
    store_id INT
）
PARASHTION by HASH（store_id）
PARTITIONS 4;

如果不包含 PARTITIONS 子句，则分区数默认为 1 ; 使用 PARTITIONS 后面没有数字 的 关键字会导致语法错误。

您还可以使用返回整数的SQL表达式 expr 。 例如，您可能希望根据雇用员工的年份进行分区。 这可以如下所示完成：

CREATE TABLE员工（
    id INT NOT NULL，
    fname VARCHAR（30），
    lname VARCHAR（30），
    雇用DATE NOT NULL DEFAULT'1970-01-01'，
    分隔DATE NOT NULL DEFAULT'9999-12-31'，
    job_code INT，
    store_id INT
）
哈希分居（年（雇用））
PARTITIONS 4;

expr 必须返回非常量非随机整数值（换句话说，它应该是变化的但是确定性的），并且不得包含 第23.6节“分区的限制和限制”中 所述的任何禁止的构造 。 您还应该记住，每次插入或更新（或可能删除）行时都会评估此表达式; 这意味着非常复杂的表达式可能会导致性能问题，尤其是在执行一次影响大量行的操作（例如批量插入）时。

最有效的散列函数是在单个表列上操作的函数，其值随列值一致地增加或减少，因为这允许 在分区范围上 “ 修剪 ” 。 也就是说，表达式越接近它所基于的列的值，MySQL就越有效地使用表达式进行散列分区。

例如，where date_col 是一个类型的列 DATE ，然后表达式 TO_DAYS(date_col) 直接与值的 date_col 变化，因为对于 值的 每个变化， date_col 表达式的值以一致的方式变化。 表达式 YEAR(date_col) 相对于 的方差 date_col 并不像那样直接 TO_DAYS(date_col) ，因为并非所有可能的变化都会 date_col 产生相应的变化 YEAR(date_col) 。 即使这样， YEAR(date_col) 也是散列函数的一个很好的候选者，因为它直接与一部分有所不同， date_col 并且没有可能的变化 date_col 这会产生不成比例的变化 YEAR(date_col) 。

相比之下，假设您有一个名为 int_col 其类型 的列 INT 。 现在考虑表达式 POW(5-int_col,3) + 6 。 这对于散列函数来说是一个糟糕的选择，因为值的变化 int_col 不能保证表达式值的比例变化。 改变的值 int_col 由给定的量可以产生在表达式的值差异很大的变化。 例如，改变 int_col 从 5 对 6 产生的变化 -1 表达式的值，但改变的值 int_col ，从 6 对 7 产生的变化 -7 在表达式中。

换句话说，列值与表达式值的关系曲线越接近直线，如等式所示 ，其中 某些非零常数，表达式适合散列越好。 这与表达式越非线性的事实有关，它倾向于产生的分区之间的数据分布越不均匀。 y=cx c

理论上，对于涉及多个列值的表达式，修剪也是可能的，但是确定哪个表达式是合适的可能是非常困难和耗时的。 因此，不特别推荐使用涉及多列的散列表达式。

当 PARTITION BY HASH 被使用时，存储引擎确定哪个分区 num 分区使用基于表达式的结果的模量。 换句话说，对于给定的表达式 expr ，存储记录的分区是分区号 N ，其中 。 假设该表 定义如下，因此它有4个分区： N = MOD(expr, num) t1

CREATE TABLE t1（col1 INT，col2 CHAR（5），col3 DATE）
    哈希分区（年份（col3））
    PARTITIONS 4;

如果您在 t1 其 col3 值中 插入记录 '2005-09-15' ，则存储它的分区将按如下方式确定：

MOD（YEAR（ '2005-09-01'），4）
= MOD（2005,4）
= 1

MySQL 8.0还支持 HASH 称为 线性散列 的 分区 变体， 它使用更复杂的算法来确定插入分区表中的新行的位置。 有关 此算法的说明， 请参见 第23.2.4.1节“线性哈希分区” 。

每次插入或更新记录时，都会评估用户提供的表达式。 它也可能 - 取决于具体情况 - 在删除记录时进行评估。

CREATE TABLE员工（
    id INT NOT NULL，
    fname VARCHAR（30），
    lname VARCHAR（30），
    雇用DATE NOT NULL DEFAULT'1970-01-01'，
    分隔DATE NOT NULL DEFAULT'9999-12-31'，
    job_code INT，
    store_id INT
）
线性哈希分区（年（雇用））
PARTITIONS 4;

CREATE TABLE t1（col1 INT，col2 CHAR（5），col3 DATE）
    线性哈希分区（年份（col3））
    分数6;

V= POWER（2，CEILING（LOG（2,6）））= 8
 N=年（'2003-04-14'）和（8-1）
   = 2003＆7
   = 3

（3> = 6为FALSE：记录存储在分区＃3中）

V= 8
 N=年（'1998-10-19'）和（8-1）
  = 1998年和7年
  = 6

（6> = 6为TRUE：需要额外步骤）

N = 6＆（（8/2） -  1）
  = 6＆3
  = 2

（2> = 6为FALSE：记录存储在分区＃2中）

按密钥分区类似于通过散列进行分区，除了散列分区采用用户定义的表达式之外，密钥分区的散列函数由MySQL服务器提供。 NDB Cluster MD5() 用于此目的; 对于使用其他存储引擎的表，服务器使用自己的内部散列函数，该函数基于与之相同的算法 PASSWORD() 。

语法规则 CREATE TABLE ... PARTITION BY KEY 类似于创建由哈希分区的表的 规则 。 这里列出了主要差异：

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

CREATE TABLE tk（
    col1 INT NOT NULL，
    col2 CHAR（5），
    col3 DATE
）
线性键分区（col1）
PARTITIONS 3;

所述 LINEAR 关键字对相同的效果 KEY 分隔因为它在 HASH 分区，使用权力-的二个一个算法，而不是模运算而导出的分区号。 有关 此算法及其含义的说明， 请参见 第23.2.4.1节“线性HASH分区” 。

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

CREATE TABLE ts（id INT，购买日期）
    按比例分区（年（购买））
    HASH的子公司（TO_DAYS（已购买））
    SUBPARTITIONS 2（
        分数p0值低于（1990），
        分区p1值小于（2000），
        分区p2值小于MAXVALUE
    ）;

表 ts 有3个 RANGE 分区。 这些分区-中的每一个 p0 ， p1 和 p2 -is进一步分成2子分区。 实际上，整个表分为多个 3 * 2 = 6 分区。 但是，由于该 PARTITION BY RANGE 子句 的作用 ，其中前两个仅存储 purchased 列中 值小于1990的那些记录 。

可以对由 RANGE 或 分区的子表进行分区 LIST 。 子 分区 可以使用 HASH 或 KEY 分区。 这也称为 复合分区 。

也可以使用 SUBPARTITION 子句 显式定义子分区， 以指定各个子分区的选项。 例如，创建与 ts 上一个示例中显示 的相同的表的更详细的方式 是：

CREATE TABLE ts（id INT，购买日期）
    按比例分区（年（购买））
    HASH的消息（TO_DAYS（购买））（
        分数p0值低于（1990）（
            SUBPARTITION s0，
            SUBPARTITION s1
        ）
        分区p1值低于（2000）（
            SUBPARTITION s2，
            SUBPARTITION s3
        ）
        分区p2值低于MAXVALUE（
            SUBPARTITION s4，
            SUBPARTITION s5
        ）
    ）;

这里列出了一些注释的句法项：

MySQL中的分区没有什么可以 NULL 作为分区表达式的值 来禁止 ，无论它是列值还是用户提供的表达式的值。 即使允许使用 NULL 表达式的值，否则必须产生一个整数，重要的是要记住，这 NULL 不是一个数字。 MySQL的分区实现视为 NULL 小于任何非 NULL 值，就像那样 ORDER BY 。

这意味着 NULL 不同类型的分区之间的 处理会 有所不同，如果您没有做好准备，可能会产生您不期望的行为。 在这种情况下，我们将在本节中讨论每个MySQL分区类型 NULL 在确定应存储行的分区时 如何处理 值，并为每个分区提供示例。

使用RANGE分区处理NULL。  如果将行插入到由 RANGE 用于确定分区的列值分隔的表中 NULL ，则该行将插入到最低分区中。 在名为的数据库中考虑这两个表 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行（0.00秒）

（有关此表的更多信息，请参见 第25.17节“INFORMATION_SCHEMA PARTITIONS表” 。）现在让我们使用包含 NULL 在用作分区键的列中的 一行的每一个表填充这些表 ，并验证是否插入了行使用一对 SELECT 陈述：

MySQL的> INSERT INTO t1 VALUES (NULL, 'mothra');
查询正常，1行受影响（0.00秒）

MySQL的> INSERT INTO t2 VALUES (NULL, 'mothra');
查询正常，1行受影响（0.00秒）

MySQL的> SELECT * FROM t1;
+ ------ + -------- +
| id | 名字|
+ ------ + -------- +
| NULL | mothra |
+ ------ + -------- +
1排（0.00秒）

MySQL的> SELECT * FROM t2;
+ ------ + -------- +
| id | 名字|
+ ------ + -------- +
| NULL | mothra |
+ ------ + -------- +
1排（0.00秒）

您可以通过重新运行上一个查询 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行（0.01秒）

您还可以通过删除这些分区，然后重新运行 SELECT 语句 来证明这些行存储在每个表的编号最小的分区中 ：

MySQL的> ALTER TABLE t1 DROP PARTITION p0;
查询OK，0行受影响（0.16秒）

MySQL的> ALTER TABLE t2 DROP PARTITION p0;
查询OK，0行受影响（0.16秒）

MySQL的> SELECT * FROM t1;
空集（0.00秒）

MySQL的> SELECT * FROM t2;
空集（0.00秒）

（有关更多信息 ALTER TABLE ... DROP PARTITION ，请参见 第13.1.9节“ALTER TABLE语法” 。）

NULL 也以这种方式处理对使用SQL函数的表达式进行分区。 假设我们使用如下 CREATE TABLE 语句 定义表 ：

CREATE TABLE tndate（
    id INT，
    dt DATE
）
按比例分区（年（dt））（
    分数p0值低于（1990），
    分区p1值小于（2000），
    分区p2值小于MAXVALUE
）;

与其他MySQL函数一样， YEAR(NULL) 返回 NULL 。 用一排 dt 的列值 NULL 被视为虽然分隔表情评估到低于任何其他值的值，因此被插入到分区 p0 。

使用LIST分区处理NULL。  当且仅当使用包含的值列表定义其中一个 分区时，通过 LIST 允许 NULL 值分区的表 NULL 。 与此相反的是， 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)
    - >);
查询OK，0行受影响（0.01秒）

mysql> ERROR 1504（HY000）：表没有值为9的分区INSERT INTO ts1 VALUES (9, 'mothra');


mysql> ERROR 1504（HY000）：表没有值为NULL的分区INSERT INTO ts1 VALUES (NULL, 'mothra');

只能 插入 具有 c1 介于 0 和 之间 的 值的 行 。 落在这个范围之外，就像数字一样 。 我们可以创建表 并 包含值列表 ，如下所示： 8 ts1 NULL 9 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)
    - >);
查询OK，0行受影响（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)
    - >);
查询OK，0行受影响（0.01秒）

在定义分区的值列表时，您可以（并且应该）像处理 NULL 任何其他值一样 对待 。 例如，无论是 VALUES IN (NULL) 和 VALUES IN (1, 4, 7, NULL) 是有效的，因为是 VALUES IN (1, NULL, 4, 7) ， VALUES IN (NULL, 1, 4, 7) 等。 您可以将具有行 NULL 列 c1 到每个表 ts2 和 ts3 ：

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

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

通过发出适当的查询对 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行（0.01秒）

如本节前面所示，您还可以通过删除这些分区然后执行a来验证用于存储行的分区 SELECT 。

使用HASH和KEY分区处理NULL。  NULL 对于由 HASH 或 分区的表，处理方式有所不同 KEY 。 在这些情况下，产生 NULL 值的 任何分区表达式 都被视为其返回值为零。 我们可以通过检查文件系统对创建分区的表的影响 HASH 并使用包含适当值的记录填充它 来验证此行为 。 假设您有一个 使用以下语句创建 的表 th （也在 p 数据库中）：

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

可以使用此处显示的查询查看属于此表的分区：

mysql> SELECT TABLE_NAME，PARTITION_NAME，TABLE_ROWS，AVG_ROW_LENGTH，DATA_LENGTH
     > FROM INFORMATION_SCHEMA.PARTITIONS
     > WHERE TABLE_SCHEMA ='p'和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行（0.00秒）

TABLE_ROWS 对于每个分区为0.现在在 th 其 c1 列值为 NULL 0和0的位置 插入两行 ，并验证是否插入了这些行，如下所示：

MySQL的> INSERT INTO th VALUES (NULL, 'mothra'), (0, 'gigan');
查询正常，1行受影响（0.00秒）

MySQL的> SELECT * FROM th;
+ ------ + --------- +
| c1 | c2 |
+ ------ + --------- +
| NULL | mothra |
+ ------ + --------- +
| 0 | 吉甘|
+ ------ + --------- +
2行（0.01秒）

回想一下，对于任何整数 N ，值 始终为 。 对于由 or 分区的表，将 对此结果进行处理以确定正确的分区为 。 再次 检查 表，我们可以看到两行都插入到分区中 ： NULL MOD N NULL HASH KEY 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行（0.00秒）

通过使用 PARTITION BY KEY 代替 PARTITION BY HASH 表的定义 重复最后一个示例 ，您可以验证 NULL 对于这种类型的分区也被视为0。

以类似的方式处理范围和列表分区的添加和删除，因此我们将在本节中讨论对这两种分区的管理。 有关使用散列或密钥分区的表的信息，请参见 第23.3.2节“HASH和KEY分区的管理” 。

从通过任意分区的表中删除分区 RANGE 或 LIST 可以使用来实现 ALTER TABLE 的发言 DROP PARTITION 选项。 假设你已经创建了一个由范围分区，然后用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)
    - >     );
查询OK，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');
查询OK，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.00秒）

您还可以使用分区选择获取此信息，如下所示：

MySQL的> SELECT * FROM tr PARTITION (p2);
+ ------ + ------------- + ------------ +
| id | 名字| 购买|
+ ------ + ------------- + ------------ +
| 2 | 闹钟| 1997-11-05 |
| 10 | 熔岩灯| 1998-12-25 |
+ ------ + ------------- + ------------ +
2行（0.00秒）

有关 更多信息 ， 请参见 第23.5节“分区选择” 。

要删除命名的分区 p2 ，请执行以下命令：

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

请务必记住， 删除分区时，还会删除该分区中存储的所有数据 。 通过重新运行上一个 SELECT 查询 ，您可以看到这种情况 ：

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

因此，您必须拥有 DROP 表 的 权限才能 ALTER TABLE ... DROP PARTITION 在该表上 执行 。

如果希望在保留表定义及其分区方案的同时删除所有分区中的所有数据，请使用该 TRUNCATE TABLE 语句。 （请参见 第13.1.37节“TRUNCATE TABLE语法” 。）

如果您打算在 不 丢失数据的 情况下 更改表的分区 ，请 ALTER TABLE ... REORGANIZE PARTITION 改用。 参见下面或在 第13.1.9，“ALTER TABLE语法” ，有关的信息 REORGANIZE PARTITION 。

如果现在执行 SHOW CREATE TABLE 语句，则可以看到表的分区组成是如何更改的：

MySQL的> SHOW CREATE TABLE tr\G
*************************** 1。排******************** *******
       表：tr
创建表：CREATE TABLE`tr`（
  `id` int（11）DEFAULT NULL，
  `name` varchar（50）DEFAULT NULL，
  `purchase` date DEFAULT NULL
）ENGINE = InnoDB DEFAULT CHARSET = latin1
/ *！50100按范围划分（年（购买））
（PARTITION p0 VALUES比（1990）ENGINE = InnoDB少，
 分区p1值小于（1995）ENGINE = InnoDB，
 分区p3的价值低于（2005）ENGINE = InnoDB，
 分区p4的价值低于（2010）ENGINE = InnoDB，
 分区p5的价值低于（2015）ENGINE = InnoDB）* /
1排（0.00秒）

当您将新行插入到已更改的表中且 purchased 列值介于 '1995-01-01' 和 '2004-12-31' 包含 之间时 ，这些行将存储在分区中 p3 。 您可以按如下方式验证：

MySQL的> INSERT INTO tr VALUES (11, 'pencil holder', '1995-07-12');
查询正常，1行受影响（0.00秒）

mysql> SELECT * FROM tr WHERE purchased
    - >BETWEEN '1995-01-01' AND '2004-12-31';
+ ------ + ---------------- + ------------ +
| id | 名字| 购买|
+ ------ + ---------------- + ------------ +
| 1 | 桌面组织者| 2003-10-15 |
| 11 | 笔筒| 1995-07-12 |
+ ------ + ---------------- + ------------ +
2行（0.00秒）

MySQL的> ALTER TABLE tr DROP PARTITION p3;
查询正常，0行受影响（0.03秒）

mysql> SELECT * FROM tr WHERE purchased
    - >BETWEEN '1995-01-01' AND '2004-12-31';
空集（0.00秒）