Accelerare la ricerca vettoriale con il motore colonnare

Seleziona una versione della documentazione:

Puoi utilizzare il motore colonnare AlloyDB Omni per accelerare le ricerche vettoriali quando utilizzi l'indice Scalable Nearest Neighbors (ScaNN) o Hierarchical Navigable Small World (HNSW). Il motore colonnare funge da cache in memoria ottimizzata per la lettura per questi indici vettoriali.

La memorizzazione nella cache degli indici nel motore colonnare gestisce le query direttamente da una rappresentazione in memoria dell'indice ottimizzata per la lettura e aumenta il numero di query al secondo (QPS) che il database può gestire per i workload di ricerca di vettori.

Puoi utilizzare HNSW solo con il motore colonnare per i cluster AlloyDB Omni che eseguono PostgreSQL 17 o versioni successive. ScaNN con il motore colonnare non presenta questa limitazione.

Prima di iniziare

  • Imposta i flag di database google_columnar_engine.enabled e google_columnar_engine.enable_index_caching su on per abilitare il motore colonnare e la relativa funzionalità di memorizzazione nella cache degli indici.

    Per impostare i flag del database, esegui il comando PostgreSQL ALTER SYSTEM:

    ALTER SYSTEM SET google_columnar_engine.enabled = 'on';
ALTER SYSTEM SET google_columnar_engine.enable_index_caching = 'on';

    Ricarica la configurazione del gestore `systemd` e riavvia il servizio `alloydbomni` per applicare le modifiche: ```posix-terminal sudo systemctl restart alloydbomni18

    Per saperne di più sull'impostazione dei flag, consulta Configura i flag di database.

  • Crea un indice ScaNN o Crea un indice HNSW nel tuo database.

Aggiungi un indice al motore colonnare

Dopo aver attivato il motore colonnare, puoi aggiungere un indice esistente alla cache utilizzando la funzione SQL google_columnar_engine_add_index().

Per aggiungere un indice al motore colonnare, esegui questa query:

SELECT google_columnar_engine_add_index('INDEX_NAME');

Sostituisci INDEX_NAME con il nome dell'indice vettoriale.

Dopo aver aggiunto un indice al motore colonnare, tutte le query che utilizzano questo indice vengono accelerate automaticamente dal motore colonnare. Puoi verificare che le tue query vettoriali vengano accelerate dal motore colonnare utilizzando il piano EXPLAIN (ANALYZE, COLUMNAR_ENGINE) nella query.

Verifica l'utilizzo della cache

Per verificare che le query vettoriali vengano accelerate dal motore colonnare, puoi utilizzare il piano EXPLAIN (ANALYZE, COLUMNAR_ENGINE) nella query.

Esempio di piano di esecuzione ScaNN

Di seguito è riportato un esempio di piano di esecuzione per una query che utilizza un indice ScaNN aggiunto al motore colonnare:

EXPLAIN (ANALYZE TRUE, SCANN TRUE, COSTS FALSE, TIMING FALSE, SUMMARY FALSE, VERBOSE FALSE, COLUMNAR_ENGINE TRUE)
SELECT * FROM t ORDER BY val <=> '[0.5,0.5,0.5,0.5]' LIMIT 100;

--This contains details about ScaNN's usage from the columnar engine. Example:
------------------------------------------------------------------------------------------------------
 Index Scan using scann_idx on t t_1 (actual rows=100 loops=1)
      Order By: (val <=> '[0.5,0.5,0.5,0.5]'::vector)
      Limit: 100
      ScaNN Info: (... columnar engine nodes hit=6...)
      Columnar Engine ScaNN Info: (index found=true)
(5 rows)

La presenza di columnar engine nodes hit e Columnar Engine ScaNN Info: (index found=true) nell'output conferma che il motore colonnare viene utilizzato per la query.

Esempio di piano di esecuzione HNSW

Il piano di esecuzione mostra la sezione Informazioni su HNSW del motore colonnare per l'indice corrispondente, che mostra metriche come il rapporto tra gli elementi recuperati dal motore colonnare (elements_from_ce) e dal disco (elements_from_disk).

Di seguito è riportato un esempio di piano di esecuzione per una query che utilizza un indice HNSW aggiunto al motore colonnare:

EXPLAIN (ANALYZE, COLUMNAR_ENGINE) SELECT * FROM documents ORDER BY embedding <=> '[0.1, 0.2, 0.3, 0.4, 0.5]'::vector LIMIT 5;

--This contains details about HNSW's usage from the columnar engine. Example:
------------------------------------------------------------------------------------------------------
 Limit (actual rows=5 loops=1)
   ->  Index Scan using hnsw_idx on documents (actual rows=5 loops=1)
         Order By: (embedding '[0.1, 0.2, 0.3, 0.4, 0.5]'::vector)
         Columnar Engine HNSW Info: (index found=true elements_from_ce=385 elements_from_disk=0)
         Columnar Check: table is not in the columnar store
(5 rows)

La risposta mostra che l'indice viene accelerato dal motore colonnare, in quanto tutti gli elementi sono stati recuperati dal motore colonnare (elements_from_ce=385) e nessuno è stato recuperato dal disco (elements_from_disk=0).

Quando le modifiche ai dati, ad esempio le istruzioni INSERT, UPDATE o DELETE, invalidano le voci della cache, il motore colonnare utilizza un approccio ibrido per mantenere l'accuratezza e le prestazioni. Legge i vettori validi memorizzati nella cache direttamente dalla memoria e recupera dal disco solo i vettori modificati o nuovi.

Se modifichi una grande quantità di dati, potresti notare un aumento temporaneo di elements_from_disk e un calo delle prestazioni fino all'aggiornamento della cache.

Gestire l'indice memorizzato nella cache

Per gestire il ciclo di vita degli indici memorizzati nella cache, esegui il comando SQL per l'attività selezionata:

  • Per aggiornare manualmente la cache, esegui questo comando:

    SELECT google_columnar_engine_refresh_index('INDEX_NAME');

  • Per verificare lo stato dell'indice, esegui questo comando:

    SELECT google_columnar_engine_verify('INDEX_NAME');

  • Per eliminare l'indice dalla cache, esegui questo comando:

    SELECT google_columnar_engine_drop_index('INDEX_NAME');

  • Per visualizzare gli indici attivi, esegui questo comando:

    SELECT * FROM g_columnar_indexes;

  • Per visualizzare gli indici partizionati, esegui questo comando:

    SELECT * FROM g_columnar_index_partitions;

Sostituisci INDEX_NAME con il nome dell'indice.

Limitazioni

L'aggiornamento degli indici HNSW accelerati del motore colonnare può consumare temporaneamente memoria fino al doppio delle dimensioni dell'indice.

Passaggi successivi