Delen via

VECTOR_SEARCH (Transact-SQL) (preview)

Van toepassing op: SQL Server 2025 (17.x) Azure SQL DatabaseSQL database in Microsoft Fabric

Zoek naar vectoren die vergelijkbaar zijn met een bepaalde queryvector met behulp van een bij benadering dichtstbijzijnde buren vectorzoekingsalgoritmen. Raadpleeg vectorzoekopdrachten en vectorindexen in de SQL Database Engine voor meer informatie over hoe vectorindexering en vectorzoekopdrachten werken, en de verschillen tussen exacte en geschatte zoekopdrachten.

Azure SQL Database en SQL Database in Fabric

De functie is in preview. Zorg ervoor dat u de huidige beperkingen bekijkt voordat u deze gebruikt.

Opmerking

Omdat het om een preview-functie gaat, is de technologie die in dit artikel wordt behandeld onderhevig aan de Aanvullende gebruiksvoorwaarden voor Microsoft Azure Previews.

Belangrijk

Gebruik vectorindexen die zijn gemaakt met de nieuwste versie voor optimale prestaties en voor toegang tot de nieuwste vectorzoekmogelijkheden. Zie CREATE VECTOR INDEX - Upgrade vector indexen naar de nieuwste versie voor meer informatie over het upgraden van bestaande indexen en het vergelijken van versies.

Regionale beschikbaarheid

Deze functie wordt geïmplementeerd in Azure SQL Database en SQL Database in Microsoft Fabric. Tijdens de implementatie kan de beschikbaarheid en het gedrag per regio en per indexversie verschillen. Als een functie of syntaxis niet beschikbaar is, wordt deze automatisch beschikbaar zodra de implementatie is voltooid. Zie Beschikbaarheid van functies per regio voor de huidige regionale beschikbaarheidsstatus.

Waarschuwing

Afschaffingsmelding: de TOP_N parameter is VECTOR_SEARCH afgeschaft en wordt alleen onderhouden voor achterwaartse compatibiliteit met eerdere versievectorindexen. Nieuwe implementaties moeten in plaats daarvan syntaxis gebruiken SELECT TOP (N) WITH APPROXIMATE . Zie Syntaxis voor meer informatie.

SQL Server 2025 Preview-functie

In SQL Server 2025 is deze functie in previewversie en kan deze worden gewijzigd. Als u deze functie wilt gebruiken, moet u de configuratie van het PREVIEW_FEATURESdatabasebereik inschakelen.

Zorg ervoor dat u de huidige beperkingen bekijkt voordat u deze gebruikt.

Opmerking

De nieuwste versie van Vector Indexes is momenteel alleen beschikbaar in Azure SQL Database en SQL Database in Microsoft Fabric.

Belangrijke verbeteringen met de meest recente vectorindexen

Vectorindexen die zijn gemaakt met de nieuwste versie, introduceren aanzienlijke verbeteringen:

  • Volledige DML-ondersteuning: hiermee verwijdert u de vorige beperking die vector-geïndexeerde tabellen alleen-lezen heeft gemaakt na het maken van de index. U kunt nu INSERT-, UPDATE-, DELETE- en MERGE-bewerkingen uitvoeren met behoud van vectorindexfunctionaliteit met automatisch, realtime indexonderhoud
  • Iteratieve filtering: Predicaten in de WHERE-component worden toegepast tijdens het vectorzoekproces, niet na het ophalen
  • Optimalisatiegestuurd: De queryoptimalisatie bepaalt automatisch of de DiskANN-index of kNN-zoekopdracht moet worden gebruikt op basis van querykenmerken
  • Geavanceerde kwantisatie: Vector kwantisatietechnieken zijn geïntegreerd om betere opslagefficiëntie en snellere queryprestaties te bieden, waarbij deze optimalisaties transparant zijn voor gebruikers

Syntax

Transact-SQL syntaxis-conventies

Met de nieuwste versie vectorindexen:

Belangrijk

Bij het uitvoeren van query's op tabellen die gebruikmaken van de meest recente vectorindexversie, moet bij benadering vectorzoekopdrachten de syntaxis TOP (N) BIJ BENADERING worden gebruikt. Deze syntaxisvereiste geeft aan dat de query expliciet bij benadering dichtstbijzijnde burenresultaten aanvraagt.

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;

Met eerdere versie Vector Indexen:

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 ]

Belangrijk

De TOP_N parameter wordt niet ondersteund met de meest recente versievectorindexen. Gebruik de SELECT TOP (N) WITH APPROXIMATE bovenstaande syntaxis. Zie Fout met verouderde syntaxis voor meer informatie.

Arguments

TABLE = object [AS source_table_alias]

Tabel waarop de zoekopdracht wordt uitgevoerd. Het moet een basistabel zijn. Weergaven, tijdelijke tabellen, zowel lokaal als globaal, worden niet ondersteund.

KOLOM = vector_column

De vectorkolom waarin de zoekopdracht wordt uitgevoerd. De kolom moet een vectorgegevenstype zijn.

SIMILAR_TO = query_vector

De vector die wordt gebruikt om te zoeken. Het moet een variabele of een kolom van vectortype zijn.

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

De metrische afstand die wordt gebruikt om de afstand tussen de queryvector en de vectoren in de opgegeven kolom te berekenen. Een ANN-index (Bij benadering dichtstbijzijnde buur) wordt alleen gebruikt als een overeenkomende ANN-index, met dezelfde metrische waarde en in dezelfde kolom, wordt gevonden. Als er geen compatibele ANN-indexen zijn, wordt er een waarschuwing gegenereerd en wordt het kNN-algoritme (k-nearest neighbor) gebruikt.

TOP_N = <k>

Waarschuwing

Deze parameter is afgeschaft en wordt alleen onderhouden voor achterwaartse compatibiliteit met eerdere versievectorindexen. Gebruik SELECT TOP (N) WITH APPROXIMATE in plaats daarvan de syntaxis voor de meest recente versie-indexen. Voor nieuwe implementaties moet de nieuwste syntaxis worden gebruikt.

Het maximum aantal vergelijkbare vectoren dat moet worden geretourneerd. Het moet een positief geheel getal zijn. Deze parameter wordt niet ondersteund met vectorindexen die zijn gemaakt met behulp van de nieuwste versie.

result_table_alias

De alias wordt gebruikt om te verwijzen naar de resultatenset.

Resultaatset retourneren

De resultatenset die door de VECTOR_SEARCH functie wordt geretourneerd, bevat:

  • Alle kolommen uit de tabel die in het TABLE argument zijn opgegeven.

  • Een extra kolom met de naam distance, die de afstand aangeeft tussen de vector in de kolom die is opgegeven door het COLUMN argument en de vector die in het SIMILAR_TO argument is opgegeven.

De afstandskolom wordt gegenereerd door de VECTOR_SEARCH functie zelf, terwijl alle andere kolommen afkomstig zijn uit de tabel waarnaar in het TABLE argument wordt verwezen.

Als u een alias gebruikt voor de tabel in het TABLE argument, moet u dezelfde alias gebruiken om te verwijzen naar de kolommen in de SELECT instructie. U kunt de alias die is toegewezen om te VECTOR_SEARCH verwijzen naar kolommen uit de tabel die is opgegeven in TABLEniet gebruiken. Dit gedrag is gemakkelijker te begrijpen als u denkt aan de resultatenset die is gemaakt door de uitvoer van VECTOR_SEARCH en samen te voegen met de tabelgegevens.

Als de tabel die is opgegeven in het TABLE argument al een kolom met de naam distancebevat, is het gedrag vergelijkbaar met een SQL-join tussen twee tabellen die een kolomnaam delen. In dergelijke gevallen moet u tabelaliassen gebruiken om de kolomverwijzingen niet eenduidig te maken. Anders wordt er een fout gegenereerd.

Belangrijk

De distance kolom is de enige geldige bestelsleutel voor geschatte vectorzoekresultaten.

Limitations

  • Alleen oplopende volgorde: de distance kolom moet in oplopende volgorde (ASC) worden geordend. Aflopende volgorde (DESC) wordt niet ondersteund.

Versiespecifiek gedrag

Het gedrag van varieert afhankelijk van VECTOR_SEARCH de vectorindexversie.

Eerdere vectorindexversies

Opmerking

Deze beperkingen gelden alleen voor vectorindexen die zijn gemaakt met eerdere versies. Migreer naar de nieuwste versie om iteratieve filtering in te schakelen. Zie Migreren van eerdere vectorindexversies.

Alleen na filteren: Vector search vindt plaats voordat u een predicaat toepast. Extra predicaten worden pas toegepast nadat de meest vergelijkbare vectoren zijn geretourneerd. Het volgende voorbeeld retourneert de bovenste 10 rijen met insluitingen die het meest lijken op de queryvector @qven past vervolgens het predicaat toe dat is opgegeven in de WHERE component. Als geen van de 10 rijen die zijn gekoppeld aan de vectoren die door de vectorzoekopdracht worden geretourneerd, de accepted kolom gelijk is aan 1, is het resultaat leeg.

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;

Algemene beperkingen

VECTOR_SEARCH kan niet worden gebruikt in de hoofdtekst van een weergave.

Examples

Belangrijk

Bij het uitvoeren van query's op tabellen die gebruikmaken van de meest recente vectorindexversie, moet bij benadering vectorzoekopdrachten de TOP (N) WITH APPROXIMATE syntaxis worden gebruikt. Deze syntaxisvereiste geeft aan dat de query expliciet bij benadering dichtstbijzijnde burenresultaten aanvraagt.

In het volgende voorbeeld vindt u de 10 meest vergelijkbare artikelen Pink Floyd music style in de wikipedia_articles_embeddings tabel.

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;

De syntaxis voor het uitvoeren van query's is afhankelijk van de vectorindexversie:

Vectorindexversie Voorbeeld van syntaxis
Nieuwste versie TOP_N Zonder parameter gebruiken SELECT TOP (N) WITH APPROXIMATE
Eerdere versies (afgeschaft) Parameter in VECTOR_SEARCH functie gebruiken TOP_N

Aanbeveling

Zie Migreren van eerdere vectorindexversies om de versie van de vectorindex te bepalen.

Voor eerdere versie-indexen (afgeschafte syntaxis):

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;

Opmerking

Als u de TOP_N parameter met de meest recente versievectorindexen gebruikt, wordt fout Msg 42274 geretourneerd. Zie Fout met behulp van verouderde syntaxis in de sectie Verwachte gedragingen voor gedetailleerde informatie.

B. Werkstroom voltooien met het maken van een index

Een eenvoudig end-to-end-voorbeeld met behulp van CREATE VECTOR INDEX en de gerelateerde VECTOR_SEARCH functie. De insluitingen worden gesimuleerd. In een praktijkscenario worden insluitingen gegenereerd met behulp van een insluitmodel en AI_GENERATE_EMBEDDINGS, of een externe bibliotheek zoals OpenAI SDK.

Opmerking

Voor de meest recente versievectorindexen zijn ten minste 100 rijen met gegevens vereist voordat de index wordt gemaakt. In dit voorbeeld worden 100 rijen ingevoegd om aan deze vereiste te voldoen. Zie Minimale gegevensvereisten voor meer informatie.

In het volgende codeblok ziet u de VECTOR_SEARCH functie met gesimuleerde insluitingen:

  1. Hiermee schakelt u de preview-functie in (alleen vereist voor SQL Server 2025; niet nodig voor Azure SQL Database of SQL Database in Fabric).
  2. Maak een voorbeeldtabel dbo.Articles met een kolom embedding met gegevenstypevector (5).
  3. Voeg 100 rijen met voorbeeldgegevens in met gesimuleerde insluitingsgegevens.
  4. Maak een vectorindex op dbo.Articles.embedding.
  5. Demonstreert de vector-overeenkomstenzoekopdracht met de VECTOR_SEARCH functie.
-- 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;

De syntaxis voor het uitvoeren van query's is afhankelijk van de vectorindexversie:

Vectorindexversie Voorbeeld van syntaxis
Nieuwste versie TOP_N Zonder parameter gebruiken SELECT TOP (N) WITH APPROXIMATE
Eerdere versies (afgeschaft) Parameter in VECTOR_SEARCH functie gebruiken TOP_N

Voor eerdere versie-indexen (afgeschafte syntaxis):

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. Vector zoeken met iteratieve filtering

In het volgende voorbeeld ziet u iteratieve filters met de meest recente versievectorindexen. De query vindt vergelijkbare artikelen tijdens het toepassen van predicaten tijdens het zoekproces.

Met de meest recente versie-indexen worden de predicaten in de WHERE-component toegepast tijdens het vectorzoekproces (niet na). De engine blijft zoeken totdat er vijf in aanmerking komende rijen worden gevonden die voldoen aan alle criteria:

  • Vector-gelijkenis met 'machine learning-algoritmen'
  • Categorie is gelijk aan 'Technologie'
  • De gepubliceerde status is gelijk aan 1

Dit zorgt ervoor dat u precies 5 resultaten krijgt (als deze bestaan) zonder de zoekparameters handmatig af te stemmen. Zie Het iteratieve filtergedrag in de sectie Verwachte gedragingen voor een gedetailleerde vergelijking tussen eerdere en nieuwste versies.

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;

Opmerking

Voor bepaalde SQL-bewerkingen, zoals GROUP BY, statistische functies en vensterfuncties, is een subquerypatroon vereist. Zie Vectorzoekopdrachten combineren met andere SQL-bewerkingen voor meer informatie.

D. Joins met meerdere tabellen met INNER JOIN

In het volgende voorbeeld ziet u hoe INNER JOIN wordt gefilterd op meerdere tabellen. Gebruik deze functie wanneer insluitingen worden opgeslagen in een afzonderlijke tabel van de gegevens van de hoofdentiteit.

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

Belangrijke functies van dit voorbeeld:

  • Bereik van tabelalias: De alias e is TABLE = wikipedia_articles_embeddings AS e beschikbaar in de WHERE-component voor iteratieve filtering met de meest recente versie-indexen

Verwacht gedrag

Fout bij het gebruik van verouderde syntaxis

Als u de TOP_N parameter VECTOR_SEARCH probeert te gebruiken bij het uitvoeren van query's op een tabel met een meest recente versievectorindex, retourneert SQL Server de volgende fout:

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

Ga als volgt te werk om deze fout op te lossen:

  1. TOP_N De parameter uit de VECTOR_SEARCH functie verwijderen
  2. Gebruik SELECT TOP (N) WITH APPROXIMATE in plaats daarvan de syntaxis

Onjuist (produceert een fout met de meest recente versie-index):

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;

Juist (werkt met de meest recente versie-index):

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;

Iteratief filtergedrag

De nieuwste versie introduceert aanzienlijke verbeteringen ten opzichte van eerdere vectorindexversies:

Aspect Eerdere versie Nieuwste versie
Predicaattoepassing Relationele predicaten zijn toegepast nadat vectorzoekopdrachten een vast aantal dichtstbijzijnde buren hebben geretourneerd (alleen na filteren) Relationele predicaten worden toegepast tijdens het vectorzoekproces (iteratieve filtering)
Volledigheid van resultaat Query's kunnen minder rijen, of geen rijen, retourneren als de eerste dichtstbijzijnde buren niet voldoen aan filters, zelfs niet wanneer in aanmerking komende rijen bestonden Query's retourneren het verwachte aantal rijen wanneer er in aanmerking komende gegevens bestaan, zonder handmatig afstemmen of opnieuw schrijven van query's
TOP (N) afstemming Gebruikers moesten vaak topwaarden (N) raden of tesampleen om te compenseren voor nafiltering U hoeft GEEN TOP-waarden (N) te raden. De engine zoekt totdat er voldoende in aanmerking komende rijen worden gevonden of de zoekruimte is uitgeput
Queryoptimalisatie Niet van toepassing SQL Server selecteert automatisch de meest efficiënte uitvoeringsstrategie, waaronder schakelen tussen vectorindexzoekopdrachten en kNN-scans, indien van toepassing

Zie voorbeeld C: Vector search with iterative filtering(voorbeeld C: Vector search with iterative filtering) voor een praktisch voorbeeld van iteratieve filtering.

ORDER BY-componentvereisten

Bij gebruik SELECT TOP (N) WITH APPROXIMATEheeft de ORDER BY-component specifieke vereisten:

  • ORDER BY moet aanwezig zijn: query's zonder ORDER BY-component mislukken met fout.
  • Alleen de toegestane afstandskolom: de COMPONENT ORDER BY mag alleen verwijzen naar de afstandskolom van de VECTOR_SEARCH resultatenset. Het opnemen van extra kolommen mislukt met een fout. Als u wilt sorteren op meerdere kolommen, gebruikt u het subquerypatroon dat wordt beschreven in meerdere ORDER BY-kolommen.
  • Alleen oplopende volgorde: de afstandskolom moet in oplopende volgorde (ASC) worden geordend. Aflopende volgorde (DESC) wordt niet ondersteund.

GeldigE 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

Ongeldige ORDER BY-patronen:

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

Gedrag zonder vectorindex

VECTOR_SEARCH kan query's uitvoeren, zelfs wanneer er geen vectorindex bestaat op de doelkolom. Zonder een index voert de query een volledige tabelscan uit (k-dichtstbijzijnde neighbor(kNN)-zoekopdracht) om afstanden voor alle rijen te berekenen.

Querygedrag zonder TOP MET GESCHATTE

VECTOR_SEARCH Wanneer u zonder SELECT TOP (N) WITH APPROXIMATEgebruikt, is het querygedrag afhankelijk van de aanwezigheid van TOP en ORDER BY componenten:

  • Geen TOP, geen ORDER BY of ORDER BY niet-afstand: Volledige tabelscan (brute-force zoekopdracht) die afstanden voor alle rijen berekent en retourneert
  • TOP (geen GESCHATTE) met ORDER BY-afstand: wordt uitgevoerd als een kNN-zoekopdracht (k-dichtstbijzijnde buren), wat een exacte zoekopdracht naar dichtstbijzijnde buren is

Voorbeeld: volledige scan met kolom afstand:

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

Voorbeeld: kNN-zoekopdracht (exacte dichtstbijzijnde buren):

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

Het gebruik SELECT TOP (N) WITH APPROXIMATE zonder een VECTOR_SEARCH functie in de query resulteert in een fout. Voor de WITH APPROXIMATE component moet een VECTOR_SEARCH functie aanwezig zijn.

Onjuist: deze query mislukt:

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

Juist: gebruik 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;

BEPERKINGEN VOOR TRUNCATE TABLE

Tabellen met vectorindexen kunnen niet worden afgekapt met behulp van TRUNCATE TABLE. Als u alle gegevens uit een vectorindexeerde tabel wilt verwijderen:

  1. De vectorindex verwijderen
  2. De tabel afkappen
  3. De tabel opnieuw vullen met ten minste 100 rijen
  4. De vectorindex opnieuw maken

Voorbeeldwerkstroom:

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

U kunt tabelhints gebruiken met de functie om het VECTOR_SEARCH gedrag van de uitvoering van query's te beheren. De FORCE_ANN_ONLY tabelhint dwingt de optimalisatiefunctie voor query's af om alleen de dichtstbijzijnde buurindex (ANN) te gebruiken, zelfs wanneer de optimizer anders een andere uitvoeringsstrategie kan kiezen.

Syntaxis:

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

Voorbeeld:

In het volgende voorbeeld wordt het gebruik van de dichtstbijzijnde buurindex voor de vectorzoekquery gedimd:

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;

Gebruik FORCE_ANN_ONLY deze optie als u ervoor wilt zorgen dat de query gebruikmaakt van de dichtstbijzijnde indexstrategie van de dichtstbijzijnde buur, waarbij de automatische strategieselectie van de optimizer wordt overschreven.

Opmerking

Voor beide is het volgende FORCE_ANN_ONLY vereist:

  • Een vectorindex op de doelkolom
  • SELECT TOP (N) WITH APPROXIMATE in de query

Als een van beide vereisten ontbreekt, mislukt de query omdat deze niet de dichtstbijzijnde buurstrategie kan gebruiken die door de hint wordt afgevraagd.

Vectorzoekopdrachten combineren met andere SQL-bewerkingen

De VECTOR_SEARCH functie met TOP (N) WITH APPROXIMATE specifieke vereisten voor het gebruik. Sommige SQL-bewerkingen kunnen rechtstreeks worden gebruikt met vectorzoekopdrachten, terwijl andere een subquerypatroon vereisen.

Bewerkingen waarvoor een subquerypatroon is vereist

Wanneer u bewerkingen wilt uitvoeren die niet rechtstreeks compatibel zijn met TOP (N) WITH APPROXIMATE, gebruikt u vectorzoekopdrachten in een subquery (interne query) en past u vervolgens uw bewerkingen toe in de buitenste query. Dit patroon behoudt de prestatievoordelen van het zoeken naar vectoren terwijl volledige SQL-functionaliteit wordt ingeschakeld.

Aanbeveling

Het subquerypatroon werkt voor elke bewerking die niet rechtstreeks kan worden gecombineerd met TOP (N) WITH APPROXIMATE. Pas vectorzoekopdrachten toe in de binnenste query en gebruik vervolgens een SQL-bewerking in de buitenste query.

Algemene scenario's

De volgende tabel bevat bewerkingen waarvoor het subquery-patroon is vereist:

Operatie Voorbeeld van een toepassing
GROEP OP Statistieken per categorie berekenen
Gecompileerde functies Overall COUNT, AVG, MIN, MAX across results
Vensterfuncties ROW_NUMBER, RANK, DENSE_RANK, NTILE
Bewerkingen instellen UNION, UNION ALL, EXCEPT, INTERSECT
Meerdere ORDER BY-kolommen Sorteren op afstand en vervolgens op datum of titel
ONDERSCHEIDEND Dubbele resultaten verwijderen
KRUISLINGS TOEPASSEN Vectorzoekopdrachten per rij uit de buitenste tabel toepassen

GROUP BY en statistische functies

In het volgende voorbeeld wordt de gemiddelde afstand gevonden van de meest overeenkomende artikelen per categorie. In dit voorbeeld is een category kolom toegevoegd aan de wikipedia_articles tabel om artikelen te classificeren.

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;

Vensterfuncties

In het volgende voorbeeld worden artikelen gerangschikt op gelijkenis en worden kwartielen toegewezen.

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;

Bewerkingen instellen (UNION, INTERSECT, EXCEPT)

In het volgende voorbeeld worden resultaten van twee verschillende zoekquery's gecombineerd met behulp van 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;

ONDERSCHEIDEND

In het volgende voorbeeld worden verschillende categorieën opgehaald uit de meest overeenkomende artikelen.

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;

Meerdere ORDER BY-kolommen

In het volgende voorbeeld wordt gesorteerd op afstand en vervolgens op titel voor banden.

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;

KRUISLINGS TOEPASSEN

Wanneer u met deze functie gebruiktSELECT TOP (N) WITH APPROXIMATE, kunt u niet dezelfde component gebruiken CROSS APPLY of OUTER APPLY in dezelfde FROM component.VECTOR_SEARCH Dit geldt zelfs als er geen externe verwijzing binnen de VECTOR_SEARCH functie is.

Een query met CROSS APPLY zou logisch meerdere vectorzoekopdrachten uitvoeren (één per rij uit de buitenste tabel) en alle resultaten samenvoegen in één geordende stroom. Het dichtstbijzijnde buuralgoritmen kunnen resultaten van meerdere onafhankelijke vectorzoekopdrachten niet efficiënt samenvoegen, terwijl de garanties en prestatiekenmerken bij benadering behouden blijven.

Patroon dat een fout produceert:

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

Dit patroon probeert vergelijkbare producten te vinden voor de klantvoorkeur van elke bestelling, maar kan niet worden uitgevoerd met een geschat vectorzoekplan.

Aanbevolen patroon:

Als u vergelijkbare resultaten wilt bereiken, gebruikt u een subquery met TOP (N) WITH APPROXIMATE in het CROSS APPLY zelf:

-- 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 dit patroon:

  • Elke vectorzoekopdracht is beperkt tot de top 10 resultaten in de subquery
  • De buitenste query wordt niet gebruikt WITH APPROXIMATE
  • Resultaten worden op de juiste manier per rij uit de buitenste tabel weergegeven

Bewerkingen die rechtstreeks werken

De volgende bewerkingen kunnen rechtstreeks met VECTOR_SEARCH een subquery worden gebruikt:

Verwante inhoud

  • Last updated on