Scala és Java felhasználó által definiált függvények (UDF-ek) a Unity Katalógusban

Ez a lap bemutatja, hogyan hozhat létre Scalát és Java felhasználó által definiált függvényeket (UDF-eket), regisztrálhatja őket a Unity Catalogban, és megoszthatja őket számítási környezetekben. A Unity Catalog UDF-jei lehetővé teszik a meglévő JVM-logika újrafelhasználását a Unity Catalog szabályozási és hozzáférési vezérlőivel.

A munkamenet-hatókörű Scala UDF-ekkel ellentétben, amelyek egyetlen jegyzetfüzetre vagy fürtre korlátozódnak, a Unity Katalógusban regisztrált UDF-ek a következők:

• Szabályozva: Unity Catalog-engedélyekkel és hozzáférés-vezérléssel felügyelve.
• Újrafelhasználható: Megosztott csoportok, jegyzetfüzetek, feladatok és SQL-raktárak között.
• Felderíthető: Látható a Katalóguskezelőben és a rendszertáblákban.
• Izolált: Futtatás tesztkörnyezetekben, munkamenetenként egyszeri hidegindítási költséggel. A további hívások gyorsak.

Requirements

A munkaterületet alkalmassá kell tenni a Unity Catalog használatához. A következő további követelmények érvényesek.

Számítás: Minden számítási típus támogatott, beleértve a kiszolgáló nélküli jegyzetfüzeteket és feladatokat, az SQL-raktárakat és a Spark Deklaratív folyamatokat a Lakeflow-on. A klasszikus számításhoz a Databricks Runtime 18.2-s vagy újabb verziója szükséges. Kiszolgáló nélküli számítási és SQL-tárolók esetén az UDF-definíciónak meg kell adnia a 4. vagy újabb környezeti verziót a environment_version mezőben. Ez a követelmény az UDF-definícióra vonatkozik, nem a hívó jegyzetfüzetre vagy feladatra. Lásd: Környezeti verziók.

Fejlesztés:

• Scala: 2.13.16. A Scala 2.12 nem támogatott.
• JDK: 17.
• Csomagolás: Az UDF által használt összes külső függőséget tartalmazó zsíros JAR.

Engedélyek:

• Hozzon létre egy UDF-et: USAGE és CREATE FUNCTION a sémán, valamint USAGE a katalóguson.
• UDF végrehajtása: EXECUTE a függvényen, valamint USAGE a sémára és a katalógusra.
• Hozzáférés a JAR-fájlhoz: READ VOLUME azon a köteten, amelyen a JAR van tárolva.

A Unity-katalógus engedélyeinek kezelésével kapcsolatos további információkért lásd: Jogosultságok kezelése a Unity Katalógusban.

A UDF JAR létrehozása

Csomagolja be a lefordított kódot JAR-ként, és töltse fel egy Unity Catalog-kötetbe a UDF regisztrálása előtt. Válasszon buildelési módszert:

• Helyi buildelés
• Összeállítás jegyzetfüzetben

Helyi buildelés

Kövesse az alábbi lépéseket egy fat JAR helyi fejlesztői környezetben történő létrehozásához.

Saját környezet beállítása

Telepítse a szükséges eszközöket a helyi gépen. A következő parancsok a macOS-hez tartoznak. Más platformok esetén telepítse a JDK 17-et és az sbt-t (Scala) vagy a Mavent (Java) a platform csomagkezelőjével.

Scala

Telepítse a JDK 17-et és az sbt-t:

brew install openjdk@17
brew install sbt

Ellenőrizze a telepítést:

java -version   # Should show Java 17
sbt --version   # Should show sbt version

Java

Telepítse a JDK 17-et és a Maven-t:

brew install openjdk@17
brew install maven

Ellenőrizze a telepítést:

java -version   # Should show Java 17
mvn --version   # Should show Maven version

A projekt létrehozása

Projekt beállítása a Scalában vagy Java.

Scala

Hozzon létre egy új Scala-projektet a következővel sbt:

sbt new scala/scala-seed.g8

Amikor a rendszer kéri, adjon meg egy projektnevet (például my-udf-project).

build.sbt konfigurálása

Cserélje le a build.sbt fájl tartalmát a következő konfigurációra:

scalaVersion := "2.13.16"

ThisBuild / organization := "com.example"

lazy val myUDF = (project in file("."))
  .settings(
    name := "my-udf"
  )

Az sbt-assembly beépülő modul engedélyezése

Hozza létre vagy szerkessze a(z) project/assembly.sbt elemet, és adja hozzá:

addSbtPlugin("com.eed3si9n" % "sbt-assembly" % "2.0.0")

Ez a beépülő modul létrehoz egy kövér JAR-t, amely tartalmazza az összes függőséget.

Java

Hozzon létre egy új Maven-projektet a quickstart archetípus használatával:

mvn archetype:generate \
  -DgroupId=com.example \
  -DartifactId=my-udf \
  -DarchetypeArtifactId=maven-archetype-quickstart \
  -DinteractiveMode=false

Ez a parancs létrehozza a szabványos Maven-projektstruktúrát a src/main/java- és src/test/java könyvtárakkal.

pom.xmlkonfigurálása

A létrehozott pom.xml fájlban a <project></project> címkéken belül adjon hozzá egy blokkot <properties> a következő konfigurációval:

<properties>
  <maven.compiler.source>17</maven.compiler.source>
  <maven.compiler.target>17</maven.compiler.target>
  <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>

A címkéken <project></project> belül is adjon hozzá egy blokkot <build> a következő konfigurációval:

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-shade-plugin</artifactId>
            <version>3.5.0</version>
            <executions>
                <execution>
                    <phase>package</phase>
                    <goals>
                        <goal>shade</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

A maven-shade-plugin létrehoz egy kövér JAR-fájlt, az összes függőséggel együtt.

A UDF írása

Az UDF írásakor a támogatott adattípusokkal kapcsolatban lásd: Adattípusok, illetve a Nyelvi leképezések című részt, ahol megtekintheti, hogy a Scala- és Java-típusok hogyan feleltethetők meg az SQL-típusoknak.

Az UDF-kezelőnek meg kell felelnie a következő követelményeknek:

• Scala: A kezelőt metódusként definiálja egy object (nem egy class) rendszeren. Az HANDLER érték egy Scala object metódusára oldódik fel.
• Java: Adja meg a kezelőt public staticmetódusként.
• Szignatúra: A metódus paramétertípusainak, sorrendjének és visszatérési típusának meg kell felelnie az argumentumlistának és a RETURNS utasításban szereplő CREATE FUNCTION típusnak.
• Csak skaláris: A kezelőnek egyetlen skaláris értéket kell visszaadnia. A tábla visszaküldési típusai nem támogatottak.
• Önálló: A kezelőnek csak a bemeneti argumentumokon kell működnie. Nem használhat Spark API-kat, és nem függhet a Spark core-csomagoktól. Lásd Korlátozások.

Note

A Scala esetében a rendszer kihagy egy primitív paramétertípusú (például Int) kezelőt, és akkor ad vissza NULL , ha bármely bemeneti argumentum SQL NULL. A NULL értékek fogadásához és kezeléséhez foglalja a paramétert Option közé, például Option[Int].

Scala

Hozzon létre egy Scala-objektumot a(z) src/main/scala/com/example/MyUDF.scala elemben, és definiálja az UDF-függvényt.

Egyszerű példa

package com.example

object MyUDF {
  def addOne(x: Int): Int = x + 1
}

Példa külső függőséggel

Külső kódtárak használatához vegye fel őket a build.sbt fájlba:

scalaVersion := "2.13.16"

ThisBuild / organization := "com.example"

lazy val myUDF = (project in file("."))
  .settings(
    name := "currency-udf",
    libraryDependencies ++= Seq(
      "org.apache.commons" % "commons-lang3" % "3.12.0"
    )
  )

Ezután használja ezt a függőséget az UDF-ben:

package com.example

import org.apache.commons.lang3.StringUtils

object CurrencyUDF {
  private val rates: Map[String, Double] = Map(
    "USD" -> 1.0,
    "EUR" -> 1.1,
    "GBP" -> 1.3,
    "JPY" -> 0.007
  )

  def convertToUSD(price: Double, currency: String): Double = {
    require(currency != null, "Currency must not be null")

    val normalizedCurrency = StringUtils.upperCase(currency)

    rates.get(normalizedCurrency) match {
      case Some(rate) => price * rate
      case None => throw new IllegalArgumentException(s"Unsupported currency: $currency")
    }
  }
}

Az üzembe helyezés előtt tesztelje az UDF-et egységtesztekkel. Lásd az UDF-ek helyi tesztelését.

Java

Hozzon létre egy Java-osztályt a(z) src/main/java/com/example/MyUDF.java helyen, és adja meg az UDF-et nyilvános statikus metódusként.

Egyszerű példa

package com.example;

public class MyUDF {
    public static int addOne(int x) {
        return x + 1;
    }
}

Példa külső függőséggel

Külső könyvtárak használatához adja hozzá őket a <dependencies> fájl pom.xml szakaszához:

<dependencies>
    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-lang3</artifactId>
        <version>3.12.0</version>
    </dependency>
</dependencies>

Ezután használja ezt a függőséget az UDF-ben:

package com.example;

import org.apache.commons.lang3.StringUtils;
import java.util.Map;
import java.util.HashMap;

public class CurrencyUDF {
    private static final Map<String, Double> rates = new HashMap<>();

    static {
        rates.put("USD", 1.0);
        rates.put("EUR", 1.1);
        rates.put("GBP", 1.3);
        rates.put("JPY", 0.007);
    }

    public static double convertToUSD(double price, String currency) {
        if (currency == null) {
            throw new IllegalArgumentException("Currency must not be null");
        }

        String normalizedCurrency = StringUtils.upperCase(currency);

        if (!rates.containsKey(normalizedCurrency)) {
            throw new IllegalArgumentException("Unsupported currency: " + currency);
        }

        return price * rates.get(normalizedCurrency);
    }
}

Az üzembe helyezés előtt tesztelje az UDF-et egységtesztekkel. Lásd az UDF-ek helyi tesztelését.

Note

Az UDF egy izolált tesztkörnyezetben fut aktív Spark-munkamenet nélkül, így nem használhat Spark API-kat a függvény törzséből. Például nem hozhat létre DataFrame-eket vagy Dataseteket, és nem végezhet rajtuk műveleteket, nem futtathat spark.sql(...), illetve nem férhet hozzá a(z) SparkSession vagy SparkContext elemekhez. Az UDF-nek önálló logikának kell lennie a bemeneti argumentumai felett. A Spark core-csomagoktól sem függhet.

Készítse el a zsíros JAR-t

Buildelje a projektet úgy, hogy egy minden függőséget tartalmazó JAR-fájlt hozzon létre.

Scala

A projekt gyökérkönyvtárában futtassa a következő parancsot:

sbt clean assembly

Az önálló JAR-fájl a(z) target/scala-2.13/ könyvtárban jön létre, my-udf-assembly-0.1.0-SNAPSHOT.jar-hez hasonló néven.

Java

A projekt gyökérkönyvtárában futtassa a következő parancsot:

mvn clean package

Az önálló JAR-fájl a(z) target/ könyvtárban jön létre, my-udf-1.0-SNAPSHOT.jar-hez hasonló néven.

JAR feltöltése Unity-katalóguskötetbe

Ha még nem rendelkezik Unity Catalog-kötetel, hozzon létre egyet:

CREATE VOLUME IF NOT EXISTS my_catalog.my_schema.udf_jars
COMMENT 'Storage for UDF JAR files';

Ha más felhasználóknak is futtatniuk kell az UDF-et, adjon nekik READ VOLUME jogosultságot a köteten:

GRANT READ VOLUME ON VOLUME my_catalog.my_schema.udf_jars TO `user@example.com`;

Töltse fel JAR-fájlját a kötetre a Catalog Explorer használatával:

1. A Azure Databricks munkaterületen kattintson a Catalog elemre a Catalog Explorer megnyitásához.
2. Jelölje ki a katalógust, majd válassza ki a kötetet tartalmazó sémát.
3. Kattintson a kötet nevére.
4. Kattintson a Feltöltés erre a kötetre lehetőségre, és válassza ki a JAR-fájlt.
5. Kattintson a Feltöltés gombra.
6. A feltöltés befejezése után kattintson a JAR-fájl nevére.
7. Kattintson az Elérési út másolása elemre, hogy a kötet elérési útját a vágólapra másolja. Például ( /Volumes/my_catalog/my_schema/udf_jars/my-udf-assembly-0.1.0-SNAPSHOT.jar Scala) vagy /Volumes/my_catalog/my_schema/udf_jars/my-udf-1.0-SNAPSHOT.jar (Java). Az UDF regisztrálásakor szüksége lesz erre az elérési útra.

Összeállítás jegyzetfüzetben

Lefordíthat egy UDF-et, becsomagzhatja JAR-ként, és feltöltheti egy Unity Catalog-kötetbe közvetlenül egy Azure Databricks jegyzetfüzetből. Ez a megközelítés a kis, függőségmentes UDF-ek esetében működik. Harmadik féltől származó kódtárakat használó UDF-ekhez használja a Build locally lehetőséget.

A következő Python-cella létrehoz egy Java UDF-et, amely megtisztít egy sztringet (levágja a környező szóközöket, az egymást követő szóközöket egyetlen szóközzé alakítja, és kisbetűssé alakítja), JDK 17-tel lefordítja, JAR-fájlként becsomagolja, majd átmásolja egy Unity Catalog-kötetbe. Úgy frissítse a volume_path elemet, hogy az egy meglévő kötetre mutasson, amelyhez WRITE VOLUME jogosultsága van.

import os
import subprocess
import shutil

build_dir = "/tmp/udf_build"
package_dir = f"{build_dir}/src/com/databricks/udf"
classes_dir = f"{build_dir}/classes"
os.makedirs(package_dir, exist_ok=True)
os.makedirs(classes_dir, exist_ok=True)

# The UDF handler: a public static method on a plain Java class.
# The doubled backslashes produce a single backslash in the Java source (\\s+).
udf_code = """package com.databricks.udf;
public class StringCleanUDF {
    public static String clean(String input) {
        if (input == null) return null;
        return input.trim().replaceAll("\\\\s+", " ").toLowerCase();
    }
}
"""
with open(f"{package_dir}/StringCleanUDF.java", "w") as f:
    f.write(udf_code)

# Compile with JDK 17 to match Environment Version 4.
subprocess.run(
    ["javac", "--release", "17", "-d", classes_dir, f"{package_dir}/StringCleanUDF.java"],
    check=True,
)

# Package the compiled class into a JAR.
jar_path = f"{build_dir}/string_clean_udf.jar"
subprocess.run(["jar", "cf", jar_path, "-C", classes_dir, "."], check=True)

# Copy the JAR to a Unity Catalog volume.
volume_path = "/Volumes/my_catalog/my_schema/udf_jars/string_clean_udf.jar"
os.makedirs(os.path.dirname(volume_path), exist_ok=True)
shutil.copy2(jar_path, volume_path)

print(f"JAR uploaded to: {volume_path}")

Miután a JAR a kötetben van, regisztrálja az UDF-et. Használja a(z) LANGUAGE JAVA elemet, és állítsa a(z) HANDLER értékét a teljesen minősített metódusra, például com.databricks.udf.StringCleanUDF.clean.

Regisztrálja az UDF-jét a Unity Catalogban

A JAR létrehozása és feltöltése után az CREATE FUNCTION utasítás használatával regisztrálja az UDF-et a Unity Catalogban.

Scala

CREATE OR REPLACE FUNCTION my_catalog.my_schema.add_one(x INT)
RETURNS INT
LANGUAGE SCALA
DETERMINISTIC
ENVIRONMENT (
  java_dependencies = '["/Volumes/my_catalog/my_schema/udf_jars/my-udf-assembly-0.1.0-SNAPSHOT.jar"]',
  environment_version = '4'
)
HANDLER 'com.example.MyUDF.addOne';

Java

CREATE OR REPLACE FUNCTION my_catalog.my_schema.add_one(x INT)
RETURNS INT
LANGUAGE JAVA
DETERMINISTIC
ENVIRONMENT (
  java_dependencies = '["/Volumes/my_catalog/my_schema/udf_jars/my-udf-1.0-SNAPSHOT.jar"]',
  environment_version = '4'
)
HANDLER 'com.example.MyUDF.addOne';

Az CREATE FUNCTION utasítás a következő paramétereket használja:

• LANGUAGE: Az UDF nyelve.

• HANDLER: A metódus teljesen minősített elérési útja, a következő formátumban: 'package.Object.method' (Scala) vagy 'package.ClassName.method' (Java).

• DETERMINISTIC: Deklarálja, hogy a függvény mindig ugyanazt a kimenetet adja vissza ugyanahhoz a bemenethez, ami lehetővé teszi a lekérdezés optimalizálását.

  Note

  Távolítsa el DETERMINISTIC , ha a függvény külső API-kat hív meg, vagy bármilyen más, nem determinisztikus viselkedést észlel.

• ENVIRONMENT: Meghatározza a UDF végrehajtási környezetét.

  • java_dependencies: A Unity Catalog köteteiben található JAR-fájlok elérési útvonalainak JSON-tömbje. Ez az előző lépésben másolt fájl elérési útja. Használjon egy idézőjelet a tömb körül, és dupla idézőjeleket az útvonalak körül.
  • environment_version: A Scala és Java UDF-ek esetében a következőnek kell lennie vagy annál magasabbnak kell lennie'4'. A 4. környezeti verzió a Scala 2.13.16-ot és a JDK 17-et adja meg. Lásd: Környezeti verziók.

UDF meghívása SQL-ben és jegyzetfüzetekben

A regisztráció után meghívhatja az UDF-et SQL-lekérdezésekben, jegyzetfüzetekben és nézetekben:

-- Simple select
SELECT my_catalog.my_schema.add_one(5) AS result;

-- With table data
SELECT
  id,
  price,
  currency,
  my_catalog.my_schema.convert_to_usd(price, currency) AS price_usd
FROM my_catalog.my_schema.transactions;

-- Filtering
SELECT *
FROM my_catalog.my_schema.products
WHERE my_catalog.my_schema.convert_to_usd(price, currency) > 100;

-- Aggregation
SELECT
  category,
  SUM(my_catalog.my_schema.convert_to_usd(price, currency)) AS total_usd
FROM my_catalog.my_schema.sales
GROUP BY category;

Irányítás és megosztás

A Unity Catalog engedélyeinek használatával szabályozhatja, hogy ki futtathatja a UDF-et, és hogy az a szervezeten belül is felderíthető legyen.

Engedélyek megadása

A Catalog Explorer vagy az SQL használatával adja meg a szükséges engedélyeket más felhasználók számára az UDF-ek futtatásához.

Katalóguskezelő

1. Az oldalsávon kattintson az Katalógus.
2. Jelölje ki a katalógust, majd válassza ki a függvényt tartalmazó sémát.
3. Kattintson a függvény nevére.
4. Az Engedélyek lapon kattintson az Engedélyezés gombra.
5. Jelölje ki azokat a tagokat, amelyhez hozzáférést kíván adni, és válassza ki az EXECUTE engedélyt.
6. Kattintson a Megerősítés gombra.

SQL

Futtassa a következő parancsot egy jegyzetfüzetben vagy a Databricks SQL-szerkesztőben, hogy engedélyeket adjon EXECUTE egy felhasználónak vagy csoportnak.

-- Grant to a specific user
GRANT EXECUTE ON FUNCTION my_catalog.my_schema.add_one TO `user@example.com`;

-- Grant to a group
GRANT EXECUTE ON FUNCTION my_catalog.my_schema.add_one TO `data-engineers`;

Engedélyek visszavonása

Más felhasználók engedélyeinek visszavonásához használja a Katalóguskezelőt vagy az SQL-t.

Katalóguskezelő

1. Az oldalsávon kattintson az Katalógus.
2. Jelölje ki a katalógust, majd válassza ki a függvényt tartalmazó sémát.
3. Kattintson a függvény nevére.
4. Az Engedélyek lapon jelölje be a hozzáférést visszavonni kívánt tag melletti jelölőnégyzetet. Kattintson a Visszavonásgombra.
5. Az értesítésben kattintson a Visszavonás gombra.

SQL

Futtassa a következő parancsot egy jegyzetfüzetben vagy a Databricks SQL-szerkesztőben egy felhasználó vagy csoport engedélyeinek visszavonásához EXECUTE .

-- Revoke from specific user
REVOKE EXECUTE ON FUNCTION my_catalog.my_schema.add_one FROM `user@example.com`;

-- Revoke from a group
REVOKE EXECUTE ON FUNCTION my_catalog.my_schema.add_one FROM `data-engineers`;

UDF-ek felfedezése

A Unity Catalog által kezelt UDF-ek megkereséséhez kérdezze le a(z) information_schema.routines táblát a(z) my_catalog és my_schema értékek helyettesítésével:

SELECT
  routine_catalog,
  routine_schema,
  routine_name,
  routine_definition,
  created
FROM system.information_schema.routines
WHERE routine_catalog = 'my_catalog'
  AND routine_schema = 'my_schema';

Az UDF frissítése

Meglévő Unity Catalog UDF frissítése új kóddal:

1. Módosítsa helyileg a kódot.
2. Építse újra a JAR-t egy új verziószámmal.
   • Scala: sbt clean assembly (például my-udf-assembly-0.2.0-SNAPSHOT.jar)
   • Java: mvn clean package (például my-udf-2.0-SNAPSHOT.jar)
3. Töltse fel az új JAR-t a Unity-katalógus kötetére.
4. Használja CREATE OR REPLACE FUNCTION ugyanazzal a függvénynévvel az UDF frissítéséhez. Ellenőrizze, hogy a(z) java_dependencies a legújabb JAR-fájlra hivatkozik-e.

Azure Databricks az új kódot használja a következő meghíváskor. Nem kell újraindítania a fürtöt.

Teljesítményoptimalizálás

Hideg indítási késés

A munkamenet első UDF-hívása inicializálja az izolált tesztkörnyezetet, ami késést eredményez. A későbbi hívások ugyanabban a munkamenetben gyorsabbak. Ezt figyelembe kell venni a késésre érzékeny számítási feladatok teljesítményértékelésekor vagy tervezésekor.

Költséges számítások gyorsítótárazása

Ha az UDF költséges inicializálást vagy számítást végez, gyorsítótárazza az eredményt, hogy azt csak egyszer kelljen kiszámítani.

Scala

Az eredmény gyorsítótárazásához használjon egy val mezőt a Scala objektumban:

package example

object CachedUDF {
  // Computed once and cached
  val expensiveData: Map[String, Double] = {
    // Load data from somewhere expensive
    Map("key1" -> 1.0, "key2" -> 2.0)
  }

  def lookup(key: String): Double = {
    expensiveData.getOrElse(key, 0.0)
  }
}

Java

Az eredmény gyorsítótárazásához használjon statikus static inicializáló blokkot tartalmazó mezőt:

package example;

import java.util.Map;
import java.util.HashMap;

public class CachedUDF {
    // Computed once and cached
    private static Map<String, Double> expensiveData;

    static {
        // Load data from somewhere expensive
        expensiveData = new HashMap<>();
        expensiveData.put("key1", 1.0);
        expensiveData.put("key2", 2.0);
    }

    public static double lookup(String key) {
        return expensiveData.getOrDefault(key, 0.0);
    }
}

Használja a DETERMINISTIC elemet adott esetben.

Jelölje meg az UDF-et DETERMINISTIC értékűként, ha azonos bemenet esetén mindig ugyanazt a kimenetet adja. Ez lehetővé teszi, hogy a lekérdezés-optimalizáló gyorsítótárazza az eredményeket, és javítsa a teljesítményt.

Limitations

• A rendszer csak a skaláris UDF-eket támogatja. A felhasználó által definiált összesítő függvények (UDAF-ok) és a felhasználó által definiált táblafüggvények (UDTF-ek) nem támogatottak.
• Az UDF-ek egy izolált tesztkörnyezetben futnak aktív Spark-munkamenet nélkül. A Spark API-k (SparkSession, , SparkContextspark.sql(...)DataFrame- és Adathalmaz-műveletek) nem érhetők el.
• Az UDF-ek nem függenek a Spark core-csomagoktól.
• Az UDF-ek nem férnek hozzá a munkaterület fájljaihoz vagy a Unity-katalógus köteteihez futásidőben.

Bevált gyakorlatok

A Databricks a következő eljárásokat javasolja:

• Verziószámozza a JAR-fájlokat. Például: my-udf-0.1.0.jar. my-udf-0.2.0.jar
• Sql-típusleképezések ellenőrzése az üzembe helyezés előtt. Lásd : Nyelvleképezések.
• READ VOLUME Csak azoknak a felhasználóknak adjon és EXECUTE adjon engedélyeket, akiknek futtatniuk kell a UDF-et. Használjon csoportos tulajdonlást a csapatok között megosztott UDF-ekhez.

UDF-ek helyi tesztelése

Az éles környezetbe történő telepítés előtt tesztelje az UDF-et egységtesztekkel.

Scala

A(z) src/main/scala/example/MyUDF.scala teszteléséhez hozzon létre egy tesztfájlt itt: src/test/scala/example/MyUDFTest.scala

package example

import org.scalatest.funsuite.AnyFunSuite

class MyUDFTest extends AnyFunSuite {
  test("addOne should add 1 to input") {
    assert(MyUDF.addOne(5) == 6)
  }

  test("addOne should handle negative numbers") {
    assert(MyUDF.addOne(-1) == 0)
  }
}

Adja hozzá a tesztfüggőséget a build.sbt-hoz:

libraryDependencies += "org.scalatest" %% "scalatest" % "3.2.15" % Test

A tesztek futtatása:

sbt test

Java

A(z) src/main/java/com/example/MyUDF.java teszteléséhez hozzon létre egy tesztfájlt itt: src/test/java/com/example/MyUDFTest.java

package com.example;

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;

public class MyUDFTest {
    @Test
    public void testAddOne() {
        assertEquals(6, MyUDF.addOne(5));
    }

    @Test
    public void testAddOneWithNegativeNumbers() {
        assertEquals(0, MyUDF.addOne(-1));
    }
}

Adja hozzá a JUnit-függőséget a(z) <dependencies>pom.xml szakaszához:

<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter</artifactId>
    <version>5.10.0</version>
    <scope>test</scope>
</dependency>

A tesztek futtatása:

mvn test

További források

• Munkamenet-hatókörű Scala és Java UDF-ek
• SQL és Python felhasználó által definiált függvények (UDF-ek) a Unity Catalogban
• Mik azok a felhasználó által definiált függvények (UDF-ek)?
• Adattípusok
• Jogosultságok kezelése a Unity Catalogban