Rozpoznawanie nazw

Dotyczy: Databricks SQL Databricks Runtime

Rozpoznawanie nazw to proces rozpoznawania identyfikatorów rozpoznawanych według określonych kolumn, pól, parametrów lub odwołań do tabeli.

Rozdzielczość kolumn, pola, parametru i zmiennej

Identyfikatory w wyrażeniach mogą być odwołaniami do dowolnego z następujących elementów:

• Nazwa kolumny oparta na widoku, tabeli, wspólnym wyrażeniu tabeli (CTE) lub column_alias.
• Nazwa pola lub klucz mapy w obrębie struktury lub mapy. Pola i klucze nigdy nie mogą być niekwalifikowane.
• Nazwa parametru funkcji zdefiniowanej przez użytkownika SQL.
• Nazwa zmiennej.
• Specjalna funkcja, taka jak current_user lub current_date która nie wymaga użycia elementu ().
• Słowo DEFAULT kluczowe, które jest używane w kontekście INSERT, UPDATE, MERGElub SET VARIABLE , aby ustawić wartość kolumny lub zmiennej na wartość domyślną.

Rozpoznawanie nazw stosuje następujące zasady:

• Najbliższe dopasowanie odniesienia wygrywa i
• Kolumny i parametr wygrywają pola i klucze.

Szczegółowo rozpoznawanie identyfikatorów do określonego odwołania jest zgodne z następującymi regułami w następującej kolejności:

1. Odwołania lokalne

   1. Odwołanie do kolumny

      Dopasuj identyfikator, który może być kwalifikowany, do nazwy kolumny w odwołaniu do tabeli .FROM clause

      Jeśli istnieje więcej niż jedno dopasowanie, zgłoś błąd AMBIGUOUS_COLUMN_OR_FIELD .

   2. Dokumentacja funkcji bez parametrów

      Jeśli identyfikator jest niekwalifikowany i pasuje current_userdo elementu , current_datelub current_timestamp: Rozwiąż go jako jedną z tych funkcji.

   3. Specyfikacja DOMYŚLNa kolumny

      Jeśli identyfikator jest niekwalifikowany, dopasuje default i tworzy całe wyrażenie w kontekście UPDATE SETelementu , INSERT VALUESlub MERGE WHEN [NOT] MATCHED: Rozwiąż jako odpowiednią DEFAULT wartość tabeli INSERTUPDATE docelowej obiektu lub MERGE.

   4. Odwołanie do pola struktury lub klucza mapy

      Jeśli identyfikator jest kwalifikowany, spróbuj dopasować go do pola lub klucza mapy zgodnie z następującymi krokami:

      Odp. Usuń ostatni identyfikator i traktuj go jako pole lub klucz. B. Dopasuj resztę do kolumny w odwołaniu do tabeli .FROM clause

      Jeśli istnieje więcej niż jedno dopasowanie, zgłoś błąd AMBIGUOUS_COLUMN_OR_FIELD .

      Jeśli istnieje dopasowanie, a kolumna to:

      • STRUCT: dopasuj pole.

        Jeśli nie można dopasować pola, zgłoś błąd FIELD_NOT_FOUND .

        Jeśli istnieje więcej niż jedno pole, zgłoś błąd AMBIGUOUS_COLUMN_OR_FIELD .

      • MAP: zgłoś błąd, jeśli klucz jest kwalifikowany.

        Moduł uruchomieniowy może wystąpić, jeśli klucz nie jest rzeczywiście obecny na mapie.

      • Dowolny inny typ: zgłoś błąd. C. Powtórz poprzedni krok, aby usunąć identyfikator końcowy jako pole. Zastosuj reguły (A) i (B), gdy istnieje identyfikator pozostawiony do zinterpretowania jako kolumny.

2. Aliasowanie kolumn bocznych

   Dotyczy: Databricks SQL Databricks Runtime 12.2 LTS i nowsze

   Jeśli wyrażenie znajduje się na SELECT liście, dopasuj wiodący identyfikator do poprzedniego aliasu kolumny na tej SELECT liście.

   Jeśli istnieje więcej niż jeden taki dopasowanie, zgłoś błąd AMBIGUOUS_LATERAL_COLUMN_ALIAS .

   Dopasuj każdy pozostały identyfikator jako pole lub klucz mapy i zgłoś błąd FIELD_NOT_FOUND lub AMBIGUOUS_COLUMN_OR_FIELD , jeśli nie można ich dopasować.

3. Korelacja

   • BOCZNE

     Jeśli zapytanie jest poprzedzone LATERAL słowem kluczowym, zastosuj reguły 1.a i 1.d, biorąc pod uwagę odwołania do tabeli w FROM pliku zawierającym zapytanie i poprzedzające LATERAL.

   • Normalna

     Jeśli zapytanie jest podzapytaniem skalarnym, INlub EXISTS podzapytaniem zastosuj reguły 1.a, 1.d i 2, biorąc pod uwagę odwołania do tabeli w klauzuli zawierającej FROM zapytanie.

4. Korelacja zagnieżdżona

   Zastosuj ponownie regułę 3 iteracji na poziomach zagnieżdżania zapytania.

5. Parametry rutynowe

   Jeśli wyrażenie jest częścią instrukcji CREATE FUNCTION :

   1. Dopasuj identyfikator do nazwy parametru. Jeśli identyfikator jest kwalifikowany, kwalifikator musi być zgodny z nazwą funkcji.
   2. Jeśli identyfikator jest kwalifikowany, dopasuj do pola lub klucza mapy parametru zgodnie z regułą 1.c

6. Zmienne

   1. Dopasuj identyfikator do nazwy zmiennej. Jeśli identyfikator jest kwalifikowany, kwalifikator musi mieć wartość session lub system.session.
   2. Jeśli identyfikator jest kwalifikowany, dopasuj do pola lub klucza mapy zmiennej zgodnie z regułą 1.c

Ograniczenia

Aby zapobiec wykonywaniu potencjalnie kosztownych skorelowanych zapytań, usługa Azure Databricks ogranicza obsługiwaną korelację do jednego poziomu. To ograniczenie dotyczy również odwołań do parametrów w funkcjach SQL.

Przykłady

-- Differentiating columns and fields
> SELECT a FROM VALUES(1) AS t(a);
 1

> SELECT t.a FROM VALUES(1) AS t(a);
 1

> SELECT t.a FROM VALUES(named_struct('a', 1)) AS t(t);
 1

-- A column takes precendece over a field
> SELECT t.a FROM VALUES(named_struct('a', 1), 2) AS t(t, a);
 2

-- Implict lateral column alias
> SELECT c1 AS a, a + c1 FROM VALUES(2) AS T(c1);
 2  4

-- A local column reference takes precedence, over a lateral column alias
> SELECT c1 AS a, a + c1 FROM VALUES(2, 3) AS T(c1, a);
 2  5

-- A scalar subquery correlation to S.c3
> SELECT (SELECT c1 FROM VALUES(1, 2) AS t(c1, c2)
           WHERE t.c2 * 2 = c3)
    FROM VALUES(4) AS s(c3);
 1

-- A local reference takes precedence over correlation
> SELECT (SELECT c1 FROM VALUES(1, 2, 2) AS t(c1, c2, c3)
           WHERE t.c2 * 2 = c3)
    FROM VALUES(4) AS s(c3);
  NULL

-- An explicit scalar subquery correlation to s.c3
> SELECT (SELECT c1 FROM VALUES(1, 2, 2) AS t(c1, c2, c3)
           WHERE t.c2 * 2 = s.c3)
    FROM VALUES(4) AS s(c3);
 1

-- Correlation from an EXISTS predicate to t.c2
> SELECT c1 FROM VALUES(1, 2) AS T(c1, c2)
    WHERE EXISTS(SELECT 1 FROM VALUES(2) AS S(c2)
                  WHERE S.c2 = T.c2);
 1

-- Attempt a lateral correlation to t.c2
> SELECT c1, c2, c3
    FROM VALUES(1, 2) AS t(c1, c2),
         (SELECT c3 FROM VALUES(3, 4) AS s(c3, c4)
           WHERE c4 = c2 * 2);
 [UNRESOLVED_COLUMN] `c2`

-- Successsful usage of lateral correlation with keyword LATERAL
> SELECT c1, c2, c3
    FROM VALUES(1, 2) AS t(c1, c2),
         LATERAL(SELECT c3 FROM VALUES(3, 4) AS s(c3, c4)
                  WHERE c4 = c2 * 2);
 1  2  3

-- Referencing a parameter of a SQL function
> CREATE OR REPLACE TEMPORARY FUNCTION func(a INT) RETURNS INT
    RETURN (SELECT c1 FROM VALUES(1) AS T(c1) WHERE c1 = a);
> SELECT func(1), func(2);
 1  NULL

-- A column takes precedence over a parameter
> CREATE OR REPLACE TEMPORARY FUNCTION func(a INT) RETURNS INT
    RETURN (SELECT a FROM VALUES(1) AS T(a) WHERE t.a = a);
> SELECT func(1), func(2);
 1  1

-- Qualify the parameter with the function name
> CREATE OR REPLACE TEMPORARY FUNCTION func(a INT) RETURNS INT
    RETURN (SELECT a FROM VALUES(1) AS T(a) WHERE t.a = func.a);
> SELECT func(1), func(2);
 1  NULL

-- Lateral alias takes precedence over correlated reference
> SELECT (SELECT c2 FROM (SELECT 1 AS c1, c1 AS c2) WHERE c2 > 5)
    FROM VALUES(6) AS t(c1)
  NULL

-- Lateral alias takes precedence over function parameters
> CREATE OR REPLACE TEMPORARY FUNCTION func(x INT)
    RETURNS TABLE (a INT, b INT, c DOUBLE)
    RETURN SELECT x + 1 AS x, x
> SELECT * FROM func(1)
  2 2

-- All together now
> CREATE OR REPLACE TEMPORARY VIEW lat(a, b) AS VALUES('lat.a', 'lat.b');

> CREATE OR REPLACE TEMPORARY VIEW frm(a) AS VALUES('frm.a');

> CREATE OR REPLACE TEMPORARY FUNCTION func(a INT, b int, c int)
  RETURNS TABLE
  RETURN SELECT t.*
    FROM lat,
         LATERAL(SELECT a, b, c
                   FROM frm) AS t;

> VALUES func('func.a', 'func.b', 'func.c');
  a      b      c
  -----  -----  ------
  frm.a  lat.b  func.c

Rozpoznawanie tabeli i wyświetlania

Identyfikator w odwołaniu do tabeli może być jednym z następujących elementów:

• Trwała tabela lub widok w wykazie aparatu Unity lub magazynie metadanych Hive
• Wspólne wyrażenie tabeli (CTE)
• Widok tymczasowy

Rozpoznawanie identyfikatora zależy od tego, czy jest on kwalifikowany:

• Kwalifikowaną

  Jeśli identyfikator jest w pełni kwalifikowany z trzema częściami: catalog.schema.relation, jest unikatowy.

  Jeśli identyfikator składa się z dwóch części: schema.relation, jest on dodatkowo kwalifikowany z wynikiem SELECT current_catalog() , aby był unikatowy.

• Niekwalifikowanych

  1. Wspólne wyrażenie tabeli

     Jeśli odwołanie znajduje się w zakresie WITH klauzuli, dopasuj identyfikator do CTE, zaczynając od natychmiast zawierającej WITH klauzulę i przenosząc się z tego miejsca na zewnątrz.

  2. Widok tymczasowy

     Dopasuj identyfikator do dowolnego widoku tymczasowego zdefiniowanego w bieżącej sesji.

  3. Utrwalonej tabeli

     W pełni kwalifikowanie identyfikatora przez wstępne oczekiwanie na wynik SELECT current_catalog() i SELECT current_schema() wyszukanie go jako trwałej relacji.

Jeśli nie można rozpoznać relacji z żadną tabelą, widokiem lub CTE, usługa Databricks zgłasza błąd TABLE_OR_VIEW_NOT_FOUND .

Przykłady

-- Setting up a scenario
> USE CATALOG spark_catalog;
> USE SCHEMA default;

> CREATE TABLE rel(c1 int);
> INSERT INTO rel VALUES(1);

-- An fully qualified reference to rel:
> SELECT c1 FROM spark_catalog.default.rel;
 1

-- A partially qualified reference to rel:
> SELECT c1 FROM default.rel;
 1

-- An unqualified reference to rel:
> SELECT c1 FROM rel;
 1

-- Add a temporary view with a conflicting name:
> CREATE TEMPORARY VIEW rel(c1) AS VALUES(2);

-- For unqualified references the temporary view takes precedence over the persisted table:
> SELECT c1 FROM rel;
 2

-- Temporary views cannot be qualified, so qualifiecation resolved to the table:
> SELECT c1 FROM default.rel;
 1

-- An unqualified reference to a common table expression wins even over a temporary view:
> WITH rel(c1) AS (VALUES(3))
    SELECT * FROM rel;
 3

-- If CTEs are nested, the match nearest to the table reference takes precedence.
> WITH rel(c1) AS (VALUES(3))
    (WITH rel(c1) AS (VALUES(4))
      SELECT * FROM rel);
  4

-- To resolve the table instead of the CTE, qualify it:
> WITH rel(c1) AS (VALUES(3))
    (WITH rel(c1) AS (VALUES(4))
      SELECT * FROM default.rel);
  1

-- For a CTE to be visible it must contain the query
> SELECT * FROM (WITH cte(c1) AS (VALUES(1))
                   SELECT 1),
                cte;
  [TABLE_OR_VIEW_NOT_FOUND] The table or view `cte` cannot be found.

Rozpoznawanie funkcji

Odwołanie do funkcji jest rozpoznawane przez obowiązkowy zestaw nawiasów końcowych.

Może to rozwiązać problem:

• Wbudowana funkcja udostępniana przez usługę Azure Databricks,
• Funkcja zdefiniowana przez użytkownika tymczasowego w zakresie bieżącej sesji lub
• Trwała funkcja zdefiniowana przez użytkownika przechowywana w magazynie metadanych hive lub katalogu aparatu Unity.

Rozpoznawanie nazwy funkcji zależy od tego, czy jest kwalifikowana:

• Kwalifikowaną

  Jeśli nazwa jest w pełni kwalifikowana z trzema częściami: catalog.schema.function, jest unikatowa.

  Jeśli nazwa składa się z dwóch części: schema.function, jest ona dodatkowo kwalifikowana z wynikiem SELECT current_catalog() , aby była unikatowa.

  Funkcja zostanie następnie wyszukana w wykazie.

• Niekwalifikowanych

  W przypadku niekwalifikowanych nazw funkcji usługa Azure Databricks jest zgodna ze stałą kolejnością pierwszeństwa (PATH):

  1. Builtin, funkcja

     Jeśli funkcja o tej nazwie istnieje wśród zestawu wbudowanych funkcji, zostanie wybrana ta funkcja.

  2. Funkcja tymczasowa

     Jeśli funkcja o tej nazwie istnieje wśród zestawu funkcji tymczasowych, zostanie wybrana ta funkcja.

  3. Utrwalone funkcje

     W pełni kwalifikowanie nazwy funkcji przez wstępne oczekiwanie na wynik SELECT current_catalog() i SELECT current_schema() wyszukanie jej jako funkcji trwałej.

Jeśli nie można rozpoznać funkcji, usługa Azure Databricks zgłasza UNRESOLVED_ROUTINE błąd.

Przykłady

> USE CATALOG spark_catalog;
> USE SCHEMA default;

-- Create a function with the same name as a builtin
> CREATE FUNCTION concat(a STRING, b STRING) RETURNS STRING
    RETURN b || a;

-- unqualified reference resolves to the builtin CONCAT
> SELECT concat('hello', 'world');
 helloworld

-- Qualified reference resolves to the persistent function
> SELECT default.concat('hello', 'world');
 worldhello

-- Create a persistent function
> CREATE FUNCTION func(a INT, b INT) RETURNS INT
    RETURN a + b;

-- The persistent function is resolved without qualifying it
> SELECT func(4, 2);
 6

-- Create a conflicting temporary function
> CREATE FUNCTION func(a INT, b INT) RETURNS INT
    RETURN a / b;

-- The temporary function takes precedent
> SELECT func(4, 2);
 2

-- To resolve the persistent function it now needs qualification
> SELECT spark_catalog.default.func(4, 3);
 6

Powiązane artykuły

• CREATE FUNCTION (SQL i Python)
• Wyrażenie SQL
• Identyfikatory
• Nazwy
• odwołanie do tabeli
• Zapytanie