Pilih tabel dan tampilan
BERLAKU UNTUK:
Azure Database for PostgreSQL - Hyperscale (Citus)
Hyperscale (Citus) membuat dan mempertahankan tabel khusus yang berisi informasi tentang data terdistribusi di grup server. Node koordinator berkonsultasi dengan tabel ini saat merencanakan cara menjalankan kueri di seluruh node pekerja.
Metadata Koordinator
Hyperscale (Citus) membagi setiap tabel terdistribusi menjadi beberapa pecahan logis berdasarkan kolom distribusi. Koordinator kemudian mempertahankan tabel metadata untuk melacak statistik dan informasi tentang kesehatan dan lokasi pecahan ini.
Di bagian ini, kami menjelaskan masing-masing tabel metadata dan skemanya. Anda dapat melihat dan membuat kueri tabel ini menggunakan SQL setelah masuk ke node koordinator.
Catatan
Grup server Hyperscale (Citus) yang menjalankan versi lama Citus Engine mungkin tidak menawarkan semua tabel yang tercantum di bawah ini.
Tabel partisi
Tabel pg_dist_partiotion menyimpan metadata tentang tabel dalam database yang terdistribusi. Untuk setiap tabel terdistribusi, informasi tentang metode distribusi dan informasi terperinci tentang kolom distribusi juga disimpan.
| Nama | Jenis | Deskripsi |
|---|---|---|
| logicalrelid | regclass | Tabel terdistribusi yang terkait dengan baris ini. Nilai ini mereferensikan kolom relfilenode dalam tabel katalog sistem pg_class. |
| partmethod | char | Metode yang digunakan untuk partisi / distribusi. Nilai kolom ini yang terkait dengan metode distribusi yang berbeda ditambahkan: 'a', hash: 'h', tabel referensi: 'n' |
| partkey | teks | Detail informasi tentang kolom distribusi termasuk nomor kolom, jenis, dan informasi terkait lainnya. |
| colocationid | bilangan bulat | Grup kolokasi tempat tabel ini berada. Tabel dalam grup yang sama memungkinkan gabungan yang dikolokasi dan rollup terdistribusi di antara pengoptimalan lainnya. Nilai ini mereferensikan kolom colocationid dalam pg_dist_colocation tabel. |
| repmodel | char | Metode yang digunakan untuk replikasi data. Nilai kolom ini yang sesuai dengan metode replikasi yang berbeda adalah: Replikasi berbasis pernyataan Citus: 'c', replikasi streaming postgresql: 's', komitmen dua fase (untuk tabel referensi): 't' |
SELECT * from pg_dist_partition;
logicalrelid | partmethod | partkey | colocationid | repmodel
---------------+------------+------------------------------------------------------------------------------------------------------------------------+--------------+----------
github_events | h | {VAR :varno 1 :varattno 4 :vartype 20 :vartypmod -1 :varcollid 0 :varlevelsup 0 :varnoold 1 :varoattno 4 :location -1} | 2 | c
(1 row)
Tabel shard
Tabel pg_dist_shard menyimpan metadata tentang setiap shard tabel. Pg_dist_shard berisi informasi tentang shard tabel terdistribusi mana yang termasuk, dan statistik tentang kolom distribusi untuk shard. Untuk lampiran tabel terdistribusi, statistik ini sesuai dengan nilai min / maks dari kolom distribusi. Untuk tabel terdistribusi hash, statistik ini merupakan rentang token hash yang ditetapkan untuk shard itu. Statistik ini digunakan untuk memangkas shard yang tidak terkait selama kueri SELECT.
| Nama | Jenis | Deskripsi |
|---|---|---|
| logicalrelid | regclass | Tabel terdistribusi yang terkait dengan baris ini. Nilai ini mereferensikan kolom relfilenode dalam tabel katalog sistem pg_class. |
| shardid | bigint | Pengidentifikasi unik global yang ditetapkan untuk shard ini. |
| shardstorage | char | Jenis penyimpanan yang digunakan untuk shard ini. Jenis penyimpanan yang berbeda dibahas dalam tabel di bawah ini. |
| shardminvalue | teks | Untuk lampiran tabel terdistribusi, nilai minimum kolom distribusi dalam shard ini (inklusif). Untuk tabel terdistribusi hash, nilai token hash minimum yang ditetapkan untuk shard itu (inklusif). |
| shardmaxvalue | teks | Untuk lampiran tabel terdistribusi, nilai maksimum kolom distribusi dalam shard ini (inklusif). Untuk tabel terdistribusi hash, nilai token hash maksimum yang ditetapkan untuk shard itu (inklusif). |
SELECT * from pg_dist_shard;
logicalrelid | shardid | shardstorage | shardminvalue | shardmaxvalue
---------------+---------+--------------+---------------+---------------
github_events | 102026 | t | 268435456 | 402653183
github_events | 102027 | t | 402653184 | 536870911
github_events | 102028 | t | 536870912 | 671088639
github_events | 102029 | t | 671088640 | 805306367
(4 rows)
Jenis Penyimpanan Pecahan
Kolom shardstorage dalam pg_dist_shard menunjukkan jenis penyimpanan yang digunakan untuk shard. Gambaran umum singkat tentang berbagai jenis penyimpanan shard dan representasinya di bawah ini.
| Jenis Penyimpanan | Nilai shardstorage | Deskripsi |
|---|---|---|
| TABEL | 't' | Menunjukkan bahwa shard menyimpan data milik tabel terdistribusi reguler. |
| KOLUMNAR | 'c' | Menunjukkan bahwa shard menyimpan data columnar. (Digunakan oleh tabel cstore_fdw terdistribusi) |
| ASING | 'f' | Menunjukkan bahwa shard menyimpan data asing. (Digunakan oleh tabel file_fdw terdistribusi) |
Tampilan informasi pecahan
Selain tabel metadata pecahan tingkat rendah yang dijelaskan di atas, Hyperscale (Citus) menyediakan citus_shards tampilan untuk dengan mudah memeriksa:
- Di mana setiap pecahan adalah (node, dan port),
- Meja seperti apa yang dimilikinya, dan
- Ukurannya
Tampilan ini membantu Anda memeriksa pecahan untuk menemukan, antara lain, ketidakseimbangan ukuran di seluruh node.
SELECT * FROM citus_shards;
.
table_name | shardid | shard_name | citus_table_type | colocation_id | nodename | nodeport | shard_size
------------+---------+--------------+------------------+---------------+-----------+----------+------------
dist | 102170 | dist_102170 | distributed | 34 | localhost | 9701 | 90677248
dist | 102171 | dist_102171 | distributed | 34 | localhost | 9702 | 90619904
dist | 102172 | dist_102172 | distributed | 34 | localhost | 9701 | 90701824
dist | 102173 | dist_102173 | distributed | 34 | localhost | 9702 | 90693632
ref | 102174 | ref_102174 | reference | 2 | localhost | 9701 | 8192
ref | 102174 | ref_102174 | reference | 2 | localhost | 9702 | 8192
dist2 | 102175 | dist2_102175 | distributed | 34 | localhost | 9701 | 933888
dist2 | 102176 | dist2_102176 | distributed | 34 | localhost | 9702 | 950272
dist2 | 102177 | dist2_102177 | distributed | 34 | localhost | 9701 | 942080
dist2 | 102178 | dist2_102178 | distributed | 34 | localhost | 9702 | 933888
colocation_id mengacu pada kelompok kolokasi.
Tabel penempatan shard
Tabel pg_dist_placement melacak lokasi replika shard pada node pekerja. Setiap replika shard yang ditetapkan ke node tertentu disebut penempatan shard. Tabel ini menyimpan informasi tentang kesehatan dan lokasi setiap penempatan shard.
| Nama | Jenis | Deskripsi |
|---|---|---|
| shardid | bigint | Pengidentifikasi shard yang terkait dengan penempatan ini. Nilai ini mereferensikan kolom shardid dalam tabel katalog pg_dist_shard. |
| shardstate | int | Menjelaskan status penempatan ini. Berbagai status shard dibahas di bagian berikut. |
| shardlength | bigint | Untuk tabel terdistribusi lampiran, ukuran penempatan shard pada node pekerja dalam byte. Untuk tabel terdistribusi hash, nol. |
| placementid | bigint | Pengidentifikasi otomatis yang unik untuk setiap penempatan individu. |
| groupid | int | Menunjukkan sekelompok satu server utama dan nol atau lebih server sekunder saat model replikasi streaming digunakan. |
SELECT * from pg_dist_placement;
shardid | shardstate | shardlength | placementid | groupid
---------+------------+-------------+-------------+---------
102008 | 1 | 0 | 1 | 1
102008 | 1 | 0 | 2 | 2
102009 | 1 | 0 | 3 | 2
102009 | 1 | 0 | 4 | 3
102010 | 1 | 0 | 5 | 3
102010 | 1 | 0 | 6 | 4
102011 | 1 | 0 | 7 | 4
Status Penempatan Shard
Hyperscale (Citus) mengelola kesehatan shard pada basis per penempatan. Jika penempatan menjadikan sistem dalam keadaan tidak konsisten, Citus secara otomatis menandainya sebagai tidak tersedia. Status penempatan dicatat dalam tabel pg_dist_shard_placement, di dalam kolom shardstate. Berikut adalah gambaran umum singkat dari berbagai status penempatan shard:
| Nama negara | Nilai Shardstate | Deskripsi |
|---|---|---|
| DISELESAIKAN | 1 | Status shard baru dibuat. Penempatan shard dalam keadaan ini dianggap mutakhir dan digunakan dalam perencanaan dan eksekusi kueri. |
| TIDAK AKTIF | 3 | Penempatan Shard dalam keadaan ini dianggap tidak aktif karena tidak sinkron dengan replika lain dari shard yang sama. Status dapat terjadi saat penambahan, modifikasi (SISIPKAN, PERBARUI, HAPUS), atau operasi DDL gagal dilakukan untuk penempatan ini. Perencana kueri akan mengabaikan penempatan dalam keadaan ini selama perencanaan dan eksekusi. Pengguna dapat menyinkronkan data dalam pecahan ini dengan replika yang diselesaikan sebagai aktivitas latar belakang. |
| TO_DELETE | 4 | Jika Citus mencoba untuk menjatuhkan penempatan shard sebagai tanggapan atas master_apply_delete_command dan gagal, penempatan diubah ke status ini. Pengguna kemudian dapat menghapus shard ini sebagai aktivitas latar belakang berikutnya. |
Tabel node pekerja
Tabel pg_dist_node berisi informasi tentang node pekerja dalam kluster.
| Nama | Jenis | Deskripsi |
|---|---|---|
| nodeid | int | Pengidentifikasi otomatis untuk node individual. |
| groupid | int | Pengidentifikasi digunakan untuk menunjukkan sekelompok satu server utama dan nol atau lebih banyak server sekunder saat model replikasi streaming digunakan. Secara default sama dengan nodeid. |
| nodename | teks | Nama Host atau Alamat IP node pekerja PostgreSQL. |
| nodeport | int | Nomor port di mana node pekerja PostgreSQL mendengarkan. |
| noderack | teks | (Opsional) Informasi penempatan rak untuk node pekerja. |
| hasmetadata | boolean | Dicadangkan untuk penggunaan internal. |
| isaktif | boolean | Apakah node aktif menerima penempatan shard. |
| noderole | teks | Apakah node adalah primer atau sekunder |
| nodecluster | teks | Nama kluster yang memuat node ini |
| shouldhaveshards | boolean | Jika salah, shard akan dipindahkan dari node (dikeringkan) saat menyeimbangkan kembali, shard dari tabel terdistribusi baru juga tidak akan ditempatkan pada node, kecuali jika dikolokasi dengan shard yang sudah ada |
SELECT * from pg_dist_node;
nodeid | groupid | nodename | nodeport | noderack | hasmetadata | isactive | noderole | nodecluster | shouldhaveshards
--------+---------+-----------+----------+----------+-------------+----------+----------+-------------+------------------
1 | 1 | localhost | 12345 | default | f | t | primary | default | t
2 | 2 | localhost | 12346 | default | f | t | primary | default | t
3 | 3 | localhost | 12347 | default | f | t | primary | default | t
(3 rows)
Tabel objek terdistribusi
Tabel citus.pg_dist_object berisi objek seperti jenis dan fungsi yang telah dibuat pada node koordinator dan disebarluaskan ke node pekerja. Ketika administrator menambahkan node pekerja baru ke klaster, Hyperscale (Citus) secara otomatis membuat salinan objek terdistribusi pada node baru (dalam urutan yang benar untuk memenuhi dependensi objek).
| Nama | Jenis | Deskripsi |
|---|---|---|
| classid | oid | Kelas objek terdistribusi |
| objid | oid | ID objek dari objek terdistribusi |
| objsubid | bilangan bulat | Sub ID objek dari objek terdistribusi, misalnya, attnum |
| jenis | teks | Bagian dari alamat stabil yang digunakan selama pemutakhiran pg |
| object_names | text[] | Bagian dari alamat stabil yang digunakan selama pemutakhiran pg |
| object_args | text[] | Bagian dari alamat stabil yang digunakan selama pemutakhiran pg |
| distribution_argument_index | bilangan bulat | Hanya valid untuk fungsi/prosedur terdistribusi |
| colocationid | bilangan bulat | Hanya valid untuk fungsi/prosedur terdistribusi |
“Alamat stabil” secara unik mengidentifikasi objek dari server tertentu secara independen. Hyperscale (Citus) melacak objek selama peningkatan PostgreSQL menggunakan alamat stabil yang dibuat dengan fungsi pg_identify_object_as_address().
Berikutcontoh cara create_distributed_function() menambahkan entri ke tabel citus.pg_dist_object:
CREATE TYPE stoplight AS enum ('green', 'yellow', 'red');
CREATE OR REPLACE FUNCTION intersection()
RETURNS stoplight AS $$
DECLARE
color stoplight;
BEGIN
SELECT *
FROM unnest(enum_range(NULL::stoplight)) INTO color
ORDER BY random() LIMIT 1;
RETURN color;
END;
$$ LANGUAGE plpgsql VOLATILE;
SELECT create_distributed_function('intersection()');
-- will have two rows, one for the TYPE and one for the FUNCTION
TABLE citus.pg_dist_object;
-[ RECORD 1 ]---------------+------
classid | 1247
objid | 16780
objsubid | 0
type |
object_names |
object_args |
distribution_argument_index |
colocationid |
-[ RECORD 2 ]---------------+------
classid | 1255
objid | 16788
objsubid | 0
type |
object_names |
object_args |
distribution_argument_index |
colocationid |
Tampilan tabel terdistribusi
Tampilan citus_tables menampilkan ringkasan semua tabel yang dikelola oleh Hyperscale (Citus) (tabel terdistribusi dan referensi). Tampilan menggabungkan informasi dari tabel metadata Hyperscale (Citus) untuk gambaran umum yang mudah dan dapat dibaca manusia dari properti tabel ini:
- Jenis tabel
- Kolom distribusi
- ID grup colocation
- Ukuran yang dapat dibaca manusia
- jumlah shard
- Pemilik (pengguna database)
- Metode akses (heap atau kolum kolumnar)
Berikut adalah contohnya:
SELECT * FROM citus_tables;
┌────────────┬──────────────────┬─────────────────────┬───────────────┬────────────┬─────────────┬─────────────┬───────────────┐
│ table_name │ citus_table_type │ distribution_column │ colocation_id │ table_size │ shard_count │ table_owner │ access_method │
├────────────┼──────────────────┼─────────────────────┼───────────────┼────────────┼─────────────┼─────────────┼───────────────┤
│ foo.test │ distributed │ test_column │ 1 │ 0 bytes │ 32 │ citus │ heap │
│ ref │ reference │ <none> │ 2 │ 24 GB │ 1 │ citus │ heap │
│ test │ distributed │ id │ 1 │ 248 TB │ 32 │ citus │ heap │
└────────────┴──────────────────┴─────────────────────┴───────────────┴────────────┴─────────────┴─────────────┴───────────────┘
Tampilan partisi waktu
Hyperscale (Citus) menyediakan UDFs untuk mengelola partisi untuk kasus penggunaan Data Timeseries. Ini juga mempertahankan time_partitions pandangan untuk memeriksa partisi yang dikelolanya.
Kolom:
- parent_table tabel yang dipartisi
- partition_column kolom tempat tabel induk dipartisi
- mempartisi nama tabel partisi
- from_value batas bawah pada waktunya untuk baris di partisi ini
- to_value batas atas tepat waktu untuk baris di partisi ini
- access_method heap untuk penyimpanan berbasis baris, dan kolumnar untuk penyimpanan kolumnar
SELECT * FROM time_partitions;
┌────────────────────────┬──────────────────┬─────────────────────────────────────────┬─────────────────────┬─────────────────────┬───────────────┐
│ parent_table │ partition_column │ partition │ from_value │ to_value │ access_method │
├────────────────────────┼──────────────────┼─────────────────────────────────────────┼─────────────────────┼─────────────────────┼───────────────┤
│ github_columnar_events │ created_at │ github_columnar_events_p2015_01_01_0000 │ 2015-01-01 00:00:00 │ 2015-01-01 02:00:00 │ columnar │
│ github_columnar_events │ created_at │ github_columnar_events_p2015_01_01_0200 │ 2015-01-01 02:00:00 │ 2015-01-01 04:00:00 │ columnar │
│ github_columnar_events │ created_at │ github_columnar_events_p2015_01_01_0400 │ 2015-01-01 04:00:00 │ 2015-01-01 06:00:00 │ columnar │
│ github_columnar_events │ created_at │ github_columnar_events_p2015_01_01_0600 │ 2015-01-01 06:00:00 │ 2015-01-01 08:00:00 │ heap │
└────────────────────────┴──────────────────┴─────────────────────────────────────────┴─────────────────────┴─────────────────────┴───────────────┘
Tabel grup kolokasi
Tabel pg_dist_colocation berisi informasi tentang shard tabel mana yang harus ditempatkan bersama-sama, atau dikolokasi. Ketika dua tabel berada dalam kelompok kolokasi yang sama, Hyperscale (Citus) memastikan shard dengan nilai kolom distribusi yang sama akan ditempatkan pada node pekerja yang sama. Kolokasi memungkinkan pengoptimalan gabungan, rollup terdistribusi tertentu, dan dukungan kunci asing. Kolokasi shard disimpulkan ketika shard dihitung, faktor replikasi, dan jenis kolom partisi semuanya cocok di antara dua tabel; namun, grup kolokasi kustom dapat ditentukan saat membuat tabel terdistribusi, jika diinginkan.
| Nama | Jenis | Deskripsi |
|---|---|---|
| colocationid | int | Pengidentifikasi unik untuk grup kolokasi yang sesuai dengan baris ini. |
| shardcount | int | Jumlah shard untuk semua tabel dalam grup kolokasi ini |
| replikasifactor | int | Faktor replikasi untuk semua tabel dalam kelompok kolokasi ini. |
| distributioncolumntype | oid | Jenis kolom distribusi untuk semua tabel dalam grup kolokasi ini. |
SELECT * from pg_dist_colocation;
colocationid | shardcount | replicationfactor | distributioncolumntype
--------------+------------+-------------------+------------------------
2 | 32 | 2 | 20
(1 row)
Tabel strategi penyeimbang
Tabel ini menjelaskan strategi yang rebalance_table_shards gunakan untuk menentukan tempat memindahkan shard.
| Nama | Jenis | Deskripsi |
|---|---|---|
| default_strategy | boolean | Apakah rebalance_table_shards harus memilih strategi ini secara default. Gunakan citus_set_default_rebalance_strategy untuk memperbarui kolom ini |
| shard_cost_function | regproc | Pengidentifikasi untuk fungsi biaya, yang harus mengambil shardid sebagai bigint, dan mengembalikan gagasannya tentang biaya, sebagai jenis nyata |
| node_capacity_function | regproc | Pengidentifikasi untuk fungsi kapasitas, yang harus mengambil nodeid sebagai int, dan mengembalikan gagasannya tentang kapasitas node sebagai jenis nyata |
| shard_allowed_on_node_function | regproc | Pengidentifikasi untuk fungsi yang diberikan shardid bigint, dan nodeidarg int, mengembalikan boolean untuk mengetahui apakah Citus dapat menyimpan shard pada node |
| default_threshold | float4 | Ambang batas untuk menganggap node terlalu penuh atau terlalu kosong, yang menentukan kapan rebalance_table_shards harus mencoba memindahkan shard |
| minimum_threshold | float4 | Perlindungan untuk mencegah argumen ambang batas rebalance_table_shards() diatur terlalu rendah |
Penginstalan Hyperscale (Citus) dikirim dengan strategi ini dalam tabel:
SELECT * FROM pg_dist_rebalance_strategy;
-[ RECORD 1 ]-------------------+-----------------------------------
Name | by_shard_count
default_strategy | true
shard_cost_function | citus_shard_cost_1
node_capacity_function | citus_node_capacity_1
shard_allowed_on_node_function | citus_shard_allowed_on_node_true
default_threshold | 0
minimum_threshold | 0
-[ RECORD 2 ]-------------------+-----------------------------------
Name | by_disk_size
default_strategy | false
shard_cost_function | citus_shard_cost_by_disk_size
node_capacity_function | citus_node_capacity_1
shard_allowed_on_node_function | citus_shard_allowed_on_node_true
default_threshold | 0.1
minimum_threshold | 0.01
Strategi default, by_shard_count, menetapkan biaya yang sama untuk setiap shard. Efeknya adalah untuk menyamakan jumlah shard di seluruh node. Strategi lain yang telah ditentukan sebelumnya, by_disk_size, menetapkan biaya untuk setiap shard yang cocok dengan ukuran disknya dalam byte ditambah dengan shard yang dikolokasi dengannya. Ukuran disk dihitung menggunakan pg_total_relation_size, termasuk indeks. Strategi ini mencoba untuk mencapai ruang disk yang sama pada setiap node. Perhatikan ambang batas 0,1--mencegah gerakan shard yang tidak perlu yang disebabkan oleh perbedaan yang tidak signifikan dalam ruang disk.
Membuat strategi penyeimbang kustom
Berikut contoh fungsi yang dapat digunakan dalam strategi penyeimbang shard baru, dan terdaftar di pg_dist_rebalance_strategy dengan fungsi citus_add_rebalance_strategy.
Mengatur pengecualian kapasitas node dengan pola hostname:
CREATE FUNCTION v2_node_double_capacity(nodeidarg int) RETURNS boolean AS $$ SELECT (CASE WHEN nodename LIKE '%.v2.worker.citusdata.com' THEN 2 ELSE 1 END) FROM pg_dist_node where nodeid = nodeidarg $$ LANGUAGE sql;Menyeimbangkan kembali dengan jumlah kueri yang masuk ke shard, sebagaimana diukur oleh citus_stat_statements:
-- example of shard_cost_function CREATE FUNCTION cost_of_shard_by_number_of_queries(shardid bigint) RETURNS real AS $$ SELECT coalesce(sum(calls)::real, 0.001) as shard_total_queries FROM citus_stat_statements WHERE partition_key is not null AND get_shard_id_for_distribution_column('tab', partition_key) = shardid; $$ LANGUAGE sql;Mengisolasi shard tertentu (10000) pada node (alamat ‘10.0.0.1’):
-- example of shard_allowed_on_node_function CREATE FUNCTION isolate_shard_10000_on_10_0_0_1(shardid bigint, nodeidarg int) RETURNS boolean AS $$ SELECT (CASE WHEN nodename = '10.0.0.1' THEN shardid = 10000 ELSE shardid != 10000 END) FROM pg_dist_node where nodeid = nodeidarg $$ LANGUAGE sql; -- The next two definitions are recommended in combination with the above function. -- This way the average utilization of nodes is not impacted by the isolated shard. CREATE FUNCTION no_capacity_for_10_0_0_1(nodeidarg int) RETURNS real AS $$ SELECT (CASE WHEN nodename = '10.0.0.1' THEN 0 ELSE 1 END)::real FROM pg_dist_node where nodeid = nodeidarg $$ LANGUAGE sql; CREATE FUNCTION no_cost_for_10000(shardid bigint) RETURNS real AS $$ SELECT (CASE WHEN shardid = 10000 THEN 0 ELSE 1 END)::real $$ LANGUAGE sql;
Tabel statistik kueri
Hyperscale (Citus) menyediakan citus_stat_statements tentang bagaimana kueri dijalankan, dan untuk siapa. Hal ini dianalogikan dengan (dan dapat digabungkan dengan) tampilan pg_stat_statements di PostgreSQL, yang melacak statistik tentang kecepatan kueri.
Tampilan ini dapat melacak kueri ke penyewa asal dalam aplikasi multi-penyewa, yang membantu memutuskan kapan harus melakukan isolasi penyewa.
| Nama | Jenis | Deskripsi |
|---|---|---|
| queryid | bigint | pengidentifikasi (cocok untuk gabungan pg_stat_statements) |
| userid | oid | pengguna yang menjalankan kueri |
| dbid | oid | instans koordinator database |
| kueri | teks | string kueri anonim |
| eksekutor | teks | Eksekutor Citus yang digunakan: adaptif, real-time, pelacak tugas, router, atau insert-select |
| partition_key | teks | nilai kolom distribusi dalam kueri yang dieksekusi router, yang lain NULL |
| panggilan | bigint | berapa kali kueri dijalankan |
-- create and populate distributed table
create table foo ( id int );
select create_distributed_table('foo', 'id');
insert into foo select generate_series(1,100);
-- enable stats
-- pg_stat_statements must be in shared_preload libraries
create extension pg_stat_statements;
select count(*) from foo;
select * from foo where id = 42;
select * from citus_stat_statements;
Hasil:
-[ RECORD 1 ]-+----------------------------------------------
queryid | -909556869173432820
userid | 10
dbid | 13340
query | insert into foo select generate_series($1,$2)
executor | insert-select
partition_key |
calls | 1
-[ RECORD 2 ]-+----------------------------------------------
queryid | 3919808845681956665
userid | 10
dbid | 13340
query | select count(*) from foo;
executor | adaptive
partition_key |
calls | 1
-[ RECORD 3 ]-+----------------------------------------------
queryid | 5351346905785208738
userid | 10
dbid | 13340
query | select * from foo where id = $1
executor | adaptive
partition_key | 42
calls | 1
Peringatan:
- Data statistik tidak direplikasi, dan tidak akan bertahan dari crash atau kegagalan database
- Melacak sejumlah kueri terbatas, yang ditetapkan oleh GUC (default 5000)
pg_stat_statements.max - Untuk memotong tabel, gunakan fungsi
citus_stat_statements_reset()
Aktivitas Kueri Terdistribusi
Hyperscale (Citus) memberikan tampilan khusus untuk menonton kueri dan kunci di seluruh kluster, termasuk kueri khusus shard yang digunakan secara internal untuk membangun hasil untuk kueri terdistribusi.
- citus_dist_stat_activity: menunjukkan kueri terdistribusi yang mengeksekusi pada semua node. Superset
pg_stat_activity, dapat digunakan di mana pun yang terakhir berada. - citus_worker_stat_activity: menunjukkan kueri pada pekerja, termasuk kueri fragmen terhadap setiap shard.
- citus_lock_waits: Kueri yang diblokir di seluruh kluster.
Dua tampilan pertama mencakup semua kolom pg_stat_activity ditambah host host/port pekerja yang memulai kueri dan host/port node koordinator kluster.
Misalnya, pertimbangkan untuk menghitung baris dalam tabel terdistribusi:
-- run from worker on localhost:9701
SELECT count(*) FROM users_table;
Kita dapat melihat bahwa kueri muncul di citus_dist_stat_activity:
SELECT * FROM citus_dist_stat_activity;
-[ RECORD 1 ]----------+----------------------------------
query_hostname | localhost
query_hostport | 9701
master_query_host_name | localhost
master_query_host_port | 9701
transaction_number | 1
transaction_stamp | 2018-10-05 13:27:20.691907+03
datid | 12630
datname | postgres
pid | 23723
usesysid | 10
usename | citus
application\_name | psql
client\_addr |
client\_hostname |
client\_port | -1
backend\_start | 2018-10-05 13:27:14.419905+03
xact\_start | 2018-10-05 13:27:16.362887+03
query\_start | 2018-10-05 13:27:20.682452+03
state\_change | 2018-10-05 13:27:20.896546+03
wait\_event_type | Client
wait\_event | ClientRead
state | idle in transaction
backend\_xid |
backend\_xmin |
query | SELECT count(*) FROM users_table;
backend\_type | client backend
Kueri ini memerlukan informasi dari semua shard. Beberapa informasi dalam shard users_table_102038, yang kebetulan disimpan di localhost:9700. Kita bisa melihat kueri yang mengakses shard dengan melihat tampilan citus_worker_stat_activity:
SELECT * FROM citus_worker_stat_activity;
-[ RECORD 1 ]----------+-----------------------------------------------------------------------------------------
query_hostname | localhost
query_hostport | 9700
master_query_host_name | localhost
master_query_host_port | 9701
transaction_number | 1
transaction_stamp | 2018-10-05 13:27:20.691907+03
datid | 12630
datname | postgres
pid | 23781
usesysid | 10
usename | citus
application\_name | citus
client\_addr | ::1
client\_hostname |
client\_port | 51773
backend\_start | 2018-10-05 13:27:20.75839+03
xact\_start | 2018-10-05 13:27:20.84112+03
query\_start | 2018-10-05 13:27:20.867446+03
state\_change | 2018-10-05 13:27:20.869889+03
wait\_event_type | Client
wait\_event | ClientRead
state | idle in transaction
backend\_xid |
backend\_xmin |
query | COPY (SELECT count(*) AS count FROM users_table_102038 users_table WHERE true) TO STDOUT
backend\_type | client backend
Bidang query menunjukkan data yang disalin keluar dari shard yang akan dihitung.
Catatan
Jika kueri router (misalnya penyewa tunggal di aplikasi multi-penyewa, 'PILIH
- DARI tabel TEMPAT tenant_id = X') dieksekusi tanpa blok transaksi, maka master_query_host_name dan kolom master_query_host_port akan menjadi NULL dalam citus_worker_stat_activity.
Berikut adalah contoh kueri berguna yang dapat Anda buat menggunakan citus_worker_stat_activity:
-- active queries' wait events on a certain node
SELECT query, wait_event_type, wait_event
FROM citus_worker_stat_activity
WHERE query_hostname = 'xxxx' and state='active';
-- active queries' top wait events
SELECT wait_event, wait_event_type, count(*)
FROM citus_worker_stat_activity
WHERE state='active'
GROUP BY wait_event, wait_event_type
ORDER BY count(*) desc;
-- total internal connections generated per node by Citus
SELECT query_hostname, count(*)
FROM citus_worker_stat_activity
GROUP BY query_hostname;
-- total internal active connections generated per node by Citus
SELECT query_hostname, count(*)
FROM citus_worker_stat_activity
WHERE state='active'
GROUP BY query_hostname;
Tampilan selanjutnya adalah citus_lock_waits. Untuk melihat cara kerjanya, kita dapat membuat situasi penguncian secara manual. Pertama kita akan menyiapkan tabel tes dari koordinator:
CREATE TABLE numbers AS
SELECT i, 0 AS j FROM generate_series(1,10) AS i;
SELECT create_distributed_table('numbers', 'i');
Kemudian, dengan menggunakan dua sesi pada koordinator, kita dapat menjalankan urutan pernyataan ini:
-- session 1 -- session 2
------------------------------------- -------------------------------------
BEGIN;
UPDATE numbers SET j = 2 WHERE i = 1;
BEGIN;
UPDATE numbers SET j = 3 WHERE i = 1;
-- (this blocks)
Tampilan citus_lock_waits menunjukkan situasi.
SELECT * FROM citus_lock_waits;
-[ RECORD 1 ]-------------------------+----------------------------------------
waiting_pid | 88624
blocking_pid | 88615
blocked_statement | UPDATE numbers SET j = 3 WHERE i = 1;
current_statement_in_blocking_process | UPDATE numbers SET j = 2 WHERE i = 1;
waiting_node_id | 0
blocking_node_id | 0
waiting_node_name | coordinator_host
blocking_node_name | coordinator_host
waiting_node_port | 5432
blocking_node_port | 5432
Dalam contoh ini kueri berasal dari koordinator, tetapi tampilan juga dapat mencantumkan kunci antara kueri yang berasal dari pekerja (dieksekusi dengan Hyperscale (Citus) MX misalnya).
Langkah berikutnya
- Pelajari bagaimana beberapa fungsi Hyperscale (Citus) mengubah tabel sistem
- Tinjau konsep node dan tabel