Condividi tramite


Tabelle e viste di sistema di Azure Cosmos DB per PostgreSQL

SI APPLICA A: Azure Cosmos DB for PostgreSQL (con tecnologia basata su estensione di database Citus per 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 Tipo 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 SELECT.

Nome Tipo 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 partizioni

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 Tipo 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 (INSERT, UPDATE, DELETE) o DDL non riesce per questo posizionamento. 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 Tipo 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 Tipo Descrizione
classid oid Classe dell'oggetto distribuito
objid oid ID oggetto dell'oggetto distribuito
objsubid integer ID secondario dell'oggetto distribuito, ad esempio attnum
type 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 Tipo 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 Tipo 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 Tipo 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 Tipo 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.max GUC (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, "SELECT)

  • 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