Gestisci indici vettoriali
Per fornire feedback o richiedere assistenza per questa funzionalità, invia un'email a [email protected].
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
Approssimativo vicino più vicino
per migliorare le prestazioni della ricerca, con la possibilità 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 eliminare un indice vettoriale, devi disporre
dell'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
)
Creare un indice vettoriale
Per creare un indice vettoriale, utilizza l'istruzione CREATE VECTOR INDEX
(Data Definition Language) (DDL):
Vai alla pagina BigQuery.
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 nello stesso 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 avere un tipo diARRAY<FLOAT64>
. La colonna non può avere campi secondari. Tutti gli elementi dell'array devono essere diversi daNULL
e tutti i valori nella colonna devono avere le stesse dimensioni dell'array.STORED_COLUMN_NAME
: il nome di una colonna di primo livello della tabella da memorizzare nell'indice vettoriale. Il tipo di colonna non può essereRANGE
. 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 attivare le colonne archiviate, consulta Archiviare colonne e prefiltro.INDEX_TYPE
: l'algoritmo da utilizzare per creare l'indice vettoriale.IVF
è l'unico valore supportato. Se specifichiIVF
, l'indice vettoriale viene creato come indice di file invertito (IVF). Un'IVF utilizza un algoritmo K-means per eseguire il cluster dei dati vettoriali e quindi partiziona i dati vettoriali in base a questi cluster. Quando usi la funzioneVECTOR_SEARCH
per cercare dati vettoriali, puoi utilizzare queste partizioni per ridurre la quantità di dati da leggere per determinare un risultato.DISTANCE_TYPE
: specifica il tipo di distanza predefinito da utilizzare per eseguire una ricerca vettoriale con questo indice. I valori supportati sonoEUCLIDEAN
eCOSINE
.EUCLIDEAN
è l'impostazione predefinita.La creazione dell'indice in sé utilizza sempre la distanza
EUCLIDEAN
per l'addestramento, ma la distanza utilizzata nella funzioneVECTOR_SEARCH
può essere diversa.Se specifichi un valore per l'argomento
distance_type
della funzioneVECTOR_SEARCH
, viene utilizzato quel valore al posto del valoreDISTANCE_TYPE
.NUM_LISTS
: un valoreINT64
inferiore o uguale a 5000 che determina il numero di elenchi creati dall'algoritmo di IVF. L'algoritmo IVF divide l'intero spazio dati in un numero di elenchi uguale aNUM_LISTS
, in cui i punti dati più vicini tra loro hanno maggiori probabilità di essere inseriti nello stesso elenco. SeNUM_LISTS
è piccolo, hai meno elenchi con più punti dati, mentre un valore più grande crea più elenchi con meno punti dati.Puoi utilizzare
NUM_LISTS
insieme all'argomentofraction_lists_to_search
nella funzioneVECTOR_SEARCH
per creare una ricerca vettoriale efficiente. Se hai dati distribuiti in molti piccoli gruppi nello spazio di incorporamento, specifica un valoreNUM_LISTS
elevato per creare un indice con più elenchi e specifica un valorefraction_lists_to_search
più basso per analizzare meno elenchi nella ricerca vettoriale. Utilizza un valoreNUM_LISTS
più basso e un valorefraction_lists_to_search
più alto quando i dati sono distribuiti in gruppi meno numerosi e più grandi. Se utilizzi un valorenum_lists
elevato, la creazione dell'indice vettoriale potrebbe richiedere più tempo.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 della 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 pre-filtro
Per migliorare ulteriormente l'efficienza dell'indice vettoriale, puoi specificare le colonne della tabella di base da memorizzare 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
genera uno struct denominatobase
che contiene tutte le colonne della tabella di base. Senza colonne archiviate, è necessario un join potenzialmente costoso per recuperare le colonne archiviate inbase
. Se la query seleziona solo le colonne archiviate dabase
, BigQuery ottimizza la query per eliminare il join.Anziché cercare in un'intera tabella, puoi chiamare la funzione
VECTOR_SEARCH
su un'istruzione di query che prefiltra la tabella di base con una clausolaWHERE
. Se la tabella ha un indice e filtri solo in base alle colonne archiviate, BigQuery ottimizza la query filtrando i dati prima di cercare e utilizzando l'indice per cercare nel set di risultati più piccolo. Se filtri in base a colonne non archiviate, BigQuery applica il filtro dopo 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 difraction_lists_to_search
nella chiamata aVECTOR_SEARCH
.
Per archiviare le colonne, elencale nella clausola STORING
dell'istruzione DDL CREATE VECTOR INDEX
.
L'archiviazione delle colonne aumenta le dimensioni dell'indice vettoriale, pertanto ti consigliamo di archiviare solo le colonne più utilizzate o filtrate.
L'esempio seguente crea un indice vettoriale con colonne archiviate e 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 viste logiche nel prefiltro.
- Se il pre-filtro contiene una sottoquery, potrebbe interferire con l'utilizzo dell'indice.
- Se selezioni una colonna di tipo
STRUCT
dall'outputquery
di una queryVECTOR_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 vengono aggiornati automaticamente quando la tabella indicizzata viene modificata. 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 sono inferiori a 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'uso della forza bruta per trovare i vicini più vicini degli incorporamenti.
Le query che utilizzano la funzione VECTOR_SEARCH
restituiscono sempre risultati corretti, anche se una parte di dati non è ancora stata indicizzata.
Ricevere informazioni sugli indici vettoriali
Puoi verificare l'esistenza e l'idoneità di un indice vettoriale eseguendo una query su INFORMATION_SCHEMA
. Le seguenti visualizzazioni contengono metadati su indici vettoriali:
La vista
INFORMATION_SCHEMA.VECTOR_INDEXES
contiene informazioni sugli indici vettoriali in un set di dati.Dopo il completamento dell'istruzione
CREATE VECTOR INDEX
, l'indice deve comunque essere compilato prima di poter essere utilizzato. Puoi utilizzare le colonnelast_refresh_time
ecoverage_percentage
per verificare l'idoneità di un indice vettoriale. Se l'indice vettoriale non è pronto, puoi comunque utilizzare la funzioneVECTOR_SEARCH
in una tabella, potrebbe essere eseguita 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 di vettore attivi nelle tabelle nel set di dati my_dataset
, che si trova nel progetto my_project
. Sono inclusi 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 completato, nel qual caso il valore 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 dalle colonne con 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 degli indici vettoriali:
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 dell'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 del mancato utilizzo dell'indice vettoriale.
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 funzioniVECTOR_SEARCH
nella query utilizzavano indici vettoriali, altre no.FULLY_USED
: ogni funzioneVECTOR_SEARCH
nella query ha utilizzato un indice vettoriale.
Quando il valore della modalità di utilizzo dell'indice è UNUSED
o PARTIALLY_USED
, i motivi di mancato utilizzo 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 gli indici e fare in modo che BigQuery li gestisca, hai due opzioni:
- Utilizza il pool di slot condiviso predefinito: quando 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 avanzamento dell'indicizzazione più prevedibile e coerente, sui tuoi carichi di lavoro di produzione più grandi, puoi utilizzare le tue prenotazioni per la gestione degli indici.
Usa gli spazi condivisi
Se non hai configurato il tuo progetto per l'utilizzo di una prenotazione dedicata per l'indicizzazione, la gestione dell'indice viene gestita nel pool di slot condiviso gratuito, in base ai vincoli seguenti.
Se aggiungi dati a una tabella e questo fa 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 è in coda per l'eliminazione. Mentre l'indice è in attesa di disattivazione, viene comunque utilizzato nelle query e ti viene addebitato il costo dell'archiviazione dell'indice.
Dopo aver eliminato 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 alcun costo per l'archiviazione dell'indice. In questo caso, il codice IndexUnusedReason
è BASE_TABLE_TOO_LARGE
.
Se elimini 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 visualizzazione
INFORMATION_SCHEMA.VECTOR_INDEXES
è ACTIVE
; le query possono utilizzare l'indice e ti viene addebitato il costo
di archiviazione dell'indice.
BigQuery non fornisce garanzie sulla capacità disponibile del pool condiviso o sulla velocità effettiva di indicizzazione visualizzata. Per le applicazioni di produzione, potresti voler usare slot dedicati per l'elaborazione dell'indice.
Usa la tua prenotazione
Anziché utilizzare il pool di slot condiviso predefinito, puoi facoltativamente designare la tua prenotazione per indicizzare le tabelle. L'utilizzo di una prenotazione personalizzata garantisce prestazioni prevedibili e coerenti dei job di gestione dell'indice, come creazione, aggiornamento e ottimizzazioni in background.
- Non sono previsti limiti di dimensione della tabella quando viene eseguito un job di indicizzazione nella tua prenotazione.
- L'utilizzo della tua prenotazione ti offre flessibilità nella gestione degli indici. Se devi creare un indice di grandi dimensioni o eseguire un aggiornamento principale di una tabella indicizzata, puoi aggiungere temporaneamente altri 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 job_type
impostato su BACKGROUND
:
SQL
Utilizza l'istruzione DDL CREATE ASSIGNMENT
.
Nella console Google Cloud, vai alla pagina BigQuery.
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 prenotazioneLOCATION
: la località della prenotazioneRESERVATION_NAME
: il nome della prenotazioneASSIGNMENT_ID
: l'ID del compitoL'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.
Fai clic su
Esegui.
Per ulteriori informazioni su come eseguire le query, consulta 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 prenotazioneLOCATION
: la località della prenotazioneRESERVATION_NAME
: il nome della prenotazionePROJECT_ID
: l'ID del progetto da assegnare a questa prenotazione
Visualizzare i job di indicizzazione
Ogni volta che viene creato o aggiornato un indice 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 tua query. Nell'esempio seguente sono elencati 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;
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, il numero di slot che utilizzano e l'aspetto del tuo utilizzo nel tempo. BigQuery attiva un job di gestione dell'indice nelle seguenti situazioni:
- Crei un indice su 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 dell'indice in una tabella dipende dai seguenti fattori:
- Le dimensioni della tabella
- La velocità di importazione dati nella tabella
- La percentuale di istruzioni DML applicate alla tabella
- Il ritardo accettabile per la creazione e la manutenzione dell'indice
- La complessità dell'indice, solitamente determinata dagli attributi dei dati, come il numero di termini duplicati
Monitoraggio di utilizzo e avanzamento
Il modo migliore per valutare il numero di slot di cui hai bisogno per eseguire in modo efficiente i job di gestione dell'indice è monitorare l'utilizzo degli slot e regolare di conseguenza la dimensione della prenotazione. La seguente query produce l'utilizzo giornaliero degli slot per i job di gestione degli indici. Sono inclusi solo gli ultimi 30 giorni nella
regione us-west1
:
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 non ci sono slot sufficienti per eseguire job di gestione dell'indice, un indice può diventare non sincronizzato con la relativa 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 a seguito dell'importazione e dell'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 in quella tabella utilizzando l'istruzione DDL DROP VECTOR INDEX
.
Ad esempio:
DROP VECTOR INDEX my_index ON my_dataset.indexed_table;
Se viene eliminata una tabella indicizzata, il relativo indice viene eliminato automaticamente.
Passaggi successivi
- Per una panoramica dei casi d'uso degli indici vettoriali, dei prezzi e delle limitazioni, consulta l'introduzione alla ricerca vettoriale.
- Prova il tutorial Cerca incorporamenti con ricerca vettoriale.