Ottimizzare le query con colonne virtuali per le espressioni

Questa pagina descrive come utilizzare le colonne virtuali per le espressioni nel motore colonnare per accelerare le query.

Il motore colonnare può materializzare e memorizzare nella cache i risultati delle espressioni utilizzate di frequente. Precalcolando e memorizzando questi risultati, AlloyDB evita l'analisi e la valutazione ripetute delle stesse espressioni in più query. Questo processo migliora le prestazioni delle query e riduce il consumo di CPU, soprattutto per i carichi di lavoro analitici su set di dati di grandi dimensioni.

Di seguito sono riportati alcuni casi d'uso delle colonne virtuali per le espressioni:

Filtro in base agli attributi JSON:quando filtri spesso le query in base a coppie chiave-valore specifiche all'interno di una colonna JSON.
Valutazione di espressioni complesse:per query che coinvolgono espressioni complesse o che richiedono un elevato numero di calcoli.

Quando abiliti le colonne virtuali per la scansione delle espressioni, le query che utilizzano il motore colonnare e contengono espressioni utilizzate di frequente vengono ottimizzate automaticamente. Il motore colonnare aggiorna automaticamente queste colonne virtuali quando aggiorna le colonne di base.

Espressioni supportate nelle colonne virtuali

AlloyDB supporta gli operatori -> e ->> nelle colonne JSON e JSONB nella release (anteprima).

Prima di iniziare

Abilita il motore colonnare per il cluster AlloyDB. Per saperne di più, consulta Configurare il motore colonnare.
Identifica le espressioni utilizzate di frequente nelle query AlloyDB utilizzando Query Insights.
Aggiungi le colonne di base delle espressioni al motore colonnare. Per saperne di più, consulta Gestire manualmente i contenuti dello store delle colonne.

Attiva le colonne virtuali per le espressioni

Puoi attivare il supporto delle colonne virtuali per le espressioni per un'istanza utilizzando il comando gcloud beta alloydb instances update.

Per utilizzare gcloud CLI, puoi installare e inizializzare Google Cloud CLI oppure puoi utilizzare Cloud Shell.

    gcloud beta alloydb instances update INSTANCE_ID \
        --region=REGION_ID \
        --cluster=CLUSTER_ID \
        --project=PROJECT_ID \
        --update-mode=INPLACE \
        --add-database-flags="google_columnar_engine.enable_virtual_columns_scan=on"

Sostituisci quanto segue:

INSTANCE_ID: l'ID istanza AlloyDB.
REGION_ID: la regione dell'istanza AlloyDB.
CLUSTER_ID: l'ID cluster della tua istanza AlloyDB.
PROJECT_ID: il tuo ID progetto Google Cloud .

Per impostare questo flag a livello di sessione, esegui questo comando:

SET google_columnar_engine.enable_virtual_columns_scan=on;

Aggiungere colonne virtuali per le espressioni

Per aggiungere espressioni di uso comune al motore colonnare, utilizza il client psql per chiamare la funzione google_columnar_engine_add. Queste espressioni vengono inserite nel motore colonnare come colonne, oltre a quelle già esistenti nel database.

Puoi specificare più espressioni come valori separati da virgole.

    SELECT google_columnar_engine_add(
    relation => 'DB.SCHEMA.TABLE_NAME',
    columns => 'COLUMN_NAME, COLUMN_NAME',
    expressions => 'EXP1, EXP2, EXP3'
    );

Sostituisci quanto segue:

DB.SCHEMA: lo schema del database in cui è archiviata la tabella.
TABLE_NAME: il nome della tabella in cui è archiviata la colonna.
COLUMN_NAME: il nome delle colonne che includono le espressioni.
EXP1, EXP2, EXP3 con un elenco di espressioni separate da virgole. Le espressioni JSON Extract supportate sono -> e ->>.

Ad esempio, per aggiungere le espressioni user ->> 'email' e user ->> 'name' per la tabella employee nello schema public, utilizza la seguente query:
```
    SELECT google_columnar_engine_add(
    relation => 'postgres.public.employee',
    expressions => '"user ->> ''email''", "user ->> ''name''"'
    );
```
Sintassi dell'espressione:
- Racchiudi l'intero valore dell'espressione tra virgolette singole, ad esempio expressions => 'EXP1,EXP2,EXP3'.
- Separa più espressioni con virgole.
- Racchiudi ogni singola espressione tra virgolette doppie.
- Esegui l'escape di qualsiasi virgoletta singola in un'espressione utilizzando un'altra virgoletta singola.
Ad esempio, per aggiungere l'espressione col -> 'level1' e col -> 'level1' ->> 'level2', utilizza il seguente formato:
```
    expressions => '"col -> ''level1''", "col -> ''level1'' ->> ''level2''"'
```

Esempio di colonne virtuali per le espressioni

Questo esempio mostra come utilizzare le colonne virtuali per le espressioni. Crea una tabella users con una colonna JSONB profile e compilala con dati di esempio. Quindi, in base all'analisi delle query, aggiungi l'espressione profile ->> 'email' utilizzata di frequente al motore colonnare con la funzione google_columnar_engine_add. Il motore colonnare utilizza quindi questa espressione frequente per ottimizzare le query successive.

Per aggiungere questa espressione frequente di esempio al motore colonnare:

Nella console Google Cloud , vai alla pagina Cluster.

Vai a Cluster
Fai clic sul nome del cluster nella colonna Nome risorsa.
Nel riquadro di navigazione, fai clic su AlloyDB Studio.
Per creare la tabella users con una colonna JSONB profile, esegui questo comando:
```
CREATE TABLE users (
id int,
username TEXT,
profile JSONB
);
```

Per compilare la tabella users con dati di esempio, esegui il comando seguente:

INSERT INTO users (id, username, profile)
SELECT
    i,
    'user' || i,
    jsonb_build_object(
        'name', 'User ' || i,
        'email', 'user' || i || '@example.com',
        'active', (i % 2 = 0)
    )
FROM generate_series(1, 100000) AS i;

Per migliorare il rendimento della query che include l'espressione utilizzata di frequente, aggiungi l'espressione profile ->> 'email' al motore colonnare:

SELECT google_columnar_engine_add(
    relation => 'users',
    columns => 'username, profile',
    expressions => '"profile ->> ''email''"'
);

Esegui una query che utilizza l'espressione frequente e osserva il tempo necessario per completarla.
```
SELECT username
FROM users
WHERE profile->>'email' = 'user50000@example.com';
```
Attiva la funzionalità delle colonne virtuali per le espressioni.
```
SET google_columnar_engine.enable_virtual_columns_scan=on;
```
Esegui di nuovo la query che utilizza l'espressione frequente e osserva il tempo necessario per completarla.
```
SELECT username
FROM users
WHERE profile->>'email' = 'user50000@example.com';
```

Il runtime della query è più veloce dopo aver abilitato le colonne virtuali per le espressioni.

Visualizzare le colonne virtuali per le espressioni

Per trovare tutte le espressioni aggiunte per una tabella specifica, esegui una query sulla visualizzazione g_columnar_virtual_columns:

    SELECT * FROM g_columnar_virtual_columns;

L'output è simile al seguente, in cui il campo description mostra tutte le espressioni aggiunte per una tabella (relazione).

SELECT * FROM g_columnar_virtual_columns;
category           | expression
database_name      | testdb
schemas            | {public}
relations          | {users}
description        | profile->>'email'
column_data_type   | text
status             | Usable
last_accessed_time | 2026-02-04 06:25:32.499601+00
num_times_accessed | 1

Rimuovere le colonne virtuali per le espressioni

Per rimuovere un'espressione, chiama la funzione google_columnar_engine_drop():

    SELECT google_columnar_engine_drop(
      relation => 'DB.SCHEMA.TABLE_NAME',
      expressions => 'EXP1, EXP2, EXP3'
    );

Sostituisci EXP1, EXP2, EXP3 con un elenco separato da virgole di espressioni nella tabella nello stesso formato utilizzato per l'aggiunta di espressioni.