Gestisci indici vettoriali

Anteprima

Questo prodotto o funzionalità è soggetto ai "Termini delle Offerte pre-GA" nella sezione Termini generali del servizio dei Termini specifici del servizio. I prodotti e le funzionalità pre-GA sono disponibili "così come sono" e potrebbero avere un supporto limitato. Per saperne di più, consulta le descrizioni della fase di lancio.

Per fornire feedback o richiedere assistenza per questa funzionalità, invia un'email all'indirizzo [e-mail].

Questo documento descrive come creare e gestire indici vettoriali.

Un indice vettoriale è una struttura di dati progettata per consentire alla funzione VECTOR_SEARCH di eseguire una ricerca vettoriale più efficiente degli incorporamenti. Quando VECTOR_SEARCH è in grado di utilizzare un indice vettoriale, la funzione utilizza la tecnica di ricerca Vicino approssimato più vicino per migliorare le prestazioni della ricerca, con il compromesso di ridurre il richiamo e restituire risultati più approssimativi.

Ruoli e autorizzazioni

Per creare un indice vettoriale, devi disporre dell'autorizzazione IAM bigquery.tables.createIndex nella tabella in cui stai creando l'indice. Per rilasciare un indice vettoriale, devi avere l'autorizzazione bigquery.tables.deleteIndex. Ciascuno dei seguenti ruoli IAM predefiniti include le autorizzazioni necessarie per lavorare con gli indici vettoriali:

• Proprietario dati BigQuery (roles/bigquery.dataOwner)
• Editor dati BigQuery (roles/bigquery.dataEditor)

Crea un indice vettoriale

Per creare un indice vettoriale, utilizza l'istruzione DDL (Data Definition Language) di CREATE VECTOR INDEX:

1. Vai alla pagina BigQuery.

   Vai a BigQuery

2. Nell'editor query, esegui la seguente istruzione SQL:

   CREATE [ OR REPLACE ] VECTOR INDEX [ IF NOT EXISTS ] INDEX_NAME
   ON DATASET_NAME.TABLE_NAME(COLUMN_NAME)
   STORING(STORED_COLUMN_NAME [, ...])
   OPTIONS(index_type = INDEX_TYPE,
     distance_type = DISTANCE_TYPE,
     ivf_options = '{"num_lists":NUM_LISTS}')
   

   Sostituisci quanto segue:

   • INDEX_NAME: il nome dell'indice vettoriale che stai creando. Poiché l'indice viene sempre creato nello stesso progetto e set di dati della tabella di base, non è necessario specificarli nel nome.
   • DATASET_NAME: il nome del set di dati che contiene la tabella.
   • TABLE_NAME: il nome della tabella che contiene la colonna con i dati degli incorporamenti.
   • COLUMN_NAME: il nome di una colonna che contiene i dati degli incorporamenti. La colonna deve essere di tipo ARRAY<FLOAT64>. La colonna non può avere campi secondari. Tutti gli elementi nell'array devono essere diversi da NULL e tutti i valori nella colonna devono avere le stesse dimensioni dell'array.
   • STORED_COLUMN_NAME: il nome di una colonna di primo livello nella tabella da archiviare nell'indice vettoriale. Il tipo di colonna non può essere RANGE. Le colonne archiviate non vengono utilizzate se la tabella ha un criterio di accesso a livello di riga o se la colonna ha un tag di criteri. Per informazioni su come abilitare le colonne archiviate, consulta Archivia colonne e prefiltro.
   • INDEX_TYPE: l'algoritmo da utilizzare per creare l'indice vettoriale. IVF è l'unico valore supportato. Se specifichi IVF, l'indice vettoriale viene creato come indice di file invertito (IVF). Un IVF utilizza un algoritmo k-means per raggruppare i dati vettoriali e quindi partiziona i dati vettoriali in base a questi cluster. Quando utilizzi la funzione VECTOR_SEARCH per cercare i dati vettoriali, questa può utilizzare queste partizioni per ridurre la quantità di dati che devono essere letti per determinare un risultato.

   • DISTANCE_TYPE: specifica il tipo di distanza predefinito da utilizzare quando si esegue una ricerca vettoriale usando questo indice. I valori supportati sono EUCLIDEAN e COSINE. EUCLIDEAN è l'impostazione predefinita.

     La creazione dell'indice utilizza sempre la distanza EUCLIDEAN per l'addestramento, ma la distanza utilizzata nella funzione VECTOR_SEARCH può essere diversa.

     Se specifichi un valore per l'argomento distance_type della funzione VECTOR_SEARCH, viene utilizzato quel valore al posto del valore DISTANCE_TYPE.

   • NUM_LISTS: un valore INT64 inferiore o uguale a 5000 che determina il numero di elenchi creati dall'algoritmo IVF. L'algoritmo IVF divide l'intero spazio di dati in un numero di elenchi uguale a NUM_LISTS, con i punti dati più vicini tra loro che hanno maggiori probabilità di essere inseriti nello stesso elenco. Se NUM_LISTS è piccolo, avrai meno elenchi con più punti dati, mentre un valore più grande crea più elenchi con meno punti dati.

     Puoi utilizzare NUM_LISTS in combinazione con l'argomento fraction_lists_to_search nella funzione VECTOR_SEARCH per creare una ricerca vettoriale efficiente. Se disponi di dati distribuiti in molti piccoli gruppi nello spazio di incorporamento, specifica un valore elevato di NUM_LISTS per creare un indice con più elenchi e specifica un valore fraction_lists_to_search più basso per analizzare un numero inferiore di elenchi nella ricerca vettoriale. Utilizza un valore NUM_LISTS più basso e un valore fraction_lists_to_search più alto quando i dati sono distribuiti in meno gruppi più grandi. L'utilizzo di un valore num_lists elevato potrebbe richiedere più tempo per la creazione dell'indice vettoriale.

     Se non specifichi NUM_LISTS, BigQuery calcola un valore appropriato.

L'esempio seguente crea un indice vettoriale nella colonna embedding di my_table:

CREATE TABLE my_dataset.my_table(embedding ARRAY<FLOAT64>);

CREATE VECTOR INDEX my_index ON my_dataset.my_table(embedding)
OPTIONS(index_type = 'IVF');

L'esempio seguente crea un indice vettoriale nella colonna embedding di my_table e specifica il tipo di distanza da utilizzare e le opzioni di IVF:

CREATE TABLE my_dataset.my_table(embedding ARRAY<FLOAT64>);

CREATE VECTOR INDEX my_index ON my_dataset.my_table(embedding)
OPTIONS(index_type = 'IVF', distance_type = 'COSINE',
ivf_options = '{"num_lists": 2500}')

Archivia colonne e prefiltro

Importante: per attivare le colonne archiviate negli indici vettoriali e il pre-filtro in VECTOR_SEARCH, compila il modulo di registrazione.

Per migliorare ulteriormente l'efficienza dell'indice vettoriale, puoi specificare le colonne della tabella di base da archiviare nell'indice vettoriale. L'utilizzo delle colonne archiviate può ottimizzare le query che chiamano la funzione VECTOR_SEARCH nei seguenti modi:

• La funzione VECTOR_SEARCH restituisce uno struct denominato base che contiene tutte le colonne della tabella di base. Senza le colonne archiviate, è necessario un join potenzialmente costoso per recuperare le colonne archiviate in base. Se la tua query seleziona solo le colonne archiviate da base, BigQuery ottimizza la query per eliminare quel join.

• Invece di cercare un'intera tabella, puoi chiamare la funzione VECTOR_SEARCH su un'istruzione di query che prefiltra la tabella di base con una clausola WHERE. Se la tabella ha un indice e filtri solo in base alle colonne archiviate, BigQuery ottimizza la query filtrando i dati prima della ricerca e poi utilizzando l'indice per cercare il set di risultati più piccolo. Se filtri in base alle colonne che non sono archiviate, BigQuery applica il filtro dopo aver eseguito la ricerca nella tabella o post-filtri.

  Il post-filtro è meno efficiente e può causare meno di top_k corrispondenze nel set di risultati. In alcuni casi, il pre-filtro può anche ridurre le dimensioni del set di risultati. In questo caso, prova ad aumentare il valore di fraction_lists_to_search nella chiamata a VECTOR_SEARCH.

Per archiviare le colonne, elencale nella clausola STORING dell'istruzione DDL CREATE VECTOR INDEX. L'archiviazione delle colonne aumenta la dimensione dell'indice vettoriale, pertanto è meglio archiviare solo le colonne utilizzate o filtrate più di frequente.

L'esempio seguente crea un indice vettoriale con colonne archiviate, quindi spiega il comportamento dei diversi tipi di ricerche vettoriali:

-- Create a table that contains an embedding.
CREATE TABLE my_dataset.my_table(embedding ARRAY<FLOAT64>, type STRING, creation_time DATETIME, id INT64);

-- Create a query table that contains an embedding.
CREATE TABLE my_dataset.my_testdata(embedding ARRAY<FLOAT64>, test_id INT64);

-- Create a vector index with stored columns.
CREATE VECTOR INDEX my_index ON my_dataset.my_table(embedding)
STORING (type, creation_time)
OPTIONS (index_type = 'IVF');

-- Select only stored columns from a vector search to avoid an expensive join.
SELECT query, base.type, distance
FROM
  VECTOR_SEARCH(
    TABLE my_dataset.my_table,
    'embedding'
    TABLE my_dataset.my_testdata);

-- Pre-filter on a stored column. The index speeds up the query.
SELECT *
FROM
  VECTOR_SEARCH(
    (SELECT * FROM my_dataset.my_table WHERE type = 'animal'),
    'embedding',
    TABLE my_dataset.my_testdata);

-- Filter on a column that isn't stored. The index is used to search the
-- entire table, and then the results are post-filtered. You might see fewer
-- than 5 matches returned for some embeddings.
SELECT query.test_id, base.type, distance
FROM
  VECTOR_SEARCH(
    (SELECT * FROM my_dataset.my_table WHERE id = 123),
    'embedding',
    TABLE my_dataset.my_testdata,
    top_k => 5);

-- Use post-filters. The index is used, but the entire table is searched and
-- the post-filtering might reduce the number of results.
SELECT query.test_id, base.type, distance
FROM
  VECTOR_SEARCH(
    TABLE my_dataset.my_table,
    'embedding',
    TABLE my_dataset.my_testdata,
    top_k => 5)
WHERE base.type = 'animal';

-- Use pre-filters with brute force. The data is filtered and then searched
-- with brute force for exact results.
SELECT query.test_id, base.type, distance
FROM
  VECTOR_SEARCH(
    (SELECT * FROM my_dataset.my_table WHERE id = 123),
    'embedding',
    TABLE my_dataset.my_testdata,
    options => '{"use_brute_force":true}');

Limitazioni

• Non puoi utilizzare le visualizzazioni logiche nel prefiltro.
• Se il prefiltro contiene una sottoquery, potrebbe interferire con l'utilizzo dell'indice.
• Se selezioni una colonna di tipo STRUCT dall'output query di una query VECTOR_SEARCH su una tabella che ha un indice con colonne archiviate, l'intera query potrebbe non riuscire.

Informazioni sull'aggiornamento dell'indice

Gli indici vettoriali sono completamente gestiti da BigQuery e aggiornati automaticamente quando la tabella indicizzata cambia. Se elimini la colonna indicizzata in una tabella o rinomini la tabella stessa, l'indice vettoriale viene eliminato automaticamente.

Se crei un indice vettoriale su una tabella di dimensioni inferiori a 10 MB, l'indice vettoriale non viene compilato. Allo stesso modo, se elimini dati da una tabella indicizzata e le dimensioni della tabella scendono al di sotto di 10 MB, l'indice vettoriale viene temporaneamente disabilitato. In questo caso, le query di ricerca vettoriale non utilizzano l'indice e il codice indexUnusedReasons nella sezione vectorSearchStatistics della risorsa Job è BASE_TABLE_TOO_SMALL. Senza l'indice, VECTOR_SEARCH torna automaticamente all'utilizzo della forza bruta per trovare i vicini più vicini agli incorporamenti.

Le query che utilizzano la funzione VECTOR_SEARCH restituiscono sempre risultati corretti, anche se parte dei dati non è ancora stata indicizzata.

Ottieni informazioni sugli indici vettoriali

Puoi verificare l'esistenza e l'idoneità di un indice vettoriale eseguendo una query su INFORMATION_SCHEMA. Le seguenti viste contengono metadati su indici vettoriali:

• La vista INFORMATION_SCHEMA.VECTOR_INDEXES contiene informazioni sugli indici vettoriali in un set di dati.

  Una volta completata l'istruzione CREATE VECTOR INDEX, l'indice deve essere ancora compilato prima di poter essere utilizzato. Puoi utilizzare le colonne last_refresh_time e coverage_percentage per verificare l'idoneità di un indice vettoriale. Se l'indice vettoriale non è pronto, puoi comunque utilizzare la funzione VECTOR_SEARCH in una tabella, ma potrebbe essere eseguito più lentamente senza l'indice.

• La vista INFORMATION_SCHEMA.VECTOR_INDEX_COLUMNS contiene informazioni sulle colonne indicizzate vettoriali per tutte le tabelle in un set di dati.

• La vista INFORMATION_SCHEMA.VECTOR_INDEX_OPTIONS contiene informazioni sulle opzioni utilizzate dagli indici vettoriali in un set di dati.

Esempi di indici vettoriali

L'esempio seguente mostra tutti gli indici vettoriali attivi nelle tabelle nel set di dati my_dataset, situato nel progetto my_project. Include i nomi, le istruzioni DDL utilizzate per crearle e la percentuale di copertura. Se una tabella di base indicizzata è inferiore a 10 MB, il suo indice non viene compilato e in questo caso il valore di coverage_percentage è 0.

SELECT table_name, index_name, ddl, coverage_percentage
FROM my_project.my_dataset.INFORMATION_SCHEMA.VECTOR_INDEXES
WHERE index_status = 'ACTIVE';

Il risultato è simile al seguente:

+-------------+-------------+-----------------------------------------------------------------------------------------------+---------------------+
| table_name  | index_name  | ddl                                                                                           | coverage_percentage |
+-------------+-------------+-----------------------------------------------------------------------------------------------+---------------------+
| small_table | myindex1    | CREATE VECTOR INDEX `myindex1` ON `my_project.my_dataset.small_table`(embeddings)             | 100                 |
|             |             | OPTIONS (distance_type = 'EUCLIDEAN', index_type = 'IVF', ivf_options = '{"numLists": 3}')    |                     |
+-------------+-------------+-----------------------------------------------------------------------------------------------+---------------------+
| large_table | myindex2    | CREATE VECTOR INDEX `myindex2` ON `my_project.my_dataset.large_table`(vectors)                |  42                 |
|             |             | OPTIONS (distance_type = 'EUCLIDEAN', index_type = 'IVF', ivf_options = '{"numLists": 12}')   |                     |
+-------------+-------------+-----------------------------------------------------------------------------------------------+---------------------+

Esempi di colonne di indici vettoriali

La seguente query estrae informazioni sulle colonne che hanno indici vettoriali:

SELECT table_name, index_name, index_column_name, index_field_path
FROM my_project.dataset.INFORMATION_SCHEMA.VECTOR_INDEX_COLUMNS;

Il risultato è simile al seguente:

+------------+------------+-------------------+------------------+
| table_name | index_name | index_column_name | index_field_path |
+------------+------------+-------------------+------------------+
| table1     | indexa     | a                 | a                |
| table2     | indexb     | b                 | b                |
| table3     | indexc     | c                 | c                |
+------------+------------+-------------------+------------------+

Esempi di opzioni di indici vettoriali

La seguente query estrae informazioni sulle opzioni dell'indice vettoriale:

SELECT table_name, index_name, option_name, option_type, option_value
FROM my_project.dataset.INFORMATION_SCHEMA.VECTOR_INDEX_OPTIONS;

Il risultato è simile al seguente:

+------------+------------+------------------+------------------+--------------------+
| table_name | index_name | option_name      | option_type      | option_value       |
+------------+------------+------------------+------------------+--------------------+
| table1     | indexa     | distance_type    | STRING           | EUCLIDEAN          |
| table1     | indexa     | index_type       | STRING           | IVF                |
| table2     | indexb     | ivf_options      | STRING           | {"num_lists": 100} |
| table2     | indexb     | index_type       | STRING           | IVF                |
+------------+------------+------------------+------------------+--------------------+

Utilizzo indice vettoriale

Le informazioni sull'utilizzo dell'indice vettoriale sono disponibili nei metadati del job che ha eseguito la query di ricerca vettoriale. Puoi visualizzare i metadati del job utilizzando la console Google Cloud, lo strumento a riga di comando bq, l'API BigQuery o le librerie client.

Quando utilizzi la console Google Cloud, puoi trovare informazioni sull'utilizzo dell'indice vettoriale nei campi Modalità di utilizzo dell'indice vettoriale e Motivi per l'utilizzo dell'indice vettoriale inutilizzati.

Quando utilizzi lo strumento bq o l'API BigQuery, puoi trovare informazioni sull'utilizzo dell'indice vettoriale nella sezione VectorSearchStatistics della risorsa Job.

La modalità di utilizzo dell'indice indica se è stato utilizzato un indice vettoriale fornendo uno dei seguenti valori:

• UNUSED: non è stato utilizzato alcun indice vettoriale.
• PARTIALLY_USED: alcune funzioni VECTOR_SEARCH nella query utilizzavano indici vettoriali, mentre altre no.
• FULLY_USED: ogni funzione VECTOR_SEARCH della query ha utilizzato un indice vettoriale.

Quando il valore della modalità di utilizzo dell'indice è UNUSED o PARTIALLY_USED, i motivi di inutilizzo dell'indice indicano perché gli indici vettoriali non sono stati utilizzati nella query.

Ad esempio, i seguenti risultati restituiti da bq show --format=prettyjson -j my_job_id mostrano che l'indice non è stato utilizzato perché l'opzione use_brute_force è stata specificata nella funzione VECTOR_SEARCH:

"vectorSearchStatistics": {
  "indexUnusedReasons": [
    {
      "baseTable": {
        "datasetId": "my_dataset",
        "projectId": "my_project",
        "tableId": "my_table"
      },
      "code": "INDEX_SUPPRESSED_BY_FUNCTION_OPTION",
      "message": "No vector index was used for the base table `my_project:my_dataset.my_table` because use_brute_force option has been specified."
    }
  ],
  "indexUsageMode": "UNUSED"
}

Opzioni di gestione degli indici

Per creare indici e fare in modo che BigQuery li mantenga, hai due opzioni:

• Utilizza il pool di slot condivisi predefinito: se i dati che prevedi di indicizzare sono al di sotto del limite per organizzazione, puoi utilizzare il pool di slot condivisi gratuito per la gestione dell'indice.
• Utilizza la tua prenotazione: per ottenere un avanzamento di indicizzazione più prevedibile e coerente nei carichi di lavoro di produzione più ampi, puoi utilizzare le tue prenotazioni per la gestione degli indici.

Utilizza slot condivisi

Se non hai configurato il progetto per l'utilizzo di una prenotazione dedicata per l'indicizzazione, la gestione dell'indice viene gestita nel pool di slot condiviso gratuito, secondo i seguenti vincoli.

Se aggiungi dati a una tabella per far sì che la dimensione totale delle tabelle indicizzate superi il limite della tua organizzazione, BigQuery mette in pausa la gestione dell'indice per tutte le tabelle indicizzate. In questo caso, il campo index_status nella vista INFORMATION_SCHEMA.VECTOR_INDEXES mostra PENDING DISABLEMENT e l'indice viene messo in coda per l'eliminazione. Mentre l'indice è in attesa di disabilitazione, viene comunque utilizzato nelle query e ti viene addebitato l'archiviazione dell'indice. Dopo l'eliminazione di un indice, il campo index_status mostra l'indice come TEMPORARILY DISABLED. In questo stato, le query non utilizzano l'indice e non ti viene addebitato l'archiviazione dell'indice. In questo caso, il codice IndexUnusedReason è BASE_TABLE_TOO_LARGE.

Se elimini i dati dalla tabella e la dimensione totale delle tabelle indicizzate scende al di sotto del limite per organizzazione, la gestione dell'indice viene ripresa per tutte le tabelle indicizzate. Il campo index_status nella vista INFORMATION_SCHEMA.VECTOR_INDEXES è ACTIVE, le query possono utilizzare l'indice e ti viene addebitato l'archiviazione dell'indice.

BigQuery non garantisce la capacità disponibile del pool condiviso o la velocità effettiva di indicizzazione visualizzata. Per le applicazioni di produzione è consigliabile usare slot dedicati per l'elaborazione dell'indice.

Utilizza la tua prenotazione

Anziché utilizzare il pool di slot condiviso predefinito, puoi facoltativamente specificare la tua prenotazione per indicizzare le tabelle. L'utilizzo della tua prenotazione garantisce prestazioni prevedibili e coerenti dei job di gestione degli indici, come creazione, aggiornamento e ottimizzazioni in background.

• Non ci sono limiti di dimensioni delle tabelle quando un job di indicizzazione viene eseguito nella prenotazione.
• L'utilizzo della tua prenotazione ti offre flessibilità nella gestione dell'indice. Se devi creare un indice molto grande o effettuare un aggiornamento importante a una tabella indicizzata, puoi aggiungere temporaneamente più slot all'assegnazione.

Per indicizzare le tabelle in un progetto con una prenotazione designata, crea una prenotazione nella regione in cui si trovano le tabelle. Quindi, assegna il progetto alla prenotazione con il job_type impostato su BACKGROUND:

SQL

Utilizza l'istruzione DDL CREATE ASSIGNMENT.

1. Nella console Google Cloud, vai alla pagina BigQuery.

   Vai a BigQuery

2. Nell'editor query, inserisci la seguente istruzione:

   CREATE ASSIGNMENT
     `ADMIN_PROJECT_ID.region-LOCATION.RESERVATION_NAME.ASSIGNMENT_ID`
   OPTIONS (
     assignee = 'projects/PROJECT_ID',
     job_type = 'BACKGROUND');
   

   Sostituisci quanto segue:

   • ADMIN_PROJECT_ID: l'ID del progetto di amministrazione proprietario della risorsa di prenotazione
   • LOCATION: la località della prenotazione
   • RESERVATION_NAME: il nome della prenotazione

   • ASSIGNMENT_ID: l'ID del compito

     L'ID deve essere univoco per il progetto e la località, iniziare e terminare con una lettera minuscola o un numero e contenere solo lettere minuscole, numeri e trattini.

   • PROJECT_ID: l'ID del progetto contenente le tabelle da indicizzare. Questo progetto è assegnato alla prenotazione.

3. Fai clic su Esegui.

Per ulteriori informazioni su come eseguire le query, vedi Eseguire una query interattiva.

bq

Usa il comando bq mk:

bq mk \
    --project_id=ADMIN_PROJECT_ID \
    --location=LOCATION \
    --reservation_assignment \
    --reservation_id=RESERVATION_NAME \
    --assignee_id=PROJECT_ID \
    --job_type=BACKGROUND \
    --assignee_type=PROJECT

Sostituisci quanto segue:

• ADMIN_PROJECT_ID: l'ID del progetto di amministrazione proprietario della risorsa di prenotazione
• LOCATION: la località della prenotazione
• RESERVATION_NAME: il nome della prenotazione
• PROJECT_ID: l'ID del progetto da assegnare a questa prenotazione

Visualizzare i job di indicizzazione

Ogni volta che un indice viene creato o aggiornato in una singola tabella, viene creato un nuovo job di indicizzazione. Per visualizzare le informazioni sul job, esegui una query sulle viste INFORMATION_SCHEMA.JOBS*. Puoi filtrare i job di indicizzazione impostando job_type IS NULL AND SEARCH(job_id, '`search_index`') nella clausola WHERE della query. L'esempio seguente elenca i cinque job di indicizzazione più recenti nel progetto my_project:

SELECT *
FROM
 region-us.INFORMATION_SCHEMA.JOBS
WHERE
  project_id  = 'my_project'
  AND job_type IS NULL
  AND SEARCH(job_id, '`search_index`')
ORDER BY
 creation_time DESC
LIMIT 5;

Nota: non puoi visualizzare le informazioni sui job di indicizzazione eseguiti nel pool di slot condiviso predefinito.

Scegli le dimensioni della prenotazione

Per scegliere il numero giusto di slot per la prenotazione, devi considerare quando vengono eseguiti i job di gestione dell'indice, quanti slot utilizzano e quale sarà l'utilizzo nel tempo. BigQuery attiva un job di gestione degli indici nelle seguenti situazioni:

• Crei un indice in una tabella.
• I dati vengono modificati in una tabella indicizzata.
• Lo schema di una tabella cambia e ciò influisce sulle colonne indicizzate.
• I dati dell'indice e i metadati vengono ottimizzati o aggiornati periodicamente.

Il numero di slot necessari per un job di gestione degli indici su una tabella dipende dai seguenti fattori:

• Le dimensioni della tabella
• La velocità di importazione dati nella tabella
• La frequenza delle istruzioni DML applicate alla tabella
• Il ritardo accettabile per la creazione e la gestione dell'indice
• La complessità dell'indice, in genere determinata dagli attributi dei dati, come il numero di termini duplicati

Monitora l'utilizzo e i progressi

Il modo migliore per valutare il numero di slot necessari per eseguire in modo efficiente i job di gestione degli indici è monitorare l'utilizzo degli slot e regolare le dimensioni della prenotazione di conseguenza. La seguente query restituisce l'utilizzo giornaliero degli slot per i job di gestione degli indici. Nella regione us-west1 sono inclusi solo gli ultimi 30 giorni:

SELECT
  TIMESTAMP_TRUNC(job.creation_time, DAY) AS usage_date,
  -- Aggregate total_slots_ms used for index-management jobs in a day and divide
  -- by the number of milliseconds in a day. This value is most accurate for
  -- days with consistent slot usage.
  SAFE_DIVIDE(SUM(job.total_slot_ms), (1000 * 60 * 60 * 24)) AS average_daily_slot_usage
FROM
  `region-us-west1`.INFORMATION_SCHEMA.JOBS job
WHERE
  project_id = 'my_project'
  AND job_type IS NULL
  AND SEARCH(job_id, '`search_index`')
GROUP BY
  usage_date
ORDER BY
  usage_date DESC
limit 30;

Se gli slot non sono sufficienti per eseguire i job di gestione dell'indice, un indice può non essere sincronizzato con la sua tabella e i job di indicizzazione potrebbero non riuscire. In questo caso, BigQuery ricrea l'indice da zero. Per evitare di avere un indice non sincronizzato, assicurati di avere slot sufficienti per supportare gli aggiornamenti dell'indice dall'importazione e dall'ottimizzazione dei dati. Per ulteriori informazioni sul monitoraggio dell'utilizzo degli slot, consulta i grafici delle risorse di amministrazione.

Eliminare un indice vettoriale

Quando non hai più bisogno di un indice vettoriale o vuoi modificare la colonna indicizzata in una tabella, puoi eliminare l'indice nella tabella utilizzando l'istruzione DDL DROP VECTOR INDEX.

Ad esempio:

DROP VECTOR INDEX my_index ON my_dataset.indexed_table;

Se una tabella indicizzata viene eliminata, il relativo indice viene eliminato automaticamente.

Passaggi successivi

• Per una panoramica dei casi d'uso, dei prezzi e dei limiti degli indici vettoriali, consulta Introduzione alla ricerca vettoriale.
• Prova il tutorial Cerca negli incorporamenti con la ricerca vettoriale.