Tabelle e viste di sistema di Azure Cosmos DB per PostgreSQL
SI APPLICA A: 
Azure Cosmos DB per PostgreSQL (basato sull'estensione del database Citus in PostgreSQL)
Azure Cosmos DB per PostgreSQL crea e gestisce tabelle speciali contenenti informazioni sui dati distribuiti nel cluster. Il nodo coordinatore consulta queste tabelle durante la pianificazione dell'esecuzione di query tra i nodi di lavoro.
Metadati coordinatore
Azure Cosmos DB per PostgreSQL divide ogni tabella distribuita in più partizioni logiche in base alla colonna di distribuzione. Il coordinatore gestisce quindi le tabelle di metadati per tenere traccia delle statistiche e delle informazioni sull'integrità e sulla posizione di queste partizioni.
In questa sezione vengono descritte ognuna di queste tabelle di metadati e il relativo schema. È possibile visualizzare ed eseguire query su queste tabelle usando SQL dopo l'accesso al nodo coordinatore.
Nota
I cluster che eseguono versioni precedenti del motore Citus potrebbero non offrire tutte le tabelle elencate di seguito.
Tabella di partizione
La tabella pg_dist_partition archivia i metadati relativi alle tabelle nel database distribuite. Per ogni tabella distribuita vengono inoltre archiviate informazioni sul metodo di distribuzione e informazioni dettagliate sulla colonna di distribuzione.
| Nome | Digita | Descrizione |
|---|---|---|
| logicalrelid | regclass | Tabella distribuita a cui corrisponde questa riga. Questo valore fa riferimento alla colonna relfilenode nella tabella del catalogo di sistema pg_class. |
| partmethod | char | Metodo utilizzato per il partizionamento/distribuzione. I valori di questa colonna corrispondenti ai diversi metodi di distribuzione sono accodati: 'a', hash: 'h', tabella di riferimento: 'n' |
| partkey | testo | Informazioni dettagliate sulla colonna di distribuzione, inclusi il numero di colonna, il tipo e altre informazioni pertinenti. |
| colocationid | integer | Gruppo di condivisione a cui appartiene la tabella. Le tabelle nello stesso gruppo consentono join con percorso condiviso e rollup distribuiti tra le altre ottimizzazioni. Questo valore fa riferimento alla colonna colocationid nella tabella pg_dist_colocation. |
| repositorymodel | char | Metodo utilizzato per la replica dei dati. I valori di questa colonna corrispondenti a metodi di replica diversi sono: replica basata su istruzioni Citus: 'c', replica di streaming postgresql: 's', commit in due fasi (per le tabelle di riferimento): '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)
Tabella partizioni
La tabella pg_dist_shard archivia i metadati relativi alle singole partizioni di una tabella. Pg_dist_shard contiene informazioni sulle partizioni di tabella distribuite a cui appartengono e statistiche sulla colonna di distribuzione per le partizioni. Per le tabelle distribuite di accodamento, queste statistiche corrispondono ai valori min/max della colonna di distribuzione. Per le tabelle con distribuzione hash, sono intervalli di token hash assegnati a tale partizione. Queste statistiche vengono usate per eliminare le partizioni non correlate durante le query edizione Standard LECT.
| Nome | Digita | Descrizione |
|---|---|---|
| logicalrelid | regclass | Tabella distribuita a cui corrisponde questa riga. Questo valore fa riferimento alla colonna relfilenode nella tabella del catalogo di sistema pg_class. |
| shardid | bigint | Identificatore univoco globale assegnato a questa partizione. |
| shardstorage | char | Tipo di spazio di archiviazione usato per questa partizione. Nella tabella seguente vengono illustrati diversi tipi di archiviazione. |
| shardminvalue | testo | Per le tabelle distribuite di accodamento, il valore minimo della colonna di distribuzione in questa partizione (inclusi). Per le tabelle con distribuzione hash, il valore minimo del token hash assegnato alla partizione (inclusiva). |
| shardmaxvalue | testo | Per le tabelle distribuite di accodamento, valore massimo della colonna di distribuzione in questa partizione (inclusi). Per le tabelle con distribuzione hash, il valore massimo del token hash assegnato alla partizione (inclusiva). |
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)
Tipi di Archiviazione di partizionamento orizzontale
La colonna shardstorage in pg_dist_shard indica il tipo di spazio di archiviazione usato per la partizione. Di seguito è riportata una breve panoramica dei diversi tipi di archiviazione partizioni e della relativa rappresentazione.
| Tipo di archiviazione | Valore di Shardstorage | Descrizione |
|---|---|---|
| TABLE | 't' | Indica che la partizione archivia i dati appartenenti a una normale tabella distribuita. |
| COLONNARE | 'c' | Indica che la partizione archivia i dati a colonne. (Usato dalle tabelle cstore_fdw distribuite) |
| FOREIGN | 'f' | Indica che la partizione archivia i dati stranieri. (Usato dalle tabelle file_fdw distribuite) |
Visualizzazione informazioni partizioni
Oltre alla tabella dei metadati di partizione di basso livello descritta in precedenza, Azure Cosmos DB per PostgreSQL offre una citus_shards visualizzazione per controllare facilmente:
- Dove ogni partizione è (nodo e porta),
- Che tipo di tabella appartiene e
- Le sue dimensioni
Questa vista consente di esaminare le partizioni per trovare, tra le altre cose, eventuali squilibri di dimensioni tra i nodi.
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
Il colocation_id fa riferimento al gruppo di condivisione.
Tabella di posizionamento partizioni
La tabella pg_dist_placement tiene traccia della posizione delle repliche di partizioni nei nodi di lavoro. Ogni replica di una partizione assegnata a un nodo specifico è detta posizionamento di partizioni. Questa tabella archivia informazioni sull'integrità e sulla posizione di ogni posizionamento di partizioni.
| Nome | Digita | Descrizione |
|---|---|---|
| shardid | bigint | Identificatore di partizione associato a questa posizione. Questo valore fa riferimento alla colonna shardid nella tabella del catalogo pg_dist_shard. |
| shardstate | int | Descrive lo stato di questa posizione. Nella sezione seguente vengono illustrati diversi stati di partizione. |
| shardlength | bigint | Per le tabelle distribuite di accodamento, le dimensioni del posizionamento delle partizioni nel nodo di lavoro in byte. Per le tabelle distribuite con hash, zero. |
| placementid | bigint | Identificatore univoco generato automaticamente per ogni singolo posizionamento. |
| groupid | int | Indica un gruppo di un server primario e zero o più server secondari quando viene usato il modello di replica di streaming. |
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
Stati di posizionamento partizioni
Azure Cosmos DB per PostgreSQL gestisce l'integrità delle partizioni in base al posizionamento. Se un posizionamento inserisce il sistema in uno stato incoerente, Azure Cosmos DB per PostgreSQL lo contrassegna automaticamente come non disponibile. Lo stato di posizionamento viene registrato nella tabella pg_dist_shard_placement, all'interno della colonna shardstate. Ecco una breve panoramica dei diversi stati di posizionamento delle partizioni:
| Nome dello stato | Valore di Shardstate | Descrizione |
|---|---|---|
| FINALIZZATO | 1 | Le nuove partizioni di stato vengono create. I posizionamenti delle partizioni in questo stato vengono considerati aggiornati e vengono usati per la pianificazione e l'esecuzione delle query. |
| INATTIVO | 3 | I posizionamenti delle partizioni in questo stato sono considerati inattivi a causa della mancata sincronizzazione con altre repliche della stessa partizione. Lo stato può verificarsi quando un'operazione di accodamento, modifica (IN edizione Standard RT, UPDATE, DELETE) o DDL non riesce per questa posizione. Query Planner ignorerà i posizionamenti in questo stato durante la pianificazione e l'esecuzione. Gli utenti possono sincronizzare i dati in queste partizioni con una replica finalizzata come attività in background. |
| TO_DELETE | 4 | Se Azure Cosmos DB per PostgreSQL tenta di eliminare una posizione di partizione in risposta a una chiamata master_apply_delete_command e non riesce, il posizionamento viene spostato in questo stato. Gli utenti possono quindi eliminare queste partizioni come attività in background successiva. |
Tabella dei nodi del ruolo di lavoro
La tabella pg_dist_node contiene informazioni sui nodi di lavoro nel cluster.
| Nome | Digita | Descrizione |
|---|---|---|
| Nodeid | int | Identificatore generato automaticamente per un singolo nodo. |
| groupid | int | Identificatore usato per indicare un gruppo di un server primario e zero o più server secondari, quando viene usato il modello di replica di streaming. Per impostazione predefinita, è uguale a nodeid. |
| nodename | testo | Nome host o indirizzo IP del nodo del ruolo di lavoro PostgreSQL. |
| nodeport | int | Numero di porta in cui il nodo del ruolo di lavoro PostgreSQL è in ascolto. |
| noderack | testo | (Facoltativo) Informazioni sul posizionamento del rack per il nodo di lavoro. |
| hasmetadata | boolean | Riservato a un uso interno. |
| Isactive | boolean | Indica se il nodo è attivo accettando posizioni di partizione. |
| noderole | testo | Indica se il nodo è primario o secondario |
| nodecluster | testo | Nome del cluster contenente questo nodo |
| shouldhaveshards | boolean | Se false, le partizioni verranno spostate all'esterno del nodo (svuotato) durante il ribilanciamento, né le partizioni delle nuove tabelle distribuite verranno posizionate nel nodo, a meno che non si trovino in un percorso con partizioni già presenti |
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)
Tabella oggetti distribuita
La tabella citus.pg_dist_object contiene un elenco di oggetti quali tipi e funzioni creati nel nodo coordinatore e propagati ai nodi di lavoro. Quando un amministratore aggiunge nuovi nodi di lavoro al cluster, Azure Cosmos DB per PostgreSQL crea automaticamente copie degli oggetti distribuiti nei nuovi nodi (nell'ordine corretto per soddisfare le dipendenze degli oggetti).
| Nome | Digita | Descrizione |
|---|---|---|
| Classid | oid | Classe dell'oggetto distribuito |
| objid | oid | ID oggetto dell'oggetto distribuito |
| objsubid | integer | ID secondario dell'oggetto distribuito, ad esempio attnum |
| Tipo | testo | Parte dell'indirizzo stabile usato durante gli aggiornamenti pg |
| object_names | text[] | Parte dell'indirizzo stabile usato durante gli aggiornamenti pg |
| object_args | text[] | Parte dell'indirizzo stabile usato durante gli aggiornamenti pg |
| distribution_argument_index | integer | Valido solo per funzioni/routine distribuite |
| colocationid | integer | Valido solo per funzioni/routine distribuite |
Gli "indirizzi stabili" identificano in modo univoco gli oggetti indipendentemente da un server specifico. Azure Cosmos DB per PostgreSQL tiene traccia degli oggetti durante un aggiornamento di PostgreSQL usando indirizzi stabili creati con la funzione pg_identify_object_as_address().
Ecco un esempio di come create_distributed_function() aggiunge voci alla citus.pg_dist_object tabella:
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 |
Visualizzazione schemi distribuiti
Citus 12.0 ha introdotto il concetto di partizionamento orizzontale basato su schema e con esso la vista "citus_schemas", che mostra quali schemi sono stati distribuiti nel sistema. La visualizzazione elenca solo gli schemi distribuiti, gli schemi locali non vengono visualizzati.
| Nome | Digita | Descrizione |
|---|---|---|
| schema_name | regnamespace | Nome dello schema distribuito |
| colocation_id | integer | ID di condivisione dello schema distribuito |
| schema_size | testo | Riepilogo delle dimensioni leggibili di tutti gli oggetti all'interno dello schema |
| schema_owner | name | Ruolo proprietario dello schema |
Ecco un esempio:
schema_name | colocation_id | schema_size | schema_owner
-------------+---------------+-------------+--------------
userservice | 1 | 0 bytes | userservice
timeservice | 2 | 0 bytes | timeservice
pingservice | 3 | 632 kB | pingservice
Visualizzazione tabelle distribuite
La citus_tables vista mostra un riepilogo di tutte le tabelle gestite da Azure Cosmos DB per PostgreSQL (tabelle distribuite e di riferimento). La vista combina le informazioni delle tabelle di metadati di Azure Cosmos DB per PostgreSQL per una panoramica semplice e leggibile di queste proprietà della tabella:
- Tipo di tabella
- Colonna di distribuzione
- ID gruppo di condivisione
- Dimensioni leggibili
- Numero di partizioni
- Proprietario (utente del database)
- Metodo di accesso (heap o columnar)
Ecco un esempio:
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 │
└────────────┴──────────────────┴─────────────────────┴───────────────┴────────────┴─────────────┴─────────────┴───────────────┘
Visualizzazione delle partizioni temporali
Azure Cosmos DB per PostgreSQL fornisce funzioni definite dall'utente per gestire le partizioni per il caso d'uso Timeseries Data. Gestisce anche una time_partitions visualizzazione per controllare le partizioni gestite.
Colonne:
- parent_table tabella partizionata
- partition_column la colonna in cui è partizionata la tabella padre
- partizionare il nome di una tabella di partizione
- from_value limite inferiore nel tempo per le righe in questa partizione
- to_value limite superiore nel tempo per le righe in questa partizione
- access_method heap per l'archiviazione basata su righe e columnar per l'archiviazione a colonne
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 │
└────────────────────────┴──────────────────┴─────────────────────────────────────────┴─────────────────────┴─────────────────────┴───────────────┘
Tabella del gruppo di condivisione
La tabella pg_dist_colocation contiene informazioni sulle partizioni delle tabelle da posizionare o raggruppare. Quando due tabelle si trovano nello stesso gruppo di condivisione, Azure Cosmos DB per PostgreSQL garantisce che le partizioni con gli stessi valori di colonna di distribuzione vengano posizionate negli stessi nodi di lavoro. La condivisione consente l'ottimizzazione dei join, alcuni rollup distribuiti e il supporto di chiavi esterne. La corilevazione delle partizioni viene dedotta quando i conteggi delle partizioni, i fattori di replica e i tipi di colonna di partizione corrispondono tutti tra due tabelle; Tuttavia, è possibile specificare un gruppo di condivisione personalizzato quando si crea una tabella distribuita, se necessario.
| Nome | Digita | Descrizione |
|---|---|---|
| colocationid | int | Identificatore univoco per il gruppo di condivisione a cui corrisponde questa riga. |
| shardcount | int | Numero di partizioni per tutte le tabelle di questo gruppo di condivisione |
| replicationfactor | int | Fattore di replica per tutte le tabelle di questo gruppo di condivisione. |
| distributioncolumntype | oid | Tipo della colonna di distribuzione per tutte le tabelle di questo gruppo di condivisione. |
SELECT * from pg_dist_colocation;
colocationid | shardcount | replicationfactor | distributioncolumntype
--------------+------------+-------------------+------------------------
2 | 32 | 2 | 20
(1 row)
Tabella della strategia di ribilanciamento
Questa tabella definisce le strategie che rebalance_table_shards possono usare per determinare dove spostare le partizioni.
| Nome | Digita | Descrizione |
|---|---|---|
| default_strategy | boolean | Indica se rebalance_table_shards deve scegliere questa strategia per impostazione predefinita. Usare citus_set_default_rebalance_strategy per aggiornare questa colonna |
| shard_cost_function | regproc | Identificatore per una funzione di costo, che deve accettare un valore shardid come bigint e restituire il concetto di costo, come tipo reale |
| node_capacity_function | regproc | Identificatore per una funzione di capacità, che deve accettare un nodeid come int e restituire il concetto di capacità del nodo come tipo reale |
| shard_allowed_on_node_function | regproc | L'identificatore per una funzione che specifica bigint shardid e nodeidarg int restituisce un valore booleano per verificare se Azure Cosmos DB per PostgreSQL può archiviare la partizione nel nodo |
| default_threshold | float4 | Soglia per la valutazione di un nodo troppo pieno o troppo vuoto, che determina quando il rebalance_table_shards deve provare a spostare le partizioni |
| minimum_threshold | float4 | Una protezione per impedire che l'argomento soglia di rebalance_table_shards() sia impostato su un valore troppo basso |
Per impostazione predefinita, Cosmos DB per PostgreSQL viene fornito con queste strategie nella tabella:
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
La strategia by_disk_size assegna a ogni partizione lo stesso costo. L'effetto è di equalizzare il numero di partizioni tra i nodi. La strategia predefinita, by_disk_size, assegna un costo a ogni partizione corrispondente alle dimensioni del disco in byte e a quella delle partizioni con cui si trovano le partizioni. Le dimensioni del disco vengono calcolate usando pg_total_relation_size, quindi includono indici. Questa strategia tenta di ottenere lo stesso spazio su disco in ogni nodo. Si noti la soglia di 0.1, impedisce lo spostamento di partizioni non necessario causato da differenze insignificanti nello spazio su disco.
Creazione di strategie di ribilanciamento personalizzate
Ecco alcuni esempi di funzioni che possono essere usate all'interno di nuove strategie di ribilanciamento delle partizioni e registrate nella pg_dist_rebalance_strategy con la funzione citus_add_rebalance_strategy.
Impostazione di un'eccezione di capacità del nodo in base al modello hostname:
CREATE FUNCTION v2_node_double_capacity(nodeidarg int) RETURNS boolean AS $$ SELECT (CASE WHEN nodename LIKE '%.v2.worker.citusdata.com' THEN 2 ELSE 1 END) FROM pg_dist_node where nodeid = nodeidarg $$ LANGUAGE sql;Ribilanciamento in base al numero di query che passano a una partizione, come misurato dal 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;Isolamento di una partizione specifica (10000) in un nodo (indirizzo '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;
Tabella delle statistiche delle query
Azure Cosmos DB per PostgreSQL fornisce citus_stat_statements statistiche su come vengono eseguite le query e per chi. È analogo a (e può essere unito a) la vista pg_stat_statements in PostgreSQL, che tiene traccia delle statistiche sulla velocità delle query.
Questa vista può tracciare le query ai tenant di origine in un'applicazione multi-tenant, che consente di decidere quando eseguire l'isolamento del tenant.
| Nome | Digita | Descrizione |
|---|---|---|
| queryid | bigint | identificatore (valido per i join pg_stat_statements) |
| userid | oid | utente che ha eseguito la query |
| dbid | oid | Istanza di database del coordinatore |
| query | testo | stringa di query anonimizzata |
| Esecutore | testo | Citus executor usato: adaptive, real-time, task-tracker, router o insert-select |
| partition_key | testo | valore della colonna di distribuzione nelle query eseguite dal router, altrimenti NULL |
| calls | bigint | numero di esecuzioni della query |
-- 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;
Risultati:
-[ 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
Avvertenze:
- I dati delle statistiche non vengono replicati e non sopravvivono a arresti anomali o failover del database
- Tiene traccia di un numero limitato di query, impostate dal
pg_stat_statements.maxGUC (impostazione predefinita 5000) - Per troncare la tabella, usare la
citus_stat_statements_reset()funzione
Attività di query distribuite
Azure Cosmos DB per PostgreSQL offre visualizzazioni speciali per controllare query e blocchi in tutto il cluster, incluse le query specifiche delle partizioni usate internamente per compilare i risultati per le query distribuite.
- citus_dist_stat_activity: mostra le query distribuite in esecuzione in tutti i nodi. Superset di
pg_stat_activity, utilizzabile ovunque quest'ultimo sia. - citus_worker_stat_activity: mostra le query sui ruoli di lavoro, incluse le query di frammento sulle singole partizioni.
- citus_lock_waits: query bloccate in tutto il cluster.
Le prime due viste includono tutte le colonne di pg_stat_activity più l'host host/porta del ruolo di lavoro che ha avviato la query e l'host/porta del nodo coordinatore del cluster.
Si consideri ad esempio il conteggio delle righe in una tabella distribuita:
-- run from worker on localhost:9701
SELECT count(*) FROM users_table;
È possibile notare che la query viene visualizzata 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
Questa query richiede informazioni da tutte le partizioni. Alcune informazioni si trovano nella partizione users_table_102038, che viene archiviata in localhost:9700. È possibile visualizzare una query che accede alla partizione esaminando la citus_worker_stat_activity vista:
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
Il query campo mostra i dati copiati dalla partizione da contare.
Nota
Se una query router (ad esempio, un tenant singolo in un'applicazione multi-tenant, "edizione Standard LECT)
- FROM table WHERE tenant_id = X') viene eseguito senza un blocco di transazioni, quindi master_query_host_name e master_query_host_port colonne saranno NULL in citus_worker_stat_activity.
Di seguito sono riportati esempi di query utili che è possibile compilare usando 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;
La visualizzazione successiva è citus_lock_waits. Per vedere come funziona, è possibile generare manualmente una situazione di blocco. Prima di tutto verrà configurata una tabella di test dal coordinatore:
CREATE TABLE numbers AS
SELECT i, 0 AS j FROM generate_series(1,10) AS i;
SELECT create_distributed_table('numbers', 'i');
Usando quindi due sessioni sul coordinatore, è possibile eseguire questa sequenza di istruzioni:
-- session 1 -- session 2
------------------------------------- -------------------------------------
BEGIN;
UPDATE numbers SET j = 2 WHERE i = 1;
BEGIN;
UPDATE numbers SET j = 3 WHERE i = 1;
-- (this blocks)
La citus_lock_waits visualizzazione mostra la situazione.
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 questo esempio le query originate dal coordinatore, ma la vista può anche elencare i blocchi tra le query provenienti dai ruoli di lavoro (eseguite con Azure Cosmos DB per PostgreSQL MX, ad esempio).
Passaggi successivi
- Informazioni su come alcune funzioni di Azure Cosmos DB per PostgreSQL modificano le tabelle di sistema
- Esaminare i concetti relativi a nodi e tabelle