Risoluzione dei nomi

  • Articolo

Si applica a:segno di spunta sì Databricks SQL segno di spunta sì Databricks Runtime

La risoluzione dei nomi è il processo in base al quale gli identificatori vengono risolti in specifici riferimenti a colonne, campi, parametri o tabelle.

Risoluzione di colonne, campi, parametri e variabili

Gli identificatori nelle espressioni possono essere riferimenti a uno dei seguenti elementi:

  • Nome di colonna basato su una vista, una tabella, un'espressione di tabella comune (CTE) o un column_alias.
  • Nome del campo o chiave della mappa all'interno di uno struct o di una mappa. I campi e le chiavi non possono mai essere non qualificati.
  • Nome del parametro di una funzione definita dall'utente SQL.
  • Nome variabile.
  • Una funzione speciale, current_user ad esempio o current_date che non richiede l'utilizzo di ().
  • Parola DEFAULT chiave usata nel contesto di INSERT, UPDATE, MERGEo SET VARIABLE per impostare un valore di colonna o variabile sul valore predefinito.

La risoluzione dei nomi applica i principi seguenti:

  • Il riferimento corrispondente più vicino vince e
  • Colonne e parametri vincono campi e chiavi.

In dettaglio, la risoluzione degli identificatori a un riferimento specifico segue queste regole nell'ordine seguente:

  1. Riferimenti locali

    1. Informazioni di riferimento sulle colonne

      Trovare la corrispondenza dell'identificatore, che può essere qualificato, a un nome di colonna in un riferimento di tabella dell'oggetto FROM clause.

      Se sono presenti più corrispondenze di questo tipo, generare un errore di AMBIGUOUS_COLUMN_OR_FIELD .

    2. Informazioni di riferimento sulle funzioni senza parametri

      Se l'identificatore non è qualificato e corrisponde current_usera , current_dateo current_timestamp: risolverlo come una di queste funzioni.

    3. Specifica DEFAULT colonna

      Se l'identificatore non è qualificato, corrisponde default e costituisce l'intera espressione nel contesto di un UPDATE SEToggetto , INSERT VALUESo MERGE WHEN [NOT] MATCHED: Resolve come valore corrispondente DEFAULT della tabella di destinazione dell'oggetto INSERTo UPDATEMERGE.

    4. Informazioni di riferimento sul campo Struct o sulla chiave della mappa

      Se l'identificatore è qualificato, cercare di associarlo a un campo o a una chiave di mapping in base ai passaggi seguenti:

      R. Rimuovere l'ultimo identificatore e considerarlo come campo o chiave. B. Trova la corrispondenza tra il resto e una colonna nel riferimento alla tabella dell'oggetto FROM clause.

      Se sono presenti più corrispondenze di questo tipo, generare un errore di AMBIGUOUS_COLUMN_OR_FIELD .

      Se è presente una corrispondenza e la colonna è una:

      • STRUCT: trova la corrispondenza con il campo.

        Se il campo non può essere confrontato, generare un errore di FIELD_NOT_FOUND .

        Se sono presenti più campi, generare un errore di AMBIGUOUS_COLUMN_OR_FIELD .

      • MAP: genera un errore se la chiave è qualificata.

        Un runtime eror può verificarsi se la chiave non è effettivamente presente nella mappa.

      • Qualsiasi altro tipo: generare un errore. C. Ripetere il passaggio precedente per rimuovere l'identificatore finale come campo. Applicare regole (A) e (B) mentre è rimasto un identificatore da interpretare come colonna.

  2. Aliasing delle colonne laterali

    Si applica a:segno di spunta sì Databricks SQL segno di spunta sì Databricks Runtime 12.2 LTS e versioni successive

    Se l'espressione si trova all'interno di un SELECT elenco, associare l'identificatore iniziale a un alias di colonna precedente nell'elencoSELECT.

    Se sono presenti più corrispondenze di questo tipo, generare un errore di AMBIGUOUS_LATERAL_COLUMN_ALIAS .

    Trova la corrispondenza di ogni identificatore rimanente come campo o chiave della mappa e genera FIELD_NOT_FOUND o AMBIGUOUS_COLUMN_OR_FIELD errore se non è possibile trovare una corrispondenza.

  3. Correlazione

    • LATERALE

      Se la query è preceduta da una LATERAL parola chiave, applicare le regole 1.a e 1.d considerando i riferimenti alla tabella nell'oggetto FROM contenente la query e precedendo .LATERAL

    • Regolare

      Se la query è una sottoquery scalare, INo EXISTS sottoquery, applicare regole 1.a, 1.d e 2 considerando i riferimenti alla tabella nella clausola della FROM query contenitore.

  4. Correlazione annidata

    Riapplicare la regola 3 che esegue l'iterazione sui livelli di annidamento della query.

  5. Parametri di routine

    Se l'espressione fa parte di un'istruzione CREATE FUNCTION :

    1. Associare l'identificatore a un nome di parametro. Se l'identificatore è qualificato, il qualificatore deve corrispondere al nome della funzione.
    2. Se l'identificatore è qualificato, trovare la corrispondenza con un campo o una chiave della mappa di un parametro che segue la regola 1.c

  6. Variabili

    1. Trovare la corrispondenza dell'identificatore con un nome di variabile. Se l'identificatore è qualificato, il qualificatore deve essere session o system.session.
    2. Se l'identificatore è qualificato, trovare la corrispondenza con un campo o una chiave della mappa di una variabile che segue la regola 1.c

Limiti

Per evitare l'esecuzione di query correlate potenzialmente costose, Azure Databricks limita la correlazione supportata a un livello. Questa restrizione si applica anche ai riferimenti ai parametri nelle funzioni SQL.

Esempi

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

Risoluzione tabella e vista

Un identificatore nel riferimento di tabella può essere uno dei seguenti:

  • Tabella o vista persistente nel catalogo unity o nel metastore Hive
  • Espressione di tabella comune (CTE)
  • Visualizzazione temporanea

La risoluzione di un identificatore dipende dal fatto che sia qualificato:

  • Qualificato

    Se l'identificatore è completo con tre parti: catalog.schema.relation, è univoco.

    Se l'identificatore è costituito da due parti: schema.relation, è ulteriormente qualificato con il risultato di SELECT current_catalog() per renderlo univoco.

  • Senza riserve

    1. Espressione di tabella comune

      Se il riferimento è compreso nell'ambito di una WITH clausola , associare l'identificatore a un CTE a partire dalla clausola che lo contiene WITH immediatamente e spostandosi verso l'esterno.

    2. Visualizzazione temporanea

      Associare l'identificatore a qualsiasi visualizzazione temporanea definita all'interno della sessione corrente.

    3. Tabella persistente

      Qualificare completamente l'identificatore anteponendo il risultato di SELECT current_catalog() e SELECT current_schema() cercarlo come relazione permanente.

Se la relazione non può essere risolta in alcuna tabella, vista o CTE, Databricks genera un errore di TABLE_OR_VIEW_NOT_FOUND .

Esempi

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

Risoluzione delle funzioni

Un riferimento a una funzione viene riconosciuto dal set di parentesi finale obbligatorio.

Può essere risolto in:

  • Funzione predefinita fornita da Azure Databricks,
  • Una funzione definita dall'utente temporanea con ambito alla sessione corrente o
  • Funzione definita dall'utente persistente archiviata nel metastore hive o nel catalogo unity.

La risoluzione di un nome di funzione dipende dal fatto che sia qualificato:

  • Qualificato

    Se il nome è completo con tre parti: catalog.schema.function, è univoco.

    Se il nome è costituito da due parti: schema.function, è ulteriormente qualificato con il risultato di SELECT current_catalog() per renderlo univoco.

    La funzione viene quindi cercata nel catalogo.

  • Senza riserve

    Per i nomi di funzione non qualificati, Azure Databricks segue un ordine di precedenza fisso (PATH):

    1. Funzione Builtin

      Se esiste una funzione con questo nome tra il set di funzioni predefinite, tale funzione viene scelta.

    2. Funzione temporanea

      Se esiste una funzione con questo nome tra il set di funzioni temporanee, tale funzione viene scelta.

    3. Funzione persistente

      Qualificare completamente il nome della funzione anteponendo il risultato di SELECT current_catalog() e SELECT current_schema() cercarlo come funzione persistente.

Se la funzione non può essere risolta, Azure Databricks genera un UNRESOLVED_ROUTINE errore.

Esempi

> 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