Acelerar a pesquisa de vetores com o mecanismo colunar

Selecione uma versão da documentação:

É possível usar o mecanismo colunar do AlloyDB Omni para acelerar as pesquisas vetoriais ao usar o índice Scalable Nearest Neighbors (ScaNN) ou Hierarchical Navigable Small World (HNSW). O mecanismo colunar atua como um cache na memória otimizado para leitura desses índices vetoriais.

O armazenamento em cache dos índices no mecanismo colunar atende às consultas diretamente de uma representação do índice na memória otimizada para leitura e aumenta o número de consultas por segundo (QPS) que o banco de dados pode processar para cargas de trabalho de pesquisa vetorial.

Só é possível usar o HNSW com o mecanismo colunar para clusters do AlloyDB Omni que executam o PostgreSQL 17 ou versões mais recentes. O ScaNN com o mecanismo colunar não tem essa limitação.

Antes de começar

  • Defina as flags de banco de dados google_columnar_engine.enabled e google_columnar_engine.enable_index_caching como on para ativar o mecanismo colunar e o recurso de armazenamento em cache de índice.

    Para definir as flags de banco de dados, execute o ALTER SYSTEM comando do PostgreSQL:

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

    Para que a mudança nos parâmetros de configuração entre em vigor, reinicie o contêiner em execução com o AlloyDB Omni:

    Docker 

      sudo docker restart CONTAINER_NAME
  ```
* { Podman }
```posix-terminal
  sudo podman restart CONTAINER_NAME
  ```



    


    For more information on setting flags, see Configure database flags.

  • Create a ScaNN index or Create an HNSW index in your database.

Add an index to the columnar engine

After enabling the columnar engine, you can add an existing index to the cache using the google_columnar_engine_add_index() SQL function.

To add an index to the columnar engine, run the following query:

SELECT google_columnar_engine_add_index('INDEX_NAME');

Substitua INDEX_NAME pelo nome do índice vetorial.

Depois de adicionar um índice ao mecanismo colunar, todas as consultas que usam esse índice são aceleradas automaticamente pelo mecanismo colunar. Para verificar se as consultas vetoriais estão sendo aceleradas pelo mecanismo colunar, use o plano EXPLAIN (ANALYZE, COLUMNAR_ENGINE) na consulta.

Verificar o uso do cache

Para verificar se as consultas vetoriais estão sendo aceleradas pelo mecanismo colunar, use o plano EXPLAIN (ANALYZE, COLUMNAR_ENGINE) na consulta.

Exemplo de plano de execução do ScaNN

Confira a seguir um exemplo de plano de execução para uma consulta que usa um índice ScaNN que foi adicionado ao mecanismo colunar:

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)

A presença de columnar engine nodes hit e Columnar Engine ScaNN Info: (index found=true) na saída confirma que o mecanismo colunar é usado para a consulta.

Exemplo de plano de execução do HNSW

O plano de execução mostra a seção Columnar Engine HNSW Info para o índice respectivo que mostra métricas como a proporção de elementos recuperados do mecanismo colunar (elements_from_ce) e do disco (elements_from_disk).

Confira a seguir um exemplo de plano de execução para uma consulta que usa um índice HNSW que foi adicionado ao mecanismo colunar:

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)

A resposta mostra que o índice está sendo acelerado pelo mecanismo colunar, já que todos os elementos foram recuperados do mecanismo colunar (elements_from_ce=385) e nenhum foi recuperado do disco (elements_from_disk=0).

Quando modificações de dados, como instruções INSERT, UPDATE ou DELETE, invalidam as entradas de cache, o mecanismo colunar usa uma abordagem híbrida para manter a precisão e o desempenho. Ele lê vetores válidos e armazenados em cache diretamente da memória e busca apenas os vetores modificados ou novos do disco.

Se você modificar uma grande quantidade de dados, poderá observar temporariamente um aumento em elements_from_disk e uma queda no desempenho até que o cache seja atualizado.

Gerenciar o índice armazenado em cache

Para gerenciar o ciclo de vida dos índices armazenados em cache, execute o comando SQL para a tarefa selecionada:

  • Para atualizar o cache manualmente, execute o seguinte comando:

    SELECT google_columnar_engine_refresh_index('INDEX_NAME');

  • Para verificar o status do índice, execute o seguinte comando:

    SELECT google_columnar_engine_verify('INDEX_NAME');

  • Para remover o índice do cache, execute o seguinte comando:

    SELECT google_columnar_engine_drop_index('INDEX_NAME');

  • Para visualizar os índices ativos, execute o seguinte comando:

    SELECT * FROM g_columnar_indexes;

  • Para visualizar índices particionados, execute o seguinte comando:

    SELECT * FROM g_columnar_index_partitions;

Substitua INDEX_NAME pelo nome do índice.

Limitações

A atualização de índices HNSW acelerados pelo mecanismo colunar pode consumir temporariamente a memória até duas vezes o tamanho do índice.

A seguir