DICHTSTBIJZIJNDE BY-component

Van toepassing op:controleren gemarkeerd als Ja Databricks Runtime 18.3 en hoger

Breidt een JOIN met top-k-classificatie uit op een aangepaste afstands- of gelijkenisexpressie. Voor elke rij in de query (links) table_reference wordt gezocht naar de bovenste num_results overeenkomende rijen uit de doeltabel (rechts) op basis van de ranking_expressiontabel , die deze als samengevoegde rijen retourneert.

ranking_expression kan elke ordelijke scalaire expressie zijn waarmee een paar rijen uit de twee tabellen worden gescored, bijvoorbeeld vector_cosine_similarity, vector_l2_distance, vector_inner_product of een samengestelde expressie waarin verschillende functies worden gecombineerd.

Syntax

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

Parameters

  • target_table_reference

    De doeltabel om te zoeken. Kan een tabel, subquery of CTE zijn.

  • { INNER | LEFT [ OUTER ] }

    Optional. Het jointype. De standaardwaarde is INNER.

    • INNER verwijdert queryrijen die geen overeenkomende kandidaten hebben.
    • LEFT OUTER retourneert elke queryrij. Kolommen aan de doelzijde zijn NULL wanneer er geen kandidaten bestaan, bijvoorbeeld wanneer de doeltabel leeg is of elke kandidaat is NULL. Als er minder dan num_results kandidaten bestaan voor een queryrij, worden alleen de beschikbare kandidaten geretourneerd.

    Andere jointypen (RIGHT, FULL, SEMI, ANTI, , CROSS) NATURALverhogen NEAREST_BY_JOIN.UNSUPPORTED_JOIN_TYPE.

  • { APPROX | EXACT }

    Hiermee bepaalt u het contract voor de resultatenset.

    • EXACT retourneert de exacte bovenste k rijen onder ranking_expression.
    • APPROX retourneert een top-k-set die de exacte rangschikking nadert. De optimizer kan snellere, geschatte zoekstrategieën gebruiken in plaats van elke kandidaat te evalueren.

  • DICHTSTBIJZIJNDe [ num_results ]

    Optioneel positief geheel getal letterlijk. Wordt standaard ingesteld op 1. Moet binnen het bereik [1, 100000]liggen. Als de doeltabel minder overeenkomende rijen heeft dan num_results, worden alleen de beschikbare rijen geretourneerd.

    Waarden buiten het bereik verhogen NEAREST_BY_JOIN.NUM_RESULTS_OUT_OF_RANGE.

  • OP AFSTAND | GELIJKENIS

    Hiermee stelt u de volgorde van ranking_expression.

    • DISTANCE rangschikt rijen op kleinste waarde eerst (dichtstbijzijnde = laagste afstand).
    • SIMILARITY rangschikt rijen op de hoogste waarde eerst (dichtstbijzijnde = hoogste overeenkomst).

  • ranking_expression

    Een scalaire expressie die kan verwijzen naar kolommen uit beide tabellen.

    Veelvoorkomende keuzes zijn:

    Als deze expressie een gegevenstype retourneert dat geen ondersteuning biedt voor ordenen, zoals MAP, wordt Azure Databricks DATATYPE_MISMATCH. INVALID_ORDERING_TYPE.

Opmerkingen

Asymmetrie

NEAREST BY is niet commutatief. Het resultaat wordt door de queryzijde verankerd. Elke queryrij produceert maximaal num_results uitvoerrijen:

  • Wanneer 100 rijen uit tabeldeelname users met 1.000 rijen uit tabel products met NEAREST 5, retourneert de join maximaal 500 rijen.
  • Als u de twee zijden van de join wijzigt om mee userste worden samengevoegdproducts, worden maximaal 5.000 rijen geretourneerd.

Het wisselen van de twee zijden stelt een andere vraag, dus het resultaat verschilt zelfs voor INNER JOIN.

Streaming

NEAREST BY wordt niet ondersteund voor streaming dataframes of gegevenssets. Query's op streamingbronnen genereren NEAREST_BY_JOIN.STREAMING_NOT_SUPPORTED.

Invoer insluiten

Bij het gebruik van vectorscorefuncties moeten beide vectorargumenten dezelfde dimensionaliteit hebben ARRAY<FLOAT> . Zie vector_cosine_similarity de functie voor type- en NULL verwerkingsregels.

Als u insluitingen wilt berekenen op basis van tekenreekswaarden, gebruikt u ai_query met een databricks-gehost insluitmodel, zoals databricks-gte-large-en.

Algemene foutvoorwaarden

Examples

In de volgende voorbeelden worden deze tabellen gebruikt. Insluitingen worden weergegeven als driedimensionale vectoren voor de beknoptheid; in de praktijk worden ze hoger-dimensional en berekend door een insluitmodel.

> 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
  • Last updated on