Sdílet prostřednictvím

Systémové tabulky a zobrazení služby Azure Cosmos DB for PostgreSQL

  • Článek

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.
SLOUPCOVITÝ "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ČIL 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á 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.