Разделение столбцов диапазона подобно разделению диапазона, но позволяет Вам определить разделы, используя диапазоны, основанные на многократных значениях столбцов. Кроме того, можно определить столбцы использования диапазонов типов кроме целочисленных типов.

RANGE COLUMNS разделение отличается значительно от RANGE разделение следующими способами:

Основной синтаксис для того, чтобы составить таблицу, разделенную RANGE COLUMNS показывается здесь:

CREATE TABLE table_namePARTITIONED BY RANGE COLUMNS(column_list) (    PARTITION partition_name VALUES LESS THAN (value_list)[,    PARTITION partition_name VALUES LESS THAN (value_list)][,    ...]) column_list:    column_name[, column_name][, ...]value_list:    value[, value][, ...]

В синтаксисе, только показанном, column_list список одного или более столбцов (иногда названный списком столбцов разделения), и value_list список значений (то есть, это - список значения определения раздела). A value_list должен быть предоставлен для каждого определения раздела, и каждого value_list должен иметь то же самое число значений как column_list имеет столбцы. Вообще говоря, если Вы используете N столбцы в COLUMNS пункт, тогда каждый VALUES LESS THAN пункт должен также быть предоставлен списком N значения.

Элементы в списке столбцов разделения и в списке значения, определяющем каждый раздел, должны произойти в том же самом порядке. Кроме того, каждый элемент в списке значения должен иметь тот же самый тип данных как соответствующий элемент в списке столбцов. Однако, порядок имен столбцов в списке столбцов разделения и списках значения не должен быть тем же самым как порядком определений столбца таблицы в основной части CREATE TABLE оператор. Как с таблицей, разделенной RANGE, можно использовать MAXVALUE чтобы представить значение так, что, любое юридическое значение, вставленное в данный столбец, всегда является меньше чем это значение. Вот пример a CREATE TABLE оператор, который помогает проиллюстрировать все эти тезисы:

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,'mmmm'),    ->     PARTITION p2 VALUES LESS THAN
        (15,30,'sss'),    ->     PARTITION p3 VALUES LESS THAN
        (MAXVALUE,MAXVALUE,MAXVALUE)    -> );Query OK, 0 rows affected (0.15 sec)

Таблица rcx содержит столбцы a, b, c, d. Список столбцов разделения, предоставленный COLUMNS пункт использует 3 из этих столбцов в порядке a, d, c. Каждый список значения, используемый, чтобы определить раздел, содержит 3 значения в том же самом порядке; то есть, у каждого кортежа списка значения есть форма (INT, INT, CHAR(3)), который соответствует типам данных, используемым столбцами a, d, и c (в том порядке).

Размещение строк в разделы определяется, сравнивая кортеж от строки, которая будет вставлена, который соответствует список столбцов в COLUMNS пункт с кортежами, используемыми в VALUES LESS THAN пункты, чтобы определить разделы таблицы. Поскольку мы сравниваем кортежи (то есть, списки или наборы значений), а не скалярные значения, семантика VALUES LESS THAN как использующийся с RANGE COLUMNS разделы отличаются несколько от случая с простым RANGE разделы. В RANGE разделение, строка, генерирующая значение выражения, которое равно предельному значению в a VALUES LESS THAN никогда не помещается в соответствующий раздел; однако, при использовании RANGE COLUMNS разделение, для строки иногда возможно, разделение которой первого элемента списка столбцов равной стоимости к тому из первого элемента в a VALUES LESS THAN оцените список, который будет помещен в соответствующий раздел.

Рассмотрите RANGE разделенная таблица создала этим оператором:

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

Если мы вставляем 3 строки в эту таблицу так, что значение столбца для a 5 для каждой строки все 3 строки сохранены в разделе p1 потому что a значение столбца находится в каждом случае не меньше чем 5, как мы можем видеть, выполняя надлежащий запрос против INFORMATION_SCHEMA.PARTITIONS таблица:

mysql> INSERT INTO r1 VALUES (5,10), (5,11),
        (5,12);Query OK, 3 rows affected (0.00 sec)Records: 3  Duplicates: 0  Warnings: 0mysql> SELECT PARTITION_NAME,TABLE_ROWS    ->     FROM INFORMATION_SCHEMA.PARTITIONS    ->     WHERE TABLE_NAME = 'r1';+----------------+------------+| PARTITION_NAME | TABLE_ROWS |+----------------+------------+| p0             |          0 || p1             |          3 |+----------------+------------+2 rows in set (0.00 sec)

Теперь рассмотрите подобную таблицу rc1 это использует RANGE COLUMNS разделение с обоими столбцами a и b ссылаемый в COLUMNS пункт, создаваемый как показано здесь:

CREATE TABLE rc1 (    a INT,     b INT) PARTITION BY RANGE COLUMNS(a, b) (    PARTITION p0 VALUES LESS THAN (5, 12),    PARTITION p3 VALUES LESS THAN (MAXVALUE, MAXVALUE));

Если мы вставляем точно те же самые строки в rc1 поскольку мы только вставили в r1, распределение строк очень отличается:

mysql> INSERT INTO rc1 VALUES (5,10), (5,11),
        (5,12);Query OK, 3 rows affected (0.00 sec)Records: 3  Duplicates: 0  Warnings: 0mysql> 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)

Это - то, потому что мы сравниваем строки, а не скалярные значения. Мы можем сравнить значения строки, вставленные с ограничивающим значением строки от VALUES THAN LESS THAN пункт, используемый, чтобы определить раздел p0 в таблице rc1, как это:

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 row in set (0.00 sec)

Эти 2 кортежа (5,10) и (5,11) оцените как меньше чем (5,12), таким образом, они сохранены в разделе p0. С тех пор 5, не меньше чем 5 и 12 являются не меньше чем 12, (5,12) считается не меньше чем (5,12), и сохранен в разделе p1.

SELECT оператор в предыдущем примере, возможно, также был записан, используя явных конструкторов строки, как это:

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

Для получения дополнительной информации об использовании конструкторов строки в MySQL, см. Раздел 13.2.10.5, "Подзапросы Строки".

Для таблицы, разделенной RANGE COLUMNS используя только единственный столбец разделения, хранение строк в разделах является тем же самым как той из переводной таблицы, которая делится RANGE. Следующий CREATE TABLE оператор составляет таблицу, разделенную RANGE COLUMNS использование 1 столбца разделения:

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

Если мы вставляем строки (5,10), (5,11), и (5,12) в эту таблицу мы можем видеть, что их размещение является тем же самым, как это для таблицы r мы создали и заполнили ранее:

mysql> INSERT INTO rx VALUES (5,10), (5,11),
        (5,12);Query OK, 3 rows affected (0.00 sec)Records: 3  Duplicates: 0  Warnings: 0mysql> 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)

Также возможно составить таблицы, разделенные RANGE COLUMNS где предельные значения для одного или более столбцов повторяются в последовательных определениях раздела. Можно сделать это, пока кортежи значений столбцов, используемых, чтобы определить разделы, строго увеличиваются. Например, каждый из следующих CREATE TABLE операторы допустимы:

CREATE TABLE rc2 (    a INT,    b INT)PARTITION BY RANGE COLUMNS(a,b) (    PARTITION p0 VALUES LESS THAN (0,10),    PARTITION p1 VALUES LESS THAN (10,20),    PARTITION p2 VALUES LESS THAN (10,30),    PARTITION p3 VALUES LESS THAN (MAXVALUE,MAXVALUE) ); CREATE TABLE rc3 (    a INT,    b INT)PARTITION BY RANGE COLUMNS(a,b) (    PARTITION p0 VALUES LESS THAN (0,10),    PARTITION p1 VALUES LESS THAN (10,20),    PARTITION p2 VALUES LESS THAN (10,30),    PARTITION p3 VALUES LESS THAN (10,35),    PARTITION p4 VALUES LESS THAN (20,40),    PARTITION p5 VALUES LESS THAN (MAXVALUE,MAXVALUE) );

Следующий оператор также успешно выполняется, даже при том, что могло бы казаться на первый взгляд, что это не будет, начиная с предельного значения столбца b 25 для раздела p0 и 20 для раздела p1, и предельное значение столбца c 100 для раздела p1 и 50 для раздела p2:

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

Разрабатывая таблицы, разделенные RANGE COLUMNS, можно всегда тестировать последовательные определения раздела, сравнивая требуемые кортежи, используя mysql клиент, как это:

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)

Если a CREATE TABLE оператор содержит определения раздела, которые не находятся в строго увеличивающемся порядке, он перестал работать с ошибкой, как показано в этом примере:

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 LESS THAN value must be strictly increasing for each partition

Когда Вы получаете такую ошибку, можно вывести, какие определения раздела недопустимы, делая "меньше чем" сравнения между их списками столбцов. В этом случае проблема с определением раздела p2 потому что кортеж, используемый, чтобы определить это, не является меньше чем кортеж, используемый, чтобы определить раздел p3, как показано здесь:

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)

Это также возможно для MAXVALUE появиться для того же самого столбца в больше чем одном VALUES LESS THAN пункт при использовании RANGE COLUMNS. Однако, предельные значения для отдельных столбцов в последовательных определениях раздела должны иначе увеличиваться, должен быть не больше, чем один раздел, определенный где MAXVALUE используется в качестве верхнего предела для всех значений столбцов, и это определение раздела должно казаться последним в списке PARTITION ... VALUES LESS THAN пункты. Кроме того, невозможно использовать MAXVALUE как предельное значение для первого столбца больше чем в одном определении раздела.

Как утверждено ранее, это также возможно с RANGE COLUMNS разделение, чтобы использовать столбцы нецелого числа в качестве разделения столбцов. (См. Раздел 18.2.3,"COLUMNS Разделение", для полного списка их.) Считают таблицу названной employees (который не делится), создал использование следующего оператора:

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

Используя RANGE COLUMNS разделение, можно создать версию этой таблицы, которая хранит каждую строку в одном из четырех разделов, основанных на фамилии сотрудника, как это:

CREATE TABLE employees_by_lname (    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 COLUMNS (lname)  (    PARTITION p0 VALUES LESS THAN ('g'),    PARTITION p1 VALUES LESS THAN ('m'),    PARTITION p2 VALUES LESS THAN ('t'),    PARTITION p3 VALUES LESS THAN (MAXVALUE));

Альтернативно, Вы могли вызвать employees таблица как создающийся ранее, чтобы быть разделенным, используя эту схему, выполняя следующий ALTER TABLE оператор:

ALTER TABLE employees PARTITION BY RANGE COLUMNS (lname)  (    PARTITION p0 VALUES LESS THAN ('g'),    PARTITION p1 VALUES LESS THAN ('m'),    PARTITION p2 VALUES LESS THAN ('t'),    PARTITION p3 VALUES LESS THAN (MAXVALUE));

Точно так же можно вызвать employees таблица, которая будет разделена таким способом, которым каждая строка сохранена в одном из нескольких разделов, основанных на десятилетии, в которое соответствующий сотрудник был нанят, используя ALTER TABLE оператор, показанный здесь:

ALTER TABLE employees PARTITION BY RANGE COLUMNS (hired)  (    PARTITION p0 VALUES LESS THAN ('1970-01-01'),    PARTITION p1 VALUES LESS THAN ('1980-01-01'),    PARTITION p2 VALUES LESS THAN ('1990-01-01'),    PARTITION p3 VALUES LESS THAN ('2000-01-01'),    PARTITION p4 VALUES LESS THAN ('2010-01-01'),    PARTITION p5 VALUES LESS THAN (MAXVALUE));

См. Раздел 13.1.17,"CREATE TABLE Синтаксис", для дополнительной информации о PARTITION BY RANGE COLUMNS синтаксис.