Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

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 archiviando questi risultati, AlloyDB evita l'analisi e la valutazione ripetute delle stesse espressioni in più query. Questo processo migliora il rendimento delle query e riduce il consumo di CPU, in particolare 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 degli 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 le query che coinvolgono espressioni complesse o a elevato utilizzo di risorse di calcolo.

Quando abiliti la scansione delle colonne virtuali per le 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 ->> sulle 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 dell'archivio colonne.

Abilitare le colonne virtuali per le espressioni

Puoi abilitare il supporto per le 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 dell'istanza AlloyDB.
REGION_ID: la regione dell'istanza AlloyDB.
CLUSTER_ID: l'ID del cluster dell'istanza AlloyDB.
PROJECT_ID: il tuo Google Cloud ID progetto.

Per impostare questo flag a livello di sessione, esegui quanto segue:

SET google_columnar_engine.enable_virtual_columns_scan=on;

Aggiungere colonne virtuali per le espressioni

Per aggiungere le 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 alle colonne 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 di estrazione JSON supportate sono -> e ->>.

Ad esempio, per aggiungere le espressioni user ->> 'email' e user ->> 'name' per la employee tabella nello schema public, utilizza la seguente query:
```
    SELECT google_columnar_engine_add(
    relation => 'postgres.public.employee',
    expressions => '"user ->> ''email''", "user ->> ''name''"'
    );
```
Sintassi delle espressioni:
- Racchiudi l'intero valore dell'espressione tra virgolette singole, ad esempio expressions => 'EXP1,EXP2,EXP3'.
- Separa più espressioni con le 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 la funzionalità delle colonne virtuali per le espressioni. Crea una tabella users con una colonna JSONB profile e compilala con dati di esempio. Poi, in base all'analisi delle query, aggiungi l' espressione profile ->> 'email'utilizzata di frequente al motore colonnare con la google_columnar_engine_add funzione. Il motore colonnare utilizza quindi questa espressione frequente per ottimizzare le query successive.

Per aggiungere questa espressione frequente di esempio al motore colonnare:

Nella Google Cloud console, 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 quanto segue:
```
CREATE TABLE users (
id int,
username TEXT,
profile JSONB
);
```

Per compilare la tabella users con dati di esempio, esegui quanto segue:

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 impiegato per completare la query.
```
SELECT username
FROM users
WHERE profile->>'email' = 'user50000@example.com';
```
Abilita 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 impiegato per completare la query.
```
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, dove 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 di espressioni separate da virgole nella tabella nello stesso formato utilizzato quando aggiungi le espressioni.