Auf dieser Seite wird die AlloyDB Omni-Version 18.4.0 mit der Bereitstellungsoption Container-Orchestrator dokumentiert. Wählen Sie eine andere Bereitstellungsoption aus.

Google verwendet KI-Technologie, um Inhalte in Ihre bevorzugte Sprache zu übersetzen. KI-Übersetzungen können Fehler enthalten.

Spaltenbasierte Engine überwachen

Wählen Sie eine Dokumentationsversion aus:

Auf dieser Seite wird beschrieben, wie Sie die Auslastung der spaltenbasierten Engine überwachen.

Verwendung der spaltenbasierten Engine mit `EXPLAIN` überprüfen

Wenn Sie die neuen spaltenbasierten Operatoren sehen möchten, die im generierten Abfrageplan einer Abfrage angezeigt werden, können Sie die Verwendung der spaltenbasierten Engine mit der Anweisung EXPLAIN prüfen.

EXPLAIN (ANALYZE,COSTS OFF,BUFFERS,TIMING OFF,SUMMARY OFF)
  SELECT l_returnflag, l_linestatus, l_quantity, l_extendedprice,
         l_discount, l_tax
    FROM lineitem
   WHERE l_shipdate <= date '1992-08-06'
;
                                 QUERY PLAN
-----------------------------------------------------------------------------
 Append (actual rows=3941797 loops=1)
   Buffers: shared hit=9
   ->  Custom Scan (columnar scan) on lineitem (actual rows=3941797 loops=1)
         Filter: (l_shipdate <= '1992-08-06'::date)
         Rows Removed by Columnar Filter: 56054083
         Columnar cache search mode: columnar filter only
         Buffers: shared hit=9
   ->  Seq Scan on lineitem (never executed)
  Filter: (l_shipdate <= '1992-08-06'::date)

Custom Scan (columnar scan) gibt an, dass das Scannen mit der spaltenbasierten Engine im Abfrageplan enthalten ist.
Rows Removed by Columnar Filter gibt die Anzahl der Zeilen an, die durch die spaltenbasierte vektorisierte Ausführung herausgefiltert wurden.
Columnar cache search mode kann columnar filter only, native oder row store scan sein. Der Planer wählt den Suchmodus automatisch basierend auf den Kosten und der Pushdown-Bewertungsfunktion aus.

Wenn der Planer den Modus native auswählt, werden einige der spaltenbasierten Operatoren in den Scan verschoben:

Rows Aggregated by Columnar Scan gibt die Anzahl der aggregierten Zeilen an.
Rows Sorted by Columnar Scan listet die Anzahl der sortierten Zeilen auf.
Rows Limited by Columnar Scan listet die begrenzte Anzahl der gescannten Zeilen auf.

Bei Joins können spaltenbasierte Scanoperatoren auch den Modus Late Materialization verwenden.

EXPLAIN (ANALYZE,COSTS OFF,BUFFERS,TIMING OFF,SUMMARY OFF)
  SELECT l_shipmode, o_orderpriority
    FROM orders, lineitem
   WHERE o_orderkey = l_orderkey
         AND l_shipmode in ('AIR', 'FOB')
         AND l_receiptdate >= date '1995-01-01'
;
                                 QUERY PLAN
-----------------------------------------------------------------------------
 Hash Join (actual rows=9865288 loops=1)
   Hash Cond: (lineitem.l_orderkey = orders.o_orderkey)
   Buffers: temp read=127738 written=127738
   ->  Append (actual rows=9865288 loops=1)
         ->  Custom Scan (columnar scan) on lineitem (actual rows=9865288 loops=1)
               Filter: ((l_shipmode = ANY ('{AIR,FOB}'::bpchar[])) AND
               (l_receiptdate >= '1995-01-01'::date))
               Rows Removed by Columnar Filter: 50130592
               Columnar cache search mode: native
         ->  Index Scan using idx_lineitem_orderkey_fkidx on lineitem
             (never executed)
               Filter: ((l_shipmode = ANY ('{AIR,FOB}'::bpchar[])) AND
               (l_receiptdate >= '1995-01-01'::date))
   ->  Hash (actual rows=15000000 loops=1)
         Buckets: 1048576  Batches: 32  Memory Usage: 37006kB
         Buffers: temp written=83357
         ->  Append (actual rows=15000000 loops=1)
               ->  Custom Scan (columnar scan) on orders (actual rows=15000000
                   loops=1)
                     Rows Removed by Columnar Filter: 0
                     Columnar projection mode: late materialization
                     Columnar cache search mode: native
               ->  Seq Scan on orders (never executed)

Columnar projection mode kann late materialization sein. Spaltenbasierte Operatoren wählen diesen Modus automatisch aus, wenn der Planer die Projektion optimiert, indem er die Materialisierung einiger Spaltenwerte verzögert.

Nutzung des vektorisierten Joins der spaltenbasierten Engine ansehen

Sie können den neuen vektorisierten Join-Operator mit der Anweisung EXPLAIN prüfen, um den neuen Operator Vectorized Hash Join zu beobachten, der im generierten Abfrageplan einer Abfrage angezeigt wird.

EXPLAIN (ANALYZE,COSTS OFF,BUFFERS,TIMING OFF,SUMMARY OFF)
  SELECT l_quantity, l_extendedprice, l_discount, l_tax
    FROM lineitem, orders
    WHERE l_shipdate <= date '2022-08-06'
    AND  l_orderkey = o_orderkey
    AND  o_orderdate <= date '2025-03-07';
                                      QUERY PLAN
---------------------------------------------------------------------------------------
 Vectorized Hash Join (actual rows=3934686 loops=1)
   Vectorized partitioning, Partitions: 16 (Disk usage: 208MB)
   (Peak Memory Usage: 27MB, Threads: 1)
   Hash Cond: (lineitem.l_orderkey = orders.o_orderkey)
   Rows Removed by Bloom Filter: 0
   Buffers: temp read=26728 written=26728
   ->  Append (actual rows=3934686 loops=1)
         ->  Custom Scan (columnar scan) on lineitem (actual rows=3934686 loops=1)
               Filter: (l_shipdate <= '2022-08-06'::date)
               Rows Removed by Columnar Filter: 56051366
               Columnar cache search mode: native
         ->  Seq Scan on lineitem (never executed)
               Filter: (l_shipdate <= '2022-08-06'::date)
   ->  Vectorized Hash (actual rows=7245824 loops=1)
         Build bloom filter, Memory Usage: 1024kB
         ->  Append (actual rows=7245824 loops=1)
               ->  Custom Scan (columnar scan) on orders (actual rows=7245824 loops=1)
                     Filter: (o_orderdate <= '2025-03-07'::date)
                     Rows Removed by Columnar Filter: 7754176
                     Columnar cache search mode: native
               ->  Seq Scan on orders (never executed)
                     Filter: (o_orderdate <= '2025-03-07'::date)

Vectorized Hash Join gibt an, dass für den Join zwischen den beiden Beziehungen der vektorisierte Hash-Join verwendet wurde.
Vectorized partitioning, Partitions: gibt die Anzahl der Partitionen an, in die die Daten aufgeteilt wurden.

Informationen zu Tabellen mit Spalten im Spaltenspeicher ansehen

Sie können Informationen zu den Tabellen oder materialisierten Ansichten mit Spalten im Spaltenspeicher abrufen, indem Sie die Ansicht g_columnar_relations abfragen.

SELECT * FROM g_columnar_relations;

┌─[ RECORD 1 ]────────┬───────────────────┐
│ relation_name       │ tbl_parallel_test │
│ schema_name         │ public            │
│ database_name       │ advisor           │
│ status              │ Usable            │
│ size                │ 581431259         │
│ columnar_unit_count │ 3                 │
│ invalid_block_count │ 0                 │
│ total_block_count   │ 8337              │
├─[ RECORD 2 ]────────┼───────────────────┤
│ relation_name       │ lineitem          │
│ schema_name         │ public            │
│ database_name       │ advisor           │
│ status              │ Usable            │
│ size                │ 423224944         │
│ columnar_unit_count │ 29                │
│ invalid_block_count │ 0                 │
│ total_block_count   │ 115662            │
├─[ RECORD 3 ]────────┼───────────────────┤

Informationen zu den Spalten im Spaltenspeicher ansehen

Sie können Informationen zu den Spalten im Spaltenspeicher abrufen, indem Sie die Ansicht g_columnar_columns abfragen, einschließlich der Größe dieser Spalten und der letzten Zugriffszeit.

SELECT database_name, schema_name, relation_name, column_name, size_in_bytes, last_accessed_time FROM g_columnar_columns;

Spaltenspeicher in der Web-UI ansehen

Sie können das Spaltenspeicherinventar auch in der AlloyDB Omni-Web-Benutzeroberfläche aufrufen:

Stellen Sie eine Verbindung zur Web-UI her und wählen Sie Ihren Cluster aus.
Klicken Sie im Navigationsmenü auf Spaltenbasierte Engine.
Sehen Sie sich in der Tabelle Spaltenspeicherdaten die Spalten an, die im Spaltenspeicher ausgefüllt sind:
- Datenbankname: Die Datenbank, die die Beziehung enthält.
- Schemaname: Das Schema der Beziehung.
- Beziehungsname: Der Name der Tabelle oder materialisierten Ansicht.
- Spaltenname: Der Name der Spalte, die in Spalten aufgeteilt wurde.
- Spaltentyp: Der SQL-Datentyp der Spalte.
- Status: Der Bereitschaftsstatus der Spalte im Spaltenspeicher (z. B. Usable).
- Größe: Der Speicherbedarf der Spalte im Spaltenspeicher.
- Zugriffe: Gibt an, wie oft über spaltenbasierte Scans auf die Spalte zugegriffen wurde.
- Letzter Zugriff: Der Zeitstempel des letzten Zugriffs auf den Spaltenscan.

Ausführungsstatistiken der spaltenbasierten Engine für aktuelle Abfragen ansehen

In der Ansicht g_columnar_stat_statements können Sie die Ausführungsstatistiken der spaltenbasierten Engine für aktuelle Abfragen aufrufen. In dieser Ansicht werden der Ansicht pg_stat_statements, die von der Erweiterung pg_stat_statements bereitgestellt wird, Statistiken zur spaltenbasierten Engine hinzugefügt. Wenn Sie diese Ansicht verwenden möchten, müssen Sie zuerst die Erweiterung pg_stat_statements aktivieren.

Aktivieren Sie die Erweiterung pg_stat_statements:
```
CREATE EXTENSION pg_stat_statements;
```
Führen Sie die Abfragen aus, deren Statistiken Sie aufrufen möchten. Sie können dies manuell tun oder warten, bis Ihre Anwendungen diese Abfragen mit aktiviertem pg_stat_statements ausgeführt haben.

Fragen Sie die Ansichten g_columnar_stat_statements und pg_stat_statements ab. Beachten Sie, dass die folgende Abfrage alle spaltenbasierten Ausführungsstatistiken abruft, einschließlich derer, die vor dem Erstellen der Erweiterung pg_stat_statements erfasst wurden. Der 10-Wert von userid gibt an, dass die Statistiken vor dem Erstellen der Erweiterung pg_stat_statements erfasst wurden.

SELECT *
FROM pg_stat_statements(TRUE) AS pg_stats
     FULL JOIN g_columnar_stat_statements AS g_stats
     ON pg_stats.userid = g_stats.user_id AND
        pg_stats.dbid = g_stats.db_id AND
        pg_stats.queryid = g_stats.query_id
WHERE columnar_unit_read > 0;

┌─[ RECORD 1 ]────────┬───────────────────────────────
│ userid              │ 10                            │
│ dbid                │ 33004                         │
│ queryid             │ 6779068104316758833           │
│ query               │ SELECT  l_returnflag,        ↵│
│                     │         l_linestatus,        ↵│
│                     │         l_quantity,          ↵│
│                     │         l_extendedprice,     ↵│
│                     │         l_discount,          ↵│
│                     │         l_tax                ↵│
│                     │FROM  lineitem                ↵│
│                     │WHERE  l_shipdate <= date $1│
│ calls               │ 1                             │
│ total_time          │ 299.969983                    │
│ min_time            │ 299.969983                    │
│ max_time            │ 299.969983                    │
│ mean_time           │ 299.969983                    │
│ stddev_time         │ 0                             │
│ rows                │ 392164                        │
│ shared_blks_hit     │ 0                             │
│ shared_blks_read    │ 0                             │
│ shared_blks_dirtied │ 0                             │
│ shared_blks_written │ 0                             │
│ local_blks_hit      │ 0                             │
│ local_blks_read     │ 0                             │
│ local_blks_dirtied  │ 0                             │
│ local_blks_written  │ 0                             │
│ temp_blks_read      │ 0                             │
│ temp_blks_written   │ 0                             │
│ blk_read_time       │ 0                             │
│ blk_write_time      │ 0                             │
│ user_id             │ 10                            │
│ db_id               │ 33004                         │
│ query_id            │ 6779068104316758833           │
│ columnar_unit_read  │ 29                            │
│ page_read           │ 115662                        │
│ rows_filtered       │ 0                             │
│ columnar_scan_time  │ 0                             │
└─────────────────────┴───────────────────────────────┘

Spaltenbasierte Abfragestatistiken in der Web-UI ansehen

Nachdem Sie die Erweiterung pg_stat_statements aktiviert haben, können Sie sich auch die Statistiken zur Ausführung von spaltenbasierten Abfragen in der AlloyDB Omni-Web-Benutzeroberfläche ansehen:

Stellen Sie eine Verbindung zur Web-UI her und wählen Sie Ihren Cluster aus.
Klicken Sie im Navigationsmenü auf Spaltenbasierte Engine.
Sehen Sie sich in der Tabelle Spaltenbasierte Abfragen die Ausführungsstatistiken für analytische Abfragen an, die den Spaltenspeicher verwendet haben:
- Abfrage-ID: Die Kennung der bereinigten Abfrage.
- Abfrage: Der bereinigte SQL-Anweisungstext, wobei konstante Werte durch Platzhalter ersetzt werden.
- Aufrufe: Gibt an, wie oft die Abfrage ausgeführt wurde.
- Durchschnittlich abgerufene Zeilen: Die durchschnittliche Anzahl der pro Ausführung zurückgegebenen Zeilen.
- Durchschnittliche Latenz: Die durchschnittliche Ausführungslatenz der Abfrage.
- Maximale Latenz: Die maximale Ausführungslatenz, die für die Abfrage aufgezeichnet wurde.
- Gelesene spaltenbasierte Einheiten: Die Anzahl der spaltenbasierten Einheiten, die aus dem Columnstore gelesen wurden.
- Gelesene Seiten: Die Anzahl der während der Ausführung gelesenen Seiten.

Arbeitsspeichernutzung des Spaltenspeichers ansehen

Wenn Sie wissen möchten, wie viel ungenutzter RAM für die spaltenbasierte Engine verfügbar ist, können Sie die Funktion google_columnar_engine_memory_available abfragen. Die Ausgabe-Ganzzahl zeigt den verfügbaren Arbeitsspeicher in Megabyte (MB) an.

SELECT google_columnar_engine_memory_available();

Größe und Einstellungen des Spaltenspeichers in der Web-UI ansehen

Sie können den Arbeitsspeicherverbrauch und die Konfigurationseinstellungen des Spaltenspeichers auch in der AlloyDB Omni-Web-Benutzeroberfläche prüfen:

Stellen Sie eine Verbindung zur Web-UI her und wählen Sie Ihren Cluster aus.
Klicken Sie im Navigationsmenü auf Spaltenbasierte Engine.
Sehen Sie sich den Abschnitt Einstellungen für den spaltenbasierten Speicher an. Dort finden Sie die folgenden Status- und Arbeitsspeicheranzeigen:
- Spaltenbasierte Engine: Gibt an, ob die spaltenbasierte Engine aktiv ist (z. B. Enabled).
- Speichergröße: Zeigt die Menge des verwendeten Spaltenspeichers im Verhältnis zum gesamten zugewiesenen Spaltenspeicher an (z. B. 2.0 MB used of 1024.0 MB).
- Automatische Spaltenformatierung: Gibt an, ob die automatische Spaltenformatierung aktiviert ist (z. B. Enabled).
- Ausführungshäufigkeit: Zeigt das Zeitplanintervall für automatische Spaltenformatierungsläufe an (z. B. Every 5 minutes).
- Spaltenbasierter Scan: Gibt an, ob die Ausführung des spaltenbasierten Scans aktiviert ist (z. B. Enabled).

Speicher-Cache der spaltenbasierten Engine ansehen

Mit den folgenden Befehlen können Sie Daten zum Speichercache der spaltenbasierten Engine aufrufen und überwachen:

Befehl	Beschreibung
`SELECT google_columnar_engine_storage_cache_used();`	Gibt die Größe des verwendeten Speichercaches der spaltenbasierten Engine zurück.
`SELECT google_columnar_engine_storage_cache_available();`	Gibt die Größe des nicht verwendeten Speichercaches der spaltenbasierten Engine zurück.
`SHOW google_columnar_engine.storage_cache_size;`	Gibt die Gesamtgröße des konfigurierten Speichercaches für die spaltenbasierte Engine zurück.

Spaltenbasierte Engine überwachen Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

Verwendung der spaltenbasierten Engine mit EXPLAIN überprüfen