Bagikan melalui

Tabel dan tampilan sistem Azure Cosmos DB for PostgreSQL

  • Artikel

BERLAKU UNTUK: Azure Cosmos DB for PostgreSQL (didukung oleh ekstensi database Citus ke PostgreSQL)

Azure Cosmos DB for PostgreSQL membuat dan memelihara tabel khusus yang berisi informasi tentang data terdistribusi dalam kluster. Node koordinator berkonsultasi dengan tabel ini saat merencanakan cara menjalankan kueri di seluruh node pekerja.

Metadata Koordinator

Azure Cosmos DB for PostgreSQL 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

kluster yang menjalankan versi Citus Engine yang lebih lama 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 Tipe 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 text Detail informasi tentang kolom distribusi termasuk nomor kolom, jenis, dan informasi terkait lainnya.
colocationid Integer 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 Tipe 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 text 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 text 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
TABLE '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 shard tingkat rendah yang dijelaskan di atas, Azure Cosmos DB for PostgreSQL menyediakan citus_shards tampilan untuk memeriksa dengan mudah:

  • 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 Tipe 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

Azure Cosmos DB for PostgreSQL mengelola kesehatan shard per penempatan. Jika penempatan menempatkan sistem dalam keadaan tidak konsisten, Azure Cosmos DB for PostgreSQL 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 Azure Cosmos DB for PostgreSQL mencoba menghilangkan penempatan shard sebagai respons terhadap panggilan master_apply_delete_command dan gagal, penempatan dipindahkan 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 Tipe 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 text Nama Host atau Alamat IP node pekerja PostgreSQL.
nodeport int Nomor port di mana node pekerja PostgreSQL mendengarkan.
noderack text (Opsional) Informasi penempatan rak untuk node pekerja.
hasmetadata Boolean Dicadangkan untuk penggunaan internal.
isaktif Boolean Apakah node aktif menerima penempatan shard.
noderole text Apakah node adalah primer atau sekunder
nodecluster text 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 simpul pekerja baru ke kluster, Azure Cosmos DB for PostgreSQL secara otomatis membuat salinan objek terdistribusi pada simpul baru (dalam urutan yang benar untuk memenuhi dependensi objek).

Nama Tipe Deskripsi
classid oid Kelas objek terdistribusi
objid oid ID objek dari objek terdistribusi
objsubid Integer Sub ID objek dari objek terdistribusi, misalnya, attnum
jenis text 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 Integer Hanya valid untuk fungsi/prosedur terdistribusi
colocationid Integer Hanya valid untuk fungsi/prosedur terdistribusi

“Alamat stabil” secara unik mengidentifikasi objek dari server tertentu secara independen. Azure Cosmos DB for PostgreSQL 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 skema terdistribusi

Citus 12.0 memperkenalkan konsep sharding berbasis skema dan dengan tampilan 'citus_schemas'', yang menunjukkan skema mana yang telah didistribusikan dalam sistem. Tampilan hanya mencantumkan skema terdistribusi, skema lokal tidak ditampilkan.

Nama Tipe Deskripsi
nama_skema regnamespace Nama skema terdistribusi
colocation_id Integer ID kolokasi skema terdistribusi
schema_size text Ringkasan ukuran yang dapat dibaca manusia dari semua objek dalam skema
schema_owner nama Peran yang memiliki skema

Berikut adalah contohnya:

 schema_name | colocation_id | schema_size | schema_owner
-------------+---------------+-------------+--------------
 userservice |             1 | 0 bytes     | userservice
 timeservice |             2 | 0 bytes     | timeservice
 pingservice |             3 | 632 kB      | pingservice

Tampilan tabel terdistribusi

Tampilan memperlihatkan citus_tables ringkasan semua tabel yang dikelola oleh Azure Cosmos DB for PostgreSQL (tabel terdistribusi dan referensi). Tampilan ini menggabungkan informasi dari tabel metadata Azure Cosmos DB for PostgreSQL untuk gambaran umum yang mudah 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

Azure Cosmos DB for PostgreSQL menyediakan UDF 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 grup kolokasi yang sama, Azure Cosmos DB for PostgreSQL memastikan pecahan dengan nilai kolom distribusi yang sama akan ditempatkan pada simpul pekerja yang sama. Kolokasi memungkinkan pengoptimalan gabungan, rollup terdistribusi tertentu, dan dukungan kunci asing. Kolokasi pecahan disimpulkan ketika shard dihitung, faktor replikasi, dan jenis kolom partisi semuanya cocok antara dua tabel; namun, grup kolokasi kustom dapat ditentukan saat membuat tabel terdistribusi, jika diinginkan.

Nama Tipe 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 Tipe 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 apakah Azure Cosmos DB for PostgreSQL dapat menyimpan shard pada simpul
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

Secara default Cosmos DB for PostgreSQL dikirim dengan strategi ini dalam tabel:

SELECT * FROM pg_dist_rebalance_strategy;

-[ RECORD 1 ]-------------------+-----------------------------------
Name                            | by_shard_count
default_strategy                | false
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                | true
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 by_disk_size ini menetapkan setiap shard dengan biaya yang sama. Efeknya adalah untuk menyamakan jumlah shard di seluruh node. Strategi default, by_disk_size, menetapkan biaya ke setiap shard yang cocok dengan ukuran disknya dalam byte ditambah pecahan yang dikolokasikan 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 pecahan yang tidak perlu yang disebabkan oleh perbedaan ruang disk yang tidak signifikan.

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

Azure Cosmos DB for PostgreSQL menyediakan citus_stat_statements statistik 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 multipenyewa, yang membantu memutuskan kapan harus melakukan isolasi penyewa.

Nama Tipe Deskripsi
queryid bigint pengidentifikasi (cocok untuk gabungan pg_stat_statements)
id pengguna oid pengguna yang menjalankan kueri
dbid oid instans koordinator database
pertanyaan text string kueri anonim
eksekutor text Eksekutor Citus yang digunakan: adaptif, real-time, pelacak tugas, router, atau insert-select
partition_key text 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

Azure Cosmos DB for PostgreSQL menyediakan tampilan khusus untuk menonton kueri dan kunci di seluruh kluster, termasuk kueri khusus shard yang digunakan secara internal untuk membangun hasil 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 Azure Cosmos DB for PostgreSQL

SELECT query_hostname, count(*)
  FROM citus_worker_stat_activity
 GROUP BY query_hostname;

-- total internal active connections generated per node by Azure Cosmos DB for PostgreSQL

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 (dijalankan dengan Azure Cosmos DB for PostgreSQL MX misalnya).

Langkah berikutnya

  • Pelajari bagaimana beberapa fungsi Azure Cosmos DB for PostgreSQL mengubah tabel sistem
  • Tinjau konsep node dan tabel