Gestisci indici vettoriali
Per fornire feedback o richiedere assistenza per questa funzione, 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
Funzione VECTOR_SEARCH
Eseguire una ricerca vettoriale più efficiente
degli incorporamenti. Quando VECTOR_SEARCH
è in grado di utilizzare un indice vettoriale, la funzione
utilizza
Vicino approssimato più vicino
di ricerca per migliorare il rendimento della ricerca, con il compromesso
riduzione
richiamo
generando così risultati più approssimativi.
Ruoli e autorizzazioni
Per creare un indice vettoriale, è necessario
Autorizzazione IAM bigquery.tables.createIndex
nella tabella in cui stai creando l'indice. Per rilasciare un indice vettoriale,
l'autorizzazione bigquery.tables.deleteIndex
. Ciascuno dei seguenti valori predefiniti
I ruoli IAM includono le autorizzazioni con cui devi lavorare
Indici vettoriali:
- Proprietario dati BigQuery (
roles/bigquery.dataOwner
) - Editor dati BigQuery (
roles/bigquery.dataEditor
)
Crea un indice vettoriale
Per creare un indice vettoriale, utilizza il metodo
CREATE VECTOR INDEX
Istruzione DDL (Data Definition Language):
Vai alla pagina BigQuery.
Nell'editor di query, seleziona un tipo di indice ed esegui il comando SQL estratti conto:
Per creare un indice vettoriale IVF:
CREATE [ OR REPLACE ] VECTOR INDEX [ IF NOT EXISTS ] INDEX_NAME ON DATASET_NAME.TABLE_NAME(COLUMN_NAME) STORING(STORED_COLUMN_NAME [, ...]) OPTIONS(index_type = "IVF", distance_type = "DISTANCE_TYPE", ivf_options = '{"num_lists":NUM_LISTS}')
Per creare un indice vettoriale TreeAH:
CREATE [ OR REPLACE ] VECTOR INDEX [ IF NOT EXISTS ] INDEX_NAME ON DATASET_NAME.TABLE_NAME(COLUMN_NAME) OPTIONS(index_type = "TREE_AH", distance_type = "DISTANCE_TYPE", tree_ah_options = '{"leaf_node_embedding_count":LEAF_NODE_EMBEDDING_COUNT, "normalization_type":"NORMALIZATION_TYPE"}')
Consulta Scegliere un tipo di indice vettoriale per ulteriori informazioni. informazioni.
Sostituisci quanto segue:
INDEX_NAME
: il nome del tuo indice vettoriale in fase di creazione. Poiché l'indice viene sempre creato nello stesso progetto come 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 dai dati degli incorporamenti. La colonna deve essere di tipoARRAY<FLOAT64>
. La non può avere campi secondari. Tutti gli elementi dell'array devono essere nonNULL
e tutti i valori nella colonna devono avere lo stesso array dimensioni.STORED_COLUMN_NAME
: il nome di una colonna di primo livello nella tabella da archiviare nell'indice vettoriale. Il tipo di colonna non può essereRANGE
. Le colonne archiviate non vengono utilizzate se la tabella ha accesso a livello di riga o se la colonna ha un tag di criteri. Per informazioni su come abilitare le colonne archiviate, Archivia colonne e pre-filtro.DISTANCE_TYPE
: specifica il tipo di distanza predefinito da utilizzare quando si esegue una ricerca vettoriale usando questo indice. Lo strumento i valori sonoEUCLIDEAN
,COSINE
, eDOT_PRODUCT
EUCLIDEAN
è l'impostazione predefinita.La creazione dell'indice 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
delVECTOR_SEARCH
, questo valore viene utilizzato al posto dellaDISTANCE_TYPE
valore.NUM_LISTS
: un valoreINT64
minore di o pari a 5000 che determina quanti elenchi vengono creati dall'algoritmo IVF. L'algoritmo IVF divide l'intero spazio dei dati in un numero di elenchi uguale aNUM_LISTS
, con punti dati che sono più vicine tra loro e hanno maggiori probabilità di essere inserite nello stesso elenco. SeNUM_LISTS
è un numero piccolo, hai meno liste con più punti dati, mentre un valore più alto crea più elenchi con meno e i punti dati.Puoi utilizzare
NUM_LISTS
in con l'argomentofraction_lists_to_search
nelVECTOR_SEARCH
: per creare una ricerca vettoriale efficiente. Se disponi di dati distribuiti in molti piccoli gruppi nello spazio di incorporamento, quindi specificaNUM_LISTS
alta per creare un indice con più elenchi e specifica un valorefraction_lists_to_search
più basso di cui eseguire la scansione nella ricerca vettoriale. Utilizza un valore inferioreNUM_LISTS
e una successivafraction_lists_to_search
quando i dati sono distribuiti in meno risorse, gruppi più grandi. L'utilizzo di un valorenum_lists
alto potrebbe rendere il la creazione dell'indice vettoriale richiede più tempo.Se non specifichi
NUM_LISTS
, BigQuery calcola un valore appropriato.LEAF_NODE_EMBEDDING_COUNT
: un valoreINT64
maggiore o uguale a 500 che specifica il numero approssimativo di in ciascun nodo foglia dell'albero creato dall'algoritmo TreeAH. L'algoritmo TreeAH divide l'intero spazio dei dati in un numero di elenchi, e ogni elenco contiene circaLEAF_NODE_EMBEDDING_COUNT
e i punti dati. Un valore più basso crea più elenchi con meno punti dati, mentre un valore un valore maggiore crea meno elenchi con più punti dati. L'impostazione predefinita è 1000.NORMALIZATION_TYPE
: un valoreSTRING
. La i valori supportati sonoNONE or
L2
Il valore predefinito èNONE
. La normalizzazione avviene prima di qualsiasi elaborazione, sia i dati della tabella di base sia i dati delle query, ma non modifica colonna di incorporamentoCOLUMN_NAME
inTABLE_NAME
. A seconda del set di dati, di incorporamento e il tipo di distanza utilizzato duranteVECTOR_SEARCH
, la normalizzazione degli incorporamenti potrebbe migliorare il richiamo.
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}')
L'esempio seguente crea un indice vettoriale nella colonna embedding
di my_table
e specifica il tipo di distanza da utilizzare e le opzioni TreeAH:
CREATE TABLE my_dataset.my_table(id INT64, embedding ARRAY<FLOAT64>); CREATE VECTOR INDEX my_index ON my_dataset.my_table(embedding) OPTIONS (index_type = 'TREE_AH', distance_type = 'EUCLIDEAN', tree_ah_options = '{"normalization_type": "L2"}');
Scegli un tipo di indice vettoriale
BigQuery offre due tipi di indici vettoriali.
Indice IVF
IVF è un indice di file invertito che utilizza un algoritmo k-means per raggruppare
di dati vettoriali, per poi eseguire il partizionamento dei dati vettoriali in base ai cluster. Quando
utilizzi
Funzione VECTOR_SEARCH
per cercare i dati vettoriali, può utilizzare queste partizioni per ridurre
quantità di dati che devono leggere per determinare un risultato.
Indice TreeAH
TreeAH è un tipo di indice vettoriale che utilizza la tecnologia Algoritmo ScaNN. Funziona nel seguente modo:
La tabella di base è divisa in shard più piccoli e più gestibili.
Viene addestrato un modello di clustering, con il numero di cluster derivato l'opzione
leaf_node_embedding_count
intree_ah_options
.I vettori vengono quantificati e archiviati nelle tabelle degli indici.
Durante il periodo
VECTOR_SEARCH
, un elenco di candidati per ogni vettore di query è efficiente viene calcolata utilizzando l'hashing asimmetrico, ottimizzato per l'hardware per calcoli delle distanze. Questi candidati vengono quindi rivalutati e riclassificati utilizzando incorporamenti esatti.
L'algoritmo TreeAH è ottimizzato per le query batch che elaborano centinaia o più vettori di query. L'uso della quantizzazione dei prodotti può ridurre significativamente latenza e costo, potenzialmente per ordini di grandezza rispetto alla IVF. Tuttavia, a causa dell'overhead maggiore, l'algoritmo IVF potrebbe essere migliore quando un numero inferiore di vettori di query.
Ti consigliamo di provare il tipo di indice TreeAH se il tuo caso d'uso soddisfa quanto segue di classificazione:
La tabella contiene al massimo 200 milioni di righe.
Esegui spesso query batch di grandi dimensioni che coinvolgono centinaia o più vettori di rete.
Per query batch di piccole dimensioni,
VECTOR_SEARCH
che utilizza il tipo di indice TreeAH potrebbe rientrare di nuovo alla forza bruta. In questo caso, viene compilato un motivo per il mancato utilizzo dell'indice vettoriale. per spiegarne il motivo.Il flusso di lavoro non richiede l'utilizzo di colonne archiviate o pre-filtri. BigQuery tratta i pre-filtri utilizzati con un indice TreeAH come e post-filtri.
Per qualsiasi domanda e dubbio, in particolare su scalabilità, limiti e prestazioni, contattaci all'indirizzo [email protected].
Archivia colonne e prefiltro
Per migliorare ulteriormente l'efficienza dell'indice vettoriale, puoi specificare colonne
dalla tabella di base per archiviarli nel tuo indice vettoriale. L'uso delle colonne archiviate può
ottimizza le query che chiamano la funzione VECTOR_SEARCH
nei seguenti modi:
La funzione
VECTOR_SEARCH
restituisce uno struct denominatobase
che contiene tutte le colonne della tabella di base. Senza colonne memorizzate, viene potenzialmente è necessario un join costoso per recuperare le colonne archiviate inbase
. Se la query seleziona solo le colonne archiviate dabase
, BigQuery ottimizza la query per eliminare quel join.Invece di cercare un'intera tabella, puoi chiamare il metodo
VECTOR_SEARCH
funzione su un'istruzione di query che prefiltra la tabella di base con unWHERE
. Se la tabella ha un indice e filtri solo in base a elementi archiviati colonne, BigQuery ottimizza la query filtrando dati prima di cercare e quindi utilizzare l'indice per cercare il risultato più piccolo per iniziare. Se filtri in base alle colonne che non sono archiviate: BigQuery applica il filtro dopo aver eseguito la ricerca nella tabella oppure post-filtri.Il post-filtro è meno efficiente e può causare meno di
top_k
corrispondenze nel set di risultati. In alcuni casi, il prefiltro 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
della
CREATE VECTOR INDEX
Istruzione DDL.
L'archiviazione delle colonne aumenta la dimensione dell'indice vettoriale, quindi è meglio
per archiviare solo le colonne utilizzate o filtrate più di frequente.
L'esempio seguente crea un indice vettoriale con colonne memorizzate e 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 pre-filtro contiene un sottoquery, interferiscono con l'uso dell'indice.
- Se la modalità, il tipo o lo schema di una colonna vengono modificati nella tabella di base e se è una colonna memorizzata nell'indice vettoriale, può esserci un ritardo prima la modifica si riflette nell'indice vettoriale. Fino a quando gli aggiornamenti non saranno stati applicati all'indice, le query di ricerca vettoriale utilizzano le colonne memorizzate modificate dalla tabella di base.
- Se selezioni una colonna di tipo
STRUCT
dall'outputquery
di unVECTOR_SEARCH
su una tabella che ha un indice con colonne archiviate, quindi l'intera query potrebbe non riuscire. - Le colonne archiviate non sono supportate per gli indici TreeAH in anteprima.
Informazioni sull'aggiornamento dell'indice
Gli indici vettoriali sono completamente gestiti da BigQuery e automaticamente vengono aggiornate quando cambia la tabella indicizzata. Se elimini la colonna indicizzata in una tabella o rinomina la tabella, 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. Analogamente, se elimini dati da un file
tabella e le dimensioni sono inferiori a 10 MB, l'indice vettoriale è
temporaneamente disattivata. In questo caso, le query di ricerca vettoriale non utilizzano l'indice
e il codice indexUnusedReasons
nella
vectorSearchStatistics
della risorsa Job
è BASE_TABLE_TOO_SMALL
. Senza l'indice,
VECTOR_SEARCH
torna automaticamente all'utilizzo della forza bruta per trovare
vicini più prossimi agli incorporamenti.
Query che utilizzano lo strumento VECTOR_SEARCH
funzione
restituiscono sempre risultati corretti, anche se una parte dei dati non è ancora stata indicizzata.
Ottieni informazioni sugli indici vettoriali
Puoi verificare l'esistenza e l'idoneità di un indice vettoriale eseguendo query
INFORMATION_SCHEMA
. Le seguenti viste contengono metadati su indici vettoriali:
La
INFORMATION_SCHEMA.VECTOR_INDEXES
visualizzazione contiene informazioni sugli indici vettoriali in un set di dati.Una volta completata l'istruzione
CREATE VECTOR INDEX
, l'indice deve ancora viene compilato prima di poterlo utilizzare. Puoi usarelast_refresh_time
ecoverage_percentage
colonne per verificare l'idoneità di un vettore indice. Se l'indice vettoriale non è pronto, puoi comunque utilizzare il metodoVECTOR_SEARCH
su una tabella, potrebbe essere eseguita più lentamente senza dell'indice.La
INFORMATION_SCHEMA.VECTOR_INDEX_COLUMNS
visualizzazione contiene informazioni sulle colonne indicizzate vettoriali per tutte le tabelle in un set di dati.La
INFORMATION_SCHEMA.VECTOR_INDEX_OPTIONS
visualizzazione 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
. Sono inclusi i loro nomi,
Istruzioni DDL utilizzate per crearle e la relativa percentuale di copertura. Se
tabella di base indicizzata è inferiore a 10 MB, il relativo indice non viene compilato,
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 | +------------+------------+-------------------------------------------------------------------------------------------------+---------------------+ | table1 | indexa | CREATE VECTOR INDEX `indexa` ON `my_project.my_dataset.table1`(embeddings) | 100 | | | | OPTIONS (distance_type = 'EUCLIDEAN', index_type = 'IVF', ivf_options = '{"num_lists": 100}') | | +------------+------------+-------------------------------------------------------------------------------------------------+---------------------+ | table2 | indexb | CREATE VECTOR INDEX `indexb` ON `my_project.my_dataset.table2`(vectors) | 42 | | | | OPTIONS (distance_type = 'COSINE', index_type = 'IVF', ivf_options = '{"num_lists": 500}') | | +------------+------------+-------------------------------------------------------------------------------------------------+---------------------+ | table3 | indexc | CREATE VECTOR INDEX `indexc` ON `my_project.my_dataset.table3`(vectors) | 98 | | | | OPTIONS (distance_type = 'DOT_PRODUCT', index_type = 'TREE_AH', | | | | | tree_ah_options = '{"leaf_node_embedding_count": 1000, "normalization_type": "NONE"}') | | +------------+------------+-------------------------------------------------------------------------------------------------+---------------------+
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 | embeddings | embeddings | | table2 | indexb | vectors | vectors | | table3 | indexc | vectors | vectors | +------------+------------+-------------------+------------------+
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 | index_type | STRING | IVF | | table1 | indexa | distance_type | STRING | EUCLIDEAN | | table1 | indexa | ivf_options | STRING | {"num_lists": 100} | | table2 | indexb | index_type | STRING | IVF | | table2 | indexb | distance_type | STRING | COSINE | | table2 | indexb | ivf_options | STRING | {"num_lists": 500} | | table3 | indexc | index_type | STRING | TREE_AH | | table3 | indexc | distance_type | STRING | DOT_PRODUCT | | table3 | indexc | tree_ah_options | STRING | {"leaf_node_embedding_count": 1000, "normalization_type": "NONE"} | +------------+------------+------------------+------------------+-------------------------------------------------------------------+
Utilizzo indice vettoriale
Le informazioni sull'uso dell'indice vettoriale sono disponibili nei metadati del job della 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 librerie client.
Quando utilizzi la console Google Cloud, puoi trovare l'utilizzo dell'indice vettoriale informazioni nella modalità di utilizzo dell'indice vettoriale e Motivi del mancato utilizzo dell'indice vettoriale.
Quando usi lo strumento bq o l'API BigQuery, puoi
trovare informazioni sull'utilizzo dell'indice vettoriale
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
nel vettore utilizzato nella query indici e altri no.FULLY_USED
: ogni funzioneVECTOR_SEARCH
della query ha utilizzato un indice vettoriale.
Quando il valore della modalità di utilizzo dell'indice è UNUSED
o PARTIALLY_USED
,
I motivi per cui l'indice non viene utilizzato 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
indica che l'indice non è stato utilizzato
perché l'opzione use_brute_force
è stata specificata in 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 condiviso predefinito: quando i dati che pianifichi a indice è al di sotto del limite per organizzazione, può utilizzare il pool di slot condiviso gratuito per la gestione dell'indice.
- Utilizza la tua prenotazione: Per ottenere un'indicizzazione più prevedibile e coerente progressi sui carichi di lavoro di produzione più grandi, puoi utilizzare per la gestione degli indici.
Utilizza slot condivisi
Se non hai configurato il tuo progetto per l'utilizzo di una prenotazione dedicata per l'indicizzazione, la gestione degli indici viene gestita nel pool di slot condiviso gratuito, in base alle rispetto ai vincoli.
Se aggiungi dati a una tabella che determina la dimensione totale
per superare il limite della tua organizzazione,
BigQuery mette in pausa la gestione degli indici
per tutte le tabelle indicizzate. In questo caso, il campo index_status
nella
INFORMATION_SCHEMA.VECTOR_INDEXES
visualizzazione
visualizza PENDING DISABLEMENT
e l'indice è in coda per l'eliminazione. Mentre
l'indice è in attesa di disabilitazione,
ancora utilizzato nelle query e ti viene addebitato l'importo per 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 usano l'indice,
e non ti viene addebitato alcun costo per
l'archiviazione dell'indice. In questo caso,
Codice IndexUnusedReason
è BASE_TABLE_TOO_LARGE
.
Se elimini dati dalla tabella e la dimensione totale delle tabelle indicizzate
è inferiore al limite per organizzazione, la gestione dell'indice verrà ripresa per
tutte le tabelle indicizzate. Il campo index_status
nella
INFORMATION_SCHEMA.VECTOR_INDEXES
visualizzazione è ACTIVE
, le query possono utilizzare l'indice e ti vengono addebitati i costi
l'archiviazione degli indici.
BigQuery non garantisce la disponibilità del pool condiviso o la velocità effettiva di indicizzazione visualizzata. Per le applicazioni di produzione, potresti voler usare slot dedicati per l'elaborazione dell'indice.
Utilizza la tua prenotazione
Anziché utilizzare il pool di slot condiviso predefinito, puoi specificare facoltativamente i tuoi per indicizzare le tue tabelle. L'utilizzo della tua prenotazione garantisce le prestazioni prevedibili e coerenti dei job di gestione degli indici, come creazione, aggiornamento e ottimizzazioni dello sfondo.
- Non ci sono limiti di dimensioni delle tabelle quando viene eseguito un job di indicizzazione in prenotazione.
- L'utilizzo della tua prenotazione ti offre flessibilità nella gestione dell'indice. Se devi creare un indice molto grande aggiornare una tabella indicizzata, puoi aggiungerne temporaneamente 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
prenotazione con job_type
impostato su BACKGROUND
:
SQL
Utilizza la
CREATE ASSIGNMENT
Istruzione DDL.
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 progetto del progetto di amministrazione proprietario della risorsa di prenotazioneLOCATION
: il valore località della prenotazioneRESERVATION_NAME
: il nome del prenotazioneASSIGNMENT_ID
: l'ID del compitoL'ID deve essere univoco per il progetto e la località, iniziano e terminano con una lettera minuscola o un numero e contenere solo lettere minuscole, numeri e trattini.
PROJECT_ID
: l'ID del progetto che contiene 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 progetto del progetto di amministrazione proprietario della risorsa di prenotazioneLOCATION
: il valore località della prenotazioneRESERVATION_NAME
: il nome del prenotazionePROJECT_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 data, viene creato un nuovo job di indicizzazione
una singola tabella. Per visualizzare le informazioni sul job, esegui una query
INFORMATION_SCHEMA.JOBS*
visualizzazioni. Tu
può filtrare i job di indicizzazione per
impostazione job_type IS NULL AND SEARCH(job_id, '`search_index`')
in WHERE
della tua query. Nell'esempio seguente sono elencate le cinque indici di indicizzazione più recenti
job 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 tua prenotazione, devi considerare quando vengono eseguiti i job di gestione degli indici, quanti slot utilizzano e quale 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 i 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, solitamente determinata dagli attributi dei dati, ad esempio il numero di termini duplicati
Monitora l'utilizzo e i progressi
Il modo migliore per valutare il numero di slot necessari per gestire
dei job di gestione degli indici consiste nel monitorare l'utilizzo degli slot e regolare
dimensioni della prenotazione di conseguenza. La seguente query restituisce l'utilizzo giornaliero degli slot
per i job di gestione degli indici. Il valore include solo gli ultimi 30 giorni
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 gli slot non sono sufficienti per eseguire job di gestione dell'indice, un indice può non saranno sincronizzati con la relativa tabella e i job di indicizzazione potrebbero non riuscire. In questo caso, BigQuery ricrea l'indice da zero. A evitare di avere un indice non sincronizzato, assicurati di avere slot sufficienti per supportare l'indice e gli aggiornamenti dell'importazione e dell'ottimizzazione dei dati. Per ulteriori informazioni monitorare l'utilizzo degli slot, grafici delle risorse di amministrazione.
Eliminare un indice vettoriale
Quando non hai più bisogno di un indice vettoriale o vuoi modificare la colonna
indicizzato su una tabella, puoi eliminare l'indice della tabella utilizzando
DROP VECTOR INDEX
Istruzione DDL.
Ad esempio:
DROP VECTOR INDEX my_index ON my_dataset.indexed_table;
Se viene eliminata una tabella indicizzata, anche 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 Cerca negli incorporamenti con la ricerca vettoriale tutorial di Google Cloud.