Risoluzione dei nomi

Si applica a: Databricks SQL Databricks Runtime

La risoluzione dei nomi è il processo attraverso cui identificatori vengono risolti in riferimenti specifici 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 colonna in base a 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 ().
• La parola chiave DEFAULT usata nel contesto di INSERT, UPDATE, MERGEo SET VARIABLE per impostare il valore di una colonna o di una variabile al 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. riferimento alla colonna

      Trovare la corrispondenza dell'identificatore, che può essere qualificato, con un nome di colonna in riferimento alla tabella del 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 a current_user, current_dateo current_timestamp: risolverlo come una di queste funzioni.

   3. specifica colonna DEFAULT

      Se l'identificatore non è qualificato, corrisponde a default e costituisce l'intera espressione nel contesto di un UPDATE SET, INSERT VALUESo MERGE WHEN [NOT] MATCHED: Risolvere come il rispettivo valore DEFAULT della tabella destinata a INSERT, UPDATE o MERGE.

   4. Riferimento al campo di struttura o alla chiave della mappa

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

      A. Rimuovere l'ultimo identificatore e considerarlo come campo o chiave. B. Trova la corrispondenza tra il resto e una colonna nella tabella , riferimento del FROM clause.

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

      Se esiste una corrispondenza e la colonna è un:

      • STRUCT: trova la corrispondenza con il campo.

        Se il campo non può essere corrisposto, viene generato 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 laterale

   Si applica a: Databricks SQL Databricks Runtime 12.2 LTS e versioni successive

   Se l'espressione si trova all'interno di un elenco , associa l'identificatore iniziale a un alias di colonna precedente in tale elenco .

   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 un errore FIELD_NOT_FOUND o AMBIGUOUS_COLUMN_OR_FIELD se non possono essere abbinati.

3. Correlazione

   • LATERALE

     Se la query è preceduta da una parola chiave LATERAL, applicare le regole 1.a e 1.d considerando i riferimenti alla tabella nel FROM contenente la query e precedente al LATERAL.

   • Regolare

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

4. Correlazione annidata

   Riapplicare la regola 3 iterando sui livelli di annidamento della query.

5. i parametri della routine

   Se l'espressione è 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. Associare l'identificatore a 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 della tabella e della vista

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

• Tabella o vista persistente nel Unity Catalog o nell'Hive Metastore
• 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.

• Non qualificato

  1. Espressione di Tabella Comune

     Se il riferimento rientra nell'ambito di una clausola WITH, associare l'identificatore a un CTE, iniziando dalla clausola WITH che lo contiene immediatamente e proseguendo 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() e 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:

• Una funzione predefinita fornita da Azure Databricks,
• Una funzione definita dall'utente temporanea con ambito alla sessione corrente o
• Funzione utente definita e 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.

• Non qualificato

  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

     Completare la qualificazione del nome della funzione anteponendo il risultato di SELECT current_catalog() e SELECT current_schema() e verificarlo come una 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

Articoli correlati

• CREATE FUNCTION (SQL e Python)
• Espressione SQL
• Identificatori
• Nomi
• riferimento alla tabella
• Query