Namensauflösung

Gilt für:durch Häkchen mit „Ja“ markiert Databricks SQL durch Häkchen mit „Ja“ markiert Databricks Runtime

Die Namensauflösung ist der Prozess, mit dem Bezeichner in bestimmte Spalten-, Feld-, Parameter- oder Tabellenverweise aufgelöst werden.

Auflösung von Spalten, Feldern, Parametern und Variablen

Bezeichner in Ausdrücken können Verweise auf eines der folgenden Elemente sein:

  • Spaltenname basierend auf einer Sicht, einer Tabelle, einem allgemeinen Tabellenausdruck (Common Table Expression, CTE) oder einem column_alias.
  • Feldname oder Zuordnungsschlüssel in einer Struktur oder Zuordnung. Felder und Schlüssel können niemals nicht qualifiziert sein.
  • Parametername einer benutzerdefinierten SQL-Funktion oder SQL-Prozedur.
  • Name der lokalen Variablen des Sitzungs- oder SQL-Skripts.
  • Eine spezielle Funktion wie current_user oder current_date, für die eine Verwendung von () nicht erforderlich ist.
  • Das Schlüsselwort DEFAULT, das im Kontext von INSERT, UPDATE, MERGE oder SET VARIABLE verwendet wird, um einen Spalten- oder Variablenwert auf den Standardwert festzulegen.

Bei der Namensauflösung werden die folgenden Prinzipien angewendet:

  • Der am genauesten übereinstimmende Verweis gewinnt.
  • Spalten und Parameter haben Vorrang vor Feldern und Schlüsseln.

Im Detail folgt die Auflösung von Bezeichnern in einen bestimmten Verweis den folgenden Regeln in dieser Reihenfolge:

  1. Lokale Verweise

    1. Spaltenverweis

      Der Bezeichner, der qualifiziert werden kann, wird mit einem Spaltennamen in einem Tabellenverweis der FROM clause abgeglichen.

      Wenn mehr als eine solche Übereinstimmung vorhanden ist, wird ein AMBIGUOUS_COLUMN_OR_FIELD-Fehler ausgelöst.

    2. Referenz für parameterlose Funktionen

      Wenn der Bezeichner nicht qualifiziert ist und mit current_user, current_date oder current_timestampübereinstimmt, wird er als eine dieser Funktionen aufgelöst.

    3. DEFAULT-Spaltenspezifikation

      Wenn der Bezeichner nicht qualifiziert ist, mit default übereinstimmt und den gesamten Ausdruck im Kontext von UPDATE SET, INSERT VALUES oder MERGE WHEN [NOT] MATCHED erstellt: Die Auflösung erfolgt als entsprechender DEFAULT-Wert der Zieltabelle von INSERT, UPDATE oder MERGE.

    4. Referenz für Strukturfeld oder Zuordnungsschlüssel

      Wenn der Bezeichner qualifiziert ist, wird versucht, ihn gemäß den folgenden Schritten mit einem Feld- oder Zuordnungsschlüssel abzugleichen:

      Ein. Der letzte Bezeichner wird entfernt und als Feld oder Schlüssel behandelt. B: Der Rest wird mit einer Spalte im Tabellenverweis der FROM clause abgeglichen.

      Wenn mehr als eine solche Übereinstimmung vorhanden ist, wird ein AMBIGUOUS_COLUMN_OR_FIELD-Fehler ausgelöst.

      Wenn eine Übereinstimmung vorhanden ist und die Spalte eines der folgenden Elemente ist:

      • STRUCT: Das Feld wird abgeglichen.

        Wenn das Feld nicht abgeglichen werden kann, wird ein FIELD_NOT_FOUND-Fehler ausgelöst.

        Wenn mehr als ein Feld vorhanden ist, wird ein AMBIGUOUS_COLUMN_OR_FIELD-Fehler ausgelöst.

      • MAP: Es wird ein Fehler ausgelöst, wenn der Schlüssel qualifiziert ist.

        Ein Laufzeitfehler kann auftreten, wenn der Schlüssel nicht tatsächlich in der Karte vorhanden ist.

      • Jeder andere Typ: Es wird ein Fehler ausgelöst. C. Der vorherige Schritt wird wiederholt, um den nachgestellten Bezeichner als Feld zu entfernen. Die Regeln (A) und (B) werden angewendet, sofern noch ein Bezeichner vorhanden ist, der als Spalte interpretiert werden soll.

  2. Laterales Spaltenaliasing

    Gilt für:Häkchen ja Databricks SQL Häkchen gesetzt ja Databricks Runtime 12.2 LTS und höher

    Wenn sich der Ausdruck in einer SELECT-Liste befindet, wird der führende Bezeichner mit einem vorangehenden Spaltenalias in dieser SELECT-Liste abgeglichen.

    Wenn mehr als eine solche Übereinstimmung vorhanden ist, wird ein AMBIGUOUS_LATERAL_COLUMN_ALIAS-Fehler ausgelöst.

    Jeder verbleibende Bezeichner wird als Feld- oder Zuordnungsschlüssel abgeglichen, und es wird der Fehler FIELD_NOT_FOUND oder AMBIGUOUS_COLUMN_OR_FIELD ausgelöst, wenn keine Übereinstimmung vorhanden ist.

  3. Korrelation

    • SEITLICH

      Wenn der Abfrage ein LATERAL-Schlüsselwort vorangestellt ist, werden die Regeln 1.a und 1.d unter Berücksichtigung der Tabellenverweise im FROM-Element angewendet, das die Abfrage enthält und LATERAL vorangeht.

    • Regulär

      Wenn es sich bei der Abfrage um eine skalare Unterabfrage, IN, oder EXISTS Unterabfrage handelt, gelten Regeln 1.a, 1.d und 2 unter Berücksichtigung der Tabellenverweise in der Klausel der enthaltenden AbfrageFROM.

  4. Geschachtelte Korrelation

    Gilt für:Haken markiert ja Databricks SQL Haken ja Databricks Runtime 20.0 und höher

    Wenden Sie Regel 3 erneut an und iterieren Sie über die Verschachtelungsebenen der Abfrage, sodass ein Identifikator in jeder umschließenden Abfrage auf eine korrelierte Referenz auflösen kann, nicht nur in der unmittelbar umschließenden.

  5. FOR-Schleife

    Wenn die Anweisung in einer FOR Schleife enthalten ist:

    Ein. Ordnen Sie den Bezeichner einer Spalte in der FOR-Schleifenanweisung zu. Wenn der Bezeichner qualifiziert ist, muss der Qualifizierer dem Namen der for-Schleifenvariablen entsprechen, falls diese definiert ist. B: Wenn der Bezeichner qualifiziert ist, erfolgt ein Abgleich mit einem Feld- oder Zuordnungsschlüssel eines Parameters gemäß Regel 1.c.

  6. Zusammengesetzte Anweisung

    Wenn die Anweisung in einer zusammengesetzten Anweisung enthalten ist:

    Ein. Ordne den Bezeichner einer Variablen zu, die in dieser zusammengesetzten Anweisung deklariert ist. Wenn der Bezeichner qualifiziert ist, muss der Qualifizierer mit der Bezeichnung der Zusammengesetzten Anweisung übereinstimmen, wenn eine definiert wurde. B: Wenn der Bezeichner qualifiziert ist, erfolgt ein Abgleich mit einem Feld- oder Zuordnungsschlüssel einer Variable gemäß Regel 1.c.

  7. Geschachtelte Zusammengesetzte Anweisung oder FOR Schleife

    Wenden Sie die Regeln 5 und 6 erneut an, indem Sie die Schachtelungsebenen der zusammengesetzten Anweisung durchlaufen.

  8. Routineparameter

    Wenn der Ausdruck Teil einer CREATE FUNCTION oder CREATE PROCEDURE-Anweisung ist:

    1. Der Bezeichner wird mit einem Parameternamen abgeglichen. Wenn der Bezeichner qualifiziert ist, muss der Qualifikator dem Namen der Routine entsprechen.
    2. Wenn der Bezeichner qualifiziert ist, erfolgt ein Abgleich mit einem Feld- oder Zuordnungsschlüssel eines Parameters gemäß Regel 1.c.
  9. Sitzungsvariablen

    1. Entspricht dem Bezeichner für einen Variablennamen. Wenn der Bezeichner qualifiziert ist, muss der Qualifizierer session oder system.session sein. In Databricks SQL und Databricks Runtime 19 und höher stimmt eine unqualifizierte Identifikatorin nur dann mit einer Sitzungsvariable überein, wenn system.session sich auf dem PATH befindet.
    2. Wenn der Bezeichner qualifiziert ist, erfolgt ein Abgleich mit einem Feld- oder Zuordnungsschlüssel einer Variable gemäß Regel 1.c.

Namensauflösung in HAVING, ORDER BYund QUALIFY

Die HAVING, ORDER BYund QUALIFY Klauseln können auf Namen aus der SELECT Liste sowie Spalten aus den zugrunde liegenden Tabellen verweisen. Wenn ein Name in einer dieser Klauseln sowohl einem Spaltenalias in der SELECT Liste als auch einer Tabellenspalte entspricht, lösen die Klauseln die Mehrdeutigkeit unterschiedlich auf:

  • ORDER BY bevorzugt den SELECT Listenalias über der Tabellenspalte.
  • HAVING bevorzugt die Tabellenspalte über dem SELECT Listenalias.
  • QUALIFY bevorzugt die Tabellenspalte über dem SELECT Listenalias (identisch mit HAVING).

Beispiele

> CREATE OR REPLACE TEMPORARY VIEW t(a, b) AS VALUES (1, 10), (2, 20), (3, 30);

-- ORDER BY prefers the alias over the column.
-- 'a' in ORDER BY refers to the alias (-a), not column 'a',
-- so the row with the largest column 'a' comes first.
> SELECT -a AS a FROM t ORDER BY a LIMIT 1;
  -3

-- HAVING prefers the column over the alias.
-- 'a' in HAVING refers to column 'a', not the alias sum(b).
> SELECT sum(b) AS a FROM t GROUP BY a HAVING a > 1;
  20
  30

-- QUALIFY prefers the column over the alias (same as HAVING).
-- 'a' in QUALIFY refers to column 'a', not the alias -row_number().
> SELECT -row_number() OVER (ORDER BY b) AS a FROM t QUALIFY a > 1;
  -2
  -3

Priorität der Feldextraktion und Namensauflösung

Wenn ein qualifizierter Name wie z a.b . B. in HAVING oder ORDER BYverwendet wird, gelten die oben genannten Prioritätsregeln weiterhin, aber mit einer zusätzlichen Überlegung: Der bevorzugte Kandidat muss strukturfeld- oder zuordnungsschlüsselextraktion unterstützen. Wenn dies nicht der Fall ist, wird stattdessen der andere Kandidat verwendet.

Wenn der Alias a beispielsweise in eine einfacheINT, aber die Tabellenspalte a ein STRUCT Feld xist, wählt die ORDER BY Spalte aus, STRUCT da ein Feld nicht aus dem INT Alias extrahiert werden kann. Wenn es sich bei der Tabellenspalte um eine einfache INT Spalte handelt und der Alias ein STRUCTist, HAVING fällt er auf den Alias für die Feldextraktion zurück.

Beispiele

-- ORDER BY fallback: the table column is a STRUCT, the alias is an INT.
-- ORDER BY normally prefers the alias, but the alias (INT) cannot have
-- field 'x' extracted, so the struct column wins.
> CREATE OR REPLACE TEMPORARY VIEW s1(a) AS VALUES (named_struct('x', 1)), (named_struct('x', 2));

> SELECT -a.x AS a FROM s1 ORDER BY a.x LIMIT 1;
  -1

-- HAVING fallback: the table column is an INT, the alias is a STRUCT.
-- HAVING normally prefers the table column, but the column (INT) cannot have
-- field 'x' extracted, so the alias wins.
> CREATE OR REPLACE TEMPORARY VIEW s2(a) AS VALUES (1), (2);

> SELECT named_struct('x', 2) AS a FROM s2 GROUP BY a HAVING a.x > 1;
  {"x":2}
  {"x":2}

-- Map key extraction follows the same rules.
-- ORDER BY fallback: alias (INT) cannot have key extracted, map column wins.
> CREATE OR REPLACE TEMPORARY VIEW s3(a) AS VALUES (map('key', 100)), (map('key', 200));

> SELECT -a['key'] AS a FROM s3 ORDER BY a['key'] LIMIT 1;
  -100

-- HAVING fallback: column (INT) cannot have key extracted, map alias wins.
> CREATE OR REPLACE TEMPORARY VIEW s4(a) AS VALUES (100), (200);

> SELECT map('key', 200) AS a FROM s4 GROUP BY a HAVING a['key'] > 100;
  {"key":200}
  {"key":200}

Begrenzungen

In Databricks SQL und Databricks Runtime 20.0 und höher wird verschachtelte Korrelation (eine Unterabfrage, die auf Spalten einer umschließenden Abfrage jenseits ihres unmittelbaren Elterngeräts verweist) unterstützt, mit folgenden Einschränkungen:

  • Verschachtelte Korrelation wird für Subqueries in einer HAVING Klausel nicht unterstützt.
  • Eine LATERAL Subquery kann nicht verschachtelt-korreliert sein. Seine äußeren Referenzen müssen auf die direkt umschließende Abfrage aufgelöst werden.

In Databricks Runtime-Versionen unterhalb von 20.0 ist die Korrelation auf eine einzige Ebene beschränkt: Eine Unterabfrage kann nur Spalten aus der unmittelbar umschließenden Abfrage referenzieren.

Beispiele

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

-- Nested correlation: the innermost EXISTS references t1.a from the outermost query
> CREATE OR REPLACE TEMPORARY VIEW t1(a) AS VALUES(1), (2), (3);
> CREATE OR REPLACE TEMPORARY VIEW t2(b) AS VALUES(1), (2);
> CREATE OR REPLACE TEMPORARY VIEW t3(c) AS VALUES(2), (3);

> SELECT a FROM t1
    WHERE EXISTS(SELECT 1 FROM t2
                  WHERE t2.b = t1.a
                    AND EXISTS(SELECT 1 FROM t3
                                WHERE t3.c = t1.a));
 2

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

Auflösung von Tabellen und Sichten

Ein Bezeichner in einem Tabellenverweis kann eines der folgenden Elemente sein:

  • Persistente Tabelle oder Sicht in Unity Catalog oder dem Hive-Metastore
  • Allgemeine Tabellenausdrücke (CTE, Common Table Expression)
  • Temporäre Ansicht oder temporäre Tabelle

Die Auflösung eines Bezeichners hängt davon ab, ob er qualifiziert ist:

  • Qualifiziert

    Wenn der Bezeichner mit drei Teilen vollqualifiziert ist, catalog.schema.relation, ist er eindeutig.

    Wenn der Bezeichner aus zwei Teilen besteht, schema.relation, wird er mit dem Ergebnis von SELECT current_catalog() weiter qualifiziert, um ihn eindeutig zu machen.

    Wenn das Schema ist session, wird es weiter mit system einer temporären Ansicht oder temporären Tabelle qualifiziert und interpretiert. Wenn das Schema ist global_temp, wird es in Databricks Runtime weiter qualifiziert system und als globale temporäre Ansicht interpretiert.

  • Nicht qualifiziert

    1. Allgemeiner Tabellenausdruck

      Wenn sich der Verweis im Bereich einer WITH-Klausel befindet, wird der Bezeichner mit einem CTE abgeglichen. Der Abgleich beginnt mit der direkt enthaltenden WITH-Klausel und wird von dort nach außen fortgesetzt.

    2. Schema-Suchpfad

      In Databricks SQL und Databricks Runtime 19 und höher wird die Beziehung zu jedem Schema auf dem PATH der Reihe nach qualifiziert, bis eine Übereinstimmung gefunden wird.

      • Fehlende Kataloge oder Schemata: Fehlende Kataloge oder Schemata auf dem Pfad werden übersprungen. Ein Objekt, für das der Benutzer unzureichende Rechte hat, wird nicht übersprungen; Azure Databricks löst den entsprechenden Fehler aus.
      • Temporäre Ansichten und Tabellen: Temporäre Ansichten und temporäre Tabellen befinden sich in system.session, sodass sie jederzeit erreichbar sind, wann immer system.session auf der PATH.
      • Persistente Tabellen und Ansichten im aktuellen Schema: Persistente Tabellen und Ansichten im aktuellen Schema werden über den virtuellen CURRENT_SCHEMA Eintrag erreicht.

      Der Pfad gilt für unqualifizierte Relationsnamen in Abfragen und DML sowie für unqualifizierte Namen in einer Abfrage, die Teil einer DDL-Anweisung ist.

      • Wo der Weg verläuft:

        Kontext Verwendeter Weg
        Abfragen und DML (SELECT, INSERT, UPDATE, DELETE, ) MERGE Sitzungs-PFAD
        Abfrage von CREATE TABLE AS Sitzungs-PFAD
        Abfrage eines persistenten CREATE VIEW PATH zur Erstellungszeit erfasst
        Subjekt von CREATE, DROP, , ALTERund ähnlichen current_catalog.current_schema (keine Wegsuche)
      • Frühere Versionen: In Databricks Runtime 18 und darunter wird eine unqualifizierte Beziehung, die kein CTE ist, in einer festen Reihenfolge aufgelöst.

        1. Temporäre Ansicht oder temporäre Tabelle

          Ordnen Sie den Bezeichner jeder temporären Ansicht oder temporären Tabelle zu, die in der aktuellen Sitzung definiert ist.

        2. Persistente Tabelle

          Der Bezeichner wird als vollqualifiziert festgelegt, indem das Ergebnis von SELECT current_catalog() und SELECT current_schema() vorab als ausstehend markiert und als persistente Beziehung nachgeschlagen wird.

Wenn die Beziehung weder in eine Tabelle, eine Sicht oder einen CTE aufgelöst werden kann, löst Databricks einen TABLE_OR_VIEW_NOT_FOUND-Fehler aus.

Eroberter Weg

Eine persistente Ansicht erfasst den Sitzungspfad zur Erstellung. Spätere Abfragen der Ansicht lösen unqualifizierte Namen gegen diesen erfassten Pfad, nicht gegen den Sitzungspfad des Aufrufers. current_path() und current_schema() in dieser Abfrage werden weiterhin die Sitzungswerte des Aufrufers zurückgegeben.

Beispiele

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

Funktion und Prozedurauflösung

Eine Routinereferenz (ein Funktionsaufruf oder Prozeduraufruf) wird durch die obligatorische nachlaufende Menge von Klammern erkannt.

Er kann in Folgendes aufgelöst werden:

  • Eine integrierte Funktion, die von Azure Databricks bereitgestellt wird
  • Eine temporäre benutzerdefinierte Funktion, die auf die aktuelle Sitzung beschränkt ist
  • Eine persistente, benutzerdefinierte Funktion oder Prozedur, die im Hive Metastore oder Unity-Katalog gespeichert ist.

Die Auflösung eines Routinenamens hängt davon ab, ob er qualifiziert ist:

  • Qualifiziert

    Wenn der Name mit drei Teilen vollqualifiziert ist, catalog.schema.routine, ist er eindeutig.

    Wenn der Name aus zwei Teilen besteht, schema.routine, wird er mit dem Ergebnis von SELECT current_catalog() weiter qualifiziert, um ihn eindeutig zu machen.

    Ist das Schema session, wird es weiter mit system qualifiziert und als temporäre Funktion interpretiert.

    Die Routine wird dann im Katalog nachgeschlagen.

  • Nicht qualifiziert

    • Schema-Suchpfad: In Databricks SQL und Databricks Runtime 19 und höher wird der Routinenamen mit jedem Schema auf dem PATH der Reihenfolge nach qualifiziert und der erste Treffer ausgewählt.
    • Fehlende Kataloge oder Schemata: Fehlende Kataloge oder Schemata auf dem Pfad werden übersprungen. Ein Objekt, für das der Benutzer unzureichende Rechte hat, wird nicht übersprungen; Azure Databricks löst den entsprechenden Fehler aus.
    • Wo sich Routinen befinden: Eingebaute skalare und tabellenartige Funktionen befinden sich in system.builtin, KI-Funktionen in system.ai, und temporäre Funktionen in system.session.
    • Standardpfad: Der StandardwegPATH ist system.session, dann system.builtin, dann system.ai, dann CURRENT_SCHEMA.

    Warning

    Temporäre Funktionen mit demselben Namen wie eingebaute Funktionen haben Vorrang, da system.session sie auf dem Standardpfad vorankommen system.builtin . Du kannst den Pfad mit SET PATH neu ordnen. Verlassen Sie sich nicht darauf, dass temporäre Funktionen die eingebauten Funktionen überschatten.

    • Wo der Weg verläuft:

      Kontext Verwendeter Weg
      Unqualifizierte Routinenamen in Abfragen und DML Sitzungs-PFAD
      Körper einer benutzerdefinierten SQL-Funktion PATH zur Erstellungszeit erfasst
      Ablauf eines Verfahrens SQL SECURITY DEFINER PATH wird zur Erstellungszeit erfasst, ohne system.session
      Ablauf eines Verfahrens SQL SECURITY INVOKER Anrufer live PATH
      Subjekt von CREATE FUNCTION, DROP FUNCTION, , CREATE PROCEDUREund ähnlichen Aktuelles Schema (keine Pfadsuche)
    • Frühere Versionen: In Databricks Runtime 18 und niedriger folgt Azure Databricks einer festen Vorrangfolge.

      1. Integrierte Funktion

        Wenn eine Funktion mit diesem Namen im Satz integrierter Funktionen vorhanden ist, wird diese Funktion ausgewählt.

      2. Temporäre Funktion

        Wenn eine Funktion mit diesem Namen im Satz temporärer Funktionen vorhanden ist, wird diese Funktion ausgewählt.

      3. Persistente Funktion

        Der Funktionsname wird als vollqualifiziert festgelegt, indem das Ergebnis von SELECT current_catalog() und SELECT current_schema() vorab als ausstehend markiert und als persistente Funktion nachgeschlagen wird.

Wenn die Routine nicht aufgelöst werden kann, löst Azure Databricks einen UNRESOLVED_ROUTINE Fehler aus.

Eroberter Weg

  • SQL-benutzerdefinierte Funktion: Unqualifizierte Namen im Körper werden gegen den PATH aufgelöst, der bei erfasst wird CREATE FUNCTION, nicht gegen den Sitzungspfad des Aufrufers. current_path() und current_schema() in diesem Körper werden die Sitzungswerte des Aufrufers weiterhin zurückgegeben.
  • Prozedur mit SQL SECURITY DEFINER: Unqualifizierte Namen werden gegen den bei CREATE PROZEDUR erfassten PFAD aufgelöst, wobei system.session ausgelassen wird. current_path() In diesem Körper kehrt derselbe gefangene Weg zurück.
  • Vorgehen mit SQL SECURITY INVOKER: Unqualifizierte Namen nutzen den Live-Pfad des Anrufers.

Beispiele

> 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