Klauzule NEAREST BY

Platí pro: check označený ano Databricks Runtime 18.3 a vyšší

JOIN Rozšíří nejvyšší hodnocení podle vlastní vzdálenosti nebo výrazu podobnosti. Pro každý řádek v dotazu (vlevo) table_reference najde až horní num_results odpovídající řádky z cílové tabulky (vpravo) na ranking_expressionzákladě tabulky , která je vrací jako zřetězené řádky.

ranking_expression může být libovolný uspořádaný skalární výraz, který vyhodnotí dvojici řádků ze dvou tabulek – například vector_cosine_similarity, vector_l2_distance, vector_inner_product nebo složený výraz, který kombinuje několik funkcí.

Syntax

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

Parameters

target_table_reference

Cílová tabulka, která se má prohledávat. Může to být tabulka, poddotaz nebo CTE.
{ INNER | LEFT [ OUTER ] }

Optional. Typ spojení. Výchozí hodnota je INNER.
- INNER zahodí řádky dotazu, které nemají odpovídající kandidáty.
- LEFT OUTER vrátí každý řádek dotazu. Sloupce na straně cíle jsou NULL , když neexistují žádní kandidáti – například když je cílová tabulka prázdná nebo každý kandidát je NULL. Pokud pro řádek dotazu existuje méně num_results než kandidátů, vrátí se pouze dostupné kandidáty.
Jiné typy spojení (RIGHT, FULL, SEMI, ANTI, CROSS, ), NATURALzvýšit NEAREST_BY_JOIN.UNSUPPORTED_JOIN_TYPE.
{ APPROX | EXACT }

Řídí kontrakt sady výsledků.
- EXACT vrátí přesné horní k řádky pod ranking_expression.
- APPROX vrátí sadu top-k, která se blíží přesnému hodnocení. Optimalizátor může místo vyhodnocení každého kandidáta použít rychlejší a přibližné strategie hledání.
NEAREST [ num_results ]

Volitelný kladný celočíselná literál. Výchozí hodnota je 1. Musí být v rozsahu [1, 100000]. Pokud cílová tabulka obsahuje méně odpovídajících řádků než num_results, vrátí se pouze dostupné řádky.

Hodnoty mimo rozsah umocní NEAREST_BY_JOIN.NUM_RESULTS_OUT_OF_RANGE.
BY DISTANCE | PODOBNOST

Nastaví řazení .ranking_expression
- DISTANCE seřadí řádky podle nejmenší hodnoty jako první (nejbližší = nejnižší vzdálenost).
- SIMILARITY řadí řádky podle nejvyšší hodnoty jako první (nejbližší = nejvyšší podobnost).
ranking_expression

Skalární výraz, který může odkazovat na sloupce z obou tabulek.

Mezi běžné volby patří:
- funkce podobnosti, jako jsou vector_cosine_similarity a vector_inner_product,
- funkce vzdálenosti, jako je vector_l2_distance,
- číselné vzdálenosti jako Manhattan vzdálenost: vector_norm(zip_with(a.col, b.col, (x, y) -> x - y), 1.0f).
Pokud tento výraz vrátí datový typ, který nepodporuje řazení, například MAP, Azure Databricks vyvolá DATATYPE_MISMATCH. INVALID_ORDERING_TYPE.

Poznámky

Asymetrie

NEAREST BY není komutativní. Na straně dotazu se výsledek ukotvení – každý řádek dotazu vytvoří až num_results výstupní řádky:

Když 100 řádků z tabulky users spojí s 1 000 řádky z tabulky products , NEAREST 5vrátí spojení až 500 řádků.
Pokud přepnete obě strany spojení na spojení productsusers, vrátí se až 5 000 řádků.

Prohození obou stran položí jinou otázku, takže výsledek se liší i pro INNER JOIN.

Streamování

NEAREST BY nepodporuje streamované datové rámce ani datové sady. Dotazy na zdroje streamování vyvolávají NEAREST_BY_JOIN.STREAMING_NOT_SUPPORTED.

Vkládání vstupů

Při použití funkcí bodování vektoru musí být ARRAY<FLOAT> oba vektorové argumenty se stejnou dimenzionální sadou. Vizvector_cosine_similarity funkce pro typ a NULL zpracování pravidel.

Pokud chcete vypočítat vkládání z řetězcových hodnot, použijte ai_query s modelem vkládání hostovaným v Databricks, jako databricks-gte-large-enje například .

Běžné chybové podmínky

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

Příklady

Následující příklady používají tyto tabulky. Vkládání se zobrazuje jako 3rozměrné vektory pro stručnost; v praxi jsou dimenzionální a vypočítané modelem vkládání.

> 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

Váš názor

Byla tato stránka užitečná?

Last updated on 2026-06-01