Topik ini menjelaskan sintaks, klausa, dan parameter dari pernyataan CREATE TABLE yang digunakan untuk membuat tabel terpartisi, serta metode partisi yang dapat digunakan dalam pernyataan tersebut. Sintaks ini hanya berlaku untuk database dalam mode AUTO.
Catatan Penggunaan
Sebelum menggunakan sintaks untuk membuat tabel terpartisi, pastikan Anda menyetel parameter mode ke auto saat membuat basis data logis saat ini. Nilai auto menunjukkan mode partisi otomatis. Jika parameter ini tidak disetel ke auto, Anda tidak dapat menggunakan sintaks tersebut. Anda dapat mengeksekusi pernyataan
SHOW CREATE DATABASE db_nameuntuk memeriksa mode partisi dari basis data logis saat ini. Contoh:CREATE DATABASE part_db mode='auto'; Query OK, 1 row affected (4.29 sec) SHOW CREATE DATABASE part_db; +----------+-----------------------------------------------+ | DATABASE | CREATE DATABASE | +----------+-----------------------------------------------+ | part_db | CREATE DATABASE `part_db` /* MODE = 'auto' */ | +----------+-----------------------------------------------+ 1 row in set (0.18 sec)Untuk informasi lebih lanjut tentang sintaks pembuatan basis data, lihat CREATE DATABASE.
Jika kunci utama tabel terpartisi tidak mengandung kunci partisi dan bukan kunci utama auto-increment, pastikan bahwa kunci utamanya unik.
Jika fitur terkait partisi level-2 diperlukan saat pembuatan tabel terpartisi, versi instance PolarDB-X Anda adalah 5.4.17-16952556 atau lebih baru.
Sintaks
CREATE [PARTITION] TABLE [IF NOT EXISTS] tbl_name
(create_definition, ...)
[table_options]
[table_partition_definition]
[local_partition_definition]
create_definition:
col_name column_definition
| mysql_create_definition
| [UNIQUE] GLOBAL INDEX index_name [index_type] (index_sharding_col_name,...)
[global_secondary_index_option]
[index_option] ...
index_sharding_col_name:
col_name [(length)] [ASC | DESC]
index_option:
KEY_BLOCK_SIZE [=] value
| index_type
| WITH PARSER parser_name
| COMMENT 'string'
index_type:
USING {BTREE | HASH}
# Buat indeks sekunder global.
global_secondary_index_option:
[COVERING (col_name,...)]
[partition_options]
[VISIBLE|INVISIBLE]
table_options:
table_option [[,] table_option] ...
table_option: {
# Tentukan grup tabel tempat tabel yang dipartisi termasuk.
TABLEGROUP [=] value,...,}
# Tentukan jenis tabel yang dipartisi.
table_partition_definition:
single
| broadcast
| partition_options
# Tentukan partisi.
partition_options:
partition_columns_definition
[subpartition_columns_definition]
[subpartition_specs_definition]/* Tentukan partisi level-2 dengan template.*/
partition_specs_definition
# Tentukan kolom kunci partisi level-1.
partition_columns_definition:
PARTITION BY
HASH({column_name | partition_func(column_name)}) partitions_count
| KEY(column_list) partitions_count
| RANGE ({column_name | partition_func(column_name)})
| RANGE COLUMNS(column_list)
| LIST ({column_name | partition_func(column_name)})
| LIST COLUMNS(column_list)
| CO_HASH({column_expr_list}) partitions_count
# Tentukan kolom kunci partisi level-2.
subpartition_columns_definition:
SUBPARTITION BY
HASH({column_name | partition_func(column_name)}) subpartitions_count
| KEY(column_list) subpartitions_count
| RANGE ({column_name | partition_func(column_name)})
| RANGE COLUMNS(column_list)
| LIST ({column_name | partition_func(column_name)})
| LIST COLUMNS(column_list)
| CO_HASH({column_expr_list}) partitions_count
column_expr_list:
{column_name | partition_func(column_name)},{column_name | partition_func(column_name)}[,{column_name | partition_func(column_name)},...]
partitions_count:
PARTITIONS partition_count
subpartitions_count:
SUBPARTITIONS partition_count
# Tentukan fungsi partisi.
partition_func:
YEAR
| TO_DAYS
| TO_MONTHS
| TO_WEEKS
| TO_SECOND
| UNIX_TIMESTAMP
| MONTH
| DAYOFWEEK
| DAYOFMONTH
| DAYOFYEAR
| SUBSTR
| SUBSTRING
| RIGHT
| LEFT
# Tentukan tiga jenis partisi level-1.
partition_specs_definition:
hash_partition_list
| range_partition_list
| list_partition_list
# Tentukan tiga jenis partisi level-2.
subpartition_specs_definition:
hash_subpartition_list
| range_subpartition_list
| list_subpartition_list
# Tentukan subpartisi HASH atau KEY dari partisi level-1.
hash_partition_list:
/* Semua subpartisi di partisi level-1 adalah tipe partisi HASH.*/
| ( hash_partition [, hash_partition, ...] )
hash_partition:
PARTITION partition_name [partition_spec_options] /* Tentukan partisi murni level-1 atau subpartisi bertemplate.*/
| PARTITION partition_name subpartitions_count [subpartition_specs_definition] /* Tentukan subpartisi non-template di bawah partisi level-1.*/
# Tentukan subpartisi HASH atau KEY dari partisi level-2.
hash_subpartition_list:
| empty
| ( hash_subpartition [, hash_subpartition, ...] )
hash_subpartition:
SUBPARTITION subpartition_name [partition_spec_options]
# Tentukan subpartisi RANGE atau RANGE COLUMNS dari partisi level-1.
range_partition_list:
( range_partition [, range_partition, ... ] )
range_partition:
PARTITION partition_name VALUES LESS THAN (range_bound_value) [partition_spec_options] /* Tentukan partisi murni level-1 atau subpartisi bertemplate.*/
| PARTITION partition_name VALUES LESS THAN (range_bound_value) [[subpartitions_count] [subpartition_specs_definition]] /* Tentukan subpartisi non-template di bawah partisi level-1.*/
# Tentukan subpartisi RANGE atau RANGE COLUMNS dari partisi level-2.
range_subpartition_list:
( range_subpartition [, range_subpartition, ... ] )
range_subpartition:
SUBPARTITION subpartition_name VALUES LESS THAN (range_bound_value) [partition_spec_options]
range_bound_value:
maxvalue /* Tentukan jumlah maksimum partisi RANGE.*/
| expr /* Tentukan nilai batas rentang untuk satu kolom kunci partisi.*/
| value_list /* Tentukan nilai batas rentang untuk beberapa kolom kunci partisi.*/
# Tentukan subpartisi LIST atau LIST COLUMNS dari partisi level-1.
list_partition_list:
(list_partition [, list_partition ...])
list_partition:
PARTITION partition_name VALUES LESS THAN (range_bound_value) [partition_spec_options] /* Tentukan partisi murni level-1 atau subpartisi bertemplate.*/
| PARTITION partition_name VALUES IN (list_bound_value) [[subpartitions_count] [subpartition_specs_definition]] /* Tentukan subpartisi non-template di bawah partisi level-1.*/
# Tentukan subpartisi LIST atau LIST COLUMNS dari partisi level-2.
list_subpartition_list:
(list_subpartition [, list_subpartition ...])
list_subpartition:
SUBPARTITION subpartition_name VALUES IN (list_bound_value) [partition_spec_options]
list_bound_value:
default /* Tentukan partisi LIST default.*/
| value_set
value_set:
value_list /* Tentukan satu set nilai untuk satu kolom kunci partisi.*/
| (value_list) [, (value_list), ...] /* Tentukan satu set nilai untuk beberapa kolom kunci partisi.*/
value_list:
value [, value, ...]
partition_spec_options:
[[STORAGE] ENGINE [=] engine_name]
[COMMENT [=] 'string']
[LOCALITY [=] locality_option]
table_option:
[[STORAGE] ENGINE [=] engine_name]
[COMMENT [=] 'string']
[{CHARSET | CHARACTER SET} [=] charset]
[COLLATE [=] collation]
[TABLEGROUP [=] table_group_id]
[LOCALITY [=] locality_option]
locality_option:
'dn=storage_inst_id_list'
storage_inst_id_list:
storage_inst_id[,storage_inst_id_list]
local_partition_definition:
LOCAL PARTITION BY RANGE (column_name)
[STARTWITH 'yyyy-MM-dd']
INTERVAL interval_count [YEAR|MONTH|DAY]
[EXPIRE AFTER expire_after_count]
[PRE ALLOCATE pre_allocate_count]
[PIVOTDATE pivotdate_func]
[DISABLE SCHEDULE]
pivotdate_func:
NOW()
| DATE_ADD(...)
| DATE_SUB(...)Sintaks pernyataan DDL PolarDB-X dikembangkan berdasarkan MySQL. Konten sebelumnya menunjukkan perbedaan antara sintaks PolarDB-X dan MySQL. Untuk informasi lebih lanjut tentang sintaks lengkap, lihat Dokumentasi MySQL.
Istilah
Kunci partisi: satu atau lebih kolom berdasarkan mana tabel dibagi secara horizontal.
Kolom kunci partisi: kolom berdasarkan mana PolarDB-X merutekan data ke partisi tabel. Kolom kunci partisi merupakan bagian dari kunci partisi tabel. Kunci partisi dapat berisi satu atau lebih kolom kunci partisi.
Vektor kunci partisi: kunci partisi yang berisi satu atau lebih kolom kunci partisi.
Kunci partisi kolom tunggal: kunci partisi yang hanya berisi satu kolom kunci partisi.
Kolom kunci partisi awalan: Jika vektor kunci partisi berisi N kolom kunci partisi, K kolom kunci partisi pertama didefinisikan sebagai kolom kunci partisi awalan dari vektor kunci partisi. N adalah angka lebih besar dari 1, dan K adalah angka lebih besar dari atau sama dengan 1 dan lebih kecil dari atau sama dengan N.
Fungsi partisi: fungsi yang menggunakan kolom kunci partisi sebagai parameter input dan mengembalikan hasil berdasarkan mana PolarDB-X merutekan data ke partisi tabel.
Pemangkasan partisi: fitur yang digunakan untuk mengoptimalkan query dengan menyaring partisi yang tidak perlu dipindai berdasarkan konfigurasi partisi dan kondisi query.
Pemisahan partisi panas: fitur yang digunakan untuk menyeimbangkan beban kerja partisi. Saat data panas ada di kolom kunci partisi awalan dari vektor kunci partisi, Anda dapat membagi data panas menjadi beberapa partisi berdasarkan kolom kunci partisi lainnya.
Partisi fisik: partisi dalam node data yang sesuai dengan shard tabel fisik. Partisi fisik sesuai dengan shard tabel fisik.
Partisi logis: partisi virtual yang sesuai dengan satu atau lebih partisi fisik. Partisi logis mewakili konsep logis. Misalnya, saat Anda membuat tabel terpartisi yang berisi partisi level-2, partisi level-1 dari partisi level-2 adalah partisi logis.
Parameter
Komponen | deskripsi |
CHARSET | CHARACTER SET | Menentukan set karakter default yang digunakan untuk kolom dalam tabel yang dipartisi. Nilai valid:
|
COLLATE | Menentukan string default yang digunakan untuk kolom dalam tabel yang dipartisi. Nilai valid:
|
TABLEGROUP | Menentukan grup tabel tempat tabel yang dipartisi termasuk. Jika parameter ini tidak ditentukan, PolarDB-X secara otomatis menetapkan tabel yang dipartisi ke grup tabel yang ada atau membuat grup tabel. Dalam grup tabel, semua tabel harus dipartisi menggunakan metode partisi yang sama. |
LOCALITY | Menentukan node data tempat tabel yang dipartisi diterapkan. |
Tabel Non-partisi
PolarDB-X memungkinkan Anda menentukan kata kunci SINGLE untuk membuat tabel non-partisi. Contoh pernyataan:
CREATE TABLE single_tbl(
id bigint not null auto_increment,
bid int,
name varchar(30),
primary key(id)
) SINGLE;Tabel Siaran
PolarDB-X memungkinkan Anda menentukan kata kunci BROADCAST untuk membuat tabel siaran. Saat Anda membuat tabel siaran dalam instance PolarDB-X, tabel siaran direplikasi pada setiap node data dari instance PolarDB-X. Contoh pernyataan:
CREATE TABLE broadcast_tbl(
id bigint not null auto_increment,
bid int,
name varchar(30),
primary key(id)
) BROADCAST;Tabel Terpartisi
Jenis Partisi
PolarDB-X memungkinkan Anda mengonfigurasi sintaks dalam klausa yang digunakan untuk membuat partisi guna membuat tabel terpartisi yang sesuai dengan kebutuhan bisnis Anda. PolarDB-X menyediakan jenis-jenis partisi berikut:
HASH partitioning: Jenis partisi ini menggunakan hashing konsisten bawaan untuk menghitung nilai hash dari ekspresi tertentu yang mengandung fungsi partisi atau kolom kunci partisi dan merutekan data ke partisi. Jenis partisi HASH mencakup KEY partitioning dan HASH partitioning berdasarkan apakah ekspresi yang mengandung fungsi partisi digunakan atau kolom kunci partisi digunakan sebagai kunci partisi.
RANGE partitioning: Jenis partisi ini membandingkan dan menghitung nilai kolom kunci partisi tertentu atau nilai yang dikembalikan oleh ekspresi tertentu yang mengandung fungsi partisi untuk menentukan rentang partisi yang telah ditentukan sebelumnya di mana data didistribusikan dan merutekan data ke partisi. Jenis partisi RANGE mencakup RANGE COLUMNS partitioning dan RANGE partitioning berdasarkan apakah ekspresi yang mengandung fungsi partisi digunakan atau kolom kunci partisi digunakan sebagai kunci partisi.
LIST partitioning: Jenis partisi ini membandingkan dan menghitung nilai kolom kunci partisi tertentu atau nilai yang dikembalikan oleh ekspresi tertentu yang mengandung fungsi partisi untuk menentukan koleksi nilai partisi yang telah ditentukan sebelumnya di mana data didistribusikan dan merutekan data ke partisi. Metode partisi ini mirip dengan metode partisi RANGE. Jenis partisi LIST mencakup LIST COLUMNS dan LIST partitioning berdasarkan apakah beberapa kolom kunci partisi digunakan sebagai kunci partisi dan metode penggunaannya.
COHASH partisi: Sebagai jenis partisi baru yang disediakan oleh PolarDB-X, cocok untuk skenario di mana tabel dipartisi berdasarkan kolom kunci partisi yang berbeda dengan nilai serupa.
Partisi HASH
Jenis partisi HASH dalam PolarDB-X mencakup partisi HASH dan partisi KEY. Partisi HASH dan KEY didukung oleh sintaks asli MySQL. PolarDB-X kompatibel secara sintaksis dengan sintaks partisi HASH dan KEY yang digunakan untuk membuat tabel terpartisi di MySQL untuk memberikan kemampuan manajemen partisi yang fleksibel dan kuat seperti pemisahan, penggabungan, dan migrasi serta mendukung pemisahan partisi panas dalam kunci partisi vektor. Namun, PolarDB-X merutekan data ke partisi dengan cara yang berbeda dari MySQL. PolarDB-X menentukan ulang rute data dalam partisi HASH dan KEY. Untuk informasi lebih lanjut tentang sintaks berbagai jenis partisi, lihat Jenis Partisi. Tabel berikut mencantumkan perbedaan antara partisi KEY dan partisi HASH.
Tabel 1. Perbandingan antara partisi KEY dan partisi HASH
Jenis Partisi | Kunci Partisi yang Didukung | Apakah mendukung fungsi partisi | Sintaks Pernyataan | Batasan | Kebijakan Rute (query titik) |
Partisi KEY (default) | Kunci partisi kolom tunggal | Dinonaktifkan | PARTITION BY KEY(c1) |
|
|
Vektor kunci partisi | Dinonaktifkan | PARTITION BY KEY(c1,c2,...,cn) |
|
| |
Hash | Kunci partisi kolom tunggal | Dinonaktifkan | PARTITION BY HASH(c1) |
| Strategi rute PARTITION BY HASH(c1) sama dengan PARTITION BY KEY(c1). |
Diaktifkan | PARTITION BY HASH(YEAR(c1)) |
| |||
Vektor kunci partisi | Dinonaktifkan | PARTITIONBY HASH(c1,c2,...,cn) |
|
|
Example 1-1:KEY partitioning
Partisi KEY adalah jenis partisi default untuk PolarDB-X. Partisi KEY mendukung kunci partisi vektor. Jika Anda ingin menggunakan kolom nama dan id sebagai kunci partisi tabel dan menetapkan jumlah partisi menjadi 8, Anda dapat mengeksekusi pernyataan berikut untuk membuat tabel:
CREATE TABLE key_tbl(
id bigint not null auto_increment,
bid int,
name varchar(30),
birthday datetime not null,
primary key(id)
)
PARTITION BY KEY(name, id)
PARTITIONS 8;Dalam contoh ini, kunci partisi vektor yang terdiri dari kolom nama dan id digunakan untuk mempartisi tabel. Secara default, data dirutekan ke partisi hanya berdasarkan nilai dalam kolom nama. Oleh karena itu, untuk mengoptimalkan pernyataan SQL dengan menggunakan pemangkasan partisi, Anda hanya perlu menentukan kondisi berdasarkan kolom nama dalam klausa WHERE dari pernyataan SQL.
## Pernyataan SQL berikut memenuhi kondisi pemangkasan partisi dan hanya memindai data dalam satu partisi.
SELECT id from key_tbl where name='Jack';Jika data dalam kolom nama tidak terdistribusi secara merata atau data tertentu sering diakses, Anda dapat menggunakan kolom kunci partisi lain dalam vektor, seperti kolom id, untuk membagi partisi demi optimalisasi kinerja. Untuk informasi lebih lanjut, lihat ALTER TABLEGROUP.
Jika kunci partisi vektor terdiri dari N kolom kunci partisi dan data dirutekan ke K (1 ≤ K ≤ N) kolom kunci partisi pertama, Anda perlu menentukan kondisi untuk pemangkasan partisi hanya berdasarkan K kolom pertama dari kunci partisi vektor dalam klausa WHERE dari pernyataan SQL.
Example 1-2: HASH partitioning
Jika Anda ingin menggunakan kolom id sebagai kunci partisi untuk mempartisi tabel secara horizontal dan menetapkan jumlah partisi menjadi 8, Anda dapat mengeksekusi pernyataan berikut untuk membuat tabel dengan menggunakan partisi HASH:
CREATE TABLE hash_tbl(
id bigint not null auto_increment,
bid int,
name varchar(30),
birthday datetime not null,
primary key(id)
)
partition by hash(id)
partitions 8;Dalam partisi HASH, Anda dapat menggunakan fungsi partisi seperti YEAR dan TO_DAYS untuk mengonversi timestamp menjadi bilangan bulat. Jika Anda ingin menggunakan kolom ulang tahun sebagai kunci partisi tabel dan menetapkan jumlah partisi menjadi 8, Anda dapat mengeksekusi pernyataan berikut untuk membuat tabel:
CREATE TABLE hash_tbl_todays(
id bigint not null auto_increment,
bid int,
name varchar(30),
birthday datetime not null,
primary key(id)
)
PARTITION BY HASH(TO_DAYS(birthday))
PARTITIONS 8;Fungsi partisi berikut didukung oleh PolarDB-X:
YEAR
MONTH
DAYOFMONTH
DAYOFWEEK
DAYOFYEAR
TO_DAYS
TO_MONTHS
TO_WEEKS
TO_SECONDS
UNIX_TIMESTAMP
SUBSTR/SUBSTRING
Oleh karena itu, kecuali tipe data kolom kunci partisi fungsi SUBSTR atau SUBSTRING harus berupa STRING, tipe data kolom kunci partisi fungsi partisi lainnya harus berupa tipe berikut: DATE, DATETIME, dan TIMESTAMP.
Example 1-3: Extended HASH partitioning
PolarDB-X memperluas sintaks partisi HASH dan memungkinkan Anda menggunakan kunci partisi vektor yang didukung oleh sintaks MySQL asli. Untuk informasi tentang sintaks berbagai jenis partisi, lihat Jenis Partisi. Contoh pernyataan:
CREATE TABLE hash_tbl2(
id bigint not null auto_increment,
bid int,
name varchar(30),
birthday datetime not null,
primary key(id)
)
PARTITION BY HASH(name, birthday)
PARTITIONS 8;Jika Anda menggunakan jenis partisi HASH untuk mempartisi tabel, kunci partisi vektor digunakan. Data dalam tabel dirutekan ke partisi berdasarkan nilai hash dari semua kolom kunci partisi. Anda harus menentukan kondisi untuk pemangkasan partisi berdasarkan semua kolom kunci partisi dalam klausa WHERE dari pernyataan SQL. Dalam contoh berikut, SQL1 memenuhi kondisi pemangkasan partisi tabel hash_tbl2, dan SQL2 tidak memenuhi kondisi pemangkasan partisi tabel hash_tbl2.
## Pernyataan SQL berikut SQL1 memenuhi kondisi pemangkasan partisi. Saat pernyataan dieksekusi, hanya partisi yang ditentukan yang dipindai.
SELECT id from hash_tbl2 where name='Jack' and birthday='1990-11-11';
## Pernyataan SQL berikut SQL2 tidak memenuhi kondisi pemangkasan partisi. Saat pernyataan dieksekusi, semua partisi dipindai.
SELECT id from hash_tbl2 where name='Jack';Dalam partisi HASH, data dirutekan berdasarkan nilai hash dari semua kolom kunci partisi. Oleh karena itu, data lebih merata didistribusikan dalam partisi HASH dibandingkan dalam partisi KEY di mana data dirutekan berdasarkan nilai hash dari hanya kolom tertentu dari kunci partisi vektor. Partisi HASH tidak mendukung pemisahan partisi panas karena semua kolom kunci partisi digunakan untuk partisi data dan tidak ada kolom kunci partisi yang tersedia untuk pemisahan partisi panas.
Limits
Batasan pada tipe data
Tipe bilangan bulat: BIGINT, BIGINT UNSIGNED, INT UNSIGNED, INT, MEDIUMINT, MEDIUMINT UNSIGNED, SMALLINT, SMALLINT UNSIGNED, TINYINT, dan TINYINT UNSIGNED.
Tipe tanggal dan waktu: DATETIME, DATE, dan TIMESTAMP.
Tipe string: CHAR dan VARCHAR.
Batasan pada sintaks
Jika kunci partisi tabel adalah kunci partisi kolom tunggal dan tipe data kolom kunci partisi adalah DATETIME, DATE, atau TIMESTAMP, fungsi partisi tertentu didukung.
Jika kunci partisi tabel adalah kunci partisi vektor, fungsi partisi dan pemisahan partisi panas tidak didukung.
Secara default, tabel terpartisi dapat berisi hingga 8.192 partisi.
Secara default, kunci partisi dapat terdiri dari hingga lima kolom kunci partisi.
Data balancing
Partisi KEY dan HASH diimplementasikan berdasarkan algoritma hashing konsisten bawaan MurmurHash3. Algoritma ini telah diuji secara luas di industri dan terbukti memiliki tabrakan data rendah dan kinerja tinggi.
Saat menggunakan partisi KEY atau HASH, distribusi data di seluruh partisi yang berbeda menjadi seimbang ketika jumlah nilai berbeda dari kunci partisi lebih besar dari 3.000 berdasarkan algoritma MurmurHash3. Data didistribusikan secara lebih seimbang ketika kunci partisi mencakup lebih banyak nilai berbeda.
Partisi RANGE
Jenis partisi RANGE dalam PolarDB-X mencakup partisi RANGE dan partisi RANGE COLUMNS. Partisi RANGE dan RANGE COLUMNS didukung oleh sintaks MySQL asli. Untuk informasi lebih lanjut tentang sintaks berbagai jenis partisi, lihat Jenis Partisi. Tabel berikut mencantumkan perbedaan antara partisi RANGE dan partisi RANGE COLUMNS.
Tabel 2. Perbandingan antara partisi RANGE dan partisi RANGE COLUMNS
Jenis Partisi | Kunci Partisi yang Didukung | Apakah mendukung fungsi partisi | Sintaks Pernyataan | Batasan | Kebijakan Rute (query titik) |
RANGE Columns | Kunci partisi kolom tunggal dan kunci partisi vektor | Dinonaktifkan | PARTITION BY RANGE COLUMNS (c1,c2,...,cn) ( PARTITION p1 VALUES LESS THAN (1,10,...,1000), PARTITION p2 VALUES LESS THAN (2,20,...,2000) ...) | Pemisahan partisi panas didukung. Jika sejumlah besar baris berisi nilai yang sama seperti 88 di kolom kunci partisi c1, Anda dapat membagi data panas berdasarkan nilai dalam kolom kunci partisi c2. |
|
Range | Kunci partisi kolom tunggal | Diaktifkan | PARTITION BY RANGE(YEAR(c1)) ( PARTITION p1 VALUES LESS THAN (2019), PARTITION p2 VALUES LESS THAN (2021) ...) |
|
|
Example 2-1: RANGE COLUMNS partitioning
Partisi RANGE COLUMNS mendukung kunci partisi vektor tetapi tidak mendukung fungsi partisi. Misalnya, Anda dapat mengeksekusi pernyataan berikut untuk membuat tabel yang dipartisi berdasarkan rentang nilai yang ditentukan dalam kolom order_id dan order_time:
CREATE TABLE orders(
order_id int,
order_time datetime not null)
PARTITION BY range columns(order_id,order_time)
(
PARTITION p1 VALUES LESS THAN (10000,'2021-01-01'),
PARTITION p2 VALUES LESS THAN (20000,'2021-01-01'),
PARTITION p3 VALUES LESS THAN (30000,'2021-01-01'),
PARTITION p4 VALUES LESS THAN (40000,'2021-01-01'),
PARTITION p5 VALUES LESS THAN (50000,'2021-01-01'),
PARTITION p6 VALUES LESS THAN (MAXVALUE,MAXVALUE)
);Partisi RANGE COLUMNS tidak mendukung kunci partisi yang berisi data TIMESTAMP atau TIME.
Example 2-2: RANGE partitioning
Partisi RANGE hanya mendukung kunci partisi kolom tunggal. Jika Anda ingin menggunakan kolom yang berisi nilai tanggal dan waktu sebagai kolom kunci partisi, Anda harus menggunakan ekspresi yang berisi fungsi partisi seperti YEAR, TO_DAYS, TO_SECONDS, atau MONTH untuk mengonversi nilai tanggal dan waktu dalam kolom tersebut menjadi nilai integer.
Kolom yang berisi string tidak dapat digunakan sebagai kolom kunci partisi dalam partisi RANGE.
Misalnya, Anda dapat mengeksekusi pernyataan berikut untuk membuat tabel yang dipartisi berdasarkan rentang nilai dalam kolom order_time dan menyimpan data dalam partisi yang berbeda per kuartal:
CREATE TABLE orders_todays(
id int,
order_time datetime not null)
PARTITION BY RANGE(to_days(order_time))
(
PARTITION p1 VALUES LESS THAN (to_days('2021-01-01')),
PARTITION p2 VALUES LESS THAN (to_days('2021-04-01')),
PARTITION p3 VALUES LESS THAN (to_days('2021-07-01')),
PARTITION p4 VALUES LESS THAN (to_days('2021-10-01')),
PARTITION p5 VALUES LESS THAN (to_days('2022-01-01')),
PARTITION p6 VALUES LESS THAN (MAXVALUE)
);Dalam partisi RANGE, hanya kolom yang berisi nilai integer yang dapat digunakan sebagai kolom kunci partisi. Dalam partisi RANGE, kunci partisi hanya dapat berisi satu kolom kunci partisi.
Limits
Batasan pada tipe data
Tipe bilangan bulat: BIGINT, BIGINT UNSIGNED, INT UNSIGNED, INT, MEDIUMINT, MEDIUMINT UNSIGNED, SMALLINT, SMALLINT UNSIGNED, TINYINT, dan TINYINT UNSIGNED.
Tipe tanggal dan waktu: DATETIME dan DATE.
Tipe string: CHAR dan VARCHAR.
Batasan pada sintaks
Partisi RANGE COLUMNS dan partisi RANGE tidak mendukung NULL sebagai batas nilai rentang.
Partisi RANGE COLUMNS tidak mendukung kolom tipe TIMESTAMP sebagai kolom kunci partisi.
Dalam partisi RANGE, hanya kolom yang berisi nilai integer yang dapat digunakan sebagai kolom kunci partisi. Untuk menggunakan kolom tipe TIMESTAMP sebagai kolom kunci partisi, Anda harus menggunakan fungsi partisi UNIX_TIMSTAMP untuk mengonversi nilai timestamp ke timestamp dalam zona waktu yang sama.
Partisi RANGE tidak mendukung pemisahan partisi panas.
Jika nilai NULL ditentukan dalam permintaan SQL, nilai NULL dianggap sebagai nilai minimum selama rute data.
Secara default, tabel terpartisi dapat berisi hingga 8.192 partisi.
Secara default, kunci partisi dapat terdiri dari hingga lima kolom kunci partisi.
Partisi LIST
Jenis partisi LIST dalam PolarDB-X mencakup partisi LIST dan partisi LIST COLUMNS. Partisi LIST dan LIST COLUMNS didukung oleh sintaks MySQL asli. Untuk informasi lebih lanjut tentang sintaks berbagai jenis partisi, lihat Jenis Partisi. Partisi LIST dan LIST COLUMNS dalam PolarDB-X juga mendukung partisi DEFAULT. Tabel berikut mencantumkan perbedaan antara partisi LIST dan partisi LIST COLUMNS.
Tabel 3. Perbandingan antara partisi LIST dan partisi LIST COLUMNS
Jenis Partisi | Kunci Partisi yang Didukung | Apakah mendukung fungsi partisi | Sintaks Pernyataan | Batasan | Kebijakan Rute (query titik) |
List Columns | Kunci partisi kolom tunggal dan kunci partisi vektor | Dinonaktifkan | PARTITION BY LIST COLUMNS (c1,c2,...,cn) ( PARTITION p1 VALUES IN ((1,10,...,1000),(2,20,...,2000) ), PARTITION p2 VALUES IN ((3,30,...,3000),(3,30,...,3000) ), ...) | Pemisahan partisi panas tidak didukung. |
|
List | Kunci partisi kolom tunggal | Diaktifkan | PARTITION BY LIST(YEAR(c1)) ( PARTITION p1 VALUES IN (2018,2019), PARTITION p2 VALUES IN (2020,2021) ...) | Pemisahan partisi panas tidak didukung. |
Example 3-1: LIST COLUMNS partitioning
Partisi LIST COLUMNS mendukung kunci partisi vektor tetapi tidak mendukung fungsi partisi. Misalnya, Anda dapat mengeksekusi pernyataan berikut untuk membuat tabel yang dipartisi berdasarkan nilai dalam kolom negara dan kota:
CREATE TABLE orders_region(
id int,
country varchar(64),
city varchar(64),
order_time datetime not null)
PARTITION BY LIST COLUMNS(country,city)
(
PARTITION p1 VALUES IN (('China','Hangzhou'), ('China','Beijing')),
PARTITION p2 VALUES IN (('United States','NewYork'),('United States','Chicago')),
PARTITION p3 VALUES IN (('Russian','Moscow'))
);Partisi LIST COLUMNS tidak mendukung kunci partisi yang berisi data TIMESTAMP atau TIME.
Example 3-2: LIST partitioning
Partisi LIST hanya mendukung kunci partisi kolom tunggal. Jika Anda ingin menggunakan kolom yang berisi nilai tanggal dan waktu sebagai kolom kunci partisi, Anda harus menggunakan fungsi partisi seperti YEAR, MONTH, DAYOFMONTH, TO_DAYS, atau TO_SECONDS untuk mengonversi nilai timestamp dalam kolom kunci partisi menjadi integer.
Misalnya, Anda dapat mengeksekusi pernyataan berikut untuk membuat tabel yang dipartisi berdasarkan nilai dalam kolom order_time dan menyimpan data dalam partisi yang berbeda per tahun:
CREATE TABLE orders_years(
id int,
country varchar(64),
city varchar(64),
order_time datetime not null)
PARTITION BY LIST(YEAR(order_time))
(
PARTITION p1 VALUES IN (1990,1991,1992,1993,1994,1995,1996,1997,1998,1999),
PARTITION p2 VALUES IN (2000,2001,2002,2003,2004,2005,2006,2007,2008,2009),
PARTITION p3 VALUES IN (2010,2011,2012,2013,2014,2015,2016,2017,2018,2019)
);Dalam partisi LIST, hanya kolom yang berisi nilai integer yang dapat digunakan sebagai kolom kunci partisi. Kolom yang berisi string tidak dapat digunakan sebagai kolom kunci partisi.
Example 3-3: LIST COLUMNS partitioning or LIST partitioning with a DEFAULT partition
PolarDB-X memungkinkan Anda membuat partisi LIST COLUMNS atau LIST dengan partisi DEFAULT. Data yang tidak didefinisikan dalam partisi umum dirutekan ke partisi DEFAULT.
Hanya satu partisi DEFAULT yang dapat ditentukan, dan hanya dapat muncul sebagai partisi terakhir.
CREATE TABLE orders_region(
id int,
country varchar(64),
city varchar(64),
order_time datetime not null)
PARTITION BY LIST COLUMNS(country,city)
(
PARTITION p1 VALUES IN (('China','Hangzhou'), ('China','Beijing')),
PARTITION p2 VALUES IN (('United States','NewYork'),('United States','Chicago')),
PARTITION p3 VALUES IN (('Russian','Moscow')),
PARTITION pd VALUES IN (DEFAULT)
);
CREATE TABLE orders_years(
id int,
country varchar(64),
city varchar(64),
order_time datetime not null)
PARTITION BY LIST(YEAR(order_time))
(
PARTITION p1 VALUES IN (1990,1991,1992,1993,1994,1995,1996,1997,1998,1999),
PARTITION p2 VALUES IN (2000,2001,2002,2003,2004,2005,2006,2007,2008,2009),
PARTITION p3 VALUES IN (2010,2011,2012,2013,2014,2015,2016,2017,2018,2019),
PARTITION pd VALUES IN (DEFAULT)
);Limits
Batasan pada tipe data
Tipe bilangan bulat: BIGINT, BIGINT UNSIGNED, INT UNSIGNED, INT, MEDIUMINT, MEDIUMINT UNSIGNED, SMALLINT, SMALLINT UNSIGNED, TINYINT, dan TINYINT UNSIGNED.
Tipe tanggal dan waktu: DATETIME dan DATE.
Tipe string: CHAR dan VARCHAR.
Batasan pada sintaks
Partisi LIST COLUMNS tidak mendukung kolom tipe TIMESTAMP sebagai kolom kunci partisi.
Dalam partisi LIST, hanya kolom yang berisi nilai integer yang dapat digunakan sebagai kolom kunci partisi.
Partisi LIST COLUMNS dan partisi LIST tidak mendukung pemisahan partisi panas.
Secara default, tabel terpartisi dapat berisi hingga 8.192 partisi.
Secara default, kunci partisi dapat terdiri dari hingga lima kolom kunci partisi.
Partisi COHASH
Jenis partisi COHASH eksklusif untuk PolarDB-X.
Versi yang Didukung
Versi instance harus 5.4.18-17047709 atau lebih baru.
Skenario
Jenis partisi COHASH cocok untuk skenario berikut:
Tabel bisnis berisi satu atau lebih kolom serupa. Misalnya, tabel berisi kolom c1 dan c2 di mana empat karakter terakhir dari nilai kolom selalu sama. Anda ingin mempartisi tabel berdasarkan kolom-kolom tersebut dan menyertakan kondisi query ekuivalen dari kolom c1 atau c2 dalam query. Anda juga ingin merutekan kondisi tersebut ke partisi yang sama.
Untuk menggunakan jenis partisi ini dalam kasus ini, Anda harus menjaga kesamaan antara nilai kolom kunci partisi yang berbeda dalam tabel yang dipartisi.
Contoh 4-1: Gunakan fungsi partisi untuk menentukan kesamaan antara nilai kolom kunci partisi yang berbeda dalam tabel yang dipartisi COHASH
Anggaplah kolom order_id dan buyer_id dari tabel pesanan berisi empat karakter terakhir yang sama dalam baris yang sama. Jika Anda ingin mempartisi tabel pesanan berdasarkan enam karakter terakhir dalam kolom order_id dan buyer_id, dan ingin kondisi ekuivalen dari kolom dalam baris yang sama dirutekan ke partisi yang sama, eksekusi pernyataan berikut:
CREATE TABLE t_orders(
id bigint not null auto_increment,
order_id bigint,
buyer_id bigint,
order_time datetime not null,
primary key(id)
)
PARTITION BY CO_HASH(
RIGHT('order_id',6) /* Partisi tabel berdasarkan enam karakter terakhir dari nilai kolom c1.*/,
RIGHT('buyer_id',6) /* Partisi tabel berdasarkan enam karakter terakhir dari nilai kolom c2.*/
)
PARTITIONS 8;Contoh 4-2: Gunakan syntactic sugar RANGE_HASH untuk memigrasikan instance PolarDB-X 1.0 ke instance PolarDB-X 2.0
Anda ingin memigrasikan instance PolarDB-X 1.0 ke instance PolarDB-X 2.0. Instance sumber memiliki tabel pesanan yang menggunakan skema sharding range_hash. Tabel tersebut didefinisikan dengan sintaks DBPARTITION BY RANGE_HASH(`order_id`,`buyer_id`, 6). Definisi tabel partisi yang sesuai untuk tabel dalam database instance tujuan pada mode AUTO adalah sebagai berikut:
CREATE TABLE orders(
id bigint not null auto_increment,
buyer_id bigint,
order_id bigint,
...
primary key(id)
)
PARTITION BY RANGE_HASH(order_id, buyer_Id,6)
PARTITIONS 8;PolarDB-X secara otomatis mengonversi sintaks RANGE_HASH menjadi definisi partisi COHASH yang sesuai. Sebagai contoh, klausa RANGE_HASH(order_id, buyer_Id, 6) dalam pernyataan di atas dikonversi oleh PolarDB-X menjadi definisi partisi COHASH berikut:
CREATE TABLE orders(
id bigint not null auto_increment,
buyer_id bigint,
order_id bigint,
...
primary key(id)
)
PARTITION BY CO_HASH(
RIGHT('order_id',6) /* Partisi tabel berdasarkan enam karakter terakhir dari nilai kolom c1.*/,
RIGHT('buyer_id',6) /* Partisi tabel berdasarkan enam karakter terakhir dari nilai kolom c2.*/
)
PARTITIONS 8;Perbandingan Partisi COHASH, HASH, dan KEY
Tipe partisi COHASH serupa dengan tipe partisi HASH dan KEY. Tabel berikut menyajikan perbandingan antara tipe-tipe tersebut.
Perbedaan | CO_HASH | KEY | HASH |
Sintaks | PARTITION BY CO_HASH(c1, c2) PARTITIONS 8 | PARTITION BY KEY(c1, c2) PARTITIONS 8 | PARTITION BY HASH(c1, c2) PARTISI 8 |
Kunci partisi kolom tunggal | Tidak didukung | Didukung | Didukung |
Kunci partisi vektor | Didukung | Didukung | Didukung |
Fungsi partisi pada kolom kunci partisi vektor | Didukung. Contoh: PARTITION BY CO_HASH( /* Partisi tabel berdasarkan empat karakter terakhir dari nilai kolom c1.*/ RIGHT(c1, 4), /* Partisi tabel berdasarkan empat karakter terakhir dari nilai kolom c2.*/ RIGHT(c2, 4) ) PARTITIONS 8 | Tidak didukung | Tidak didukung |
Hubungan antar kolom kunci partisi | Nilai dalam kolom serupa. Anda harus menjaga kesamaan antara nilai kolom kunci partisi yang berbeda dalam tabel yang dipartisi. Contoh:
| Mirip dengan awalan indeks federasi. | Mirip dengan awalan indeks federasi. |
Query ekuivalen untuk kolom kunci partisi dengan awalan, pemangkasan partisi, dan contoh | Didukung. Contoh:
| Didukung. Contoh:
| Tidak didukung. Pemangkasan partisi hanya didukung ketika kondisi ekuivalen untuk semua kolom kunci partisi disertakan. Contoh:
|
Query ekuivalen untuk kolom kunci partisi tanpa awalan, pemangkasan partisi, dan contoh | Didukung. Kondisi ekuivalen untuk semua kolom kunci partisi mendukung pemangkasan partisi. Contoh:
| Tidak didukung. Kondisi ekuivalen untuk partisi tanpa awalan harus menghasilkan pemindaian untuk semua partisi. Contoh:
| Tidak didukung. Kondisi ekuivalen untuk partisi tanpa awalan harus menghasilkan pemindaian untuk semua partisi. Contoh:
|
Query rentang | Tidak didukung. Semua partisi dipindai. | Tidak didukung. Semua partisi dipindai. | Tidak didukung. Semua partisi dipindai. |
Kebijakan rute (query titik) |
| Lihat konten sebelumnya terkait partisi KEY dan HASH. | Lihat konten sebelumnya terkait partisi KEY dan HASH. |
Pemisahan partisi panas | Tidak didukung. Pemisahan partisi panas lebih lanjut tidak dapat dilakukan pada nilai kunci panas seperti c1='88'. | Didukung | Tidak didukung |
Manajemen partisi seperti pemisahan, penggabungan, dan migrasi partisi | Didukung | Didukung | Didukung |
Partisi level-2 | Didukung | Didukung | Didukung |
Catatan Penggunaan
Anda harus memastikan kesamaan antara nilai kolom kunci partisi yang berbeda. Tabel partisi hanya memeriksa hasil rute. Nilai kolom kunci partisi yang berbeda dalam tabel COHASH dikelola oleh Anda. Oleh karena itu, setiap baris dalam tabel harus dirutekan ke partisi yang sama berdasarkan nilai kolom kunci partisi tersebut. Namun, kesamaan antara nilai kolom kunci partisi yang berbeda dapat terganggu. PolarDB-X hanya memvalidasi hasil rute dan tidak memeriksa kesamaannya.
Sebagai contoh, jika empat karakter terakhir dari nilai kolom c1 dan c2 harus sama, dan c1=1001234 serta c2=1320 dirutekan ke shard 0, maka pernyataan
insert (c1,c2) values (100234,1320)akan didukung. Namun, empat karakter terakhir dari nilai kolom tersebut berbeda.
Batasan diberlakukan saat pernyataan DML digunakan untuk memodifikasi kolom kunci partisi. Nilai kolom kunci partisi dalam tabel COHASH serupa. Untuk mencegah distribusi data yang salah, PolarDB-X memberlakukan batasan berikut ketika Anda menggunakan pernyataan DML untuk memodifikasi nilai kolom kunci partisi:
Jika nilai kolom kunci partisi yang berbeda dalam baris yang sama pada klausa VALUES dari pernyataan INSERT atau REPLACE dirutekan ke partisi yang berbeda, nilai tersebut tidak dapat dimasukkan dan kesalahan akan dilaporkan.
Jika Anda ingin menggunakan klausa SET dari pernyataan UPDATE atau UPSERT untuk memodifikasi beberapa kolom kunci partisi, Anda harus memodifikasi semua kolom kunci partisi. Sebagai contoh, jika kolom c1 dan c2 adalah kolom kunci partisi, Anda dapat menggunakan pernyataan
UPDATE t1 SET c1='xx',c2='yy' WHERE id=1untuk memodifikasi nilai kolom. Jika setelah menggunakan klausa SET untuk memodifikasi beberapa kolom kunci partisi, nilai baru dari kolom tersebut dirutekan ke partisi yang berbeda, pernyataan UPDATE atau UPSERT akan dilarang dan kesalahan dilaporkan.Setelah Anda menggunakan jenis partisi COHASH untuk tabel GSI, jika operasi DML seperti INSERT atau UPDATE pada tabel utama menyebabkan nilai kolom kunci partisi yang berbeda dalam baris yang sama dari tabel GSI dirutekan ke partisi yang berbeda, operasi tersebut juga dilarang dan kesalahan dilaporkan.
Awalan kolom kunci partisi dalam tabel yang dipartisi COHASH adalah 0. Nilai kolom kunci partisi yang berbeda dalam tabel yang dipartisi COHASH cenderung serupa. Oleh karena itu, kolom-kolom tersebut harus didefinisikan menggunakan fungsi partisi seperti SUBSTR, LEFT, atau RIGHT. Setelah beberapa digit dari tipe integer dipotong, awalan 0 dihasilkan. Sebagai contoh, jika Anda menentukan bahwa empat karakter terakhir dari nilai kolom c1 dan c2 sama, dengan c1=1000034 dan c2=34, maka empat karakter terakhir dari nilai kolom c1 adalah '0034'. Setelah semua nilai asli kolom kunci partisi dalam tabel yang dipartisi COHASH yang menggunakan tipe integer dipotong, nilai asli secara otomatis dikonversi menjadi integer sesuai dengan nilai baru sebelum dirutekan. Dengan demikian, string '0034' dikonversi menjadi '34'. Selanjutnya, hash dari string '34' dihitung dan dirutekan ke partisi. Dengan cara ini, awalan dari string '0034' diproses secara otomatis.
Batasan Fungsi Partisi
RIGHT
LEFT
SUBSTR
Batasan pada Tipe Data
Tipe bilangan bulat: BIGINT, BIGINT UNSIGNED, INT, INT UNSIGNED, MEDIUMINT, MEDIUMINT UNSIGNED, SMALLINT, SMALLINT UNSIGNED, TINYINT, dan TINYINT UNSIGNED.
Tipe titik tetap: DECIMAL. Bagian desimal dari tipe data ini harus bernilai nol.
Tipe tanggal dan waktu: Tidak didukung.
Tipe string: CHAR dan VARCHAR.
Batasan Sintaks
Jika fungsi partisi digunakan pada kolom kunci partisi, beberapa fungsi partisi bersarang tidak dapat diterapkan pada kolom tersebut. Contoh:
SUBSTR(SUBSTR(c1,-6),-4).
Saat menggunakan syntactic sugar RANGE_HASH, nilai panjang terakhir tidak boleh negatif.
Tipe semua kolom kunci partisi harus identik dalam hal berikut:
Charsets dan collation.
Definisi panjang dan presisi.
Secara default, tabel yang dipartisi dapat memiliki hingga 8.192 partisi.
Secara default, kunci partisi dapat mencakup hingga lima kolom kunci partisi.
Partisi Level-2
Mirip dengan MySQL, PolarDB-X memungkinkan Anda menggunakan sintaks partisi level-2 untuk membuat tabel yang dipartisi yang berisi partisi level-2. Partisi level-2 adalah subpartisi dari semua partisi level-1 berdasarkan kolom kunci partisi tertentu dan kebijakan partisi.
Setiap partisi level-1 dari partisi level-2 sebenarnya menjadi satu partisi logis dan sesuai dengan satu set partisi level-2.
Setiap subpartisi dari partisi level-2 sebenarnya menjadi satu partisi fisik dan sesuai dengan satu shard tabel fisik pada node data.
Sintaks bertemplate dan non-template
Dalam PolarDB-X, partisi level-2 dibagi menjadi dua jenis partisi: partisi bertemplate dan partisi non-template.
Partisi level-2 bertemplate: Jumlah partisi level-2 di bawah setiap partisi level-1 selalu konsisten dengan nilai batas setiap partisi level-1.
Partisi level-2 non-template: Jumlah partisi level-2 di bawah setiap partisi level-1 dapat tidak konsisten dengan nilai batas setiap partisi level-1.
Batasan pada sintaks
Dalam tabel yang dipartisi yang berisi partisi level-2, jumlah partisi fisik tidak boleh melebihi 8.192 secara default.
Dalam tabel yang dipartisi yang berisi partisi level-1 non-template, nama setiap partisi level-2 harus unik dan tidak boleh duplikat dengan nama semua partisi level-1.
Dalam tabel yang dipartisi yang berisi partisi level-1 bertemplate, nama setiap partisi level-2 bertemplate harus unik dan tidak boleh duplikat dengan nama semua partisi level-1.
Setelah partisi level-2 digunakan, jumlah partisi level-2 dalam tabel yang dipartisi adalah total jumlah partisi level-2 di bawah semua partisi level-1. Oleh karena itu, jumlah partisi dalam tabel yang dipartisi meningkat secara eksponensial. Untuk menghindari efek negatif yang disebabkan oleh operasi partisi yang berlebihan atau kesalahan yang disebabkan oleh kegagalan mempertahankan jumlah total partisi, kami sarankan Anda hati-hati mengontrol jumlah shard dalam partisi level-1 dan level-2.
Contoh 5-1: Partisi level template
/*
* Tentukan subpartisi bertemplate berdasarkan partisi LIST dan partisi KEY.
* Partisi Level-1 dibagi menjadi tiga partisi level-2 berdasarkan partisi LIST COLUMNS.
* Setiap partisi level-2 dibagi menjadi empat subpartisi berdasarkan partisi KEY.
* Oleh karena itu, jumlah total partisi fisik adalah 12.
*/
CREATE TABLE sp_tbl_list_key_tp(
id int,
country varchar(64),
city varchar(64),
order_time datetime not null,
PRIMARY KEY(id)
)
PARTITION BY LIST COLUMNS(country,city)
SUBPARTITION BY KEY(id) SUBPARTITIONS 4
(
PARTITION p1 VALUES IN (('China','Hangzhou')),
PARTITION p2 VALUES IN (('Russian','Moscow')),
PARTITION p3 VALUES IN (DEFAULT)
);Contoh 5-2: Partisi level-2 non-template
/*
* Tentukan subpartisi non-template berdasarkan partisi LIST dan partisi KEY.
* Partisi Level-1 dibagi menjadi tiga partisi level-2 berdasarkan partisi LIST COLUMNS.
* Setiap partisi level-2 dibagi menjadi satu atau lebih subpartisi berdasarkan partisi KEY.
* Jumlah subpartisi yang ditentukan dalam setiap partisi level-2 adalah 2, 3, dan 4.
* Oleh karena itu, jumlah total partisi fisik adalah 9.
*/
CREATE TABLE sp_tbl_list_key_ntp(
id int,
country varchar(64),
city varchar(64),
order_time datetime not null,
PRIMARY KEY(id)
)
PARTITION BY LIST COLUMNS(country,city)
SUBPARTITION BY KEY(id)
(
PARTITION p1 VALUES IN (('China','Hangzhou')) SUBPARTITIONS 2,
PARTITION p2 VALUES IN (('Russian','Moscow')) SUBPARTITIONS 3,
PARTITION pd VALUES IN (DEFAULT) SUBPARTITIONS 4
);Partisi Otomatis
Secara default, partisi otomatis dinonaktifkan untuk basis data dalam mode AUTO. Untuk mengaktifkan partisi otomatis untuk basis data dalam mode AUTO, eksekusi pernyataan berikut:
SET GLOBAL AUTO_PARTITION=true;Setelah Anda mengaktifkan partisi otomatis:
Jika Anda tidak menentukan kunci partisi dalam pernyataan CREATE TABLE, PolarDB-X melakukan partisi otomatis default menggunakan partisi KEY berdasarkan kunci utama untuk membuat tabel partisi level-1. Jika Anda tidak menentukan kunci utama, PolarDB-X menggunakan kunci utama implisit sebagai kunci partisi.
Jumlah partisi default tempat tabel dipartisi menggunakan metode partisi otomatis default dapat dihitung menggunakan rumus berikut: Jumlah node logis dalam instance PolarDB-X x 8. Misalnya, jika jumlah node logis dalam instance PolarDB-X adalah 2, jumlah partisi default adalah 16.
Secara default, tabel utama dipartisi berdasarkan kunci utama, dan semua indeks tabel utama dipartisi secara otomatis berdasarkan kolom kunci indeks dan kolom kunci utama.
Contoh berikut menunjukkan sintaks standar pernyataan CREATE TABLE. Dalam contoh ini, kolom kunci utama adalah kolom id, dan kolom kunci indeks adalah kolom name.
CREATE TABLE auto_part_tbl(
id bigint not null auto_increment,
bid int,
name varchar(30),
primary key(id),
index idx_name (name)
);Jika Anda mengeksekusi pernyataan SHOW CREATE TABLE untuk memeriksa informasi tentang pernyataan CREATE TABLE, sintaks standar pernyataan CREATE TABLE diperiksa dan semua informasi partisi tidak dikembalikan.
show create table auto_part_tbl;
+---------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| TABLE | CREATE TABLE |
+---------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| auto_part_tbl | CREATE TABLE `auto_part_tbl` (
`id` bigint(20) NOT NULL AUTO_INCREMENT,
`bid` int(11) DEFAULT NULL,
`name` varchar(30) DEFAULT NULL,
PRIMARY KEY (`id`),
INDEX `idx_name` (`name`)
) ENGINE = InnoDB DEFAULT CHARSET = utf8 |
+---------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
1 row in set (0.06 sec)Jika Anda mengeksekusi pernyataan SHOW FULL CREATE TABLE untuk memeriksa informasi tentang pernyataan CREATE TABLE, semua informasi partisi dari tabel utama dan tabel indeks sebelumnya dikembalikan.
show full create table auto_part_tbl;
+---------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| TABLE | CREATE TABLE |
+---------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| auto_part_tbl | CREATE PARTITION TABLE `auto_part_tbl` (
`id` bigint(20) NOT NULL AUTO_INCREMENT,
`bid` int(11) DEFAULT NULL,
`name` varchar(30) DEFAULT NULL,
PRIMARY KEY (`id`),
GLOBAL INDEX /* idx_name_$a870 */ `idx_name` (`name`) PARTITION BY KEY (`name`, `id`) PARTITIONS 16,
LOCAL KEY `_local_idx_name` (`name`)
) ENGINE = InnoDB DEFAULT CHARSET = utf8
PARTITION BY KEY(`id`)
PARTITIONS 16
/* tablegroup = `tg108` */ |
+---------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
1 row in set (0.03 sec)Hasil eksekusi sebelumnya menunjukkan bahwa:
Tabel utama bernama auto_part_tbl dipartisi secara otomatis berdasarkan kolom id menjadi 16 partisi menggunakan partisi KEY.
Indeks tabel utama adalah idx_name yang merupakan indeks global, dan tabel indeks dipartisi menjadi 16 partisi berdasarkan kolom kunci partisi 'name' dan 'id'.
Partisi Manual
Jika Anda menentukan kolom kunci partisi, fungsi partisi, dan jenis partisi dalam pernyataan CREATE TABLE, tabel yang dipartisi secara manual dibuat setelah pernyataan dieksekusi. Untuk informasi lebih lanjut, lihat Buat tabel partisi secara manual (mode AUTO).
Tipe data yang Didukung
Tabel 4 Tipe data kolom kunci partisi dalam jenis partisi yang berbeda
Tipe data | Partisi HASH | Partisi RANGE | Partisi LIST | |||||
HASH | Kunci | Rentang | Kolom Rentang | List | Kolom Daftar | |||
Kolom kunci partisi tunggal | Kolom kunci partisi ganda | |||||||
Bilangan Bulat | TINYINT |
|
|
|
|
|
|
|
TINYINT UNSIGNED |
|
|
|
|
|
|
| |
SMALLINT |
|
|
|
|
|
|
| |
SMALLINT UNSIGNED |
|
|
|
|
|
|
| |
MEDIUMINT |
|
|
|
|
|
|
| |
MEDIUMINT UNSIGNED |
|
|
|
|
|
|
| |
INT |
|
|
|
|
|
|
| |
INT UNSIGNED |
|
|
|
|
|
|
| |
BIGINT |
|
|
|
|
|
|
| |
BIGINT UNSIGNED |
|
|
|
|
|
|
| |
Bilangan titik tetap | DESIMAL |
(Fungsi partisi tidak didukung oleh kolom kunci partisi yang berisi nilai dari tipe data ini.) |
|
|
|
|
|
|
Tanggal dan waktu | TANGGAL |
|
|
|
|
|
|
|
DATETIME |
|
|
|
|
|
|
| |
TIMESTAMP |
|
|
|
|
|
|
| |
String | CHAR |
|
|
|
|
|
|
|
VARCHAR |
|
|
|
|
|
|
| |
Biner | BINARY |
|
|
|
|
|
|
|
VARBINARY |
|
|
|
|
|
|
| |
Tipe data kolom kunci partisi dan kebijakan rute
Strategi rute data yang digunakan selama partisi ditentukan oleh tipe data kolom kunci partisi, terutama dalam partisi HASH dan KEY. Jika Anda menggunakan kolom yang berisi tipe data berbeda sebagai kolom kunci partisi, data dirutekan ke partisi dengan cara yang berbeda berdasarkan algoritma hashing atau perbandingan yang berbeda. Misalnya, algoritma perbandingan dapat digunakan untuk merutekan data berdasarkan perbandingan sensitif huruf besar-kecil atau perbandingan tidak sensitif huruf besar-kecil. Strategi rute data MySQL juga ditentukan oleh tipe data kolom kunci partisi.
Dalam contoh berikut, tabel bernama tbl_int dipartisi menjadi 1.024 partisi berdasarkan kolom kunci partisi yang berisi nilai INT, dan tabel bernama tbl_bigint dipartisi menjadi 1.024 partisi berdasarkan kolom kunci partisi yang berisi nilai BIGINT. Tipe data kolom kunci partisi dari kedua tabel tersebut berbeda. Oleh karena itu, PolarDB-X merutekan data ke partisi yang berbeda saat nilai yang sama 12345678 diperiksa di kedua tabel.
show create table tbl_int;
+---------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| TABLE | CREATE TABLE |
+---------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| tbl_int | CREATE TABLE `tbl_int` (
`a` int(11) NOT NULL,
KEY `auto_shard_key_a` USING BTREE (`a`)
) ENGINE = InnoDB DEFAULT CHARSET = utf8mb4
PARTITION BY KEY(`a`)
PARTITIONS 1024 |
+---------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
1 row in set (0.02 sec)
show create table tbl_bigint;
+------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| TABLE | CREATE TABLE |
+------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| tbl_bigint | CREATE TABLE `tbl_bigint` (
`a` bigint(20) NOT NULL,
KEY `auto_shard_key_a` USING BTREE (`a`)
) ENGINE = InnoDB DEFAULT CHARSET = utf8mb4
PARTITION BY KEY(`a`)
PARTITIONS 1024 |
+------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
1 row in set (0.10 sec)mysql> create table if not exists tbl_bigint(a bigint not null)
-> partition by key(a) partitions 1024;
Query OK, 0 rows affected (28.41 sec)
explain select * from tbl_int where a=12345678;
+---------------------------------------------------------------------------------------------------+
| LOGICAL EXECUTIONPLAN |
+---------------------------------------------------------------------------------------------------+
| LogicalView(tables="tbl_int[p260]", sql="SELECT `a` FROM `tbl_int` AS `tbl_int` WHERE (`a` = ?)") |
| HitCache:false |
| Source:PLAN_CACHE |
| TemplateId: c90af636 |
+---------------------------------------------------------------------------------------------------+
4 rows in set (0.45 sec)
explain select * from tbl_bigint where a=12345678;
+------------------------------------------------------------------------------------------------------------+
| LOGICAL EXECUTIONPLAN |
+------------------------------------------------------------------------------------------------------------+
| LogicalView(tables="tbl_bigint[p477]", sql="SELECT `a` FROM `tbl_bigint` AS `tbl_bigint` WHERE (`a` = ?)") |
| HitCache:false |
| Source:PLAN_CACHE |
| TemplateId: 9b2fa47c |
+------------------------------------------------------------------------------------------------------------+
4 rows in set (0.02 sec)
The case-sensitiveness, character set, and collation of partition key columns
Set karakter dan collation kolom kunci partisi dari tabel yang dipartisi menentukan strategi rute data yang digunakan untuk merutekan data dalam tabel. Misalnya, set karakter dan collation menentukan apakah perbandingan sensitif huruf besar-kecil diperlukan. Jika collation tabel yang dipartisi sensitif huruf besar-kecil, perbandingan sensitif huruf besar-kecil dilakukan selama rute data berdasarkan algoritma hashing atau perbandingan. Jika collation tabel yang dipartisi tidak sensitif huruf besar-kecil, perbandingan sensitif huruf besar-kecil tidak dilakukan selama rute data. Secara default, kolom kunci partisi yang berisi string menggunakan set karakter UTF-8 dan collation utf8_general_ci yang tidak memerlukan perbandingan sensitif huruf besar-kecil.
Example 1
Jika Anda ingin melakukan rute data pada tabel yang dipartisi secara sensitif huruf besar-kecil, atur collation tabel yang dipartisi ke collation sensitif huruf besar-kecil, seperti utf8_bin, saat Anda membuat tabel. Dalam pernyataan sampel berikut, CHARACTER SET utf8 COLLATE utf8_bin ditentukan untuk tabel yang dipartisi tbl_varchar_cs. Dalam hal ini, sistem merutekan string 'AbcD' dan 'abcd' ke partisi yang berbeda dari tabel.
show create table tbl_varchar_cs;
+----------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| TABLE | CREATE TABLE |
+----------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| tbl_varchar_cs | CREATE TABLE `tbl_varchar_cs` (
`a` varchar(64) CHARACTER SET utf8 COLLATE utf8_bin NOT NULL,
KEY `auto_shard_key_a` USING BTREE (`a`)
) ENGINE = InnoDB DEFAULT CHARSET = utf8
PARTITION BY KEY(`a`)
PARTITIONS 64 |
+----------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
1 row in set (0.07 sec)
explain select a from tbl_varchar_cs where a in ('AbcD');
+-------------------------------------------------------------------------------------------------------------------------+
| LOGICAL EXECUTIONPLAN |
+-------------------------------------------------------------------------------------------------------------------------+
| LogicalView(tables="tbl_varchar_cs[p29]", sql="SELECT `a` FROM `tbl_varchar_cs` AS `tbl_varchar_cs` WHERE (`a` IN(?))") |
| HitCache:false |
| Source:PLAN_CACHE |
| TemplateId: 2c49c244 |
+-------------------------------------------------------------------------------------------------------------------------+
4 rows in set (0.11 sec)
explain select a from tbl_varchar_cs where a in ('abcd');
+-------------------------------------------------------------------------------------------------------------------------+
| LOGICAL EXECUTIONPLAN |
+-------------------------------------------------------------------------------------------------------------------------+
| LogicalView(tables="tbl_varchar_cs[p11]", sql="SELECT `a` FROM `tbl_varchar_cs` AS `tbl_varchar_cs` WHERE (`a` IN(?))") |
| HitCache:true |
| Source:PLAN_CACHE |
| TemplateId: 2c49c244 |
+-------------------------------------------------------------------------------------------------------------------------+
4 rows in set (0.02 sec)Example 2
Jika Anda ingin melakukan rute data pada tabel yang dipartisi secara tidak sensitif huruf besar-kecil, atur collation tabel yang dipartisi ke collation tidak sensitif huruf besar-kecil, seperti utf8_general_ci, saat Anda membuat tabel. Dalam pernyataan sampel berikut, CHARACTER SET utf8 COLLATE utf8_general_ci ditentukan untuk tabel yang dipartisi tbl_varchar_ci. Dalam hal ini, sistem merutekan string 'AbcD' dan 'abcd' ke partisi yang sama.
show create table tbl_varchar_ci;
+----------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| TABLE | CREATE TABLE |
+----------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| tbl_varchar_ci | CREATE TABLE `tbl_varchar_ci` (
`a` varchar(64) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
KEY `auto_shard_key_a` USING BTREE (`a`)
) ENGINE = InnoDB DEFAULT CHARSET = utf8
PARTITION BY KEY(`a`)
PARTITIONS 64 |
+----------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
1 row in set (0.06 sec)
explain select a from tbl_varchar_ci where a in ('AbcD');
+------------------------------------------------------------------------------------------------------------------------+
| LOGICAL EXECUTIONPLAN |
+------------------------------------------------------------------------------------------------------------------------+
| LogicalView(tables="tbl_varchar_ci[p4]", sql="SELECT `a` FROM `tbl_varchar_ci` AS `tbl_varchar_ci` WHERE (`a` IN(?))") |
| HitCache:false |
| Source:PLAN_CACHE |
| TemplateId: 5c97178e |
+------------------------------------------------------------------------------------------------------------------------+
4 rows in set (0.15 sec)
explain select a from tbl_varchar_ci where a in ('abcd');
+------------------------------------------------------------------------------------------------------------------------+
| LOGICAL EXECUTIONPLAN |
+------------------------------------------------------------------------------------------------------------------------+
| LogicalView(tables="tbl_varchar_ci[p4]", sql="SELECT `a` FROM `tbl_varchar_ci` AS `tbl_varchar_ci` WHERE (`a` IN(?))") |
| HitCache:true |
| Source:PLAN_CACHE |
| TemplateId: 5c97178e |
+------------------------------------------------------------------------------------------------------------------------+
4 rows in set (0.02 sec)Change the character set and collation of partition key columns
Strategi rute data tabel yang dipartisi ditentukan oleh tipe data kolom kunci partisi tabel. Setelah Anda mengubah set karakter dan collation kolom kunci partisi, PolarDB-X mendistribusikan ulang semua data pada partisi. Berhati-hatilah saat Anda mengubah set karakter dan collation kolom kunci partisi tabel.
Pemotongan dan konversi tipe data kolom kunci partisi
Truncate values in partition key columns
Saat Anda mengeksekusi pernyataan SQL untuk query atau menyisipkan data, jika nilai kunci partisi yang ditentukan oleh ekspresi konstan melebihi rentang valid dari tipe data kolom kunci partisi, PolarDB-X memotong nilai yang ditentukan berdasarkan tipe data kolom kunci partisi dan kemudian menggunakan nilai yang dipotong untuk menghitung strategi rute.
Sebagai contoh, tipe data kolom kunci partisi tabel bernama tbl_smallint adalah SMALLINT. Rentang nilai SMALLINT yang valid adalah [-32768, 32767]. Jika Anda menyisipkan nilai yang tidak berada dalam rentang nilai SMALLINT yang valid, seperti 12745678 atau -12345678, nilai tersebut akan dipotong menjadi 32767 atau -32768. Contoh berikut menunjukkan bagaimana nilai kunci partisi dipotong.
show create table tbl_smallint;
+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| TABLE | CREATE TABLE |
+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| tbl_smallint | CREATE TABLE `tbl_smallint` (
`a` smallint(6) NOT NULL,
KEY `auto_shard_key_a` USING BTREE (`a`)
) ENGINE = InnoDB DEFAULT CHARSET = utf8mb4
PARTITION BY KEY(`a`)
PARTITIONS 128 |
+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
1 row in set (0.06 sec)
set sql_mode='';
Query OK, 0 rows affected (0.00 sec)
insert into tbl_smallint values (12345678),(-12345678);
Query OK, 2 rows affected (0.07 sec)
select * from tbl_smallint;
+--------+
| a |
+--------+
| -32768 |
| 32767 |
+--------+
2 rows in set (3.51 sec)
explain select * from tbl_smallint where a=12345678;
+------------------------------------------------------------------------------------------------------------------+
| LOGICAL EXECUTIONPLAN |
+------------------------------------------------------------------------------------------------------------------+
| LogicalView(tables="tbl_smallint[p117]", sql="SELECT `a` FROM `tbl_smallint` AS `tbl_smallint` WHERE (`a` = ?)") |
| HitCache:false |
| Source:PLAN_CACHE |
| TemplateId: afb464d5 |
+------------------------------------------------------------------------------------------------------------------+
4 rows in set (0.16 sec)
explain select * from tbl_smallint where a=32767;
+------------------------------------------------------------------------------------------------------------------+
| LOGICAL EXECUTIONPLAN |
+------------------------------------------------------------------------------------------------------------------+
| LogicalView(tables="tbl_smallint[p117]", sql="SELECT `a` FROM `tbl_smallint` AS `tbl_smallint` WHERE (`a` = ?)") |
| HitCache:true |
| Source:PLAN_CACHE |
| TemplateId: afb464d5 |
+------------------------------------------------------------------------------------------------------------------+
4 rows in set (0.03 sec)Jika Anda menentukan nilai kunci utama yang tidak berada dalam rentang nilai SMALLINT yang valid dalam permintaan query, PolarDB-X juga memotong nilai tersebut, lalu merutekan data berdasarkan nilai kunci utama yang telah dipotong. Saat menjalankan query pada tabel tbl_smallint, PolarDB-X mengembalikan hasil yang sama saat Anda menetapkan nilai kolom kunci partisi menjadi 12345678 atau 32767 dalam permintaan query.
Convert the data type of values in partition key columns
Saat Anda mengeksekusi pernyataan SQL untuk query atau menyisipkan data, jika tipe data kolom kunci partisi yang ditentukan oleh ekspresi konstan berbeda dari tipe data sebenarnya dari kolom tersebut, PolarDB-X secara implisit mengonversi tipe data lalu melakukan rute berdasarkan nilai dari tipe data baru. Namun, konversi tipe data mungkin gagal. Sebagai contoh, string abc tidak dapat dikonversi menjadi integer.
Saat PolarDB-X mengonversi tipe data kolom kunci partisi, operasi yang berbeda dilakukan untuk pernyataan DQL, DML, dan DDL.
Pernyataan DQL di mana tipe data kolom kunci partisi dalam klausa WHERE dikonversi
Jika tipe data dikonversi, data dirutekan ke partisi berdasarkan tipe data baru.
Jika konversi tipe data gagal, kondisi yang ditentukan berdasarkan kolom kunci partisi diabaikan, dan semua data dalam tabel diperiksa.
Pernyataan DML seperti INSERT dan REPLACE
Jika tipe data dikonversi, data dirutekan ke partisi berdasarkan tipe data baru.
Jika konversi tipe data gagal, kesalahan dilaporkan dan pernyataan tidak dieksekusi.
Pernyataan DDL terkait tabel yang dipartisi seperti CREATE TABLE dan ALTER TABLE
Jika tipe data dikonversi, kesalahan dilaporkan dan pernyataan tidak dieksekusi karena konversi tipe data tidak didukung dalam operasi DDL.
Jika konversi tipe data gagal, kesalahan dilaporkan dan pernyataan tidak dieksekusi.
Perbedaan antara sintaks pernyataan CREATE TABLE dalam MySQL dan PolarDB-X
Perbedaan | MySQL | PolarDB-X |
Apakah kunci partisi harus berisi kunci utama | Diperlukan. | Tidak diperlukan. |
Partisi KEY | Data dirutekan berdasarkan operasi modulo dengan jumlah partisi. | Data dirutekan menggunakan algoritma hashing konsisten. |
Partisi HASH |
|
|
Fungsi partisi | Didukung. Dalam pernyataan PARTITION BY HASH(expr(col)), expr dapat berupa ekspresi umum, seperti YEAR(col) + 1. | Didukung saat persyaratan tertentu terpenuhi. Dalam pernyataan PARTITION BY HASH(expr(col)), expr hanya dapat berupa salah satu fungsi berikut. Operator lain seperti operator tambah (+), kurang (-), perkalian (*), dan pembagian (/) tidak dapat digunakan dalam ekspresi.
|
Tipe data kolom kunci partisi | Dalam partisi KEY, kolom dari semua tipe data dapat digunakan sebagai kolom kunci partisi. | Dalam partisi KEY, hanya kolom yang berisi nilai bertipe integer, tanggal dan waktu, serta string yang dapat digunakan sebagai kolom kunci partisi. |
Set karakter kolom kunci partisi | Semua set karakter umum didukung. | Hanya set karakter berikut yang didukung:
|
Partisi level-2 | Didukung | Didukung |
Didukung
Didukung