MySQL 5.7 分区修剪

分区修剪
分区修剪背后的核心概念相对简单,可以描述为“不扫描可能没有匹配值的分区 ”。假设你有一个由以下语句定义的分区表t1:

mysql> CREATE TABLE t1 (
    -> fname VARCHAR(50) NOT NULL,
    -> lname VARCHAR(50) NOT NULL,
    -> region_code TINYINT UNSIGNED NOT NULL,
    -> dob DATE NOT NULL
    -> )
    -> PARTITION BY RANGE( region_code ) (
    -> PARTITION p0 VALUES LESS THAN (64),
    -> PARTITION p1 VALUES LESS THAN (128),
    -> PARTITION p2 VALUES LESS THAN (192),
    -> PARTITION p3 VALUES LESS THAN MAXVALUE
    -> );
Query OK, 0 rows affected (0.02 sec)

考虑这样一种情况,您希望从SELECT语句中获得如下结果:

SELECT fname, lname, region_code, dob
FROM t1
WHERE region_code > 125 AND region_code < 130;

很容易看出,应该返回的行都不会出现在p0或p3分区中;也就是说,我们只需要在分区p1和p2中查找匹配的行。这样,查找匹配的行所花费的时 间和精力就比扫描表中的所有分区要少得多。这种“删除”不需要的分区称为剪枝(pruning)。当优化器可以在执行此查询时使用分区修剪时 ,查询的执行速度可以比针对包含相同列定义和数据的未分区表的相同查询快一个数量级。

在对已分区的MyISAM表进行修剪时,不管是否检查分区,都会打开所有分区,这取决于MyISAM存储引擎的设计。这意味着用户必须有足够数量的 文件描述符来覆盖表的所有分区。

此限制不适用于使用其他MySQL存储引擎(如InnoDB)的分区表。

只要WHERE条件可以简化为以下两种情况之一,优化器就可以进行修剪。
.partition_column = constant

.partition_column IN (constant1, constant2, ..., constantN)

在第一种情况下,优化器只是计算给定值的分区表达式,确定哪个分区包含该值,然后只扫描这个分区。在很多情况下,等号可以替换为其他算 术比较,包括< 、>、< =、>=和<>。在WHERE子句中使用BETWEEN的一些查询也可以利用分区修剪。

在第二种情况下,优化器为列表中的每个值计算分区表达式,创建一个匹配分区的列表,然后只扫描这个分区列表中的分区。

MySQL可以对SELECT、DELETE和UPDATE语句进行分区修剪。INSERT语句目前不能被修剪。

修剪也可以应用于短范围,优化器可以将其转换为等效的值列表。例如,在前面的例子中,WHERE子句可以转换为WHERE region_code in(126, 127, 128, 129)。然后,优化器可以确定列表中的前两个值在分区p1中找到,其余两个值在分区p2中找到,并且其他分区不包含相关值,因此 不需要搜索匹配的行。

对于使用范围列或列表列分区的表,如果条件涉及对多个列进行上述类型的比较,优化器还可以执行修剪。

只要分区表达式包含一个等式或一个可以简化为一组等式的范围,或者分区表达式表示一个递增或递减关系,就可以应用这种类型的优化。当分 区表达式使用YEAR()或TO_DAYS()函数时,还可以对在DATE或DATETIME列上分区的表进行剪枝。此外,在MySQL 5.7中,当分区表达式使用
TO_SECONDS()函数。

假设表t2,定义如下,在一个DATE列上分区:

mysql> CREATE TABLE t2 (
    -> fname VARCHAR(50) NOT NULL,
    -> lname VARCHAR(50) NOT NULL,
    -> region_code TINYINT UNSIGNED NOT NULL,
    -> dob DATE NOT NULL
    -> )
    -> PARTITION BY RANGE( YEAR(dob) ) (
    -> PARTITION d0 VALUES LESS THAN (1970),
    -> PARTITION d1 VALUES LESS THAN (1975),
    -> PARTITION d2 VALUES LESS THAN (1980),
    -> PARTITION d3 VALUES LESS THAN (1985),
    -> PARTITION d4 VALUES LESS THAN (1990),
    -> PARTITION d5 VALUES LESS THAN (2000),
    -> PARTITION d6 VALUES LESS THAN (2005),
    -> PARTITION d7 VALUES LESS THAN MAXVALUE
    -> );
Query OK, 0 rows affected (0.02 sec)

以下使用t2的语句可以利用分区修剪:

SELECT * FROM t2 WHERE dob = '1982-06-23';

UPDATE t2 SET region_code = 8 WHERE dob BETWEEN '1991-02-15' AND '1997-04-25';

DELETE FROM t2 WHERE dob >= '1984-06-21' AND dob < = '1999-06-21'

最后一条语句,优化器也可以这样做:
1.找到包含范围下限的分区。
YEAR('1984-06-21')产生值1984,该值在分区d3中找到。

2.找到包含范围高端的分区。
YEAR('1999-06-21')的计算结果为1999,位于分区d5。

3.只扫描这两个分区以及它们之间的任何分区。
在本例中,这意味着只扫描分区d3、d4和d5。剩余的分区可以被安全地忽略(并且被忽略)。

在针对分区表的语句的WHERE条件中引用的无效DATE和DATETIME值将被视为NULL。这意味着像SELECT * FROM partitioned_table WHERE date_column < ‘2008-12-00’这样的查询不返回任何值(见Bug #40972)。 到目前为止,我们只查看了使用范围分区的示例,但是修剪也可以应用于其他分区类型。 考虑一个按列表分区的表,其中分区表达式是递增或递减的,例如这里展示的表t3。(在这个例子中,为了简洁,我们假设region_code列的值 被限制在1到10之间,包括1和10。)

mysql> CREATE TABLE t3 (
    -> fname VARCHAR(50) NOT NULL,
    -> lname VARCHAR(50) NOT NULL,
    -> region_code TINYINT UNSIGNED NOT NULL,
    -> dob DATE NOT NULL
    -> )
    -> PARTITION BY LIST(region_code) (
    -> PARTITION r0 VALUES IN (1, 3),
    -> PARTITION r1 VALUES IN (2, 5, 8),
    -> PARTITION r2 VALUES IN (4, 9),
    -> PARTITION r3 VALUES IN (6, 7, 10)
    -> );
Query OK, 0 rows affected (0.02 sec)

对于SELECT * FROM t3 WHERE region_code BETWEEN 1 AND 3这样的语句,优化器确定在哪些分区中可以找到值1、2和3 (r0和r1),并跳过其余 的分区(r2和r3)

对于按哈希或线性键分区的表,当WHERE子句对分区表达式中使用的列使用简单=关系时,也可以进行分区修剪。考虑这样创建一个表:

mysql> CREATE TABLE t4 (
    -> fname VARCHAR(50) NOT NULL,
    -> lname VARCHAR(50) NOT NULL,
    -> region_code TINYINT UNSIGNED NOT NULL,
    -> dob DATE NOT NULL
    -> )
    -> PARTITION BY KEY(region_code)
    -> PARTITIONS 8;
Query OK, 0 rows affected (0.03 sec)

将列值与常量进行比较的语句可以被修剪:

UPDATE t4 WHERE region_code = 7;

修剪也可以用于短范围,因为优化器可以将这种条件转化为关系。例如,使用前面定义的表t4,可以对下列查询进行剪枝:

SELECT * FROM t4 WHERE region_code > 2 AND region_code < 6;

SELECT * FROM t4 WHERE region_code BETWEEN 3 AND 5;

在这两种情况下,优化器将WHERE子句转换为WHERE region_code In (3, 4, 5)。

只有当范围大小小于分区数量时,才会使用这种优化。想想这个说法:
DELETE FROM t4 WHERE region_code BETWEEN 4 AND 12;

WHERE子句中的范围包含9个值(4、5、6、7、8、9、10、11、12),但是t4只有8个分区。这意味着DELETE语句不能修剪。

当表按按哈希或线性键分区时,剪枝只能用于整型列。例如,下面的语句不能使用剪枝,因为dob是日期列:

SELECT * FROM t4 WHERE dob >= '2001-04-14' AND dob < = '2005-10-15';

但是,如果表的年份存储在INT列中,那么WHERE year_col >= 2001和year_col <= 2005的查询就会被删除。

MySQL 5.7 获取分区信息

获取分区信息
获取有关现有分区的信息,这可以通过多种方式完成。获取此类信息的方法包括:
.使用SHOW CREATE TABLE语句查看创建分区表时使用的分区子句。

.使用SHOW TABLE STATUS语句确定表是否被分区。

.查询INFORMATION_SCHEMA.PARTITIONS表。

.使用EXPLAIN SELECT语句查看给定SELECT使用了哪些分区。

正如本章其他地方所讨论的,SHOW CREATE TABLE在其输出中包含用于创建分区表的PARTITION BY子句。例如:

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 KEY (id)
PARTITIONS 2 */
1 row in set (0.01 sec)

对于已分区表,SHOW TABLE STATUS的输出与未分区表的输出相同,只是Create_options列包含字符串partitioned。Engine列包含表的所有分区 使用的存储引擎的名称。

您还可以从INFORMATION_SCHEMA中获取有关分区的信息,它包含一个PARTITIONS表。

使用EXPLAIN可以确定给定的SELECT查询涉及分区表的哪些分区。EXPLAIN输出中的partitions列列出了将从匹配的分区中查询记录。

假设您创建了一个表trb1,并按如下方式填充:

mysql> CREATE TABLE trb1 (id INT, name VARCHAR(50), purchased DATE)
    -> PARTITION BY RANGE(id)
    -> (
    -> PARTITION p0 VALUES LESS THAN (3),
    -> PARTITION p1 VALUES LESS THAN (7),
    -> PARTITION p2 VALUES LESS THAN (9),
    -> PARTITION p3 VALUES LESS THAN (11)
    -> );
Query OK, 0 rows affected (0.02 sec)

mysql> INSERT INTO trb1 VALUES
    -> (1, 'desk organiser', '2003-10-15'),
    -> (2, 'CD player', '1993-11-05'),
    -> (3, 'TV set', '1996-03-10'),
    -> (4, 'bookcase', '1982-01-10'),
    -> (5, 'exercise bike', '2004-05-09'),
    -> (6, 'sofa', '1987-06-05'),
    -> (7, 'popcorn maker', '2001-11-22'),
    -> (8, 'aquarium', '1992-08-04'),
    -> (9, 'study desk', '1984-09-16'),
    -> (10, 'lava lamp', '1998-12-25');
Query OK, 10 rows affected (0.00 sec)
Records: 10  Duplicates: 0  Warnings: 0

您可以看到在SELECT * FROM trb1;这样的查询中使用了哪些分区,如下所示:

mysql> EXPLAIN SELECT * FROM trb1\G
*************************** 1. row ***************************
           id: 1
  select_type: SIMPLE
        table: trb1
   partitions: p0,p1,p2,p3
         type: ALL
possible_keys: NULL
          key: NULL
      key_len: NULL
          ref: NULL
         rows: 10
     filtered: 100.00
        Extra: NULL
1 row in set, 1 warning (0.00 sec)

在本例中,搜索所有四个分区。然而,当在查询中添加使用分区键的限制条件时,您可以看到只有那些包含匹配值的分区才会被扫描,如下所示:

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: 6
     filtered: 33.33
        Extra: Using where
1 row in set, 1 warning (0.00 sec)

EXPLAIN还提供了使用的键和可能的键的信息:

mysql> ALTER TABLE trb1 ADD PRIMARY KEY (id);
Query OK, 0 rows affected (0.13 sec)
Records: 0  Duplicates: 0  Warnings: 0

mysql> EXPLAIN SELECT * FROM trb1 WHERE id < 5\G
*************************** 1. row ***************************
           id: 1
  select_type: SIMPLE
        table: trb1
   partitions: p0,p1
         type: range
possible_keys: PRIMARY
          key: PRIMARY
      key_len: 4
          ref: NULL
         rows: 4
     filtered: 100.00
        Extra: Using where
1 row in set, 1 warning (0.00 sec)

如果使用EXPLAIN分区来检查针对未分区表的查询,则不会产生错误,但PARTITIONS列的值始终为NULL。EXPLAIN输出的rows列显示表中的总行数 。

MySQL 5.7 分区维护

分区维护
在MySQL 5.7中,许多表和分区维护任务可以使用SQL语句在分区表上执行。

对分区表的维护可以使用CHECK TABLE,OPTIMIZE TABLE, ANALYZE TABLE和REPAIR TABLE,它们支持分区表。

用户可以使用ALTER TABLE的一些扩展来直接在一个或多个分区上执行这种类型的操作,如下所示:
.重建分区。重建分区;这与删除存储在分区中的所有记录,然后重新插入它们具有相同的效果。这对于碎片整理很有用。
例如:

ALTER TABLE t1 REBUILD PARTITION p0, p1;

.优化分区。如果你从一个分区中删除了大量的行,或者你对一个有变长度行(即有VARCHAR、BLOB或TEXT列)的分区表做了很多修改,你可以使 用ALTER TABLE … OPTIMIZE PARTITION以回收任何未使用的空间并整理分区数据文件。
例如:

ALTER TABLE t1 OPTIMIZE PARTITION p0, p1;

在一个给定分区上使用OPTIMIZE PARTITION,等价于在该分区上运行CHECK PARTITION,ANALYZE PARTITION和REPAIR PARTITION。

一些MySQL存储引擎,包括InnoDB,不支持单个分区优化;在这种情况下,ALTER TABLE … OPTIMIZE PARTITION会分析并重建整个表,并发出 适当的警告。(Bug #11751825, Bug #42822)使用ALTER TABLE … REBUILD PARTITION和ALTER TABLE … ANALYZE PARTITION 避免这个问题 。

.分析分区。这将读取并存储分区的键分布。
例如:
ALTER TABLE t1 ANALYZE PARTITION p3;

.修复分区。这将修复损坏的分区。
例如:

ALTER TABLE t1 REPAIR PARTITION p0,p1;

通常,当分区包含重复的键错误时,REPAIR PARTITION会失败。在MySQL 5.7.2及更高版本中,你可以使用ALTER IGNORE TABLE这个选项,在这 种情况下,所有因为重复键而无法移动的行都会从分区中移除(Bug #16900947)。

.检查分区。您可以检查分区是否有错误,其方式与对未分区的表使用CHECK TABLE的方式大致相同。
例如:

ALTER TABLE trb3 CHECK PARTITION p1;

这个命令将告诉您表t1的分区p1中的数据或索引是否损坏。如果是这种情况,请使用ALTER TABLE…REPAIR PARTITION修复分区。

正常情况下,当分区包含重复的键错误时,CHECK PARTITION会失败。在MySQL 5.7.2及更高版本中,你可以使用ALTER IGNORE TABLE这个选项, 在这种情况下,该语句将返回发现违反重复键的分区中每一行的内容。只报告表的分区表达式中列的值。(错误# 16900947)
刚才显示的列表中的每个语句还支持关键字ALL来代替分区名称列表。使用ALL会导致语句作用于表中的所有分区。

mysqlcheck和myisamchk对分区表不支持。

在MySQL 5.7中,你也可以使用ALTER TABLE … TRUNCATE PARTITION。这条语句可以用来删除一个或多个分区中的所有行,其方式与TRUNCATE TABLE删除表中的所有行差不多。

ALTER TABLE…TRUNCATE PARTITION ALL截断表中的所有分区。

MySQL 5.7 用非分区表交换子分区

用非分区表交换子分区
你也可以执行ALTER TABLE … EXCHANGE PARTITION语句使用一个未分区表来交换一个已分区表的子分区。在下面的例子中,我们首先创建一个 表es,它按范围分区,并按键进行子分区,然后像对表e那样填充这个表,然后创建一个空的、无分区的表es2副本,如下所示:

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 (0.03 sec)

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

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

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

尽管在创建表时我们没有显式地命名任何子分区,但是我们可以通过查询INFORMATION_SCHEMA。PARTITIONS表的UBPARTITION_NAME来获得这些生 成的名称,如下所示:

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与未分区表es2交换:

mysql> ALTER TABLE es EXCHANGE PARTITION p3sp0 WITH TABLE es2;
Query OK, 0 rows affected (0.01 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.01 sec)

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

如果一个表被子分区了,你只能用一个未分区的表交换表的子分区,而不是整个分区,如下所示:

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

MySQL使用的表结构的比较是非常严格的。分区表和非分区表的列和索引的数量、顺序、名称和类型必须完全匹配。另外,两个表必须使用相同 的存储引擎:

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

mysql> ALTER TABLE es3 REMOVE PARTITIONING;
Query OK, 0 rows affected (0.03 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.01 sec)


mysql> ALTER TABLE es3 ENGINE = MyISAM;
Query OK, 0 rows affected (0.01 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

MySQL 5.7 用非分区表交换分区

用表交换分区和子分区
在MySQL 5.7中,可以使用ALTER table pt exchange partition p with table nt来交换一个表分区或子分区,其中pt是已分区的表,p是要与 未分区的表nt交换的pt的分区或子分区,前提是以下条件成立:
1.表nt本身没有分区。

2.表nt不是一个临时表。

3.表pt和表nt的结构在其他方面是相同的。

4.表nt不包含外键引用,其他表也没有任何外键引用nt。

5.nt中没有行位于p的分区定义边界之外。如果使用了WITHOUT VALIDATION选项,则不适用此条件。在MySQL 5.7.5中增加了[{WITH|WITHOUT} VALIDATION]选项。

除了ALTER TABLE语句通常需要的ALTER、INSERT和CREATE权限外,还必须有DROP权限才能执行ALTER TABLE … EXCHANGE PARTITION。

您还应该注意ALTER TABLE … EXCHANGE PARTITION有以下影响:
.执行ALTER TABLE…EXCHANGE PARTITION不调用分区表或要交换的表上的任何触发器。

.交换表中的AUTO_INCREMENT列将被重置。

.IGNORE关键字对IGNORE关键字对ALTER TABLE…不起作用。交换分区。不起作用。

ALTER TABLE …EXCHANGE PARTITION语句的语法这里给出了,其中pt是已分区表,p是要交换的分区或子分区,nt是要交换的非分区表:
ALTER TABLE pt
EXCHANGE PARTITION p
WITH TABLE nt;

可选地,您可以添加 WITH VALIDATION 或 WITHOUT VALIDATION 子句。当指定 WITHOUT VALIDATION 时,在将分区与非分区表交换时,ALTER TABLE…EXCHANGE PARTITION 操作不会逐行验证,允许数据库管理员承担确保行在分区定义边界内的责任。WITH VALIDATION 是默认行为,无 需显式指定。[{WITH|WITHOUT} VALIDATION] 选项在 MySQL 5.7.5 中添加。

在单个 ALTER TABLE EXCHANGE PARTITION 语句中,只能将一个分区或子分区与一个非分区表进行交换。若要交换多个分区或子分区,请使用多 个 ALTER TABLE EXCHANGE PARTITION 语句。EXCHANGE PARTITION 不能与其他 ALTER TABLE 选项结合使用。分区表所使用的分区和(如适用) 子分区类型可以是 MySQL 5.7 支持的任何类型。

用非分区表交换分区
假设已经创建了一个分区表e,并使用以下SQL语句填充:

mysql> CREATE TABLE e (
    -> id INT NOT NULL,
    -> fname VARCHAR(30),
    -> lname VARCHAR(30)
    -> )
    -> PARTITION BY RANGE (id) (
    -> 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 (0.03 sec)

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

现在我们创建了e的一个未分区副本e2。这可以使用mysql客户端来完成,如下所示:

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

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

你可以通过查询INFORMATION_SCHEMA.PARTITIONS表来查看表e中哪些分区包含了哪些行,如下所示:

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

对于分区后的InnoDB表,在INFORMATION_SCHEMA.PARTITIONS的TABLE_ROWS列中给出行数。只是SQL优化中使用的一个估计值,并不总是精确的。

要将表e中的分区p0与表e2交换,可以使用ALTER TABLE语句:

mysql> ALTER TABLE e EXCHANGE PARTITION p0 WITH TABLE e2;
Query OK, 0 rows affected (0.01 sec)

更准确地说,这条语句会导致在分区中找到的任何行与在表中找到的行进行交换。你可以通过查询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中插入一个新行,通过选择一个id值小于50的列来确保该行存储在分区p0中, 然后通过查询分区表来验证这一点:

mysql> INSERT INTO e VALUES (41, "Michael", "Green");
Query OK, 1 row affected (0.00 sec)

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

现在我们再次使用与之前相同的ALTER table语句将分区p0与表e2交换:

mysql> ALTER TABLE e EXCHANGE PARTITION p0 WITH TABLE e2;
Query OK, 0 rows affected (0.01 sec)

下面查询的输出显示,在发出ALTER TABLE语句之前,存储在分区p0中的表行和存储在表e2中的表行现在交换了位置:

mysql> SELECT * FROM e;
+------+-------+-------+
| id   | fname | lname |
+------+-------+-------+
|   16 | Frank | White |
| 1669 | Jim   | Smith |
|  337 | Mary  | Jones |
| 2005 | Linda | Black |
+------+-------+-------+
4 rows in set (0.01 sec)

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

mysql> SELECT * FROM e2;
+----+---------+-------+
| id | fname   | lname |
+----+---------+-------+
| 41 | Michael | Green |
+----+---------+-------+
1 row in set (0.00 sec)

不匹配的行
您应该记住,在发出ALTER TABLE … EXCHANGE PARTITION语句之前,在未分区的表中找到的任何行必须满足将它们存储在目标分区中的条件; 否则,语句执行失败。要了解这是如何发生的,首先在e2中插入一条超出表e的p0分区定义边界的行。例如,插入一条id列值过大的行;然后, 尝试再次用分区交换表:

mysql> INSERT INTO e2 VALUES (51, "Ellen", "McDonald");
Query OK, 1 row affected (0.00 sec)

mysql> ALTER TABLE e EXCHANGE PARTITION p0 WITH TABLE e2;
ERROR 1737 (HY000): Found a row that does not match the partition

只有WITHOUT VALIDATION选项允许此操作成功:

mysql> ALTER TABLE e EXCHANGE PARTITION p0 WITH TABLE e2 WITHOUT VALIDATION;
Query OK, 0 rows affected (0.01 sec)

当一个分区与包含与分区定义不匹配的行的表交换时,数据库管理员的责任是修复不匹配的行,这可以使用REPAIR TABLE或AALTER TABLE … REPAIR PARTITION.

mysql> select * from e partition(p0);
+----+---------+----------+
| id | fname   | lname    |
+----+---------+----------+
| 41 | Michael | Green    |
| 51 | Ellen   | McDonald |
+----+---------+----------+
2 rows in set (0.00 sec)

mysql> repair table e;
+--------+--------+----------+------------------------+
| Table  | Op     | Msg_type | Msg_text               |
+--------+--------+----------+------------------------+
| test.e | repair | warning  | Moved 1 misplaced rows |
| test.e | repair | status   | OK                     |
+--------+--------+----------+------------------------+
2 rows in set (0.01 sec)

mysql> select * from e partition(p0);
+----+---------+-------+
| id | fname   | lname |
+----+---------+-------+
| 41 | Michael | Green |
+----+---------+-------+
1 row in set (0.00 sec)

不逐行验证的交换分区
为了避免在与有许多行的表交换分区时进行耗时的验证,可以通过向ALTER TABLE … EXCHANGE PARTITION语句追加WITHOUT VALIDATION来跳过 逐行验证步骤。

下面的例子比较了在使用和不使用验证的情况下,用非分区表交换分区时执行时间的差异。分区表(表e)包含两个分区,每个分区有100万行。 删除表e中p0中的行,将p0与一个100万行的未分区表交换。使验证操作耗时0.74秒。相比之下,无验证操作需要0.01秒。

# Create a partitioned table with 1 million rows in each partition
CREATE 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),
);
SELECT COUNT(*) FROM e;
| COUNT(*) |
+----------+
| 2000000  |
+----------+
1 row in set (0.27 sec)
# View the rows in each partition
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)
# Create a nonpartitioned table of the same structure and populate it with 1 million rows
CREATE 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 rows
CREATE 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 e

mysql> DELETE FROM e WHERE id < 1000001;
Query OK, 1000000 rows affected (5.55 sec)
# Confirm that there are no rows in partition p0
mysql> 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 e2
mysql> 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 e
mysql> DELETE FROM e WHERE id < 1000001;
Query OK, 1000000 rows affected (5.55 sec)
# Confirm that there are no rows in partition p0
mysql> 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 e3
mysql> 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修复分区。

MySQL 5.7 管理哈希和键分区

管理哈希和键分区
按哈希或按键分区的表在更改分区设置方面非常相似,两者与按范围或列表分区的表在许多方面有所不同。因此,本节讨论的是对按哈希或按键 分区表的修改。

您不能像从按范围或列表分区的表中删除分区那样,从哈希或按键分区的表中删除分区。但是,你可以使用ALTER TABLE … COALESCE PARTITION语句来合并哈希分区或键分区。假设你有一个包含客户端数据的表,分为12个分区。clients表定义如下:

mysql> CREATE TABLE clients (
    -> id INT,
    -> fname VARCHAR(30),
    -> lname VARCHAR(30),
    -> signed DATE
    -> )
    -> PARTITION BY HASH( MONTH(signed) )
    -> PARTITIONS 12;
Query OK, 0 rows affected (0.07 sec)

要将分区数量从12个减少到8个,请执行以下ALTER TABLE命令:

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

COALESCE同样适用于按HASH、KEY、LINEAR HASH或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.05 sec)
Records: 0  Duplicates: 0  Warnings: 0

COALESCE PARTITION后面的数字是要合并到剩余分区中的分区数量——换句话说,它是要从表中删除的分区数量。

如果您试图删除比表所拥有的更多的分区,则结果是如下所示的错误:

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

将客户端表的分区数量从12增加到18。使用ALTER TABLE … ADD PARTITION来添加分区如下所示:

mysql> ALTER TABLE clients ADD PARTITION PARTITIONS 6;
Query OK, 0 rows affected (0.17 sec)
Records: 0  Duplicates: 0  Warnings: 0

MySQL 5.7 范围和列表分区的管理

范围和列表分区的管理
范围分区和列表分区的添加和删除以类似的方式处理,因此我们将在本节中讨论这两种分区的管理。

从按范围或按列表分区的表中删除分区,可以使用带有DROP PARTITION选项的ALTER TABLE语句来完成。假设你已经创建了一个按范围分区的表 ,然后使用下面的CREATE TABLE和INSERT语句填充了10条记录:

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)
    -> );
Query OK, 0 rows affected (0.03 sec)



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');
Query OK, 10 rows affected (0.00 sec)
Records: 10  Duplicates: 0  Warnings: 0

您可以看到哪些项应该插入到分区p2中,如下所示:

mysql> SELECT * FROM tr WHERE purchased BETWEEN '1995-01-01' AND '1999-12-31';
+------+-------------+------------+
| id   | name        | purchased  |
+------+-------------+------------+
|    2 | alarm clock | 1997-11-05 |
|   10 | lava lamp   | 1998-12-25 |
+------+-------------+------------+
2 rows in set (0.00 sec)

您也可以使用分区选择来获得这些信息,如下所示:

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)

删除名称为“p2”的分区。

mysql> ALTER TABLE tr DROP PARTITION p2;
Query OK, 0 rows affected (0.07 sec)
Records: 0  Duplicates: 0  Warnings: 0

有一点非常重要,要记住,当删除一个分区时,也会删除存储在该分区中的所有数据。通过重新运行上一个SELECT查询,可以看到这一点:

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

因此,在执行ALTER TABLE …DROP PARTITION之前,用户必须对一张表具有DROP权限。

如果希望从所有分区中删除所有数据,同时保留表定义及其分区方案,请使用TRUNCATE TABLE语句。

如果您想在不丢失数据的情况下更改表的分区,请使用ALTER TABLE …REORGANIZE PARTITION。

如果你现在执行SHOW CREATE TABLE语句,你可以看到表的分区组成是如何被改变的:

mysql> SHOW CREATE TABLE tr\G
*************************** 1. row ***************************
       Table: tr
Create Table: CREATE TABLE `tr` (
  `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 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)

当你将购买的列值在‘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.01 sec)
Records: 0  Duplicates: 0  Warnings: 0

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

由于ALTER TABLE … DROP PARTITION操作从表中删除的行数不像同级的DELETE查询那样由服务器报告。

删除列表分区使用与删除范围分区完全相同的ALTER TABLE … DROP PARTITION语法。然而,这对之后使用表的影响有一个重要的区别:你不能 再向表中插入任何包含定义删除分区的值列表中的值的行。

要向已分区的表添加新的范围分区或列表分区,请使用ALTER TABLE … ADD PARTITION语句。对于按范围分区的表,这可以用来在现有分区列 表的末尾添加一个新的范围。假设你有一个包含组织成员数据的分区表,定义如下:

mysql> 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)
    -> );
Query OK, 0 rows affected (0.01 sec)

进一步假设成员的最低年龄为16岁。随着日历临近2015年年底,你意识到你很快就会接纳2000年(及之后)出生的成员。你可以修改成员表以容 纳2000年到2010年出生的新成员,如下所示:

mysql> ALTER TABLE members ADD PARTITION (PARTITION p3 VALUES LESS THAN (2010));
Query OK, 0 rows affected (0.02 sec)
Records: 0  Duplicates: 0  Warnings: 0

对于按范围分区的表,您可以使用ADD PARTITION将新分区仅添加到分区列表的高端。试图在现有分区之间或现有分区之前以这种方式添加新分 区会导致如下错误:

mysql> ALTER TABLE members ADD PARTITION (PARTITION n VALUES LESS THAN (1970));
ERROR 1493 (HY000): VALUES LESS THAN value must be strictly increasing for each partition

您可以通过将第一个分区重新组织为两个新的分区来解决这个问题,这样可以将它们之间的范围分开:

mysql> ALTER TABLE members
    -> REORGANIZE PARTITION p0 INTO (
    -> PARTITION n0 VALUES LESS THAN (1970),
    -> PARTITION n1 VALUES LESS THAN (1980)
    -> );
Query OK, 0 rows affected (0.02 sec)
Records: 0  Duplicates: 0  Warnings: 0

使用SHOW CREATE TABLE可以看到ALTER 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=utf8mb4
/*!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)

你也可以使用ALTER TABLE … ADD PARTITION向按列表分区的表中添加新分区。假设表tt是用下面的CREATE table语句定义的:

mysql> CREATE TABLE tt (
    -> id INT,
    -> data INT
    -> )
    -> PARTITION BY LIST(data) (
    -> PARTITION p0 VALUES IN (5, 10, 15),
    -> PARTITION p1 VALUES IN (6, 12, 18)
    -> );
Query OK, 0 rows affected (0.01 sec)

您可以添加一个新的分区,其中存储数据列值为7,14和21的行,如下所示:

mysql> ALTER TABLE tt ADD PARTITION (PARTITION p2 VALUES IN (7, 14, 21));
Query OK, 0 rows affected (0.00 sec)
Records: 0  Duplicates: 0  Warnings: 0

请记住,不能添加包含现有分区的值列表中已经包含的任何值的新LIST分区。如果你尝试这样做,将会产生一个错误:

mysql> ALTER TABLE tt ADD PARTITION (PARTITION np VALUES IN (4, 8, 12));
ERROR 1495 (HY000): Multiple definition of same constant in list partitioning

因为数据列值为12的任何行都已经分配给了分区p1,所以不能在表tt上创建一个包含12的新分区。为此,可以删除p1,添加np,再创建一个定义 有所修改的p1。但是,如前所述,这将导致存储在p1中的所有数据丢失,而通常情况下这并不是我们真正想要的。另一种解决方案可能是在新的 分区下复制表,然后使用CREATE TABLE … SELECT …,然后删除旧表并重命名新表,但在处理大量数据时,这可能非常耗时。在要求高可用 性的情况下,这可能也是不可行的。

您可以在单个ALTER TABLE中添加多个分区。ADD PARTITION语句如下所示:

mysql> CREATE TABLE employees (
    -> id INT NOT NULL,
    -> fname VARCHAR(50) NOT NULL,
    -> lname VARCHAR(50) NOT NULL,
    -> hired DATE NOT NULL
    -> )
    -> PARTITION BY RANGE( YEAR(hired) ) (
    -> PARTITION p1 VALUES LESS THAN (1991),
    -> PARTITION p2 VALUES LESS THAN (1996),
    -> PARTITION p3 VALUES LESS THAN (2001),
    -> PARTITION p4 VALUES LESS THAN (2005)
    -> );
Query OK, 0 rows affected (0.02 sec)

mysql> ALTER TABLE employees ADD PARTITION (
    -> PARTITION p5 VALUES LESS THAN (2010),
    -> PARTITION p6 VALUES LESS THAN MAXVALUE
    -> );
Query OK, 0 rows affected (0.08 sec)
Records: 0  Duplicates: 0  Warnings: 0

幸运的是,MySQL的分区实现提供了重新定义分区而不会丢失数据的方法。我们首先看几个涉及范围分区的简单例子。回想一下成员表的定义, 如下所示:

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=utf8mb4
/*!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来实现这一点:

mysql> ALTER TABLE members REORGANIZE PARTITION n0 INTO (
    -> PARTITION s0 VALUES LESS THAN (1960),
    -> PARTITION s1 VALUES LESS THAN (1970)
    -> );
Query OK, 0 rows affected (0.02 sec)
Records: 0  Duplicates: 0  Warnings: 0

实际上,该命令将分区p0分成两个新的分区s0和s1。它还根据PARTITION …VALUES …子句所体现的规则,将存储在p0中的数据移动到新的分 区中。,使得s0只包含年份(dob)小于1960的那些记录,s1包含年份(dob)大于或等于1960但小于1970的那些行。

REORGANIZE PARTITION子句也可以用于合并相邻的分区。你可以将前面的语句对members表的影响颠倒过来,如下所示:

mysql> ALTER TABLE members REORGANIZE PARTITION s0,s1 INTO (
    -> PARTITION p0 VALUES LESS THAN (1970)
    -> );
Query OK, 0 rows affected (0.02 sec)
Records: 0  Duplicates: 0  Warnings: 0

使用REORGANIZE PARTITION拆分或合并分区时不会丢失数据。在执行上述语句时,MySQL将存储在分区50和s1中的所有记录移动到分区p0中。

REORGANIZE PARTITION的通用语法如下所示:

ALTER TABLE tbl_name REORGANIZE PARTITION partition_list INTO (partition_definitions);

这里,tbl_name是分区表的名称,而partition_list是一个以逗号分隔的列表,其中包含一个或多个要更改的现有分区的名称。 partition_definitions是一个逗号分隔的新分区定义列表,它遵循与CREATE TABLE中使用的partition_definitions列表相同的规则。在使用 REORGANIZE PARTITION时,您并不局限于将几个分区合并为一个分区,或者将一个分区拆分为多个分区。例如,您可以将members表的所有四个 分区重组为两个,如下所示:

mysql> ALTER TABLE members REORGANIZE PARTITION p0,n1,p1,p2 INTO (
    -> PARTITION m0 VALUES LESS THAN (1980),
    -> PARTITION m1 VALUES LESS THAN (2000)
    -> );
Query OK, 0 rows affected (0.09 sec)
Records: 0  Duplicates: 0  Warnings: 0

您还可以对通过LIST进行分区的表使用REORGANIZE PARTITION。让我们回到向列表分区tt表添加新分区并失败的问题,因为新分区的值已经存在 于一个现有分区的值列表中。我们可以通过添加一个只包含非冲突值的分区来处理这个问题,然后重新组织新分区和现有分区,以便存储在现有 分区中的值现在移动到新分区中:

mysql> ALTER TABLE tt ADD PARTITION (PARTITION np VALUES IN (4, 8));
Query OK, 0 rows affected (0.02 sec)
Records: 0  Duplicates: 0  Warnings: 0


mysql> ALTER TABLE tt REORGANIZE PARTITION p2,np INTO (
    -> PARTITION p2 VALUES IN (7, 14),
    -> PARTITION np VALUES in (4, 8, 21)
    -> );
Query OK, 0 rows affected (0.02 sec)
Records: 0  Duplicates: 0  Warnings: 0

以下是使用ALTER TABLE…REORGANIZE PARTITION对按范围或列表分区的表进行重新分区时需要注意的一些关键点:
.用于确定新分区方案的PARTITION选项遵循与CREATE TABLE语句相同的规则。

一个新的范围分区方案不能有任何重叠的范围;新的列表分区方案不能有任何重叠的值集。

.partition_definitions列表中的分区组合总体上应该与partition_list中命名的组合分区的范围或值集相同。

例如,分区p1和p2一起覆盖了成员表中的1980年到1999年。这两个分区的任何重组都应该覆盖相同的年份范围。

.对于按范围分区的表,可以只重组相邻的分区;您不能跳过范围分区。

例如,不能使用以ALTER TABLE members REORGANIZE PARTITION p0,p2 INTO …开头的语句来重组members表。因为p0包含1970年之前的年份, 而p2包含1990年到1999年的年份,所以它们不是相邻的分区。(在这种情况下不能跳过分区p1。)

.不能使用REORGANIZE PARTITION分区来更改表使用的分区类型;例如,您不能将范围分区更改为散列分区或相反。也不能使用此语句更改分区 表达式或列。要在不删除和重新创建表的情况下完成上述任务,可以使用ALTER TABLE … PARTITION BY …,如下所示:

mysql> ALTER TABLE members
    -> PARTITION BY HASH( YEAR(dob) )
    -> PARTITIONS 8;
Query OK, 0 rows affected (0.04 sec)
Records: 0  Duplicates: 0  Warnings: 0

MySQL5.7 分区如何处理NULL

MySQL分区如何处理NULL
MySQL中的分区并没有禁止NULL作为分区表达式的值,无论是列值还是用户提供的表达式的值。尽管允许使用NULL作为表达式的值,但要记住 NULL不是数字,这一点很重要。MySQL的分区实现将NULL视为小于任何非空值,就像ORDER BY那样。

这意味着不同类型的分区对NULL的处理方式不同,如果你没有做好准备,可能会产生意想不到的行为。在这种情况下,本节将讨论MySQL分区类 型如何处理NULL值,并分别提供示例。

范围分区处理NULL。
如果你将一行插入到一个按范围分区的表中,以便用于确定分区的列值为NULL,那么这一行将插入到最低的分区中。考虑数据库test中的这两张表,创建方法如下:

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
    -> );
Query OK, 0 rows affected (0.02 sec)

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
    -> );
Query OK, 0 rows affected (0.02 sec)

在INFORMATION_SCHEMA数据库中,用户可以使用以下查询来查看这两个CREATE TABLE语句创建的分区:

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

现在让我们在每个表中插入一行包含NULL作为分区键的列,并使用一对SELECT语句验证这些行是否被插入:

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

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

mysql> SELECT * FROM t1;
+------+--------+
| c1   | c2     |
+------+--------+
| NULL | mothra |
+------+--------+
1 row in set (0.00 sec)

mysql> SELECT * FROM t2;
+------+--------+
| c1   | c2     |
+------+--------+
| NULL | mothra |
+------+--------+
1 row in set (0.00 sec)

通过再次对INFORMATION_SCHEMA.PARTITIONS表运行前面的查询,您可以看到哪些分区用于存储插入的行:

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

用户还可以删除这些分区,然后重新运行SELECT语句,证明这些行存储在每个表的最低分区中:

mysql> ALTER TABLE t1 DROP PARTITION p0;
Query OK, 0 rows affected (0.01 sec)
Records: 0  Duplicates: 0  Warnings: 0

mysql> ALTER TABLE t2 DROP PARTITION p0;
Query OK, 0 rows affected (0.07 sec)
Records: 0  Duplicates: 0  Warnings: 0

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

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

对于使用SQL函数的分区表达式,NULL也是这样处理的。假设我们使用CREATE TABLE语句定义一个表,如下所示:

mysql> CREATE TABLE tndate (
    -> id INT,
    -> dt DATE
    -> )
    -> PARTITION BY RANGE( YEAR(dt) ) (
    -> PARTITION p0 VALUES LESS THAN (1990),
    -> PARTITION p1 VALUES LESS THAN (2000),
    -> PARTITION p2 VALUES LESS THAN MAXVALUE
    -> );
Query OK, 0 rows affected (0.01 sec)

与其他MySQL函数一样,YEAR(NULL)返回NULL。dt列值为NULL的行被视为分区表达式的值小于任何其他值,因此被插入到分区p0中。

列表分区处理NULL。
按列表分区的表,当且仅当其中一个分区是用包含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)
    -> );
Query OK, 0 rows affected (0.01 sec)

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

只有c1值在0到8之间(包括0和8)的行才能插入到ts1中。NULL超出了这个范围,就像数字9一样。我们可以创建包含NULL的值列表的表ts2和ts3 ,如下所示:

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)
    -> );
Query OK, 0 rows affected (0.04 sec)

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)
    -> );
Query OK, 0 rows affected (0.02 sec)

在为分区定义值列表时,你可以(也应该)像对待其他值一样对待NULL。例如,(NULL)和(1,4,7,NULL)中的值都是有效的,(1,NULL, 4, 7)、(NULL, 1, 4, 7)等的值也是有效的。你可以在表ts2和ts3中分别插入列c1为NULL的行:

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

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

通过对INFORMATION_SCHEMA.PARTITIONS发出适当的查询。你可以确定哪些分区用于存储刚刚插入的行(和前面的例子一样,我们假设分区表是 在test数据库中创建的):

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

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

哈希和键分区处理NULL。
对于按哈希分区的表,对NULL的处理有些不同。在这些情况下,任何产生NULL值的分区表达式都将被视为其返回值为零。我们可以通过检查创建 按哈希分区的表并使用包含适当值的记录填充表对文件系统的影响来验证这种行为。假设你用下面的语句创建了一个表th(也在test数据库中) :

mysql> CREATE TABLE th (
    -> c1 INT,
    -> c2 VARCHAR(20)
    -> )
    -> PARTITION BY HASH(c1)
    -> PARTITIONS 2;
Query OK, 0 rows affected (0.01 sec)

属于该表的分区可以使用下面的查询来查看:

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

每个分区的TABLE_ROWS为0。现在插入两行,c1列的值分别为NULL和0,并验证这两行是否被插入,如下所示:

mysql> INSERT INTO th VALUES (NULL, 'mothra'), (0, 'gigan');
Query OK, 2 rows affected (0.00 sec)
Records: 2  Duplicates: 0  Warnings: 0

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

mysql>

回想一下,对于任何整数N, NULL MOD N的值总是NULL。对于按哈希或键进行分区的表,将该结果作为确定正确分区的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 = 'test' AND TABLE_NAME='th';
+------------+----------------+------------+----------------+-------------+
| TABLE_NAME | PARTITION_NAME | TABLE_ROWS | AVG_ROW_LENGTH | DATA_LENGTH |
+------------+----------------+------------+----------------+-------------+
| th         | p0             |          2 |           8192 |       16384 |
| th         | p1             |          0 |              0 |       16384 |
+------------+----------------+------------+----------------+-------------+
2 rows in set (0.00 sec)

键分区处理NULL。
对于按键分区的表,对NULL的处理有些不同。在这些情况下,任何产生NULL值的分区表达式都将被视为其返回值为NULL。我们可以通过检查创建 按键分区的表并使用包含适当值的记录填充表对文件系统的影响来验证这种行为。假设你用下面的语句创建了一个表tk(也在test数据库中):

mysql> CREATE TABLE tk (
    -> c1 INT NOT NULL PRIMARY KEY,
    -> c2 VARCHAR(20)
    -> )
    -> PARTITION BY KEY()
    -> PARTITIONS 2;
Query OK, 0 rows affected (0.02 sec)

属于该表的分区可以使用下面的查询来查看:

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

每个分区的TABLE_ROWS为0。现在插入两行,c1列的值分别为NULL和0,并验证这两行是否被插入,如下所示:

mysql> INSERT INTO tk VALUES (NULL, 'mothra'), (0, 'gigan');
ERROR 1048 (23000): Column 'c1' cannot be null

MySQL 5.7 子分区

子分区
子分区(也称为复合分区)是分区表中每个分区的进一步划分。请看下面的CREATE TABLE语句:

mysql> CREATE TABLE ts (id INT, purchased DATE)
    -> PARTITION BY RANGE( YEAR(purchased) )
    -> SUBPARTITION BY HASH( TO_DAYS(purchased) )
    -> SUBPARTITIONS 2 (
    -> PARTITION p0 VALUES LESS THAN (1990),
    -> PARTITION p1 VALUES LESS THAN (2000),
    -> PARTITION p2 VALUES LESS THAN MAXVALUE
    -> );
Query OK, 0 rows affected (0.02 sec)

表ts有3个范围分区。每个分区(p0、p1和p2)又进一步划分为2个子分区。实际上,整个表被分为3 * 2 = 6个分区。但是,由于PARTITION BY RANGE子句的作用,前2个只存储所购列中值小于1990的记录。

在MySQL 5.7中,可以对按范围或列表分区的表进行子分区。子分区可以使用哈希分区或键分区。这也称为复合分区。

也可以使用子分区子句显式定义子分区,为各个子分区指定选项。例如,在前面的例子中,创建相同的表ts的一种更冗长的方式是:

mysql> 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
    -> )
    -> );
Query OK, 0 rows affected (0.03 sec)

下面列出了一些语法注意事项:
.每个分区必须有相同数量的子分区。

.如果您在分区表的任何分区上使用SUBPARTITION显式地定义了任何子分区,则必须定义所有子分区。换句话说,下面的语句会失败:

mysql> CREATE TABLE ts1 (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),
    -> PARTITION p2 VALUES LESS THAN MAXVALUE (
    -> SUBPARTITION s2,
    -> SUBPARTITION s3
    -> )
    -> );
ERROR 1064 (42000): Wrong number of subpartitions defined, mismatch with previous setting near '
PARTITION p2 VALUES LESS THAN MAXVALUE (
SUBPARTITION s2,
SUBPARTITION s3
)
)' at line 8

即使包含SUBPARTITIONS 2子句,这条语句仍然会失败。

.每个子分区子句必须(至少)包含子分区的名称。否则,您可以为子分区设置任何想要的选项,或者允许它假定该选项的默认设置。

.子分区名在整个表中必须是唯一的。例如,下面的CREATE TABLE语句在MySQL 5.7中是有效的:

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
)
);

子分区可以用于特别大的MyISAM表,以便在许多磁盘上分发数据和索引。假设您有6个磁盘挂载为/disk0、/disk1、/disk2等。现在考虑下面的例子:

CREATE TABLE ts (id INT, purchased DATE)
ENGINE = MYISAM
PARTITION BY RANGE( YEAR(purchased) )
SUBPARTITION BY HASH( TO_DAYS(purchased) ) (
PARTITION p0 VALUES LESS THAN (1990) (
SUBPARTITION s0
DATA DIRECTORY = '/disk0/data'
INDEX DIRECTORY = '/disk0/idx',
SUBPARTITION s1
DATA DIRECTORY = '/disk1/data'
INDEX DIRECTORY = '/disk1/idx'
),
PARTITION p1 VALUES LESS THAN (2000) (
SUBPARTITION s2
DATA DIRECTORY = '/disk2/data'
INDEX DIRECTORY = '/disk2/idx',
SUBPARTITION s3
DATA DIRECTORY = '/disk3/data'
INDEX DIRECTORY = '/disk3/idx'
),
PARTITION p2 VALUES LESS THAN MAXVALUE (
SUBPARTITION s4
DATA DIRECTORY = '/disk4/data'
INDEX DIRECTORY = '/disk4/idx',
SUBPARTITION s5
DATA DIRECTORY = '/disk5/data'
INDEX DIRECTORY = '/disk5/idx'
)
);

在这种情况下,为每个RANGE的数据和索引使用一个单独的磁盘。许多其他的变化是可能的;另一个例子可能是:

CREATE TABLE ts (id INT, purchased DATE)
ENGINE = MYISAM
PARTITION BY RANGE(YEAR(purchased))
SUBPARTITION BY HASH( TO_DAYS(purchased) ) (
PARTITION p0 VALUES LESS THAN (1990) (
SUBPARTITION s0a
DATA DIRECTORY = '/disk0'
INDEX DIRECTORY = '/disk1',
SUBPARTITION s0b
DATA DIRECTORY = '/disk2'
INDEX DIRECTORY = '/disk3'
),
PARTITION p1 VALUES LESS THAN (2000) (
SUBPARTITION s1a
DATA DIRECTORY = '/disk4/data'
INDEX DIRECTORY = '/disk4/idx',
SUBPARTITION s1b
DATA DIRECTORY = '/disk5/data'
INDEX DIRECTORY = '/disk5/idx'
),
PARTITION p2 VALUES LESS THAN MAXVALUE (
SUBPARTITION s2a,
SUBPARTITION s2b
)
);

这里,存储如下:
.购买日期在1990年之前的行占用了大量的空间,因此以4种方式拆分,一个单独的磁盘专门用于存储数据和两个子分区(s0a和s0b)的索引,这 两个分区组成了p0分区。换句话说:
子分区s0a的数据存储在/disk0上。

.子分区s0a的数据存储在/disk0上。
.子分区s0a的索引存储在/disk1上。
.子分区s0b的数据存储在/disk2上。
.子分区s0b的索引存储在/disk3上。

.包含从1990年到1999年的日期的行(分区p1)不需要像1990年以前的行那样多的空间。它们被划分为2个磁盘(/disk4和/disk5),而不是像以 前那样存储在p0中的4个磁盘。

.属于p1的第一个子分区(s1a)的数据和索引存储在/disk4中,其中数据存储在/disk4/ Data中,索引存储在/disk4/idx中。
.属于p1的第二个子分区(s1b)的数据和索引存储在/disk5中——数据存储在/disk5/ Data中,索引存储在/disk5/idx中。

.反映2000年至今日期的行(分区p2)所占空间与前两个范围相比都没有那么大。目前,将所有这些都存储在默认位置就足够了。

将来,当从2000年开始的十年的购买数量增长到默认位置不再提供足够的空间时,可以使用ALTER TABLE … REORGANIZE PARTITION语句移动相 应的行。

MySQL 5.7 键分区

键分区
按键分区类似于按哈希分区,不同的是,哈希分区采用了用户定义的表达式,用于键分区的哈希函数由MySQL服务器提供。NDB集群使用MD5() 来实现这个目的。对于使用其他存储引擎的表,服务器使用自己的内部哈希函数,该函数基于与PASSWORD()相同的算法。

CREATE TABLE … PARTITION BY KEY的语法规则类似于按哈希分区的表。主要区别如下:
.使用KEY而不是HASH

.KEY只接受一个包含零个或多个列名的列表。任何用作分区键的列都必须包含表的主键(如果表有主键的话)的一部分或全部。如果没有指定列 名作为分区键,则使用表的主键(如果有主键的话)。例如,下面的CREATE TABLE语句在MySQL 5.7中是有效的:

mysql> CREATE TABLE k1 (
    -> id INT NOT NULL PRIMARY KEY,
    -> name VARCHAR(20)
    -> )
    -> PARTITION BY KEY()
    -> PARTITIONS 2;
Query OK, 0 rows affected (0.01 sec)

如果没有主键,但有一个唯一键,那么这个唯一键用于分区键:

mysql> CREATE TABLE k1 (
    -> id INT NOT NULL,
    -> name VARCHAR(20),
    -> UNIQUE KEY (id)
    -> )
    -> PARTITION BY KEY()
    -> PARTITIONS 2;
Query OK, 0 rows affected (0.01 sec)

但是,如果唯一键列没有定义为not NULL,那么前面的语句将失败。

在这两种情况下,分区键都是id列,尽管它没有显示在SHOW CREATE TABLE的输出中或INFORMATION_SCHEMA.PARTITIONS表的 PARTITION_EXPRESSION列中。

与其他分区类型不同的是,用于按键分区的列并不局限于整数值或NULL值。例如,下面的CREATE TABLE语句是有效的:

mysql> CREATE TABLE tm1 (
    -> s1 CHAR(32) PRIMARY KEY
    -> )
    -> PARTITION BY KEY(s1)
    -> PARTITIONS 10;
Query OK, 0 rows affected (0.04 sec)

如果指定了不同的分区类型,上述语句将无效。(在这种情况下,简单地使用按键分区()也是有效的,并且与按键分区(s1)的效果相同,因 为s1是表的主键。)

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

mysql> CREATE TABLE tk (
    -> col1 INT NOT NULL,
    -> col2 CHAR(5),
    -> col3 DATE
    -> )
    -> PARTITION BY LINEAR KEY (col1)
    -> PARTITIONS 3;
Query OK, 0 rows affected (0.02 sec)

使用LINEAR对键分区的效果与对哈希分区的效果相同,分区数是使用2的幂算法而不是模运算得到的。