VECTOR_SEARCH (Transact-SQL) (förhandsversion)

Gäller för: SQL Server 2025 (17.x) Azure SQL DatabaseSQL database in Microsoft Fabric

Sök efter vektorer som liknar en viss frågevektor med hjälp av en ungefärlig vektorsökningsalgoritm för närmaste grannar. Mer information om hur vektorindexering och vektorsökning fungerar och skillnaderna mellan exakt och ungefärlig sökning finns i Vektorsökning och vektorindex i SQL Database Engine.

Azure SQL-databas och SQL-databas i Fabric

Funktionen är i förhandsvisning. Kontrollera de aktuella begränsningarna innan du använder den.

Regional tillgänglighet

Den här funktionen distribueras i Azure SQL Database och SQL Database i Microsoft Fabric. Under distributionen kan tillgängligheten och beteendet variera beroende på region och indexversion. Om en funktion eller syntax inte är tillgänglig blir den tillgänglig automatiskt när distributionen slutförs. Aktuell regional tillgänglighetsstatus finns i Funktionstillgänglighet per region.

SQL Server 2025 Förhandsgranskningsfunktion

I SQL Server 2025 är denna funktion i förhandsgranskning och kan ändras. För att kunna använda den här funktionen måste du aktivera PREVIEW_FEATURESden databasomfångsbegränsade konfigurationen.

Kontrollera de aktuella begränsningarna innan du använder den.

Viktiga förbättringar med de senaste vektorindexen

Vektorindex som skapats med den senaste versionen medför betydande förbättringar:

• Fullständigt DML-stöd: Tar bort den tidigare begränsningen som gjorde vektorindexerade tabeller skrivskyddade när indexet skapades. Nu kan du utföra åtgärderna INSERT, UPDATE, DELETE och MERGE samtidigt som du behåller vektorindexfunktioner med automatiskt indexunderhåll i realtid
• Iterativ filtrering: Predikat i WHERE-satsen tillämpas under vektorsökningsprocessen, inte efter hämtning
• Optimizer-driven: Frågeoptimeraren avgör automatiskt om diskANN-indexet eller kNN-sökningen ska användas baserat på frågeegenskaper
• Avancerad kvantisering: Vektorkvantiseringstekniker har integrerats för att ge bättre lagringseffektivitet och snabbare frågeprestanda, och dessa optimeringar är transparenta för användarna

Syntax

Transact-SQL syntaxkonventioner

Med den senaste versionen av Vector Index:

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;

Med tidigare version av Vector Index:

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 = objekt [SOM source_table_alias]

Tabell där sökningen utförs. Det måste vara en bastabell. Vyer, temporära tabeller, både lokala och globala, stöds inte.

KOLUMN = vector_column

Vektorkolumnen där sökningen utförs. Kolumnen måste vara en vektordatatyp .

SIMILAR_TO = query_vector

Den vektor som används för sökning. Det måste vara en variabel eller en kolumn av vektortyp .

METRIC = { 'cosinine' | "dot" | "euclidean" }

Det avståndsmått som används för att beräkna avståndet mellan frågevektorn och vektorerna i den angivna kolumnen. Ett ANN-index (ungefärlig närmaste granne) används endast om ett matchande ANN-index, med samma mått och i samma kolumn, hittas. Om det inte finns några kompatibla ANN-index utlöses en varning och kNN-algoritmen (k-närmaste granne) används.

TOP_N = <k>

Det maximala antalet liknande vektorer som måste returneras. Det måste vara ett positivt heltal. Den här parametern stöds inte med vektorindex som skapats med den senaste versionen.

result_table_alias

Aliaset används för att referera till resultatuppsättningen.

Returnera resultatuppsättning

Resultatuppsättningen VECTOR_SEARCH som returneras av funktionen innehåller:

• Alla kolumner från tabellen som anges i TABLE argumentet.

• En ytterligare kolumn med namnet distance, som representerar avståndet mellan vektorn i kolumnen som anges av COLUMN argumentet och vektorn som anges i SIMILAR_TO argumentet.

Avståndskolumnen VECTOR_SEARCH genereras av själva funktionen, medan alla andra kolumner kommer från tabellen som refereras i TABLE argumentet.

Om du använder ett alias för tabellen i TABLE argumentet måste du använda samma alias för att referera till dess kolumner i -instruktionen SELECT . Du kan inte använda det alias som tilldelats till för att referera till VECTOR_SEARCH kolumner från tabellen som anges i TABLE. Det här beteendet är lättare att förstå om du tänker på resultatuppsättningen som skapats genom att ta utdata från VECTOR_SEARCH och slå samman den med tabelldata.

Om tabellen som anges i TABLE argumentet redan innehåller en kolumn med namnet distancekommer beteendet att likna en SQL-koppling mellan två tabeller som delar ett kolumnnamn. I sådana fall måste du använda tabellalias för att skilja kolumnreferenserna åt. Annars uppstår ett fel.

Limitations

• Endast stigande ordning: Kolumnen distance måste ordnas i stigande ordning (ASC). Fallande ordning (DESC) stöds inte.

Versionsspecifikt beteende

Beteendet VECTOR_SEARCH för varierar beroende på vektorindexversionen.

Tidigare vektorindexversioner

Endast efterfiltrering: Vektorsökning sker innan ett predikat tillämpas. Ytterligare predikat tillämpas endast när de mest liknande vektorerna returneras. Följande exempel returnerar de 10 översta raderna med inbäddningar som mest liknar frågevektorn @qvoch tillämpar sedan predikatet WHERE som anges i -satsen. Om ingen av de 10 rader som är associerade med vektorerna som returneras av vektorsökningen accepted har kolumnen lika med 1 är resultatet tomt.

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;

Allmänna begränsningar

VECTOR_SEARCH kan inte användas i brödtexten i en vy.

Examples

A. Grundläggande vektorlikhetssökning

I följande exempel hittar du de 10 mest liknande artiklarna Pink Floyd music style i wikipedia_articles_embeddings tabellen.

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;

Syntaxen för frågor beror på vektorindexversionen:

För tidigare versionsindex (inaktuell syntax):

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. Slutför arbetsflödet med skapande av index

Ett grundläggande exempel från slutpunkt till slutpunkt med hjälp av CREATE VECTOR INDEX och den relaterade VECTOR_SEARCH funktionen. Inbäddningarna hånas. I ett verkligt scenario genereras inbäddningar med hjälp av en inbäddningsmodell och AI_GENERATE_EMBEDDINGS, eller ett externt bibliotek som OpenAI SDK.

Följande kodblock visar VECTOR_SEARCH funktionen med falska inbäddningar:

1. Aktiverar förhandsgranskningsfunktionen (krävs endast för SQL Server 2025, behövs inte för Azure SQL Database eller SQL Database i Fabric).
2. Skapa en exempeltabell dbo.Articles med en kolumn embedding med datatypsvektor(5).
3. Infoga 100 rader med exempeldata med falska inbäddningsdata.
4. Skapa ett vektorindex på dbo.Articles.embedding.
5. Demonstrera vektorlikhetssökningen VECTOR_SEARCH med funktionen.

-- 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)
INSERT INTO Articles (id, title, content, embedding)
SELECT
    value AS id,
    'Article ' || [value],
    'Content for article ' || [value],
    CAST(JSON_ARRAY(
        CAST(value * 0.01 AS FLOAT),
        CAST(value * 0.02 AS FLOAT),
        CAST(value * 0.03 AS FLOAT),
        CAST(value * 0.04 AS FLOAT),
        CAST(value * 0.05 AS FLOAT)
    ) AS VECTOR(5))
FROM GENERATE_SERIES(1, 100);
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;

Syntaxen för frågor beror på vektorindexversionen:

För tidigare versionsindex (inaktuell syntax):

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. Vektorsökning med iterativ filtrering

I följande exempel visas iterativ filtrering med de senaste versionsvektorindexen. Frågan hittar liknande artiklar när predikat tillämpas under sökprocessen.

Med de senaste versionsindexen tillämpas predikaten i WHERE-satsen under vektorsökningsprocessen (inte efter). Motorn fortsätter att söka tills den hittar 5 kvalificerande rader som matchar alla kriterier:

• Vektorlikhet med "maskininlärningsalgoritmer"
• Kategorin är lika med "Teknik"
• Publicerad status är lika med 1

Detta säkerställer att du får exakt 5 resultat (om de finns) utan att justera sökparametrarna manuellt. En detaljerad jämförelse mellan tidigare och senaste versioner finns i Iterativt filtreringsbeteende i avsnittet Förväntade beteenden.

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. Flertabellskopplingar med INRE KOPPLING

Följande exempel visar INRE KOPPLING med filtrering på flera tabeller. Använd när inbäddningar lagras i en separat tabell från huvudentitetsdata.

-- 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;

Viktiga funktioner i det här exemplet:

• Omfång för tabellalias: Aliaset e från TABLE = wikipedia_articles_embeddings AS e är tillgängligt i WHERE-satsen för iterativ filtrering med de senaste versionsindexen

Förväntade beteenden

Fel vid användning av äldre syntax

Om du försöker använda parametern TOP_N i VECTOR_SEARCH när du frågar en tabell med ett senaste versionsvektorindex returnerar SQL Server följande fel:

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

Så här löser du det här felet:

1. Ta bort parametern TOP_N från VECTOR_SEARCH funktionen
2. Använd SELECT TOP (N) WITH APPROXIMATE syntax i stället

Fel (genererar fel med det senaste versionsindexet):

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;

Rätt (fungerar med det senaste versionsindexet):

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;

Iterativt filtreringsbeteende

Den senaste versionen introducerar betydande förbättringar jämfört med tidigare versioner av vektorindex:

Ett praktiskt exempel på iterativ filtrering finns i Exempel C: Vektorsökning med iterativ filtrering.

ORDER BY-satskrav

När du använder SELECT TOP (N) WITH APPROXIMATEhar ORDER BY-satsen specifika krav:

• ORDER BY måste finnas: Frågor utan EN ORDER BY-sats misslyckas med felet .
• Endast avståndskolumn tillåts: ORDER BY-satsen får endast referera till avståndskolumnen från den VECTOR_SEARCH resultatuppsättningen. Det går inte att inkludera ytterligare kolumner med fel. Om du vill sortera efter flera kolumner använder du det underfrågasmönster som beskrivs i flera ORDER BY-kolumner.
• Endast stigande ordning: Avståndskolumnen måste sorteras i stigande ordning (ASC). Fallande ordning (DESC) stöds inte.

Giltig ORDER BY:

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

Ogiltiga ORDER BY-mönster:

-- 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

Beteende utan vektorindex

VECTOR_SEARCH kan köra frågor även när det inte finns något vektorindex i målkolumnen. Utan ett index utför frågan en fullständig tabellgenomsökning (k-närmaste granne(kNN) för att beräkna avstånd för alla rader.

Frågebeteende utan TOP MED UNGEFÄRLIG

När du använder VECTOR_SEARCH utan SELECT TOP (N) WITH APPROXIMATEberor frågebeteendet på förekomsten av TOP och ORDER BY -satser:

• Ingen TOPP, ingen ORDER BY eller ORDER BY non-distance: Fullständig tabellgenomsökning (brute-force search) som beräknar och returnerar avstånd för alla rader
• TOP (ingen UNGEFÄRLIG) med ORDER BY-avstånd: Körs som en kNN-sökning (k-närmaste grannar), vilket är en exakt närmaste grannsökning

Exempel – Fullständig genomsökning med avståndskolumn:

-- 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

Exempel – kNN-sökning (exakt närmaste grannar):

-- 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

TOPP MED UNGEFÄRLIG UTAN VECTOR_SEARCH

Att använda SELECT TOP (N) WITH APPROXIMATE utan en VECTOR_SEARCH funktion i frågan resulterar i ett fel. Satsen WITH APPROXIMATE kräver att en VECTOR_SEARCH funktion finns.

Fel – Den här frågan misslyckas:

-- 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);

Rätt – Använd 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;

TRUNKERA TABELLbegränsningar

Tabeller med vektorindex kan inte trunkeras med .TRUNCATE TABLE Så här tar du bort alla data från en vektorindexerad tabell:

1. Ta bort vektorindexet
2. Trunkera tabellen
3. Fyll i tabellen igen med minst 100 rader
4. Återskapa vektorindexet

Exempelarbetsflöde:

-- 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');

Tabelltips för vektorsökning

Du kan använda tabelltips med VECTOR_SEARCH funktionen för att styra frågekörningsbeteendet. Tabelltipset FORCE_ANN_ONLY tvingar frågeoptimeraren att endast använda det ungefärliga närmaste grannindexet (ANN), även om optimeraren annars kan välja en annan körningsstrategi.

Syntax:

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

Ett exempel:

I följande exempel används det ungefärliga närmaste grannindexet för vektorsökningsfrågan:

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;

Använd FORCE_ANN_ONLY när du vill se till att frågan använder den ungefärliga strategin för närmaste grannindex, vilket överskrider optimeringens automatiska strategival.

Kombinera vektorsökning med andra SQL-åtgärder

Funktionen VECTOR_SEARCH med TOP (N) WITH APPROXIMATE har specifika krav för dess användning. Vissa SQL-åtgärder kan användas direkt med vektorsökning, medan andra kräver ett underfrågasmönster.

Åtgärder som kräver underfrågasmönster

När du behöver utföra åtgärder som inte är direkt kompatibla med TOP (N) WITH APPROXIMATEanvänder du vektorsökning i en underfråga (inre fråga) och tillämpar sedan åtgärderna i den yttre frågan. Det här mönstret upprätthåller prestandafördelarna med ungefärlig vektorsökning samtidigt som fullständiga SQL-funktioner aktiveras.

Vanliga scenarier

I följande tabell visas åtgärder som kräver underfrågans mönster:

GROUP BY- och aggregerade funktioner

I följande exempel hittar du det genomsnittliga avståndet för de artiklar som matchar bäst efter kategori. I det här exemplet har en category kolumn lagts till i wikipedia_articles tabellen för att klassificera artiklar.

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;

Fönsterfunktioner

I följande exempel rangordnas artiklar efter likhet och tilldelar kvartlar.

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;

Ange åtgärder (UNION, INTERSECT, EXCEPT)

I följande exempel kombineras resultat från två olika sökfrågor med 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;

SÄRSKILD

I följande exempel hämtas distinkta kategorier från de vanligaste matchande artiklarna.

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;

Flera ORDER BY-kolumner

Följande exempel sorterar efter avstånd och sedan efter rubrik för slipsar.

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

När du använder SELECT TOP (N) WITH APPROXIMATE med VECTOR_SEARCHkan du inte använda CROSS APPLY eller OUTER APPLY i samma FROM sats. Detta gäller även om det inte finns någon yttre referens i VECTOR_SEARCH funktionen.

En fråga med CROSS APPLY utför logiskt flera vektorsökningar (en per rad från den yttre tabellen) och sammanfogar alla resultat till en enda ordnad ström. Den ungefärliga närmaste grannalgoritmen kan inte effektivt slå samman resultat från flera oberoende vektorsökningar samtidigt som de ungefärliga garantierna och prestandaegenskaperna bibehålls.

Mönster som genererar ett fel:

-- 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;

Det här mönstret försöker hitta liknande produkter för varje beställnings kundpreferens, men kan inte köras med en ungefärlig vektorsökningsplan.

Rekommenderat mönster:

Om du vill uppnå liknande resultat använder du en underfråga med TOP (N) WITH APPROXIMATE i CROSS APPLY sig själv:

-- 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';

I det här mönstret:

• Varje vektorsökning är begränsad till de 10 främsta resultaten i underfrågan
• Den yttre frågan använder inte WITH APPROXIMATE
• Resultaten är korrekt begränsade per rad från den yttre tabellen

Åtgärder som fungerar direkt

Följande åtgärder kan användas direkt med VECTOR_SEARCH utan att kräva en underfråga:

• INRE KOPPLING – Se exempel D: Flera tabellkopplingar med INRE KOPPLING
• WHERE-predikat – Tillämpa iterativ eller efterfiltrering
• Enkel ORDER BY-avstånd

Relaterat innehåll

• Vektorsökning och vektorindex i SQL Database Engine
• Datatyp för vektor
• SKAPA VEKTORINDEX (Transact-SQL)
• sys.dm_db_vector_indexes (Transact-SQL)
• Azure SQL Database Vector Search-exempel