Systémové tabulky a zobrazení služby Azure Cosmos DB for PostgreSQL
PLATÍ PRO: 
Azure Cosmos DB for PostgreSQL (využívající rozšíření databáze Citus do PostgreSQL)
Azure Cosmos DB for PostgreSQL vytváří a udržuje speciální tabulky, které obsahují informace o distribuovaných datech v clusteru. Koordinační uzel tyto tabulky při plánování spouštění dotazů napříč pracovními uzly prohlížel.
Metadata koordinátoru
Azure Cosmos DB for PostgreSQL rozdělí každou distribuovanou tabulku do několika logických horizontálních oddílů na základě distribučního sloupce. Koordinátor pak udržuje tabulky metadat ke sledování statistik a informací o stavu a umístění těchto horizontálních oddílů.
V této části popisujeme všechny tyto tabulky metadat a jejich schéma. Tyto tabulky můžete zobrazit a dotazovat pomocí SQL po přihlášení do koordinačního uzlu.
Poznámka:
clustery se staršími verzemi modulu Citus Nemusí nabízet všechny tabulky uvedené níže.
Tabulka oddílů
Tabulka pg_dist_partition ukládá metadata o tom, které tabulky v databázi se distribuují. Pro každou distribuovanou tabulku také ukládá informace o metodě distribuce a podrobné informace o distribučním sloupci.
| Name | Typ | Popis |
|---|---|---|
| logicalrelid | regclass | Distribuovaná tabulka, do které tento řádek odpovídá. Tato hodnota odkazuje na sloupec relfilenode v tabulce systémového katalogu pg_class. |
| Partmethod | char | Metoda používaná pro dělení a distribuci. Hodnoty tohoto sloupce odpovídající různým distribučním metodám jsou připojeny: "a", hash: 'h', referenční tabulka: 'n'. |
| partkey | text | Podrobné informace o distribučním sloupci, včetně čísla sloupce, typu a dalších relevantních informací. |
| kolokace | integer | Skupina kolokace, do které tato tabulka patří. Tabulky ve stejné skupině umožňují spolulokované spojení a distribuované souhrny mimo jiné optimalizace. Tato hodnota odkazuje na sloupec kolokace v tabulce pg_dist_colocation. |
| repmodel | char | Metoda použitá pro replikaci dat. Hodnoty tohoto sloupce odpovídající různým metodám replikace: Replikace založená na příkazech Citus: c, postgresql streaming replication: 's', dvoufázové potvrzení (pro referenční tabulky): '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)
Tabulka horizontálních oddílů
Tabulka pg_dist_shard ukládá metadata o jednotlivých horizontálních oddílech tabulky. Pg_dist_shard obsahuje informace o tom, do kterých oddílů distribuovaných tabulek patří, a statistiky o distribučním sloupci pro horizontální oddíly. U připojených distribuovaných tabulek tyto statistiky odpovídají minimálním a maximálním hodnotám distribučního sloupce. U distribuovaných tabulek hodnot hash se jedná o rozsahy tokenů hash přiřazené k danému horizontálnímu oddílu. Tyto statistiky se používají k vyřazení nesouvisejících horizontálních oddílů během dotazů SELECT.
| Name | Typ | Popis |
|---|---|---|
| logicalrelid | regclass | Distribuovaná tabulka, do které tento řádek odpovídá. Tato hodnota odkazuje na sloupec relfilenode v tabulce systémového katalogu pg_class. |
| shardid | bigint | Globálně jedinečný identifikátor přiřazený k tomuto horizontálnímu oddílu |
| shardstorage | char | Typ úložiště použitého pro tento horizontální oddíl Různé typy úložiště jsou popsány v následující tabulce. |
| shardminvalue | text | U připojených distribuovaných tabulek je minimální hodnota distribučního sloupce v tomto horizontálním oddílu (včetně). V případě distribuovaných tabulek hash musí být k danému horizontálnímu oddílu přiřazena minimální hodnota tokenu hash (včetně). |
| shardmaxvalue | text | U připojených distribuovaných tabulek maximální hodnota distribučního sloupce v tomto horizontálním oddílu (včetně). V případě distribuovaných tabulek hash maximální hodnota tokenu hash přiřazená danému horizontálnímu oddílu (včetně). |
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)
Typy úložiště horizontálních oddílů
Sloupec shardstorage v pg_dist_shard označuje typ úložiště použitého pro horizontální oddíl. Stručný přehled různých typů úložiště horizontálních oddílů a jejich reprezentace je níže.
| Typ úložiště | Hodnota horizontálního dělení | Popis |
|---|---|---|
| TABULKA | "t" | Označuje, že horizontální oddíl ukládá data patřící do běžné distribuované tabulky. |
| SLOUPCOVÉM | "c" | Označuje, že horizontální oddíl ukládá sloupcová data. (Používá se distribuovanými tabulkami cstore_fdw) |
| ZAHRANIČNÍ | "f" | Označuje, že horizontální oddíl ukládá cizí data. (Používá se distribuovanými tabulkami file_fdw) |
Zobrazení informací o horizontálním oddílu
Kromě tabulky metadat horizontálních oddílů nízké úrovně popsané výše poskytuje citus_shards Azure Cosmos DB for PostgreSQL zobrazení, které umožňuje snadnou kontrolu:
- Kde je každý horizontální oddíl (uzel a port),
- Do jaké tabulky patří, a
- Jeho velikost
Toto zobrazení vám pomůže zkontrolovat horizontální oddíly a najít mimo jiné všechny odchylky velikosti napříč uzly.
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 odkazuje na skupinu kolokace.
Tabulka umístění horizontálních oddílů
Tabulka pg_dist_placement sleduje umístění replik horizontálních oddílů na pracovních uzlech. Každá replika horizontálního oddílu přiřazeného určitému uzlu se nazývá umístění horizontálního oddílu. Tato tabulka ukládá informace o stavu a umístění jednotlivých umístění horizontálních oddílů.
| Name | Typ | Popis |
|---|---|---|
| shardid | bigint | Identifikátor horizontálního oddílu přidružený k tomuto umístění. Tato hodnota odkazuje na sloupec shardid v tabulce katalogu pg_dist_shard. |
| shardstate | int | Popisuje stav tohoto umístění. V následující části jsou popsány různé stavy horizontálních oddílů. |
| shardlength | bigint | U připojených distribuovaných tabulek velikost umístění horizontálního dělení na pracovní uzel v bajtech. U distribuovaných tabulek hash je nula. |
| placementid | bigint | Jedinečný automaticky vygenerovaný identifikátor pro každé jednotlivá umístění. |
| groupid | int | Označuje skupinu jednoho primárního serveru a nula nebo více sekundárních serverů při použití modelu replikace streamování. |
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
Stavy umístění horizontálních oddílů
Azure Cosmos DB for PostgreSQL spravuje stav horizontálních oddílů na základě umístění. Pokud umístění umístí systém do nekonzistentního stavu, Azure Cosmos DB for PostgreSQL ho automaticky označí jako nedostupný. Stav umístění se zaznamenává v tabulce pg_dist_shard_placement ve sloupci shardstate. Tady je stručný přehled různých stavů umístění horizontálních oddílů:
| State name | Hodnota Shardstate | Popis |
|---|---|---|
| DOKONČENA | 0 | Stav nových horizontálních oddílů se vytvoří v. Umístění horizontálních oddílů v tomto stavu jsou považována za aktuální a používají se při plánování a provádění dotazů. |
| NEAKTIVNÍ | 3 | Umístění horizontálních oddílů v tomto stavu jsou považována za neaktivní kvůli tomu, že se nesynchronizují s dalšími replikami stejného horizontálního oddílu. K tomuto umístění může dojít v případě, že operace připojení, úpravy (INSERT, UPDATE, DELETE) nebo operace DDL selže. Plánovač dotazů bude během plánování a provádění ignorovat umístění v tomto stavu. Uživatelé mohou synchronizovat data v těchto horizontálních oddílech s finalizovanou replikou jako aktivitu na pozadí. |
| TO_DELETE | 4 | Pokud se Azure Cosmos DB for PostgreSQL pokusí v reakci na volání master_apply_delete_command odstranit umístění horizontálního oddílu a selže, umístění se přesune do tohoto stavu. Uživatelé pak můžou tyto horizontální oddíly odstranit jako další aktivitu na pozadí. |
Tabulka pracovních uzlů
Tabulka pg_dist_node obsahuje informace o pracovních uzlech v clusteru.
| Name | Typ | Popis |
|---|---|---|
| nodeid | int | Automaticky vygenerovaný identifikátor pro jednotlivé uzly |
| groupid | int | Identifikátor použitý k označení skupiny jednoho primárního serveru a nuly nebo více sekundárních serverů při použití modelu replikace streamování. Ve výchozím nastavení je to stejné jako id uzlu. |
| název uzlu | text | Název hostitele nebo IP adresa pracovního uzlu PostgreSQL. |
| nodeport | int | Číslo portu, na kterém naslouchá pracovní uzel PostgreSQL. |
| noderack | text | (Volitelné) Informace o umístění racku pro pracovní uzel. |
| hasmetadata | boolean | Vyhrazeno pro interní použití. |
| isactive | boolean | Určuje, jestli je uzel aktivní při přijímání umístění horizontálních oddílů. |
| noderole | text | Určuje, jestli je uzel primární nebo sekundární. |
| nodecluster | text | Název clusteru obsahujícího tento uzel |
| by se měly chovat jako horizontální oddíly | boolean | Pokud je hodnota false, přesunou se horizontální oddíly mimo uzel (vyprázdní se) při opětovném vyrovnávání, ani se do uzlu umístí horizontální oddíly z nových distribuovaných tabulek, pokud se už nepřidají s horizontálními oddíly. |
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)
Tabulka distribuovaných objektů
Tabulka citus.pg_dist_object obsahuje seznam objektů, jako jsou typy a funkce vytvořené na koordinačním uzlu a šířené do pracovních uzlů. Když správce přidá do clusteru nové pracovní uzly, Azure Cosmos DB for PostgreSQL automaticky vytvoří kopie distribuovaných objektů na nových uzlech (ve správném pořadí pro splnění závislostí objektů).
| Name | Typ | Popis |
|---|---|---|
| Classid | Oid | Třída distribuovaného objektu |
| objid | Oid | ID objektu distribuovaného objektu |
| objsubid | integer | Id podtypu objektu distribuovaného objektu, například attnum |
| type | text | Část stabilní adresy používané během upgradů pg |
| object_names | text[] | Část stabilní adresy používané během upgradů pg |
| object_args | text[] | Část stabilní adresy používané během upgradů pg |
| distribution_argument_index | integer | Platí pouze pro distribuované funkce nebo procedury. |
| kolokace | integer | Platí pouze pro distribuované funkce nebo procedury. |
"Stabilní adresy" jednoznačně identifikují objekty nezávisle na konkrétním serveru. Azure Cosmos DB for PostgreSQL sleduje objekty během upgradu PostgreSQL pomocí stabilních adres vytvořených pomocí funkce pg_identify_object_as_address().
Tady je příklad přidání create_distributed_function() položek do citus.pg_dist_object tabulky:
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 |
Zobrazení distribuovaných schémat
Citus 12.0 zavedl koncept horizontálního dělení na základě schématu a s ním zobrazení "citus_schemas", které ukazuje, která schémata byla distribuována v systému. Zobrazení obsahuje pouze distribuovaná schémata, místní schémata se nezobrazují.
| Name | Typ | Popis |
|---|---|---|
| Schema_name | regnamespace | Název distribuovaného schématu |
| colocation_id | integer | ID kolokace distribuovaného schématu |
| schema_size | text | Souhrn čitelné velikosti všech objektů ve schématu |
| schema_owner | name | Role, která vlastní schéma |
Tady je příklad:
schema_name | colocation_id | schema_size | schema_owner
-------------+---------------+-------------+--------------
userservice | 1 | 0 bytes | userservice
timeservice | 2 | 0 bytes | timeservice
pingservice | 3 | 632 kB | pingservice
Zobrazení distribuovaných tabulek
Zobrazení citus_tables zobrazuje souhrn všech tabulek spravovaných službou Azure Cosmos DB for PostgreSQL (distribuované a referenční tabulky). Zobrazení kombinuje informace z tabulek metadat Azure Cosmos DB for PostgreSQL, aby byl přehled těchto vlastností tabulky snadno čitelný pro člověka:
- Typ tabulky
- Distribuční sloupec
- ID skupiny kolokace
- Čitelné pro člověka
- Počet horizontálních oddílů
- Vlastník (uživatel databáze)
- Metoda přístupu (halda nebo sloupcový)
Tady je příklad:
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 │
└────────────┴──────────────────┴─────────────────────┴───────────────┴────────────┴─────────────┴─────────────┴───────────────┘
Zobrazení časových oddílů
Azure Cosmos DB for PostgreSQL poskytuje uživatelem definované funkce pro správu oddílů pro případ použití dat Timeseries. Udržuje také time_partitions zobrazení pro kontrolu oddílů, které spravuje.
Sloupce:
- parent_table tabulky, která je rozdělená na oddíly
- partition_column sloupec, na kterém je nadřazená tabulka rozdělená
- partition the name of a partition table
- from_value dolní mez v čase pro řádky v tomto oddílu
- to_value horní mez v čase pro řádky v tomto oddílu
- access_method haldy pro úložiště založené na řádcích a sloupcový pro sloupcové úložiště
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 │
└────────────────────────┴──────────────────┴─────────────────────────────────────────┴─────────────────────┴─────────────────────┴───────────────┘
Tabulka skupiny kolokací
Tabulka pg_dist_colocation obsahuje informace o tom, které horizontální oddíly tabulek by se měly umístit dohromady nebo společně umístit. Pokud jsou dvě tabulky ve stejné skupině kolokace, Azure Cosmos DB for PostgreSQL zajistí, že se horizontální oddíly se stejnými hodnotami distribučního sloupce umístí do stejných pracovních uzlů. Kolokace umožňuje optimalizace spojení, určité distribuované kumulativní aktualizace a podporu cizího klíče. Kolokace horizontálních oddílů se odvodí, když se počty horizontálních oddílů, faktory replikace a typy sloupců oddílů shodují mezi dvěma tabulkami; Při vytváření distribuované tabulky je však možné zadat vlastní kolokační skupinu, pokud je to žádoucí.
| Name | Typ | Popis |
|---|---|---|
| kolokace | int | Jedinečný identifikátor skupiny kolokace odpovídá tomuto řádku. |
| shardcount | int | Počethorizontálních |
| replicationfactor | int | Faktor replikace pro všechny tabulky v této skupině kolokace. |
| distributioncolumntype | Oid | Typ distribučního sloupce pro všechny tabulky v této skupině kolokace. |
SELECT * from pg_dist_colocation;
colocationid | shardcount | replicationfactor | distributioncolumntype
--------------+------------+-------------------+------------------------
2 | 32 | 2 | 20
(1 row)
Tabulka strategie rebalanceru
Tato tabulka definuje strategie, které rebalance_table_shards mohou použít k určení, kam se mají horizontální oddíly přesunout.
| Name | Typ | Popis |
|---|---|---|
| default_strategy | boolean | Zda rebalance_table_shards zvolit tuto strategii ve výchozím nastavení. Použití citus_set_default_rebalance_strategy k aktualizaci tohoto sloupce |
| shard_cost_function | regproc | Identifikátor nákladové funkce, která musí převzít shardid jako bigint a vrátit jeho pojem o nákladech, jako typ real |
| node_capacity_function | regproc | Identifikátor funkce kapacity, která musí jako int převzít id uzlu a vrátit svůj pojem o kapacitě uzlu jako skutečném typu |
| shard_allowed_on_node_function | regproc | Identifikátor funkce, která dostala shardid bigint a nodeidarg int, vrátí logickou hodnotu pro to, jestli může azure Cosmos DB for PostgreSQL uložit horizontální oddíl na uzlu. |
| default_threshold | float4 | Prahová hodnota pro nastavení příliš plného nebo prázdného uzlu, která určuje, kdy se má rebalance_table_shards pokusit přesunout horizontální oddíly |
| minimum_threshold | float4 | Ochrana, která brání nastavení příliš nízkého argumentu prahové hodnoty rebalance_table_shards() |
Ve výchozím nastavení se Cosmos DB for PostgreSQL dodává s těmito strategiemi v tabulce:
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
Strategie by_disk_size přiřazuje každé horizontální oddíly stejné náklady. Jeho účinkem je rovná se počet horizontálních oddílů napříč uzly. Výchozí strategie by_disk_size, přiřadí náklady na každý horizontální oddíl odpovídající jeho velikosti v bajtech plus horizontální oddíly, které jsou společně s ním. Velikost disku se vypočítá pomocí pg_total_relation_size, takže zahrnuje indexy. Tato strategie se pokouší dosáhnout stejného místa na disku na každém uzlu. Všimněte si prahové hodnoty , zabraňuje zbytečnému přesunu horizontálních 0.1oddílů způsobeným nevýznamnými rozdíly v prostoru na disku.
Vytváření vlastních strategií rebalanceru
Tady jsou příklady funkcí, které je možné použít v rámci nových strategií vyrovnávání horizontálních oddílů a zaregistrovat se v pg_dist_rebalance_strategy pomocí funkce citus_add_rebalance_strategy .
Nastavení výjimky kapacity uzlu podle vzoru názvu hostitele:
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;Vyrovnávání podle počtu dotazů, které přejdou do horizontálního oddílu měřené 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;Izolace konkrétního horizontálního oddílu (10000) na uzlu (adresa 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;
Tabulka statistik dotazů
Azure Cosmos DB for PostgreSQL poskytuje citus_stat_statements statistiky o způsobu spouštění dotazů a pro koho. Je to podobné zobrazení pg_stat_statements v PostgreSQL (a lze ho připojit) a sleduje statistiky o rychlosti dotazů.
Toto zobrazení může trasovat dotazy na původce tenantů ve víceklientských aplikacích, což pomáhá při rozhodování, kdy provést izolaci tenantů.
| Name | Typ | Popis |
|---|---|---|
| queryid | bigint | identifikátor (vhodný pro spojení pg_stat_statements) |
| userid | Oid | uživatel, který dotaz spustil |
| Dbid | Oid | instance databáze koordinátoru |
| query | text | anonymizovaný řetězec dotazu |
| Vykonavatel | text | Použitý exekutor Citus: adaptivní, v reálném čase, sledování úloh, směrovač nebo výběr vložení |
| partition_key | text | hodnota distribučního sloupce v dotazech spouštěných směrovačem, else NULL |
| Volání | bigint | kolikrát se dotaz spustil |
-- 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;
Výsledky:
-[ 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
Upozornění:
- Statistiky se nereplikují a nepřežijí chybové ukončení databáze ani převzetí služeb při selhání.
- Sleduje omezený počet dotazů nastavených guc
pg_stat_statements.max(výchozí 5000). - Pokud chcete tabulku zkrátit, použijte
citus_stat_statements_reset()funkci.
Aktivita distribuovaného dotazu
Azure Cosmos DB for PostgreSQL poskytuje speciální zobrazení pro sledování dotazů a zámků v celém clusteru, včetně dotazů specifických pro horizontální oddíly, které se interně používají k vytváření výsledků pro distribuované dotazy.
- citus_dist_stat_activity: zobrazuje distribuované dotazy, které se spouštějí na všech uzlech. Nadmnožina
pg_stat_activity, použitelné všude, kde je druhá. - citus_worker_stat_activity: Zobrazuje dotazy na pracovní procesy, včetně fragmentů dotazů na jednotlivé horizontální oddíly.
- citus_lock_waits: Blokované dotazy v celém clusteru.
První dvě zobrazení zahrnují všechny sloupce pg_stat_activity a hostitele nebo port pracovního procesu, který inicioval dotaz, a hostitele/port koordinačního uzlu clusteru.
Zvažte například počítání řádků v distribuované tabulce:
-- run from worker on localhost:9701
SELECT count(*) FROM users_table;
Vidíme, že dotaz se zobrazuje v 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
Tento dotaz vyžaduje informace ze všech horizontálních oddílů. Některé informace jsou v horizontálním oddílu users_table_102038, který se stane uložen v localhost:9700. Dotaz, který přistupuje k horizontálnímu oddílu, vidíme tak, že se podíváme na citus_worker_stat_activity zobrazení:
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
Pole query zobrazuje data kopírovaná z horizontálního oddílu, která se mají spočítat.
Poznámka:
Pokud dotaz směrovače (např. jeden tenant v aplikaci s více tenanty, select)
- Z tabulky WHERE tenant_id = X' se provede bez bloku transakce, master_query_host_name a master_query_host_port sloupce budou v citus_worker_stat_activity null.
Tady jsou příklady užitečných dotazů, které můžete sestavit pomocí 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;
Další zobrazení je citus_lock_waits. Abychom viděli, jak to funguje, můžeme situaci uzamčení vygenerovat ručně. Nejprve nastavíme testovací tabulku z koordinátoru:
CREATE TABLE numbers AS
SELECT i, 0 AS j FROM generate_series(1,10) AS i;
SELECT create_distributed_table('numbers', 'i');
Potom pomocí dvou relací v koordinátoru můžeme spustit tuto posloupnost příkazů:
-- session 1 -- session 2
------------------------------------- -------------------------------------
BEGIN;
UPDATE numbers SET j = 2 WHERE i = 1;
BEGIN;
UPDATE numbers SET j = 3 WHERE i = 1;
-- (this blocks)
Zobrazení citus_lock_waits ukazuje situaci.
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
V tomto příkladu dotazy pocházejí z koordinátoru, ale zobrazení může také vypsat zámky mezi dotazy pocházejícími z pracovních procesů (spouštěné pomocí azure Cosmos DB for PostgreSQL MX například).
Další kroky
- Zjistěte, jak některé funkce Azure Cosmos DB for PostgreSQL mění systémové tabulky.
- Projděte si koncepty uzlů a tabulek.