Azure Cosmos DB for PostgreSQL-systemtabeller och -vyer
GÄLLER FÖR: 
Azure Cosmos DB for PostgreSQL (drivs av Citus-databastillägget till PostgreSQL)
Azure Cosmos DB for PostgreSQL skapar och underhåller särskilda tabeller som innehåller information om distribuerade data i klustret. Koordinatornoden läser dessa tabeller när du planerar att köra frågor mellan arbetsnoderna.
Koordinatormetadata
Azure Cosmos DB for PostgreSQL delar upp varje distribuerad tabell i flera logiska shards baserat på distributionskolumnen. Koordinatorn underhåller sedan metadatatabeller för att spåra statistik och information om hälsotillståndet och platsen för dessa shards.
I det här avsnittet beskriver vi var och en av dessa metadatatabeller och deras schema. Du kan visa och köra frågor mot dessa tabeller med hjälp av SQL när du har loggat in på koordinatornoden.
Kommentar
kluster som kör äldre versioner av Citus-motorn kanske inte erbjuder alla tabeller som anges nedan.
Partitionstabell
I den pg_dist_partition tabellen lagras metadata om vilka tabeller i databasen som distribueras. För varje distribuerad tabell lagras även information om distributionsmetoden och detaljerad information om distributionskolumnen.
| Name | Type | Description |
|---|---|---|
| logicalrelid | regclass | Distribuerad tabell som den här raden motsvarar. Det här värdet refererar till kolumnen relfilenode i pg_class-systemkatalogtabellen. |
| partmethod | char | Den metod som används för partitionering/distribution. Värdena för den här kolumnen som motsvarar olika distributionsmetoder läggs till: 'a', hash: 'h', referenstabell: 'n' |
| partkey | text | Detaljerad information om distributionskolumnen, inklusive kolumnnummer, typ och annan relevant information. |
| colocationid | integer | Samlokaliseringsgrupp som den här tabellen tillhör. Tabeller i samma grupp tillåter samallokerade kopplingar och distribuerade sammanslagningar bland andra optimeringar. Det här värdet refererar till kolumnen colocationid i tabellen pg_dist_colocation. |
| repmodel | char | Den metod som används för datareplikering. Värdena för den här kolumnen som motsvarar olika replikeringsmetoder är: Citus-satsbaserad replikering: 'c', postgresql streamingreplikering: 's', tvåfas commit (för referenstabeller): '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)
Shard-tabell
I den pg_dist_shard tabellen lagras metadata om enskilda shards i en tabell. Pg_dist_shard har information om vilka distribuerade tabellshards som tillhör och statistik om distributionskolumnen för shards. För tillägg av distribuerade tabeller motsvarar den här statistiken min/max-värden för distributionskolumnen. För hash-distribuerade tabeller är de hashtokenintervall som tilldelats till fragmentet. Den här statistiken används för att rensa bort orelaterade shards under SELECT-frågor.
| Name | Type | Description |
|---|---|---|
| logicalrelid | regclass | Distribuerad tabell som den här raden motsvarar. Det här värdet refererar till kolumnen relfilenode i pg_class-systemkatalogtabellen. |
| shardid | bigint | Globalt unik identifierare som tilldelats den här fragmentet. |
| shardstorage | char | Typ av lagring som används för det här fragmentet. Olika lagringstyper beskrivs i tabellen nedan. |
| shardminvalue | text | För lägg till distribuerade tabeller, minsta värde för distributionskolumnen i den här fragmentet (inklusive). För hash-distribuerade tabeller, minsta hashtokenvärde som tilldelats till shard (inklusive). |
| shardmaxvalue | text | För lägg till distribuerade tabeller, maximalt värde för distributionskolumnen i den här fragmentet (inklusive). För hash-distribuerade tabeller, maximalt hashtokenvärde som tilldelats till fragmentet (inklusive). |
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)
Lagringstyper för fragment
Kolumnen shardstorage i pg_dist_shard anger vilken typ av lagring som används för shard. En kort översikt över olika lagringstyper för fragment och deras representation finns nedan.
| Lagringstyp | Shardstorage-värde | Description |
|---|---|---|
| TABELL | "t" | Anger att shard lagrar data som tillhör en vanlig distribuerad tabell. |
| COLUMNAR | 'c' | Anger att shard lagrar kolumndata. (Används av distribuerade cstore_fdw tabeller) |
| UTLÄNDSKA | 'f' | Anger att shard lagrar utländska data. (Används av distribuerade file_fdw tabeller) |
Shard informationsvy
Utöver tabellen med shardmetadata på låg nivå som beskrivs ovan ger Azure Cosmos DB for PostgreSQL en citus_shards vy för att enkelt kontrollera:
- Där varje shard är (nod och port),
- Vilken typ av tabell den tillhör, och
- Dess storlek
Den här vyn hjälper dig att inspektera shards för att bland annat hitta eventuella obalanser mellan noder.
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 refererar till samlokaliseringsgruppen.
Shard-placeringstabell
Tabellen pg_dist_placement spårar platsen för shardrepliker på arbetsnoder. Varje replik av en shard som tilldelats en specifik nod kallas för en shardplacering. Den här tabellen lagrar information om hälsotillståndet och platsen för varje shardplacering.
| Name | Type | Description |
|---|---|---|
| shardid | bigint | Fragmentidentifierare som är associerad med den här placeringen. Det här värdet refererar till kolumnen shardid i pg_dist_shard-katalogtabellen. |
| shardstate | heltal | Beskriver tillståndet för den här placeringen. Olika shardtillstånd beskrivs i avsnittet nedan. |
| shardlength | bigint | För lägg till distribuerade tabeller är storleken på shardplaceringen på arbetsnoden i byte. För hash-distribuerade tabeller, noll. |
| placementid | bigint | Unik autogenererad identifierare för varje enskild placering. |
| groupid | heltal | Anger en grupp med en primär server och noll eller flera sekundära servrar när strömningsreplikeringsmodellen används. |
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
Placeringstillstånd för fragment
Azure Cosmos DB for PostgreSQL hanterar shard health per placering. Om en placering försätter systemet i ett inkonsekvent tillstånd markerar Azure Cosmos DB for PostgreSQL automatiskt det som otillgängligt. Placeringstillståndet registreras i tabellen pg_dist_shard_placement i kolumnen shardstate. Här är en kort översikt över olika shardplaceringstillstånd:
| Delstatsnamn | Shardstate-värde | Description |
|---|---|---|
| SLUTBEHANDLAD | 1 | Tillståndet nya shards skapas i. Shardplaceringar i det här tillståndet anses vara uppdaterade och används i frågeplanering och körning. |
| INAKTIVA | 3 | Shardplaceringar i det här tillståndet anses vara inaktiva på grund av att de är osynkroniserade med andra repliker av samma shard. Tillståndet kan inträffa när en tilläggs-, ändringsåtgärd (INSERT, UPDATE, DELETE) eller en DDL-åtgärd misslyckas för den här placeringen. Frågehanteraren ignorerar placeringar i det här tillståndet under planering och körning. Användare kan synkronisera data i dessa fragment med en slutförd replik som en bakgrundsaktivitet. |
| TO_DELETE | 4 | Om Azure Cosmos DB for PostgreSQL försöker släppa en shardplacering som svar på ett master_apply_delete_command-anrop och misslyckas flyttas placeringen till det här tillståndet. Användarna kan sedan ta bort dessa fragment som en efterföljande bakgrundsaktivitet. |
Arbetsnodtabell
Tabellen pg_dist_node innehåller information om arbetsnoderna i klustret.
| Name | Type | Description |
|---|---|---|
| nodeid | heltal | Automatiskt genererad identifierare för en enskild nod. |
| groupid | heltal | Identifierare som används för att ange en grupp med en primär server och noll eller flera sekundära servrar, när modellen för strömmande replikering används. Som standard är det samma som nodeid. |
| nodename | text | Värdnamn eller IP-adress för PostgreSQL-arbetsnoden. |
| nodeport | heltal | Portnummer som PostgreSQL-arbetsnoden lyssnar på. |
| noderack | text | (Valfritt) Information om rackplacering för arbetsnoden. |
| hasmetadata | boolean | Reserverad för internt bruk. |
| isactive | boolean | Om noden är aktiv och accepterar shardplaceringar. |
| noderole | text | Om noden är en primär eller sekundär |
| nodecluster | text | Namnet på klustret som innehåller den här noden |
| shouldhaveshards | boolean | Om det är falskt flyttas shards från noden (tömda) vid ombalansering, och inte heller placeras shards från nya distribuerade tabeller på noden, såvida de inte är samlokaliserade med shards som redan finns där |
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)
Tabell med distribuerade objekt
Tabellen citus.pg_dist_object innehåller en lista över objekt, till exempel typer och funktioner som har skapats på koordinatornoden och spridits till arbetsnoder. När en administratör lägger till nya arbetsnoder i klustret skapar Azure Cosmos DB for PostgreSQL automatiskt kopior av de distribuerade objekten på de nya noderna (i rätt ordning för att uppfylla objektberoenden).
| Name | Type | Description |
|---|---|---|
| Classid | Oid | Klass för det distribuerade objektet |
| objid | Oid | Objekt-ID för det distribuerade objektet |
| objsubid | integer | Objektunder-ID för det distribuerade objektet, till exempel attnum |
| type | text | En del av den stabila adress som används vid pg-uppgraderingar |
| object_names | text[] | En del av den stabila adress som används vid pg-uppgraderingar |
| object_args | text[] | En del av den stabila adress som används vid pg-uppgraderingar |
| distribution_argument_index | integer | Endast giltigt för distribuerade funktioner/procedurer |
| colocationid | integer | Endast giltigt för distribuerade funktioner/procedurer |
"Stabila adresser" identifierar objekt unikt oberoende av en specifik server. Azure Cosmos DB for PostgreSQL spårar objekt under en PostgreSQL-uppgradering med hjälp av stabila adresser som skapats med funktionen pg_identify_object_as_address().
Här är ett exempel på hur create_distributed_function() du lägger till poster i citus.pg_dist_object tabellen:
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 |
Vyn Distribuerade scheman
Citus 12.0 introducerade begreppet schemabaserad horisontell partitionering och med den vyn "citus_schemas", som visar vilka scheman som har distribuerats i systemet. Vyn visar bara distribuerade scheman, lokala scheman visas inte.
| Name | Type | Description |
|---|---|---|
| schema_name | regnamespace | Namnet på det distribuerade schemat |
| colocation_id | integer | Samlokaliserings-ID för det distribuerade schemat |
| schema_size | text | Mänsklig läsbar storlekssammanfattning av alla objekt i schemat |
| schema_owner | name | Roll som äger schemat |
Här är ett exempel:
schema_name | colocation_id | schema_size | schema_owner
-------------+---------------+-------------+--------------
userservice | 1 | 0 bytes | userservice
timeservice | 2 | 0 bytes | timeservice
pingservice | 3 | 632 kB | pingservice
Vyn Distribuerade tabeller
Vyn citus_tables visar en sammanfattning av alla tabeller som hanteras av Azure Cosmos DB for PostgreSQL (distribuerade tabeller och referenstabeller). Vyn kombinerar information från Azure Cosmos DB för PostgreSQL-metadatatabeller för en enkel, läsbar översikt över dessa tabellegenskaper:
- Tabelltyp
- Distributionskolumn
- Grupp-ID för samlokalisering
- Storlek som kan läsas av människor
- Antal fragment
- Ägare (databasanvändare)
- Åtkomstmetod (heap eller columnar)
Här är ett exempel:
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 │
└────────────┴──────────────────┴─────────────────────┴───────────────┴────────────┴─────────────┴─────────────┴───────────────┘
Tidspartitionsvy
Azure Cosmos DB for PostgreSQL tillhandahåller UDF:er för att hantera partitioner för användningsfallet Timeseries Data. Den har också en time_partitions vy för att inspektera de partitioner som den hanterar.
Kolumner:
- parent_table tabellen som är partitionerad
- partition_column kolumnen där den överordnade tabellen är partitionerad
- partition namnet på en partitionstabell
- from_value lägre gräns i tid för rader i den här partitionen
- to_value övre gränsen i tid för rader i den här partitionen
- access_method heap för radbaserad lagring och columnar för columnar Storage
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 │
└────────────────────────┴──────────────────┴─────────────────────────────────────────┴─────────────────────┴─────────────────────┴───────────────┘
Grupptabell för samlokalisering
Tabellen pg_dist_colocation innehåller information om vilka tabellers fragment som ska placeras tillsammans eller samallokeras. När två tabeller finns i samma samlokaliseringsgrupp ser Azure Cosmos DB for PostgreSQL till att shards med samma distributionskolumnvärden placeras på samma arbetsnoder. Samlokalisering möjliggör kopplingsoptimeringar, vissa distribuerade sammanslagningar och stöd för sekundärnyckel. Shard colocation härleds när shardantalet, replikeringsfaktorerna och partitionskolumntyperna matchar mellan två tabeller. En anpassad samlokaliseringsgrupp kan dock anges när du skapar en distribuerad tabell, om så önskas.
| Name | Type | Description |
|---|---|---|
| colocationid | heltal | Unik identifierare för den samlokaliseringsgrupp som den här raden motsvarar. |
| shardcount | heltal | Shardantal för alla tabeller i den här samlokaliseringsgruppen |
| replicationfactor | heltal | Replikeringsfaktor för alla tabeller i den här samlokaliseringsgruppen. |
| distributioncolumntype | Oid | Typ av distributionskolumn för alla tabeller i den här samlokaliseringsgruppen. |
SELECT * from pg_dist_colocation;
colocationid | shardcount | replicationfactor | distributioncolumntype
--------------+------------+-------------------+------------------------
2 | 32 | 2 | 20
(1 row)
Tabell för ombalanseringsstrategi
Den här tabellen definierar strategier som rebalance_table_shards kan använda för att avgöra var shards ska flyttas.
| Name | Type | Description |
|---|---|---|
| default_strategy | boolean | Om rebalance_table_shards ska välja den här strategin som standard. Använd citus_set_default_rebalance_strategy för att uppdatera den här kolumnen |
| shard_cost_function | regproc | Identifierare för en kostnadsfunktion, som måste ta ett shardid som bigint och returnera begreppet kostnad, som typ verklig |
| node_capacity_function | regproc | Identifierare för en kapacitetsfunktion som måste ta ett nodeid som int och returnera begreppet nodkapacitet som typ verklig |
| shard_allowed_on_node_function | regproc | Identifierare för en funktion som givet shardid bigint och nodeidarg int returnerar booleskt värde för huruvida Azure Cosmos DB för PostgreSQL kan lagra fragmentet på noden |
| default_threshold | float4 | Tröskelvärde för att anse att en nod är för full eller för tom, vilket avgör när rebalance_table_shards ska försöka flytta shards |
| minimum_threshold | float4 | Ett skydd för att förhindra att tröskelvärdet för rebalance_table_shards() anges för lågt |
Som standard levereras Cosmos DB för PostgreSQL med följande strategier i tabellen:
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
Strategin by_disk_size tilldelar varje fragment samma kostnad. Dess effekt är att utjämna antalet fragment mellan noder. Standardstrategin, by_disk_size, tilldelar en kostnad till varje shard som matchar diskstorleken i byte plus den för de shards som är samlokaliserade med den. Diskstorleken beräknas med hjälp av pg_total_relation_size, så den innehåller index. Den här strategin försöker uppnå samma diskutrymme på varje nod. Observera tröskelvärdet 0.1för , det förhindrar onödig shard-rörelse som orsakas av obetydliga skillnader i diskutrymme.
Skapa anpassade ombalanseringsstrategier
Här är exempel på funktioner som kan användas i nya strategier för horisontell ombalansering och registreras i pg_dist_rebalance_strategy med funktionen citus_add_rebalance_strategy .
Ange ett nodkapacitetsfel efter värdnamnsmönster:
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;Ombalansera efter antal frågor som går till en shard, mätt med 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;Isolera en specifik shard (10000) på en nod (adress "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;
Tabell med frågestatistik
Azure Cosmos DB for PostgreSQL innehåller citus_stat_statements statistik om hur frågor körs och för vem. Det motsvarar (och kan kopplas till) vyn pg_stat_statements i PostgreSQL, som spårar statistik om frågehastighet.
Den här vyn kan spåra frågor till ursprungliga klienter i ett program med flera klienter, vilket hjälper dig att bestämma när klientisolering ska utföras.
| Name | Type | Description |
|---|---|---|
| queryid | bigint | identifierare (bra för pg_stat_statements kopplingar) |
| userid | Oid | användare som körde frågan |
| dbid | Oid | databasinstans av koordinator |
| query | text | anonymiserad frågesträng |
| Testamentsexekutor | text | Citus-köre som används: anpassningsbar, realtid, aktivitetsspårare, router eller insert-select |
| partition_key | text | värdet för distributionskolumnen i router-körda frågor, annars NULL |
| Samtal | bigint | antal gånger som frågan kördes |
-- 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;
Resultat:
-[ 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
Varningar:
- Statistikdata replikeras inte och överlever inte databaskrascher eller redundans
- Spårar ett begränsat antal frågor som anges av
pg_stat_statements.maxGUC (standard 5000) - Om du vill trunkera tabellen använder du
citus_stat_statements_reset()funktionen
Distribuerad frågeaktivitet
Azure Cosmos DB for PostgreSQL innehåller särskilda vyer för att titta på frågor och lås i hela klustret, inklusive shardspecifika frågor som används internt för att skapa resultat för distribuerade frågor.
- citus_dist_stat_activity: visar distribuerade frågor som körs på alla noder. En supermängd av
pg_stat_activity, användbar oavsett var den senare är. - citus_worker_stat_activity: visar frågor om arbetare, inklusive fragmentfrågor mot enskilda shards.
- citus_lock_waits: Blockerade frågor i hela klustret.
De första två vyerna innehåller alla kolumner i pg_stat_activity plus värdvärden/porten för arbetaren som initierade frågan och värden/porten för koordinatornoden i klustret.
Överväg till exempel att räkna raderna i en distribuerad tabell:
-- run from worker on localhost:9701
SELECT count(*) FROM users_table;
Vi kan se att frågan visas i 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
Den här frågan kräver information från alla shards. En del av informationen finns i shard users_table_102038, som råkar lagras i localhost:9700. Vi kan se en fråga som kommer åt fragmentet genom att titta på citus_worker_stat_activity vyn:
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
Fältet query visar data som kopieras från fragmentet som ska räknas.
Kommentar
Om en routerfråga (t.ex. en klientorganisation i ett program med flera klientorganisationer)
- FRÅN-tabellen WHERE tenant_id = X) körs utan transaktionsblock och master_query_host_name och master_query_host_port kolumner kommer att vara NULL i citus_worker_stat_activity.
Här är exempel på användbara frågor som du kan skapa med :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;
Nästa vy är citus_lock_waits. För att se hur det fungerar kan vi generera en låsningssituation manuellt. Först ska vi konfigurera en testtabell från koordinatorn:
CREATE TABLE numbers AS
SELECT i, 0 AS j FROM generate_series(1,10) AS i;
SELECT create_distributed_table('numbers', 'i');
Med två sessioner på koordinatorn kan vi sedan köra den här sekvensen med instruktioner:
-- session 1 -- session 2
------------------------------------- -------------------------------------
BEGIN;
UPDATE numbers SET j = 2 WHERE i = 1;
BEGIN;
UPDATE numbers SET j = 3 WHERE i = 1;
-- (this blocks)
Vyn citus_lock_waits visar situationen.
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
I det här exemplet har frågorna sitt ursprung i koordinatorn, men vyn kan också visa lås mellan frågor som kommer från arbetare (körs med Azure Cosmos DB för PostgreSQL MX till exempel).
Nästa steg
- Lär dig hur vissa Azure Cosmos DB for PostgreSQL-funktioner ändrar systemtabeller
- Granska begreppen för noder och tabeller