Naamomzetting

Van toepassing op:aangevinkt als ja Databricks SQL aangevinkt als ja Databricks Runtime

Naamomzetting is het proces waarmee id's worden omgezet in specifieke kolom-, veld-, parameter- of tabelverwijzingen.

Kolom-, veld-, parameter- en variabeleverwerking

Id's in expressies kunnen verwijzingen naar een van de volgende zijn:

  • Kolomnaam op basis van een view, tabel, algemene tabelexpressie (CTE) of een column_alias.
  • Veldnaam of kaartsleutel binnen een struct of kaart. Velden en sleutels kunnen nooit ongedefinieerd zijn.
  • Parameternaam van een door de gebruiker gedefinieerde SQL-functie of SQL-procedure.
  • Variabelenaam van een lokale sessie of SQL-script .
  • Een speciale functie, zoals current_user of current_date, waarvoor geen gebruik van () vereist is.
  • Het DEFAULT trefwoord dat wordt gebruikt in de context vanINSERT, UPDATEof MERGESET VARIABLEom een kolom- of variabelewaarde in te stellen op de standaardwaarde.

Naamomzetting past de volgende principes toe:

  • De dichtstbijzijnde overeenkomende referentie wint en
  • Kolommen en parameters zijn belangrijker dan velden en sleutels.

In detail volgt de oplossing van id's naar een specifieke verwijzing de volgende regels in volgorde:

  1. Lokale verwijzingen

    1. Kolomreferentie

      Koppel de identificator, die eventueel kan worden gekwalificeerd, aan een kolomnaam in een tabelreferentie van de FROM clause.

      Als er meer dan één overeenkomst is, wordt een AMBIGUOUS_COLUMN_OR_FIELD fout weergegeven.

    2. Parameterloze functie referentie

      Als de id niet gekwalificeerd is en overeenkomt met current_user, current_date of current_timestamp: Los deze op als een van deze functies.

    3. Standaardspecificatie voor kolom

      Als de identifier niet gekwalificeerd is, komt deze overeen met default en vormt deze de volledige expressie in de context van een UPDATE SET, INSERT VALUES, of MERGE WHEN [NOT] MATCHED: Oplossen als de respectieve DEFAULT waarde van de doeltabel van de INSERT, UPDATE of MERGE.

    4. Verwijzing naar veld- of mapsleutel

      Als de identificator is gekwalificeerd, moet men proberen deze te koppelen aan een veld of sleutel in een kaart volgens de volgende stappen:

      Eén. Verwijder de laatste identifier en behandel deze als een veld of sleutel. B. Koppel de rest aan een kolom in tabelreferentie van de FROM clause.

      Als er meer dan één overeenkomst is, wordt een AMBIGUOUS_COLUMN_OR_FIELD fout weergegeven.

      Als er een overeenkomst is en de kolom een:

      • STRUCT: Komt overeen met het veld.

        Als het veld niet overeenkomt, geef een FIELD_NOT_FOUND foutmelding.

        Als er meer dan één veld is, wordt een AMBIGUOUS_COLUMN_OR_FIELD fout gegenereerd.

      • MAP: Genereer een foutmelding als de sleutel is gekwalificeerd.

        Er kan een runtimefout optreden als de sleutel niet daadwerkelijk aanwezig is in de kaart.

      • Elk ander type: een fout veroorzaken. C. Herhaal de voorgaande stap om de volgende identificator als veld te verwijderen. Pas regels (A) en (B) toe terwijl er nog een identifier is die moet worden geïnterpreteerd als een kolom.

  2. Laterale kolomaliasvorming

    Van toepassing op:vinkje als ja aan Databricks SQL vinkje als ja aan Databricks Runtime 12.2 LTS en hoger

    Als de expressie zich in een SELECT lijst bevindt, komt de voorafgaande identifier overeen met een voorgaande kolomalias in die SELECT lijst.

    Als er meer dan één overeenkomst is, moet u een AMBIGUOUS_LATERAL_COLUMN_ALIAS fout melden.

    Match elke resterende identificator als een veld of een sleutel in een map, en geef de FIELD_NOT_FOUND of AMBIGUOUS_COLUMN_OR_FIELD fout weer als ze niet kunnen overeenkomen.

  3. Correlatie

    • LATERAAL

      Als de query wordt voorafgegaan door een LATERAL trefwoord, past u regels 1.a en 1.d toe, rekening houdend met de tabelverwijzingen in de FROM met de query en vóór de LATERALquery.

    • Normaal

      Als de query een scalaire subquery, IN, of EXISTS subquery is, worden regels 1.a, 1.d en 2 toegepast, rekening houdend met de tabelverwijzingen in de component van de omhullende query's FROM-clausule.

  4. Geneste correlatie

    Van toepassing op:vinkje gemarkeerd ja Databricks SQL vinkje ja Databricks Runtime 20.0 en hoger

    Pas regel 3 opnieuw toe, en herhaal de nestingsniveaus van de query, zodat een identifier kan worden opgelost naar een gecorreleerde referentie in elke omsluitende query, niet alleen de direct omslotende.

  5. FOR-lus

    Als de verklaring is opgenomen in een FOR lus:

    Eén. Koppel de id aan een kolom in een FOR lusinstructiequery. Als de id is gekwalificeerd, moet de kwalificatie overeenkomen met de naam van de FOR-lusvariabele, indien gedefinieerd. B. Als de identificator is gekwalificeerd, komt deze overeen met een veld of sleutel van een mapping van een parameter volgens regel 1.c

  6. samengestelde instructie

    Als de instructie is opgenomen in een samengestelde instructie:

    Eén. Koppel de identificator aan een variabele die binnen de samengestelde instructie is gedeclareerd. Als de identificator is gekwalificeerd, moet de kwalificatie overeenkomen met het label van de samengestelde instructie als er een is gedefinieerd. B. Als de identificator is gekwalificeerd, komt het overeen met een veld of een sleutel van een map van een variabele volgens regel 1.c

  7. geneste samengestelde instructie of FOR lus

    Pas regels 5 en 6 opnieuw toe door over de nestniveaus van de samengestelde opdracht te itereren.

  8. Routineparameters

    Als de expressie deel uitmaakt van een CREATE FUNCTION of CREATE PROCEDURE-instructie :

    1. Koppel de id aan een parameternaam. Als de identificator is gekwalificeerd, moet de kwalificatie overeenkomen met de naam van de routine.
    2. Als de identificator is gekwalificeerd, komt deze overeen met een veld of sleutel van een mapping van een parameter volgens regel 1.c

  9. Sessievariabelen

    1. Koppel de id aan een variabelenaam. Als de identifier is gekwalificeerd, moet de kwalificatie session of system.session zijn. In Databricks SQL en Databricks Runtime 19 en hoger komt een niet-gekwalificeerde identifier alleen overeen met een sessievariabele als system.session zich op het PATH bevindt.
    2. Als de identificator is gekwalificeerd, komt het overeen met een veld of een sleutel van een map van een variabele volgens regel 1.c

Naamomzetting in HAVING, ORDER BYen QUALIFY

De HAVING, ORDER BYen QUALIFY componenten kunnen verwijzen naar namen uit de SELECT lijst, evenals kolommen uit de onderliggende tabellen. Wanneer een naam in een van deze componenten overeenkomt met zowel een kolomalias in de SELECT lijst als een tabelkolom, lossen de componenten de dubbelzinnigheid anders op:

  • ORDER BY geeft de voorkeur aan de SELECT lijstalias boven de tabelkolom.
  • HAVING geeft de voorkeur aan de tabelkolom boven de SELECT lijstalias.
  • QUALIFY geeft de voorkeur aan de tabelkolom boven de SELECT lijstalias (hetzelfde als HAVING).

Voorbeelden

> 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

Prioriteit voor veldextractie en naamomzetting

Wanneer een gekwalificeerde naam zoals a.b wordt gebruikt in HAVING of ORDER BY, zijn de bovenstaande prioriteitsregels nog steeds van toepassing, maar met een extra overweging: de voorkeurskandidaat moet structveld- of kaartsleutelextractie ondersteunen. Als dit niet het geval is, wordt de andere kandidaat gebruikt.

Als de alias a bijvoorbeeld wordt omgezet in een gewone INT waarde, maar de tabelkolom a een veld met een STRUCT veld xis, ORDER BY kiest u de STRUCT kolom omdat een veld niet kan worden geëxtraheerd uit de INT alias. Als de tabelkolom daarentegen een gewone INT kolom is en de alias een STRUCT, HAVING valt terug naar de alias voor veldextractie.

Voorbeelden

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

Beperkingen

In Databricks SQL en Databricks Runtime 20.0 en hoger wordt geneste correlatie (een subquery die kolommen van een omsluitende query buiten de directe ouder verwijst) ondersteund, met de volgende beperkingen:

  • Geneste correlatie wordt niet ondersteund voor subqueries in een HAVING clausule.
  • Een LATERAL subquery kan niet genest-gecorreleerd zijn. De buitenste referenties moeten worden opgelost naar de direct omsluitende query.

In Databricks Runtime-versies onder 20.0 is correlatie beperkt tot één niveau: een subquery kan alleen kolommen verwijzen vanuit de query die deze direct omsluit.

Voorbeelden

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

Tabel- en weergave-resolutie

Een id in tabelverwijzing kan een van de volgende zijn:

  • Permanente tabel of weergave in Unity Catalog of de Hive-metastore
  • Algemene tabelexpressie (CTE)
  • Tijdelijke weergave of tijdelijke tabel

De oplossing van een id is afhankelijk van of deze is gekwalificeerd:

  • Gekwalificeerd

    Als de id volledig is gekwalificeerd met drie onderdelen: catalog.schema.relationis deze uniek.

    Als de id uit twee delen bestaat: schema.relation, wordt deze verder onderscheiden met het resultaat van SELECT current_catalog() om hem uniek te maken.

    Als het schema is session, wordt het verder gekwalificeerd met system en geïnterpreteerd als een tijdelijke weergave of tijdelijke tabel. Als het schema is global_temp, wordt het verder gekwalificeerd met system en geïnterpreteerd als een globale tijdelijke weergave in Databricks Runtime.

  • Onbevoegd

    1. Algemene tabelexpressie

      Als de verwijzing binnen het bereik van een WITH clausule valt, koppelt u de identificatie aan een CTE die begint bij de onmiddellijk bevattende WITH clausule en zich van daaruit naar buiten beweegt.

    2. Schema-zoekpad

      In Databricks SQL en Databricks Runtime 19 en hoger, kwalificeer je de relatie met elk schema op de PATH, in volgorde, totdat er een match wordt gevonden.

      • Ontbrekende catalogi of schema's: Ontbrekende catalogi of schema's op het pad worden overgeslagen. Een object waarvoor de gebruiker onvoldoende rechten heeft, wordt niet overgeslagen; Azure Databricks geeft de bijbehorende foutmelding.
      • Tijdelijke weergaven en tabellen: Tijdelijke weergaven en tijdelijke tabellen bevinden zich in system.session, dus ze worden bereikt wanneer system.session op de PATH.
      • Persistente tabellen en weergaven in het huidige schema: Persistente tabellen en weergaven in het huidige schema worden bereikt via de virtuele CURRENT_SCHEMA invoer.

      Het pad geldt voor ongekwalificeerde relatienamen in queries en DML, en voor niet-gekwalificeerde namen in een query die deel uitmaakt van een DDL-instructie.

      • Waar het pad van toepassing is:

        Context Gebruikt pad
        Queries en DML (SELECT, INSERT, UPDATE, DELETE, , MERGE) Sessie PAD
        Query van CREATE TABLE AS Sessie PAD
        Query van een persistent CREATE VIEW PATH vastgelegd op het moment van creatie
        Onderwerp van CREATE, DROP, , ALTERen soortgelijk current_catalog.current_schema (geen padzoeker)

      • Eerdere releases: In Databricks Runtime 18 en lager wordt een niet-gekwalificeerde relatie die geen CTE is in een vaste volgorde opgelost.

        1. Tijdelijke weergave of tijdelijke tabel

          Koppel de id aan een tijdelijke weergave of tijdelijke tabel die is gedefinieerd in de huidige sessie.

        2. Persistente tabel

          Het kenmerk volledig kwalificeren door het resultaat van SELECT current_catalog() voor te plaatsen en SELECT current_schema() op te zoeken als een blijvende relatie.

Als de relatie niet kan worden omgezet in een tabel, weergave of CTE, genereert Databricks een TABLE_OR_VIEW_NOT_FOUND fout.

Veroverd pad

Een persistent view legt het sessie-PAD vast tijdens het aanmaken. Latere zoekopdrachten van de view lossen ongekwalificeerde namen op tegen dat vastgelegde pad, niet tegen het sessiepad van de invoker. current_path() en current_schema() in die query geven ze nog steeds de sessiewaarden van de aanroeper terug.

Voorbeelden

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

Functie en procedure-resolutie

Een routinereferentie (een functieaanroep of procedureaanroep) wordt herkend door de verplichte achterliggende set haakjes.

Het kan leiden tot:

De oplossing van een routinenaam hangt af van of deze gekwalificeerd is:

  • Gekwalificeerd

    Als de naam volledig is gekwalificeerd met drie delen: catalog.schema.routine, is deze uniek.

    Als de naam uit twee delen bestaat, schema.routinewordt deze verder gekwalificeerd met het resultaat SELECT current_catalog() om deze uniek te maken.

    Als het schema is session, wordt het verder gekwalificeerd met system en geïnterpreteerd als een tijdelijke functie.

    De routine wordt vervolgens opgezocht in de catalogus.

  • Onbevoegd

    • Schema zoekpad: In Databricks SQL en Databricks Runtime 19 en hoger, kwalificeer je de routinenaam met elk schema op de PATH in volgorde en kies je de eerste match.
    • Ontbrekende catalogi of schema's: Ontbrekende catalogi of schema's op het pad worden overgeslagen. Een object waarvoor de gebruiker onvoldoende rechten heeft, wordt niet overgeslagen; Azure Databricks geeft de bijbehorende foutmelding.
    • Waar routines zich bevinden: Ingebouwde scalair- en tabelfuncties staan in system.builtin, AI-functies in system.ai, en tijdelijke functies in system.session.
    • Standaardpad: De standaard PATH is system.session, dan system.builtin, dan system.ai, dan CURRENT_SCHEMA.

    Warning

    Tijdelijke functies met dezelfde naam als ingebouwde functies krijgen voorrang omdat system.session ze voorafgaan system.builtin op het standaardpad. Je kunt het pad herordenen met SET PATH. Vertrouw niet op tijdelijke functies die ingebouwde functies schaduwen.

    • Waar het pad van toepassing is:

      Context Gebruikt pad
      Ongekwalificeerde routinenamen in queries en DML Sessie PAD
      Body van een door de gebruiker gedefinieerde SQL-functie PATH vastgelegd op het moment van creatie
      Lichaam van een SQL SECURITY DEFINER procedure PATH vastgelegd op het moment van creatie, zonder system.session
      Lichaam van een SQL SECURITY INVOKER procedure Bellers live PATH
      Onderwerp van CREATE FUNCTION, DROP FUNCTION, , CREATE PROCEDUREen soortgelijk Huidig schema (geen padzoek)

    • Eerdere releases: In Databricks Runtime 18 en lager volgt Azure Databricks een vaste volgorde van prioriteit.

      1. Ingebouwde functie

        Als er een functie met deze naam bestaat in de set ingebouwde functies, wordt die functie gekozen.

      2. Tijdelijke functie

        Als er een functie met deze naam bestaat tussen de set tijdelijke functies, wordt die functie gekozen.

      3. Opgeslagen functie

        Kwalificeer de functienaam volledig door het resultaat van SELECT current_catalog() eraan vooraf te laten gaan en zoek het op als een permanente functie.

Als de routine niet kan worden opgelost, levert Azure Databricks een UNRESOLVED_ROUTINE foutmelding op.

Veroverd pad

  • SQL-gebruikersgedefinieerde functie: Niet-gekwalificeerde namen in de body worden opgelost tegen het PATH dat wordt vastgelegd bij CREATE FUNCTION, niet tegen het sessiepad van de aanroeper. current_path() en current_schema() in dat lichaam geven ze nog steeds de sessiewaarden van de invoker terug.
  • Procedure met SQL SECURITY DEFINER: Niet-gekwalificeerde namen worden opgelost tegen het PAD dat bij CREATE PROCEDURE is vastgelegd, met system.session weggelaten. current_path() In dat lichaam keert datzelfde gevangen pad terug.
  • Procedure met SQL SECURITY INVOKER: Ongespecificeerde namen gebruiken het live pad van de beller.

Voorbeelden

> 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
  • Laatst bijgewerkt om