NEAREST BY záradék

A következőre vonatkozik:ellenőrizze a következőt: yes Databricks Runtime 18 LTS és újabb

Note

A Databricks Runtime 18 újabb, mint a Databricks Runtime 18.0, 18.1 és 18.2. Azok a funkciók, amelyek korábban később számozott verzióként lettek volna szállítva, mostantól a Databricks Runtime 18-as verziójának dátumozott frissítéseiként jelennek meg. További részletekért lásd: Az egyesített kibocsátási megjegyzések.

JOIN Egy egyéni távolságra vagy hasonlóság kifejezésre vonatkozó top-k rangsorolással bővíthető. A lekérdezés (bal oldali) table_reference minden egyes sorához a céltábla (jobb oldali) táblázatának első num_results egyező sorait találja meg aszerint, hogy azokat ranking_expressionösszefűzött sorokként adja vissza.

ranking_expression Bármely rendezhető skaláris kifejezés lehet, amely a két tábla sorpárját pontozza, például vector_cosine_similarity, vector_l2_distance, vector_inner_product vagy több függvényt egyesít.

Syntax

{ INNER | LEFT [ OUTER ] } JOIN target_table_reference
  { APPROX | EXACT } NEAREST [ num_results ]
  BY { DISTANCE | SIMILARITY } ranking_expression

Parameters

target_table_reference

A keresendő céltábla. Lehet tábla, alkonyat vagy CTE.
{ INNER | LEFT [ OUTER ] }

Optional. Az illesztés típusa. Az alapértelmezett érték a INNER.
- INNER elveti azokat a lekérdezési sorokat, amelyekhez nem tartoznak egyező jelöltek.
- LEFT OUTER minden lekérdezéssort visszaad. A céloldali oszlopok akkor jelennek NULL meg, ha nem léteznek jelöltek, például ha a céltábla üres, vagy minden jelölt .NULL Ha egy lekérdezéssorhoz kevesebb num_results jelölt van, csak az elérhető jelöltek lesznek visszaadva.
Egyéb illesztéstípusok (RIGHT, , FULLSEMI, ANTI, CROSS) NATURALemelésNEAREST_BY_JOIN.UNSUPPORTED_JOIN_TYPE.
{ APPROX | EXACT }

Szabályozza az eredményhalmaz-szerződést.
- EXACT A pontos felső-k sorokat adja vissza a következő alatt ranking_expression: .
- APPROX egy top-k halmazt ad vissza, amely megközelíti a pontos rangsorolást. Az optimalizáló gyorsabb, hozzávetőleges keresési stratégiákat használhat ahelyett, hogy minden jelöltet kiértékel.
LEGKÖZELEBBI [ num_results ]

Választható pozitív egész számkonstans. Alapértelmezett érték: 1. A tartományon [1, 100000]belül kell lennie. Ha a céltábla kevesebb egyező sorból áll, mint num_resultsamennyit a rendszer visszaad, akkor csak a rendelkezésre álló sorok lesznek visszaadva.

A tartományon kívüli értékek emelnek NEAREST_BY_JOIN.NUM_RESULTS_OUT_OF_RANGE.
TÁVOLSÁG ALAPJÁN | HASONLÓSÁG

Beállítja a sorrendet ranking_expression.
- DISTANCE a sorokat elsőként a legkisebb érték szerint rangsorolja (legközelebbi = legkisebb távolság).
- SIMILARITY sorokat rangsorol a legnagyobb érték szerint (legközelebbi = legmagasabb hasonlóság).
ranking_expression

Skaláris kifejezés, amely mindkét tábla oszlopaira hivatkozhat.

Gyakori lehetőségek a következők:
- hasonlósági függvények, például vector_cosine_similarity és vector_inner_product,
- távolságfüggvények, például vector_l2_distance,
- numerikus távolságok, mint a Manhattan távolság: vector_norm(zip_with(a.col, b.col, (x, y) -> x - y), 1.0f).
Ha ez a kifejezés olyan adattípust ad vissza, amely nem támogatja a rendezést (például MAP), Azure Databricks DATATYPE_MISMATCH. INVALID_ORDERING_TYPE.

Jegyzetek

Aszimmetria

NEAREST BY nem ingázás. A lekérdezési oldal rögzíti az eredményt. Minden lekérdezési sor legfeljebb kimeneti num_results sorokat hoz létre:

Ha a tábla users 100 sora 100 sorból áll, és 1000 sor van a táblázatból productsNEAREST 5, az illesztés legfeljebb 500 sort ad vissza.
Ha az illesztés két oldalát úgy váltja át, hogy csatlakozhasson productsusers, az legfeljebb 5000 sort ad vissza.

A két oldal felcserélése egy másik kérdést tesz fel, így az eredmény még a .INNER JOIN

Online közvetítés

NEAREST BY adatkeretek vagy adathalmazok streamelése esetén nem támogatott. A streamelési források lekérdezései emelkednek NEAREST_BY_JOIN.STREAMING_NOT_SUPPORTED.

Bemenetek beágyazása

Vektorpontozási függvények használatakor mindkét vektorargumentumnak azonos dimenziójúnak kell lennie ARRAY<FLOAT> . A típus- és vector_cosine_similarity kezelési szabályokért lásd .

A sztringértékek beágyazásának kiszámításához használja a ai_query egy Databricks által üzemeltetett beágyazási modellel, például databricks-gte-large-ena .

Gyakori hibafeltételek

DATATYPE_MISMATCH. INVALID_ORDERING_TYPE
NEAREST_BY_JOIN.NUM_RESULTS_OUT_OF_RANGE
NEAREST_BY_JOIN.STREAMING_NOT_SUPPORTED
NEAREST_BY_JOIN.UNSUPPORTED_JOIN_TYPE

Examples

Az alábbi példák ezeket a táblákat használják. A beágyazások 3 dimenziós vektorként jelennek meg a rövidítéshez; a gyakorlatban ezek magasabb dimenziójúak, és beágyazási modell alapján vannak kiszámítva.

> CREATE TEMP VIEW users(user_id, name, embedding) AS
    VALUES
      (1, 'Alice', ARRAY(1.0f, 0.0f, 0.0f)),
      (2, 'Bob',   ARRAY(0.0f, 1.0f, 0.0f)),
      (3, 'Carol', ARRAY(0.0f, 0.0f, 0.0f));

> CREATE TEMP VIEW products(product_id, name, price, country, embedding) AS
    VALUES
      ('P1', 'Trail running shoes', 120, 'EU', ARRAY(0.9f, 0.1f, 0.1f)),
      ('P2', 'Hiking boots',        180, 'EU', ARRAY(0.8f, 0.2f, 0.0f)),
      ('P3', 'Office shoes',         95, 'US', ARRAY(0.1f, 0.9f, 0.1f)),
      ('P4', 'Sandals',              45, 'US', ARRAY(0.0f, 0.8f, 0.2f)),
      ('P5', 'Running shoes',       110, 'EU', ARRAY(0.5f, 0.5f, 0.0f));

-- Ad-hoc vector search with an explicit query vector.
> SELECT t.product_id, t.name
    FROM (SELECT ARRAY(1.0f, 0.0f, 0.0f) AS embedding) q
    INNER JOIN products t
      APPROX NEAREST 3 BY SIMILARITY vector_cosine_similarity(q.embedding, t.embedding);
 product_id  name
 ----------  -------------------
 P1          Trail running shoes
 P2          Hiking boots
 P5          Running shoes

-- Batch recommendations: for every user, return the 2 nearest products.
> SELECT q.user_id, q.name, t.product_id, t.name AS product
    FROM users q
    INNER JOIN products t
      APPROX NEAREST 2 BY SIMILARITY vector_cosine_similarity(q.embedding, t.embedding);
 user_id  name   product_id  product
 -------  -----  ----------  -------------------
 1        Alice  P1          Trail running shoes
 1        Alice  P2          Hiking boots
 2        Bob    P3          Office shoes
 2        Bob    P4          Sandals

-- Pre-filter the target table via a subquery (EU products only).
> SELECT q.user_id, q.name, t.product_id, t.name AS product, t.price
    FROM users q
    INNER JOIN (SELECT * FROM products WHERE country = 'EU') AS t
      APPROX NEAREST 2 BY SIMILARITY vector_cosine_similarity(q.embedding, t.embedding);
 user_id  name   product_id  product              price
 -------  -----  ----------  -------------------  -----
 1        Alice  P1          Trail running shoes  120
 1        Alice  P2          Hiking boots         180
 2        Bob    P5          Running shoes        110
 2        Bob    P2          Hiking boots         180

-- LEFT OUTER returns every query row. Carol's embedding has zero magnitude,
-- so vector_cosine_similarity returns NULL for all comparisons and her row
-- is preserved with NULL target columns.
> SELECT q.user_id, q.name, t.product_id, t.name AS product
    FROM users q
    LEFT OUTER JOIN products t
      APPROX NEAREST 2 BY SIMILARITY vector_cosine_similarity(q.embedding, t.embedding);
 user_id  name   product_id  product
 -------  -----  ----------  -------------------
 1        Alice  P1          Trail running shoes
 1        Alice  P2          Hiking boots
 2        Bob    P3          Office shoes
 2        Bob    P4          Sandals
 3        Carol  NULL        NULL

-- EXACT returns the exact top-k under the ranking expression.
> SELECT t.product_id, t.name
    FROM (SELECT ARRAY(1.0f, 0.0f, 0.0f) AS embedding) q
    INNER JOIN products t
      EXACT NEAREST 3 BY DISTANCE vector_l2_distance(q.embedding, t.embedding);
 product_id  name
 ----------  -------------------
 P1          Trail running shoes
 P2          Hiking boots
 P5          Running shoes

Visszajelzés

Hasznosnak találta ezt az oldalt?

Last updated on 2026-07-28