VECTOR_SEARCH (Transact-SQL) (anteprima)

Si applica a: SQL Server 2025 (17.x) Azure SQL DatabaseSQL database in Microsoft Fabric

Cercare vettori simili a uno specifico vettore di query usando un algoritmo di ricerca di vettori vicini più vicino approssimativo. Per altre informazioni sul funzionamento dell'indicizzazione vettoriale e della ricerca vettoriale e sulle differenze tra ricerca esatta e approssimativa, vedere Ricerca vettoriale e indici vettoriali nel motore di database SQL.

Database SQL di Azure e database SQL in Fabric

La funzione è in anteprima. Assicurarsi di controllare le limitazioni correnti prima di usarlo.

Disponibilità regionale

Questa funzionalità viene distribuita nel database SQL di Azure e nel database SQL in Microsoft Fabric. Durante l'implementazione, la disponibilità e il comportamento possono variare in base all'area e alla versione dell'indice. Se una funzionalità o una sintassi non è disponibile, diventa disponibile automaticamente al termine della distribuzione. Per lo stato di disponibilità a livello di area corrente, vedere Disponibilità delle funzionalità in base all'area.

Funzionalità di anteprima di SQL Server 2025

In SQL Server 2025 questa funzione è in anteprima ed è soggetta a modifiche. Per usare questa funzionalità, è necessario abilitare la PREVIEW_FEATURESconfigurazione con ambito database.

Assicurarsi di controllare le limitazioni correnti prima di usarlo.

Miglioramenti principali con gli indici vettoriali più recenti

Gli indici vettoriali creati con la versione più recente introducono miglioramenti significativi:

• Supporto DML completo: rimuove la limitazione precedente che ha reso le tabelle indicizzate da vettori di sola lettura dopo la creazione dell'indice. È ora possibile eseguire operazioni INSERT, UPDATE, DELETE e MERGE mantenendo la funzionalità dell'indice vettoriale con la manutenzione automatica e in tempo reale degli indici
• Filtro iterativo: i predicati nella clausola WHERE vengono applicati durante il processo di ricerca vettoriale, non dopo il recupero
• Ottimizzatore: Query Optimizer determina automaticamente se usare l'indice DiskANN o la ricerca kNN in base alle caratteristiche delle query
• Quantizzazione avanzata: le tecniche di quantizzazione vettoriale sono state integrate per garantire una migliore efficienza di archiviazione e prestazioni delle query più veloci, con queste ottimizzazioni trasparenti per gli utenti

Syntax

Convenzioni relative alla sintassi Transact-SQL

Con l'ultima versione Indici vettoriali:

SELECT TOP (N) WITH APPROXIMATE
    column_list
FROM VECTOR_SEARCH(
        TABLE = object [ AS source_table_alias ]
        , COLUMN = vector_column
        , SIMILAR_TO = query_vector
        , METRIC = { 'cosine' | 'dot' | 'euclidean' }
    ) [ AS result_table_alias ]
[ WHERE predicate ]
ORDER BY distance;

Con la versione precedente Indici vettoriali:

VECTOR_SEARCH(
    TABLE = object [ AS source_table_alias ]
    , COLUMN = vector_column
    , SIMILAR_TO = query_vector
    , METRIC = { 'cosine' | 'dot' | 'euclidean' }
    , TOP_N = k
) [ AS result_table_alias ]

Arguments

TABLE = oggetto [AS source_table_alias]

Tabella in cui eseguire la ricerca. Deve essere una tabella di base. Le viste, le tabelle temporanee, sia locali che globali, non sono supportate.

COLONNA = vector_column

Colonna vettoriale in cui viene eseguita la ricerca. La colonna deve essere un tipo di dati vector .

SIMILAR_TO = query_vector

Vettore utilizzato per la ricerca. Deve essere una variabile o una colonna di tipo vettore .

METRIC = { 'coseno' | 'dot' | 'euclideo' }

Metrica della distanza usata per calcolare la distanza tra il vettore di query e i vettori nella colonna specificata. Viene usato un indice ANN (Nearest Neighbor approssimativo) solo se viene trovato un indice ANN corrispondente, con la stessa metrica e nella stessa colonna. Se non sono presenti indici ANN compatibili, viene generato un avviso e viene usato l'algoritmo kNN (k-nearest neighbor).

TOP_N = <k>

Numero massimo di vettori simili che devono essere restituiti. Deve essere un numero intero positivo. Questo parametro non è supportato con gli indici vettoriali creati usando la versione più recente.

result_table_alias

L'alias viene usato per fare riferimento al set di risultati.

Restituire il set di risultati

Il set di risultati restituito dalla VECTOR_SEARCH funzione include:

• Tutte le colonne della tabella specificata nell'argomento TABLE .

• Colonna aggiuntiva denominata distance, che rappresenta la distanza tra il vettore nella colonna specificata dall'argomento COLUMN e il vettore fornito nell'argomento SIMILAR_TO .

La colonna distance viene generata dalla VECTOR_SEARCH funzione stessa, mentre tutte le altre colonne provengono dalla tabella a cui viene fatto riferimento nell'argomento TABLE .

Se si usa un alias per la tabella nell'argomento TABLE , è necessario utilizzare lo stesso alias per fare riferimento alle colonne nell'istruzione SELECT . Non è possibile usare l'alias assegnato a per fare riferimento alle VECTOR_SEARCH colonne della tabella specificata in TABLE. Questo comportamento è più semplice da comprendere se si pensa al set di risultati compilato prendendo l'output di VECTOR_SEARCH e unendolo ai dati della tabella.

Se la tabella specificata nell'argomento TABLE contiene già una colonna denominata distance, il comportamento sarà simile a un join SQL tra due tabelle che condividono un nome di colonna. In questi casi, è necessario usare alias di tabella per evitare ambiguità con i riferimenti alle colonne. In caso contrario, verrà generato un errore.

Limitations

• Solo ordine crescente: la distance colonna deve essere ordinata in ordine crescente (ASC). L'ordine decrescente (DESC) non è supportato.

Comportamento specifico della versione

Il comportamento di VECTOR_SEARCH varia a seconda della versione dell'indice vettoriale.

Versioni precedenti dell'indice vettoriale

Solo post-filtro: la ricerca vettoriale viene eseguita prima di applicare qualsiasi predicato. I predicati aggiuntivi vengono applicati solo dopo la restituzione dei vettori più simili. L'esempio seguente restituisce le prime 10 righe con incorporamenti più simili al vettore @qvdi query , quindi applica il predicato specificato nella WHERE clausola . Se nessuna delle 10 righe associate ai vettori restituiti dalla ricerca vettoriale ha la accepted colonna uguale a 1, il risultato è vuoto.

SELECT TOP (10) s.id,
                s.title,
                r.distance
FROM VECTOR_SEARCH(
         TABLE = dbo.sessions AS s,
         COLUMN = embedding,
         SIMILAR_TO = @qv,
         METRIC = 'cosine',
         TOP_N = 10
     ) AS r
WHERE accepted = 1
ORDER BY r.distance;

Limitazioni generali

VECTOR_SEARCH non può essere usato nel corpo di una visualizzazione.

Examples

A. Ricerca di somiglianza vettoriale di base

Nell'esempio seguente vengono trovati i 10 articoli più simili a Pink Floyd music style nella wikipedia_articles_embeddings tabella .

DECLARE @qv VECTOR(1536) = AI_GENERATE_EMBEDDINGS(N'Pink Floyd music style' USE MODEL Ada2Embeddings);

SELECT TOP (10) WITH APPROXIMATE
    t.id,
    t.title,
    r.distance
FROM VECTOR_SEARCH(
        TABLE = dbo.wikipedia_articles_embeddings AS t,
        COLUMN = content_vector,
        SIMILAR_TO = @qv,
        METRIC = 'cosine'
    ) AS r
ORDER BY r.distance;

La sintassi per l'esecuzione di query dipende dalla versione dell'indice vettoriale:

Per gli indici di versione precedenti (sintassi deprecata):

DECLARE @qv VECTOR(1536) = AI_GENERATE_EMBEDDINGS(N'Pink Floyd music style' USE MODEL Ada2Embeddings);

SELECT TOP (10)
    t.id,
    t.title,
    r.distance
FROM VECTOR_SEARCH(
        TABLE = dbo.wikipedia_articles_embeddings AS t,
        COLUMN = content_vector,
        SIMILAR_TO = @qv,
        METRIC = 'cosine',
        TOP_N = 10  -- Deprecated: Use SELECT TOP (N) WITH APPROXIMATE instead
    ) AS r
ORDER BY r.distance;

B. Completare il flusso di lavoro con la creazione dell'indice

Esempio end-to-end di base che usa CREATE VECTOR INDEX e la funzione correlata VECTOR_SEARCH . Gli incorporamenti vengono fittizi. In uno scenario reale, gli incorporamenti vengono generati usando un modello di incorporamento e AI_GENERATE_EMBEDDINGS o una libreria esterna come OpenAI SDK.

Il blocco di codice seguente illustra la VECTOR_SEARCH funzione con incorporamenti fittizi:

1. Abilita la funzionalità di anteprima (necessaria solo per SQL Server 2025, non necessaria per il database SQL di Azure o il database SQL in Fabric).
2. Creare una tabella di esempio con una colonna con tipo di dati vector(5).Create a sample table dbo.Articles with a column embedding with data type vector(5).
3. Inserire 100 righe di dati di esempio con dati fittizi di incorporamento.
4. Creare un indice vettoriale in dbo.Articles.embedding.
5. Illustrare la ricerca di somiglianza del vettore con la VECTOR_SEARCH funzione .

-- Step 0: Enable Preview Feature (SQL Server 2025 only)
ALTER DATABASE SCOPED CONFIGURATION
SET PREVIEW_FEATURES = ON;
GO

-- Step 1: Create a sample table with a VECTOR(5) column
CREATE TABLE dbo.Articles
(
    id INT PRIMARY KEY,
    title NVARCHAR(100),
    content NVARCHAR(MAX),
    embedding VECTOR(5) -- mocked embeddings
);
GO

-- Step 2: Insert sample data (100 rows required for latest version indexes)
DECLARE @i INT = 1;
WHILE @i <= 100
BEGIN
    INSERT INTO Articles (id, title, content, embedding)
    VALUES (
        @i, 
        'Article ' + CAST(@i AS NVARCHAR(10)), 
        'Content for article ' + CAST(@i AS NVARCHAR(10)),
        JSON_ARRAY(
            CAST(@i * 0.01 AS FLOAT),
            CAST(@i * 0.02 AS FLOAT),
            CAST(@i * 0.03 AS FLOAT),
            CAST(@i * 0.04 AS FLOAT),
            CAST(@i * 0.05 AS FLOAT)
        )
    );
    SET @i = @i + 1;
END
GO

-- Step 3: Create a vector index on the embedding column
CREATE VECTOR INDEX vec_idx ON Articles(embedding)
WITH (METRIC = 'cosine', TYPE = 'diskann');
GO

-- Step 4: Perform a vector similarity search
DECLARE @qv VECTOR(5) = '[0.3, 0.3, 0.3, 0.3, 0.3]';
SELECT TOP(3) WITH APPROXIMATE
    t.id,
    t.title,
    t.content,
    s.distance
FROM
    VECTOR_SEARCH(
        TABLE = Articles AS t,
        COLUMN = embedding,
        SIMILAR_TO = @qv,
        METRIC = 'cosine'
    ) AS s
ORDER BY s.distance, t.title;

La sintassi per l'esecuzione di query dipende dalla versione dell'indice vettoriale:

Per gli indici di versione precedenti (sintassi deprecata):

DECLARE @qv VECTOR(5) = '[0.3, 0.3, 0.3, 0.3, 0.3]';
SELECT TOP(3)
    t.id,
    t.title,
    t.content,
    s.distance
FROM
    VECTOR_SEARCH(
        TABLE = Articles AS t,
        COLUMN = embedding,
        SIMILAR_TO = @qv,
        METRIC = 'cosine',
        TOP_N = 3  -- Deprecated: Use SELECT TOP (N) WITH APPROXIMATE instead
    ) AS s
ORDER BY s.distance, t.title;

C. Ricerca vettoriale con filtro iterativo

Nell'esempio seguente viene illustrato il filtro iterativo con gli indici vettoriali di versione più recenti. La query trova articoli simili durante l'applicazione dei predicati durante il processo di ricerca.

Con gli indici di versione più recenti, i predicati nella clausola WHERE vengono applicati durante il processo di ricerca vettoriale (non dopo). Il motore continua la ricerca finché non trova 5 righe idonee che corrispondono a tutti i criteri:

• Somiglianza vettoriale agli "algoritmi di Machine Learning"
• Categoria uguale a 'Tecnologia'
• Stato pubblicato uguale a 1

In questo modo si ottengono esattamente 5 risultati (se esistenti) senza ottimizzare manualmente i parametri di ricerca. Per un confronto dettagliato tra versioni precedenti e più recenti, vedere Comportamento di filtro iterativo nella sezione Comportamenti previsti.

DECLARE @qv VECTOR(1536) = AI_GENERATE_EMBEDDINGS(N'machine learning algorithms' USE MODEL Ada2Embeddings);

SELECT TOP (5) WITH APPROXIMATE
    t.id,
    t.title,
    t.category,
    r.distance
FROM VECTOR_SEARCH(
        TABLE = dbo.wikipedia_articles AS t,
        COLUMN = content_vector,
        SIMILAR_TO = @qv,
        METRIC = 'cosine'
    ) AS r
WHERE t.category = 'Technology'
  AND t.published = 1
ORDER BY r.distance;

D. Join a più tabelle con INNER JOIN

Nell'esempio seguente viene illustrato INNER JOIN con il filtro su più tabelle. Usare quando gli incorporamenti vengono archiviati in una tabella separata dai dati dell'entità principale.

-- Assuming a schema with separate tables for articles and embeddings
DECLARE @qv VECTOR(1536) = AI_GENERATE_EMBEDDINGS(N'artificial intelligence and machine learning' USE MODEL Ada2Embeddings);

SELECT TOP (10) WITH APPROXIMATE
    a.id,
    a.title,
    a.category,
    vs.distance
FROM wikipedia_articles a
INNER JOIN VECTOR_SEARCH(
    TABLE = wikipedia_articles_embeddings AS e,
    COLUMN = content_vector,
    SIMILAR_TO = @qv,
    METRIC = 'cosine'
) AS vs ON a.id = e.article_id
WHERE e.approved = 1                           -- Iterative filter on embedding table
  AND a.category IN ('Technology', 'Science')  -- Filter on main table
  AND a.views > 50000
ORDER BY vs.distance;

Funzionalità principali di questo esempio:

• Ambito alias di tabella: l'alias e di TABLE = wikipedia_articles_embeddings AS e è disponibile nella clausola WHERE per il filtro iterativo con gli indici di versione più recenti

Comportamenti previsti

Errore durante l'uso della sintassi legacy

Se si tenta di usare il parametro in VECTOR_SEARCH durante l'esecuzione TOP_N di query su una tabella con un indice vettore di versione più recente, SQL Server restituisce l'errore seguente:

Msg 42274, Level 16, State 1
Vector search with version 3 index does not support explicit TOP_N parameter.

Per risolvere questo errore:

1. Rimuovere il TOP_N parametro dalla VECTOR_SEARCH funzione
2. Usare SELECT TOP (N) WITH APPROXIMATE invece la sintassi

Risposta errata (genera un errore con l'indice della versione più recente):

SELECT TOP (10) 
    t.id,
    r.distance
FROM VECTOR_SEARCH(
        TABLE = dbo.wikipedia_articles AS t,
        COLUMN = title_vector,
        SIMILAR_TO = @qv,
        METRIC = 'cosine',
        TOP_N = 10  -- This parameter causes the error with latest version indexes
    ) AS r;

Corretto (funziona con l'indice della versione più recente):

SELECT TOP (10) WITH APPROXIMATE  -- Specify TOP and WITH APPROXIMATE here
    t.id,
    r.distance
FROM VECTOR_SEARCH(
        TABLE = dbo.wikipedia_articles AS t,
        COLUMN = title_vector,
        SIMILAR_TO = @qv,
        METRIC = 'cosine'
        -- No TOP_N parameter
    ) AS r
ORDER BY r.distance;

Comportamento di filtro iterativo

La versione più recente introduce miglioramenti significativi rispetto alle versioni precedenti dell'indice vettoriale:

Per un esempio pratico di filtro iterativo, vedere Esempio C: Ricerca vettoriale con filtro iterativo.

Requisiti della clausola ORDER BY

Quando si usa SELECT TOP (N) WITH APPROXIMATE, la clausola ORDER BY presenta requisiti specifici:

• ORDER BY deve essere presente: le query senza una clausola ORDER BY hanno esito negativo con errore .
• Solo la colonna distanza consentita: la clausola ORDER BY deve fare riferimento solo alla colonna distanza dal set di risultati VECTOR_SEARCH. L'inclusione di colonne aggiuntive ha esito negativo con errore. Per ordinare in base a più colonne, usare il modello di sottoquery descritto in Più colonne ORDER BY.
• Solo ordine crescente: la colonna della distanza deve essere ordinata in ordine crescente (ASC). L'ordine decrescente (DESC) non è supportato.

ORDER BY valido:

SELECT TOP (10) WITH APPROXIMATE
    t.id,
    t.title,
    r.distance
FROM VECTOR_SEARCH(
    TABLE = products,
    COLUMN = embedding,
    SIMILAR_TO = @query_vector,
    METRIC = 'cosine'
) AS r
INNER JOIN products t ON t.id = r.id
ORDER BY r.distance;  -- ✓ Valid

Criteri ORDER BY non validi:

-- Missing ORDER BY
SELECT TOP (10) WITH APPROXIMATE
    r.distance
FROM VECTOR_SEARCH(
    TABLE = products,
    COLUMN = embedding,
    SIMILAR_TO = @query_vector,
    METRIC = 'cosine'
) AS r;
-- ✗ Error Msg 42248: APPROXIMATE cannot be used in a query without ORDER BY

-- Multiple columns in ORDER BY
SELECT TOP (10) WITH APPROXIMATE
    t.title,
    r.distance
FROM VECTOR_SEARCH(
    TABLE = products,
    COLUMN = embedding,
    SIMILAR_TO = @query_vector,
    METRIC = 'cosine'
) AS r
INNER JOIN products t ON t.id = r.id
ORDER BY r.distance, t.title;
-- ✗ Error Msg 42271: TOP WITH APPROXIMATE and VECTOR_SEARCH requires ORDER BY 
-- on distance column ascending, and no other columns

-- Descending order
SELECT TOP (10) WITH APPROXIMATE
    r.distance
FROM VECTOR_SEARCH(
    TABLE = products,
    COLUMN = embedding,
    SIMILAR_TO = @query_vector,
    METRIC = 'cosine'
) AS r
ORDER BY r.distance DESC;
-- ✗ Error Msg 42271: TOP WITH APPROXIMATE and VECTOR_SEARCH requires ORDER BY 
-- on distance column ascending, and no other columns

Comportamento senza un indice vettoriale

VECTOR_SEARCH può eseguire query anche quando non esiste alcun indice vettoriale nella colonna di destinazione. Senza un indice, la query esegue un'analisi completa della tabella (ricerca k-nearest neighbor (kNN) per calcolare le distanze per tutte le righe.

Comportamento delle query senza TOP WITH APPROSSIMATO

Quando si usa VECTOR_SEARCH senza SELECT TOP (N) WITH APPROXIMATE, il comportamento della query dipende dalla presenza di TOP clausole e ORDER BY :

• No TOP, no ORDER BY, or ORDER BY non-distance: analisi completa della tabella (ricerca di forza bruta) che calcola e restituisce le distanze per tutte le righe
• TOP (nessuna APPROSSIMATA) con ORDER BY distance: esegue come ricerca kNN (k-nearest neighbors), che è una ricerca esatta vicina più vicina

Esempio - Analisi completa con colonna distance:

-- Returns all rows with calculated distances
SELECT 
    t.id,
    t.title,
    r.distance
FROM VECTOR_SEARCH(
    TABLE = dbo.wikipedia_articles AS t,
    COLUMN = title_vector,
    SIMILAR_TO = @qv,
    METRIC = 'cosine'
) AS r
ORDER BY t.id;  -- Not ordering by distance

Esempio : ricerca kNN (vicini esatti):

-- Returns exact top 10 nearest neighbors using kNN
SELECT TOP (10)
    t.id,
    t.title,
    r.distance
FROM VECTOR_SEARCH(
    TABLE = dbo.wikipedia_articles AS t,
    COLUMN = title_vector,
    SIMILAR_TO = @qv,
    METRIC = 'cosine'
) AS r
ORDER BY r.distance;  -- No WITH APPROXIMATE = exact kNN

TOP WITH APPROXIMATE senza VECTOR_SEARCH

L'uso SELECT TOP (N) WITH APPROXIMATE di senza una VECTOR_SEARCH funzione nella query genera un errore. La WITH APPROXIMATE clausola richiede che sia presente una VECTOR_SEARCH funzione.

Risposta errata: la query ha esito negativo:

-- Error: WITH APPROXIMATE requires VECTOR_SEARCH
SELECT TOP (10) WITH APPROXIMATE
    id,
    title,
    VECTOR_DISTANCE('cosine', title_vector, @qv) AS distance
FROM dbo.wikipedia_articles
WHERE title_vector IS NOT NULL
ORDER BY VECTOR_DISTANCE('cosine', title_vector, @qv);

Risposta esatta: usare VECTOR_SEARCH:

-- Correct: WITH APPROXIMATE with VECTOR_SEARCH
SELECT TOP (10) WITH APPROXIMATE
    t.id,
    t.title,
    r.distance
FROM VECTOR_SEARCH(
    TABLE = dbo.wikipedia_articles AS t,
    COLUMN = title_vector,
    SIMILAR_TO = @qv,
    METRIC = 'cosine'
) AS r
ORDER BY r.distance;

Restrizioni TRUNCATE TABLE

Le tabelle con indici vettoriali non possono essere troncate tramite TRUNCATE TABLE. Per rimuovere tutti i dati da una tabella con indicizzazione vettoriale:

1. Eliminare l'indice vettoriale
2. Tronca la tabella
3. Ripopolare la tabella con almeno 100 righe
4. Ricreare l'indice vettoriale

Flusso di lavoro di esempio:

-- Step 1: Drop the vector index
DROP INDEX idx_vector ON wikipedia_articles;

-- Step 2: Truncate the table
TRUNCATE TABLE wikipedia_articles;

-- Step 3: Repopulate with data (at least 100 rows)
-- ... insert operations ...

-- Step 4: Recreate the vector index
CREATE VECTOR INDEX idx_vector 
ON wikipedia_articles(title_vector)
WITH (METRIC = 'cosine');

Hint di tabella per la ricerca vettoriale

È possibile usare hint di tabella con la funzione per controllare il VECTOR_SEARCH comportamento di esecuzione delle query. L'hint FORCE_ANN_ONLY di tabella impone a Query Optimizer di usare solo l'indice ANN (NearEst Neighbor) approssimativo, anche quando l'utilità di ottimizzazione potrebbe altrimenti scegliere una strategia di esecuzione diversa.

Sintassi:

FROM VECTOR_SEARCH(
    TABLE      = table_name,
    COLUMN     = column_name,
    SIMILAR_TO = vector_value,
    METRIC     = 'metric_name'
) AS alias WITH (FORCE_ANN_ONLY)

Esempio:

L'esempio seguente forza l'uso dell'indice vicino più vicino approssimativo per la query di ricerca vettoriale:

DECLARE @qembedding VECTOR(1536) = AI_GENERATE_EMBEDDINGS(N'artificial intelligence' USE MODEL Ada2Embeddings);

SELECT TOP 50 WITH APPROXIMATE
    t.id,
    t.title,
    r.distance
FROM VECTOR_SEARCH(
    TABLE      = dbo.wikipedia_articles AS t,
    COLUMN     = title_vector,
    SIMILAR_TO = @qembedding,
    METRIC     = 'cosine'
) AS r WITH (FORCE_ANN_ONLY)
ORDER BY r.distance;

Usare FORCE_ANN_ONLY quando si vuole assicurarsi che la query usi la strategia approssimativa dell'indice adiacente più vicino, ignorando la selezione automatica della strategia di Optimizer.

Combinazione della ricerca vettoriale con altre operazioni SQL

La VECTOR_SEARCH funzione con TOP (N) WITH APPROXIMATE ha requisiti specifici per l'utilizzo. Alcune operazioni SQL possono essere usate direttamente con la ricerca vettoriale, mentre altre richiedono un modello di sottoquery.

Operazioni che richiedono il modello di sottoquery

Quando è necessario eseguire operazioni che non sono direttamente compatibili con TOP (N) WITH APPROXIMATE, usare la ricerca vettoriale in una sottoquery (query interna), quindi applicare le operazioni nella query esterna. Questo modello mantiene i vantaggi delle prestazioni della ricerca vettoriale approssimativa, abilitando al tempo stesso la funzionalità SQL completa.

Scenari comuni

Nella tabella seguente sono elencate le operazioni che richiedono il modello di sottoquery:

Funzioni GROUP BY e di aggregazione

Nell'esempio seguente viene trovata la distanza media degli articoli corrispondenti principali per categoria. Per questo esempio, alla tabella è stata aggiunta wikipedia_articles una category colonna per classificare gli articoli.

DECLARE @qv VECTOR(1536) = AI_GENERATE_EMBEDDINGS(N'machine learning' USE MODEL Ada2Embeddings);

SELECT 
    category,
    COUNT(*) AS article_count,
    AVG(distance) AS avg_distance,
    MIN(distance) AS closest_match
FROM (
    SELECT TOP (100) WITH APPROXIMATE
        t.id,
        t.title,
        t.category,
        r.distance
    FROM VECTOR_SEARCH(
        TABLE = dbo.wikipedia_articles AS t,
        COLUMN = title_vector,
        SIMILAR_TO = @qv,
        METRIC = 'cosine'
    ) AS r
    ORDER BY r.distance
) AS vector_results
GROUP BY category
ORDER BY avg_distance;

Funzioni finestra

L'esempio seguente classifica gli articoli in base alla somiglianza e assegna quartili.

DECLARE @qv VECTOR(1536) = AI_GENERATE_EMBEDDINGS(N'neural networks' USE MODEL Ada2Embeddings);

SELECT 
    id,
    title,
    category,
    distance,
    ROW_NUMBER() OVER (ORDER BY distance) AS rank,
    NTILE(4) OVER (ORDER BY distance) AS quartile
FROM (
    SELECT TOP (100) WITH APPROXIMATE
        t.id,
        t.title,
        t.category,
        r.distance
    FROM VECTOR_SEARCH(
        TABLE = dbo.wikipedia_articles AS t,
        COLUMN = title_vector,
        SIMILAR_TO = @qv,
        METRIC = 'cosine'
    ) AS r
    ORDER BY r.distance
) AS vector_results
WHERE distance < 0.5
ORDER BY rank;

Operazioni set (UNION, INTERSECT, EXCEPT)

Nell'esempio seguente vengono combinati i risultati di due query di ricerca diverse usando UNION.

DECLARE @qv1 VECTOR(1536) = AI_GENERATE_EMBEDDINGS(N'artificial intelligence' USE MODEL Ada2Embeddings);
DECLARE @qv2 VECTOR(1536) = AI_GENERATE_EMBEDDINGS(N'machine learning' USE MODEL Ada2Embeddings);

SELECT id, title, 'AI Search' AS source
FROM (
    SELECT TOP (50) WITH APPROXIMATE
        t.id,
        t.title,
        r.distance
    FROM VECTOR_SEARCH(
        TABLE = dbo.wikipedia_articles AS t,
        COLUMN = title_vector,
        SIMILAR_TO = @qv1,
        METRIC = 'cosine'
    ) AS r
    ORDER BY r.distance
) AS ai_results

UNION

SELECT id, title, 'ML Search' AS source
FROM (
    SELECT TOP (50) WITH APPROXIMATE
        t.id,
        t.title,
        r.distance
    FROM VECTOR_SEARCH(
        TABLE = dbo.wikipedia_articles AS t,
        COLUMN = title_vector,
        SIMILAR_TO = @qv2,
        METRIC = 'cosine'
    ) AS r
    ORDER BY r.distance
) AS ml_results
ORDER BY id;

distinto

Nell'esempio seguente vengono ottenute categorie distinte dagli articoli corrispondenti principali.

DECLARE @qv VECTOR(1536) = AI_GENERATE_EMBEDDINGS(N'deep learning' USE MODEL Ada2Embeddings);

SELECT DISTINCT category
FROM (
    SELECT TOP (100) WITH APPROXIMATE
        t.id,
        t.category,
        r.distance
    FROM VECTOR_SEARCH(
        TABLE = dbo.wikipedia_articles AS t,
        COLUMN = title_vector,
        SIMILAR_TO = @qv,
        METRIC = 'cosine'
    ) AS r
    ORDER BY r.distance
) AS vector_results
WHERE distance < 0.7
ORDER BY category;

Più colonne ORDER BY

Nell'esempio seguente viene ordinato per distanza, quindi per titolo per i legami.

DECLARE @qv VECTOR(1536) = AI_GENERATE_EMBEDDINGS(N'quantum computing' USE MODEL Ada2Embeddings);

SELECT 
    id,
    title,
    category,
    distance
FROM (
    SELECT TOP (100) WITH APPROXIMATE
        t.id,
        t.title,
        t.category,
        r.distance
    FROM VECTOR_SEARCH(
        TABLE = dbo.wikipedia_articles AS t,
        COLUMN = title_vector,
        SIMILAR_TO = @qv,
        METRIC = 'cosine'
    ) AS r
    ORDER BY r.distance
) AS vector_results
ORDER BY distance, title;

CROSS APPLY

Quando si usa SELECT TOP (N) WITH APPROXIMATE con VECTOR_SEARCH, non è possibile usare CROSS APPLY o OUTER APPLY nella stessa FROM clausola. Questo vale anche se non è presente alcun riferimento esterno all'interno della VECTOR_SEARCH funzione.

Una query con CROSS APPLY esegue logicamente più ricerche vettoriali (una per riga dalla tabella esterna) e unisce tutti i risultati in un singolo flusso ordinato. L'algoritmo adiacente più vicino approssimativo non può unire in modo efficiente i risultati di più ricerche vettoriali indipendenti mantenendo al tempo stesso le garanzie approssimative e le caratteristiche delle prestazioni.

Modello che genera un errore:

-- This query is NOT supported
SELECT TOP (100) WITH APPROXIMATE
    o.id,
    vs.title,
    vs.distance
FROM Orders AS o
    CROSS APPLY VECTOR_SEARCH(
        TABLE = Products,
        COLUMN = embedding,
        SIMILAR_TO = o.customer_preference_vector,
        METRIC = 'cosine'
    ) AS vs
WHERE o.order_date > '2026-01-01'
ORDER BY vs.distance;

Questo modello tenta di trovare prodotti simili per le preferenze dei clienti di ogni ordine, ma non può essere eseguito con un piano di ricerca vettoriale approssimativo.

Modello consigliato:

Per ottenere risultati simili, usare una sottoquery con TOP (N) WITH APPROXIMATE in CROSS APPLY se stessa:

-- This query IS supported
SELECT
    o.id,
    vs.title,
    vs.distance
FROM Orders AS o
    CROSS APPLY (
        SELECT TOP (10) WITH APPROXIMATE
            p.title,
            r.distance
        FROM VECTOR_SEARCH(
            TABLE = Products AS p,
            COLUMN = embedding,
            SIMILAR_TO = o.customer_preference_vector,
            METRIC = 'cosine'
        ) AS r
        ORDER BY r.distance
    ) AS vs
WHERE o.order_date > '2026-01-01';

In questo modello:

• Ogni ricerca vettoriale è limitata ai primi 10 risultati all'interno della sottoquery
• La query esterna non usa WITH APPROXIMATE
• I risultati hanno un ambito corretto per riga dalla tabella esterna

Operazioni che funzionano direttamente

Le operazioni seguenti possono essere usate direttamente con VECTOR_SEARCH senza richiedere una sottoquery:

• INNER JOIN - Vedere l'esempio D: join a più tabelle con INNER JOIN
• Predicati WHERE - Applicare un filtro iterativo o post-filtro
• Singola distanza ORDER BY

Contenuti correlati

• Ricerca vettoriale e indici vettoriali nel motore di database SQL
• tipo di dati vettoriale
• CREA UN INDICE VETTORIALE (Transact-SQL)
• sys.dm_db_vector_indexes (Transact-SQL)
• Esempi di ricerca vettoriale del database SQL di Azure