Systeemtabellen en weergaven van Azure Cosmos DB for PostgreSQL
VAN TOEPASSING OP: 
Azure Cosmos DB for PostgreSQL (mogelijk gemaakt door de Citus-database-extensie naar PostgreSQL)
Azure Cosmos DB for PostgreSQL maakt en onderhoudt speciale tabellen die informatie bevatten over gedistribueerde gegevens in het cluster. Het coördinatorknooppunt raadpleegt deze tabellen bij het plannen van het uitvoeren van query's op de werkknooppunten.
Coördinatormetagegevens
Azure Cosmos DB for PostgreSQL verdeelt elke gedistribueerde tabel in meerdere logische shards op basis van de distributiekolom. De coördinator onderhoudt vervolgens metagegevenstabellen om statistieken en informatie over de status en locatie van deze shards bij te houden.
In deze sectie beschrijven we elk van deze metagegevenstabellen en hun schema. U kunt deze tabellen bekijken en er query's op uitvoeren met behulp van SQL nadat u zich hebt aangemeld bij het coördinatorknooppunt.
Notitie
clusters met oudere versies van de Citus Engine bieden mogelijk niet alle onderstaande tabellen.
Partitietabel
In de pg_dist_partition tabel worden metagegevens opgeslagen over welke tabellen in de database worden gedistribueerd. Voor elke gedistribueerde tabel worden ook gegevens over de distributiemethode en gedetailleerde informatie over de distributiekolom opgeslagen.
| Name | Type | Description |
|---|---|---|
| logicalrelid | regclass | Gedistribueerde tabel waarop deze rij overeenkomt. Deze waarde verwijst naar de kolom relfilenode in de tabel pg_class systeemcatalogus. |
| partmethod | char | De methode die wordt gebruikt voor partitionering/distributie. De waarden van deze kolom die overeenkomen met verschillende distributiemethoden, worden toegevoegd: 'a', hash: 'h', referentietabel: 'n' |
| partkey | sms verzenden | Gedetailleerde informatie over de distributiekolom, inclusief kolomnummer, type en andere relevante informatie. |
| colocatieid | geheel getal | Colocatiegroep waartoe deze tabel behoort. Tabellen in dezelfde groep staan samenvoegingen en gedistribueerde samenvoegingen en gedistribueerde samenvoegingen toe onder andere optimalisaties. Deze waarde verwijst naar de kolom colocationid in de pg_dist_colocation tabel. |
| repmodel | char | De methode die wordt gebruikt voor gegevensreplicatie. De waarden van deze kolom die overeenkomen met verschillende replicatiemethoden zijn: Citus-instructiegebaseerde replicatie: 'c', postgresql-streamingreplicatie: 's', tweefasige doorvoer (voor referentietabellen): '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)
Shardtabel
In de pg_dist_shard tabel worden metagegevens over afzonderlijke shards van een tabel opgeslagen. Pg_dist_shard bevat informatie over de gedistribueerde tabel-shards en statistieken over de distributiekolom voor shards. Voor het toevoegen van gedistribueerde tabellen komen deze statistieken overeen met min/max-waarden van de distributiekolom. Voor gedistribueerde hashtabellen zijn deze hashtokenbereiken toegewezen aan die shard. Deze statistieken worden gebruikt voor het verwijderen van niet-gerelateerde shards tijdens SELECT-query's.
| Name | Type | Description |
|---|---|---|
| logicalrelid | regclass | Gedistribueerde tabel waarop deze rij overeenkomt. Deze waarde verwijst naar de kolom relfilenode in de tabel pg_class systeemcatalogus. |
| shardid | bigint | Globally unique identifier assigned to this shard. |
| shardstorage | char | Type opslag dat wordt gebruikt voor deze shard. In de onderstaande tabel worden verschillende opslagtypen besproken. |
| shardminvalue | sms verzenden | Voor het toevoegen van gedistribueerde tabellen geldt de minimale waarde van de distributiekolom in deze shard (inclusief). Voor gedistribueerde hashtabellen is de minimale hash-tokenwaarde toegewezen aan die shard (inclusief). |
| shardmaxvalue | sms verzenden | Voor het toevoegen van gedistribueerde tabellen geldt de maximale waarde van de distributiekolom in deze shard (inclusief). Voor gedistribueerde hashtabellen geldt de maximale hashtokenwaarde die is toegewezen aan die shard (inclusief). |
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)
Shard-opslagtypen
De kolom shardstorage in pg_dist_shard geeft het type opslag aan dat voor de shard wordt gebruikt. Hieronder vindt u een kort overzicht van verschillende shardopslagtypen en de bijbehorende weergave.
| Opslagtype | Shardstorage-waarde | Beschrijving |
|---|---|---|
| TABEL | 't' | Geeft aan dat shard gegevens opslaat die behoren tot een normale gedistribueerde tabel. |
| KOLOMAR | 'c' | Geeft aan dat shard kolomgegevens opslaat. (Gebruikt door gedistribueerde cstore_fdw tabellen) |
| BUITENLANDS | 'f' | Geeft aan dat shard refererende gegevens opslaat. (Gebruikt door gedistribueerde file_fdw tabellen) |
Shard-informatieweergave
Naast de tabel met shardmetagegevens op laag niveau die hierboven wordt beschreven, biedt Azure Cosmos DB for PostgreSQL een citus_shards weergave om eenvoudig te controleren:
- Waar elke shard zich bevindt (knooppunt en poort),
- Tot welk soort tabel het behoort, en
- De grootte
Deze weergave helpt u bij het inspecteren van shards om onder andere eventuele onevenwichtigheid tussen knooppunten te vinden.
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
De colocation_id verwijst naar de colocatiegroep.
Shardplaatsingstabel
In de pg_dist_placement tabel wordt de locatie van shardreplica's op werkknooppunten bijgehouden. Elke replica van een shard die aan een specifiek knooppunt is toegewezen, wordt een shardplaatsing genoemd. Deze tabel bevat informatie over de status en locatie van elke shardplaatsing.
| Name | Type | Description |
|---|---|---|
| shardid | bigint | Shard-id die is gekoppeld aan deze plaatsing. Deze waarde verwijst naar de kolom shardid in de pg_dist_shard catalogustabel. |
| shardstate | int | Beschrijft de status van deze plaatsing. In de onderstaande sectie worden verschillende shardstatussen besproken. |
| shardlength | bigint | Voor het toevoegen van gedistribueerde tabellen, de grootte van de shardplaatsing op het werkknooppunt in bytes. Voor gedistribueerde hashtabellen, nul. |
| plaatsings-id | bigint | Unieke automatisch gegenereerde id voor elke afzonderlijke plaatsing. |
| groupid | int | Geeft een groep van één primaire server en nul of meer secundaire servers aan wanneer het streamingreplicatiemodel wordt gebruikt. |
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
Shard-plaatsingsstatussen
Azure Cosmos DB for PostgreSQL beheert de shardstatus per plaatsing. Als een plaatsing het systeem in een inconsistente status plaatst, wordt dit automatisch gemarkeerd als niet beschikbaar in Azure Cosmos DB for PostgreSQL. De plaatsingsstatus wordt vastgelegd in de pg_dist_shard_placement tabel, binnen de kolom shardstate. Hier volgt een kort overzicht van verschillende shardplaatsingsstatussen:
| Naam van staat | Shardstate-waarde | Beschrijving |
|---|---|---|
| AFGEROND | 1 | De status nieuwe shards worden gemaakt in. Shard-plaatsingen in deze status worden beschouwd als up-to-date en worden gebruikt bij het plannen en uitvoeren van query's. |
| INACTIEF | 3 | Shard-plaatsingen in deze status worden als inactief beschouwd omdat ze niet synchroon zijn met andere replica's van dezelfde shard. De status kan optreden wanneer een toevoeg-, wijziging (INSERT, UPDATE, DELETE) of een DDL-bewerking mislukt voor deze plaatsing. De queryplanner negeert plaatsingen in deze status tijdens de planning en uitvoering. Gebruikers kunnen de gegevens in deze shards synchroniseren met een voltooide replica als achtergrondactiviteit. |
| TO_DELETE | 4 | Als Azure Cosmos DB for PostgreSQL een shardplaatsing probeert te verwijderen als reactie op een master_apply_delete_command-aanroep en mislukt, wordt de plaatsing verplaatst naar deze status. Gebruikers kunnen deze shards vervolgens verwijderen als een volgende achtergrondactiviteit. |
Werkknooppunttabel
De pg_dist_node tabel bevat informatie over de werkknooppunten in het cluster.
| Name | Type | Description |
|---|---|---|
| nodeid | int | Automatisch gegenereerde id voor een afzonderlijk knooppunt. |
| groupid | int | Id die wordt gebruikt om een groep van één primaire server en nul of meer secundaire servers aan te geven wanneer het streamingreplicatiemodel wordt gebruikt. Dit is standaard hetzelfde als de nodeid. |
| knooppuntnaam | sms verzenden | Hostnaam of IP-adres van het PostgreSQL-werkknooppunt. |
| nodeport | int | Poortnummer waarop het PostgreSQL-werkknooppunt luistert. |
| noderack | sms verzenden | (Optioneel) Informatie over plaatsing van rekken voor het werkknooppunt. |
| hasmetadata | boolean | Gereserveerd voor intern gebruik. |
| isactief | boolean | Of het knooppunt actief is om shardplaatsingen te accepteren. |
| noderole | sms verzenden | Of het knooppunt een primaire of secundaire knooppunt is |
| nodecluster | sms verzenden | De naam van het cluster met dit knooppunt |
| shouldhaveshards | boolean | Als dit onwaar is, worden shards verplaatst van het knooppunt (leeg) bij het opnieuw verdelen en worden er ook shards uit nieuwe gedistribueerde tabellen op het knooppunt geplaatst, tenzij ze zijn geplaatst met shards die daar al aanwezig zijn |
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)
Gedistribueerde objecttabel
De tabel citus.pg_dist_object bevat een lijst met objecten, zoals typen en functies die zijn gemaakt op het coördinatorknooppunt en die zijn doorgegeven aan werkknooppunten. Wanneer een beheerder nieuwe werkknooppunten toevoegt aan het cluster, worden in Azure Cosmos DB for PostgreSQL automatisch kopieën gemaakt van de gedistribueerde objecten op de nieuwe knooppunten (in de juiste volgorde om te voldoen aan objectafhankelijkheden).
| Name | Type | Description |
|---|---|---|
| classid | oid | Klasse van het gedistribueerde object |
| objid | oid | Object-id van het gedistribueerde object |
| objsubid | geheel getal | Objectsub-id van het gedistribueerde object, bijvoorbeeld attnum |
| type | sms verzenden | Onderdeel van het stabiele adres dat wordt gebruikt tijdens pg-upgrades |
| object_names | text[] | Onderdeel van het stabiele adres dat wordt gebruikt tijdens pg-upgrades |
| object_args | text[] | Onderdeel van het stabiele adres dat wordt gebruikt tijdens pg-upgrades |
| distribution_argument_index | geheel getal | Alleen geldig voor gedistribueerde functies/procedures |
| colocatieid | geheel getal | Alleen geldig voor gedistribueerde functies/procedures |
'Stabiele adressen' identificeren objecten op unieke wijze onafhankelijk van een specifieke server. Azure Cosmos DB for PostgreSQL houdt objecten bij tijdens een PostgreSQL-upgrade met behulp van stabiele adressen die zijn gemaakt met de functie pg_identify_object_as_address().
Hier volgt een voorbeeld van het create_distributed_function() toevoegen van vermeldingen aan de citus.pg_dist_object tabel:
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 |
Weergave gedistribueerde schema's
Citus 12.0 introduceerde het concept van op schema gebaseerde sharding en daarmee de weergave 'citus_schemas', die laat zien welke schema's in het systeem zijn gedistribueerd. In de weergave worden alleen gedistribueerde schema's weergegeven, lokale schema's worden niet weergegeven.
| Name | Type | Description |
|---|---|---|
| schema_name | regnamespace | Naam van het gedistribueerde schema |
| colocation_id | geheel getal | Colocatie-id van het gedistribueerde schema |
| schema_size | sms verzenden | Samenvatting van de leesbare grootte van alle objecten in het schema |
| schema_owner | naam | Rol die eigenaar is van het schema |
Hier volgt een voorbeeld:
schema_name | colocation_id | schema_size | schema_owner
-------------+---------------+-------------+--------------
userservice | 1 | 0 bytes | userservice
timeservice | 2 | 0 bytes | timeservice
pingservice | 3 | 632 kB | pingservice
Weergave Gedistribueerde tabellen
In de citus_tables weergave ziet u een overzicht van alle tabellen die worden beheerd door Azure Cosmos DB for PostgreSQL (gedistribueerde en referentietabellen). De weergave combineert informatie uit Azure Cosmos DB for PostgreSQL-metagegevenstabellen voor een eenvoudig, leesbaar overzicht van deze tabeleigenschappen:
- Tabeltype
- Distributiekolom
- Groeps-id voor colocatie
- Leesbare grootte voor mensen
- Aantal shards
- Eigenaar (databasegebruiker)
- Toegangsmethode (heap of kolom)
Hier volgt een voorbeeld:
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 │
└────────────┴──────────────────┴─────────────────────┴───────────────┴────────────┴─────────────┴─────────────┴───────────────┘
Weergave Tijdpartities
Azure Cosmos DB for PostgreSQL biedt UDF's voor het beheren van partities voor de use case Timeseries Data. Het onderhoudt ook een time_partitions weergave om de partities te inspecteren die worden beheerd.
Kolommen:
- parent_table de tabel die is gepartitioneerd
- partition_column de kolom waarop de bovenliggende tabel is gepartitioneerd
- de naam van een partitietabel partitioneren
- from_value ondergrens voor rijen in deze partitie
- to_value bovengrens in tijd voor rijen in deze partitie
- access_method heap voor opslag op basis van rijen en kolommen voor kolomopslag
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 │
└────────────────────────┴──────────────────┴─────────────────────────────────────────┴─────────────────────┴─────────────────────┴───────────────┘
Groepstabel colocatie
De pg_dist_colocation tabel bevat informatie over de shards van tabellen die samen moeten worden geplaatst of een punt moeten worden geplaatst. Wanneer twee tabellen zich in dezelfde colocatiegroep bevinden, zorgt Azure Cosmos DB voor PostgreSQL ervoor dat shards met dezelfde distributiekolomwaarden op dezelfde werkknooppunten worden geplaatst. Colocatie maakt join-optimalisaties, bepaalde gedistribueerde rollups en ondersteuning voor refererende sleutels mogelijk. Shard-colocatie wordt afgeleid wanneer de shardaantallen, replicatiefactoren en partitiekolomtypen allemaal overeenkomen tussen twee tabellen; Een aangepaste colocatiegroep kan echter worden opgegeven bij het maken van een gedistribueerde tabel, indien gewenst.
| Name | Type | Description |
|---|---|---|
| colocatieid | int | De unieke id voor de colocatiegroep waar deze rij mee overeenkomt. |
| shardcount | int | Aantal shards voor alle tabellen in deze colocatiegroep |
| replicatiefactor | int | Replicatiefactor voor alle tabellen in deze colocatiegroep. |
| distributioncolumntype | oid | Het type distributiekolom voor alle tabellen in deze colocatiegroep. |
SELECT * from pg_dist_colocation;
colocationid | shardcount | replicationfactor | distributioncolumntype
--------------+------------+-------------------+------------------------
2 | 32 | 2 | 20
(1 row)
Strategietabel voor opnieuw verdelen
In deze tabel worden strategieën gedefinieerd die rebalance_table_shards kunnen gebruiken om te bepalen waar shards moeten worden verplaatst.
| Name | Type | Description |
|---|---|---|
| default_strategy | boolean | Of rebalance_table_shards deze strategie standaard moet kiezen. Gebruik citus_set_default_rebalance_strategy om deze kolom bij te werken |
| shard_cost_function | regproc | Id voor een kostenfunctie, die een shardid als bigint moet aannemen en de notie van een kosten moet retourneren, als type echt |
| node_capacity_function | regproc | Id voor een capaciteitsfunctie, die een nodeid als int moet aannemen en de notie van knooppuntcapaciteit als type echt moet retourneren |
| shard_allowed_on_node_function | regproc | Id voor een functie die shardid bigint en nodeidarg int krijgt, retourneert booleaanse waarde voor of Azure Cosmos DB for PostgreSQL de shard op het knooppunt kan opslaan |
| default_threshold | float4 | Drempelwaarde voor het achten van een knooppunt te vol of te leeg, wat bepaalt wanneer de rebalance_table_shards shards moet verplaatsen |
| minimum_threshold | float4 | Een beveiliging om te voorkomen dat het drempelwaardeargument van rebalance_table_shards() te laag wordt ingesteld |
Cosmos DB for PostgreSQL wordt standaard geleverd met deze strategieën in de tabel:
SELECT * FROM pg_dist_rebalance_strategy;
-[ RECORD 1 ]-------------------+-----------------------------------
Name | by_shard_count
default_strategy | false
shard_cost_function | citus_shard_cost_1
node_capacity_function | citus_node_capacity_1
shard_allowed_on_node_function | citus_shard_allowed_on_node_true
default_threshold | 0
minimum_threshold | 0
-[ RECORD 2 ]-------------------+-----------------------------------
Name | by_disk_size
default_strategy | true
shard_cost_function | citus_shard_cost_by_disk_size
node_capacity_function | citus_node_capacity_1
shard_allowed_on_node_function | citus_shard_allowed_on_node_true
default_threshold | 0.1
minimum_threshold | 0.01
De strategie by_disk_size wijst elke shard dezelfde kosten toe. Het effect is om het aantal shards op knooppunten te gelijk te maken. Met de standaardstrategie worden by_disk_sizekosten toegewezen aan elke shard die overeenkomt met de schijfgrootte in bytes plus die van de shards die eraan zijn gekoppeld. De schijfgrootte wordt berekend met behulp van pg_total_relation_size, zodat deze indexen bevat. Deze strategie probeert dezelfde schijfruimte op elk knooppunt te bereiken. Let op de drempelwaarde van 0.1, het voorkomt onnodige shardverplaatsing die wordt veroorzaakt door onbelangrijke verschillen in schijfruimte.
Aangepaste strategieën voor opnieuw verdelen maken
Hier volgen voorbeelden van functies die kunnen worden gebruikt binnen nieuwe shardherbalancerstrategieën en die zijn geregistreerd in de pg_dist_rebalance_strategy met de functie citus_add_rebalance_strategy.
Een knooppuntcapaciteitsuitzondering instellen op hostnaampatroon:
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;Herverdeling op basis van het aantal query's dat naar een shard gaat, zoals gemeten door de 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;Een specifieke shard (10000) isoleren op een knooppunt (adres 10.0.0.1):
-- example of shard_allowed_on_node_function CREATE FUNCTION isolate_shard_10000_on_10_0_0_1(shardid bigint, nodeidarg int) RETURNS boolean AS $$ SELECT (CASE WHEN nodename = '10.0.0.1' THEN shardid = 10000 ELSE shardid != 10000 END) FROM pg_dist_node where nodeid = nodeidarg $$ LANGUAGE sql; -- The next two definitions are recommended in combination with the above function. -- This way the average utilization of nodes is not impacted by the isolated shard. CREATE FUNCTION no_capacity_for_10_0_0_1(nodeidarg int) RETURNS real AS $$ SELECT (CASE WHEN nodename = '10.0.0.1' THEN 0 ELSE 1 END)::real FROM pg_dist_node where nodeid = nodeidarg $$ LANGUAGE sql; CREATE FUNCTION no_cost_for_10000(shardid bigint) RETURNS real AS $$ SELECT (CASE WHEN shardid = 10000 THEN 0 ELSE 1 END)::real $$ LANGUAGE sql;
Tabel querystatistieken
Azure Cosmos DB for PostgreSQL biedt citus_stat_statements statistieken over hoe query's worden uitgevoerd en voor wie. Het is vergelijkbaar met (en kan worden samengevoegd met) de pg_stat_statements-weergave in PostgreSQL, waarmee statistieken over querysnelheid worden bijgehouden.
Deze weergave kan query's traceren naar oorspronkelijke tenants in een multitenant-toepassing, wat helpt bij het bepalen wanneer tenantisolatie moet worden uitgevoerd.
| Name | Type | Description |
|---|---|---|
| queryid | bigint | id (goed voor pg_stat_statements joins) |
| userid | oid | gebruiker die de query heeft uitgevoerd |
| dbid | oid | database-exemplaar van coördinator |
| query | sms verzenden | geanonimiseerde queryreeks |
| Executeur | sms verzenden | Citus executor used: adaptive, real-time, task-tracker, router, or insert-select |
| partition_key | sms verzenden | waarde van distributiekolom in door router uitgevoerde query's, anders NULL |
| Oproepen | bigint | aantal keren dat de query is uitgevoerd |
-- 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;
Resultaten:
-[ 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
Waarschuwingen:
- De statistiekengegevens worden niet gerepliceerd en overleven geen databasecrashes of failovers
- Houdt een beperkt aantal query's bij, ingesteld door de
pg_stat_statements.maxGUC (standaard 5000) - Als u de tabel wilt afkappen, gebruikt u de
citus_stat_statements_reset()functie
Gedistribueerde queryactiviteit
Azure Cosmos DB for PostgreSQL biedt speciale weergaven voor het bekijken van query's en vergrendelingen in het hele cluster, inclusief shard-specifieke query's die intern worden gebruikt om resultaten voor gedistribueerde query's te bouwen.
- citus_dist_stat_activity: toont de gedistribueerde query's die worden uitgevoerd op alle knooppunten. Een superset van
pg_stat_activity, bruikbaar waar de laatste ook is. - citus_worker_stat_activity: toont query's op werkrollen, inclusief fragmentquery's op afzonderlijke shards.
- citus_lock_waits: Geblokkeerde query's in het hele cluster.
De eerste twee weergaven bevatten alle kolommen van pg_stat_activity plus de hosthost/poort van de werkrol die de query heeft gestart en de host/poort van het coördinatorknooppunt van het cluster.
U kunt bijvoorbeeld de rijen in een gedistribueerde tabel tellen:
-- run from worker on localhost:9701
SELECT count(*) FROM users_table;
We kunnen zien dat de query wordt weergegeven in 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
Voor deze query zijn gegevens van alle shards vereist. Sommige van de informatie bevindt zich in shard users_table_102038, die toevallig wordt opgeslagen in localhost:9700. We kunnen een query zien die toegang heeft tot de shard door naar de citus_worker_stat_activity weergave te kijken:
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
In query het veld worden gegevens weergegeven die uit de shard worden gekopieerd die moeten worden geteld.
Notitie
Als een routerquery (bijvoorbeeld één tenant in een toepassing met meerdere tenants), selecteert u SELECT
- FROM table WHERE tenant_id = X') wordt uitgevoerd zonder transactieblok, dan worden master_query_host_name en master_query_host_port kolommen NULL in citus_worker_stat_activity.
Hier volgen voorbeelden van nuttige query's die u kunt bouwen met: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;
De volgende weergave is citus_lock_waits. Om te zien hoe het werkt, kunnen we handmatig een vergrendelingssituatie genereren. Eerst stellen we een testtabel in van de coördinator:
CREATE TABLE numbers AS
SELECT i, 0 AS j FROM generate_series(1,10) AS i;
SELECT create_distributed_table('numbers', 'i');
Vervolgens kunnen we met behulp van twee sessies op de coördinator deze reeks instructies uitvoeren:
-- session 1 -- session 2
------------------------------------- -------------------------------------
BEGIN;
UPDATE numbers SET j = 2 WHERE i = 1;
BEGIN;
UPDATE numbers SET j = 3 WHERE i = 1;
-- (this blocks)
In citus_lock_waits de weergave ziet u de situatie.
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
In dit voorbeeld zijn de query's afkomstig van de coördinator, maar de weergave kan ook vergrendelingen weergeven tussen query's die afkomstig zijn van werkrollen (bijvoorbeeld uitgevoerd met Azure Cosmos DB for PostgreSQL MX).
Volgende stappen
- Meer informatie over hoe sommige Azure Cosmos DB for PostgreSQL-functies systeemtabellen wijzigen
- De concepten van knooppunten en tabellen bekijken