Funções definidas pelo usuário (UDFs) no Unity Catalog

Visualização

Esse recurso está em Prévia Pública.

As funções definidas pelo usuário (UDFs) no Unity Catalog ampliam os recursos do SQL e do Python no Databricks. Eles permitem que funções personalizadas sejam definidas, usadas e compartilhadas e controladas com segurança em todos os ambientes de computação.

As UDFs do Python registradas como funções no Unity Catalog diferem em escopo e suporte das UDFs do PySpark com escopo para um Notebook ou SparkSession. Consulte Funções escalares definidas pelo usuário - Python.

Consulte CREATE FUNCTION (SQL e Python) para obter uma referência completa da linguagem SQL.

Requisitos

Para usar UDFs no Unity Catalog, os seguintes requisitos devem ser atendidos:

  • Para usar o código Python em UDFs registrados em Unity Catalog, o senhor deve usar um serverless ou pro SQL warehouse ou um cluster executando Databricks Runtime 13.3 LTS ou acima.

  • Se um view incluir um UC Python UDF, ele falhará em SQL Classic Warehouses.

  • Graviton O suporte de instância para Scala UDFs em clusters habilitado está disponível em Databricks Runtime 15.2 e acima.

Criação de UDFs no Unity Catalog

Para criar um UDF no Unity Catalog, os usuários precisam de permissão USAGE e CREATE no esquema e permissão USAGE no catálogo. Veja Unity Catalog para obter mais detalhes.

Para executar um UDF, os usuários precisam de permissão EXECUTE no UDF. Os usuários também precisam da permissão de USO no esquema e no catálogo.

O exemplo a seguir registra uma nova função no esquema my_schema Unity Catalog:

CREATE OR REPLACE FUNCTION my_catalog.my_schema.calculate_bmi(weight DOUBLE, height DOUBLE)
RETURNS DOUBLE
LANGUAGE SQL
AS
SELECT weight / (height * height);

As UDFs do Python para o Unity Catalog usam instruções compensadas por dois sinais de dólar ($$). Você também precisa especificar um mapeamento de tipo de dados. O exemplo a seguir registra um UDF que calcula o índice de massa corporal:

CREATE FUNCTION my_catalog.my_schema.calculate_bmi(weight_kg DOUBLE, height_m DOUBLE)
RETURNS DOUBLE
LANGUAGE PYTHON
AS $$
return weight_kg / (height_m ** 2)
$$;

Agora o senhor pode usar essa função do Unity Catalog em suas consultas SQL ou no código PySpark:

SELECT person_id, my_catalog.my_schema.calculate_bmi(weight_kg, height_m) AS bmi
FROM person_data;

Usando o site Unity Catalog UDF no PySpark 

from pyspark.sql.functions import expr

result = df.withColumn("bmi", expr("my_catalog.my_schema.calculate_bmi(weight_kg, height_m)"))
display(result)

Atualizar um UDF com escopo de sessão

Observação

A sintaxe e a semântica dos UDFs Python no Unity Catalog diferem dos UDFs Python registrados no SparkSession. Consulte funções escalares definidas pelo usuário - Python.

Dada a seguinte sessão baseada em UDF em um Databricks Notebook:

from pyspark.sql.functions import udf
from pyspark.sql.types import StringType

@udf(StringType())
def greet(name):
    return f"Hello, {name}!"

# Using the session-based UDF
result = df.withColumn("greeting", greet("name"))
result.show()

Para registrar isso como uma função Unity Catalog, use uma instrução SQL CREATE FUNCTION, como no exemplo a seguir:

CREATE OR REPLACE FUNCTION my_catalog.my_schema.greet(name STRING)
RETURNS STRING
LANGUAGE PYTHON
AS $$
return f"Hello, {name}!"
$$

Compartilhar UDFs no Unity Catalog

As permissões para UDFs são gerenciadas com base nos controles de acesso aplicados ao catálogo, esquema ou banco de dados em que o UDF está registrado. Veja Unity Catalog para obter mais informações.

Use a interface de usuário Databricks SQL ou Databricks workspace para conceder permissões a um usuário ou grupo (recomendado).

Permissões na interface do usuário do espaço de trabalho

  1. Localize o catálogo e o esquema em que seu UDF está armazenado e selecione o UDF.

  2. Procure a opção Permissions (Permissões ) nas configurações do UDF. Adicione usuários ou grupos e especifique o tipo de acesso que eles devem ter, como EXECUTAR ou gerenciar.

Permissões na interface do usuário do espaço de trabalho

Permissões usando o Databricks SQL

O exemplo a seguir concede a um usuário a permissão EXECUTE em uma função:

GRANT EXECUTE ON FUNCTION my_catalog.my_schema.calculate_bmi TO user@example.com;

Para remover permissões, use o comando REVOKE como no exemplo a seguir:

REVOKE EXECUTE ON FUNCTION my_catalog.my_schema.calculate_bmi FROM user@example.com;

Práticas recomendadas para UDFs

Para UDFs que precisam ser acessíveis a todos os usuários, a Databricks recomenda criar um catálogo e um esquema dedicados com controles de acesso apropriados.

Para UDFs específicos da equipe, use um esquema dedicado no catálogo da equipe para armazenamento e gerenciamento.

Databricks recomenda que o senhor inclua as seguintes informações no docstring do UDF:

  • O número da versão atual

  • Um registro de alterações para rastrear as modificações entre as versões

  • O objetivo, os parâmetros e o valor de retorno do UDF

  • Um exemplo de como usar o UDF

Aqui está um exemplo de um UDF que segue as práticas recomendadas:

CREATE OR REPLACE FUNCTION my_catalog.my_schema.calculate_bmi(weight_kg DOUBLE, height_m DOUBLE)
RETURNS DOUBLE
COMMENT ”Calculates Body Mass Index (BMI) from weight and height.”
LANGUAGE PYTHON
AS $$
 """
Parameters:
calculate_bmi (version 1.2):
- weight_kg (float): Weight of the individual in kilograms.
- height_m (float): Height of the individual in meters.


Returns:
- float: The calculated BMI.


Example Usage:

SELECT calculate_bmi(weight, height) AS bmi FROM person_data;


Change Log:
- 1.0: Initial version.
- 1.1: Improved error handling for zero or negative height values.
- 1.2: Optimized calculation for performance.


 Note: BMI is calculated as weight in kilograms divided by the square of height in meters.
 """
if height_m <= 0:
 return None  # Avoid division by zero and ensure height is positive
return weight_kg / (height_m ** 2)
$$;

UDFs para acessar APIs externas

O senhor pode usar UDFs para acessar APIs externas a partir do SQL. O exemplo a seguir usa a biblioteca Python requests para fazer uma solicitação HTTP.

Observação

Python Os UDFs permitem o tráfego de rede TCP/UDP pelas portas 80, 443 e 53 usando serverless compute ou compute configurados com o modo de acesso compartilhado.

CREATE FUNCTION my_catalog.my_schema.get_food_calories(food_name STRING)
RETURNS DOUBLE
LANGUAGE PYTHON
AS $$
import requests


api_url = f"https://example-food-api.com/nutrition?food={food_name}"
response = requests.get(api_url)

if response.status_code == 200:
   data = response.json()
   # Assuming the API returns a JSON object with a 'calories' field
   calories = data.get('calories', 0)
   return calories
else:
   return None  # API request failed

$$;

UDFs para segurança e conformidade

Use UDFs Python para implementar mecanismos personalizados de tokenização, mascaramento de dados, redação de dados ou criptografia.

O exemplo a seguir mascara a identidade de um endereço email, mantendo o comprimento e o domínio:

CREATE OR REPLACE FUNCTION my_catalog.my_schema.mask_email(email STRING)
RETURNS STRING
LANGUAGE PYTHON
AS $$
parts = email.split('@')
masked_username = username[0] + '*' * (len(username) - 2) + username[-1]
return f"{masked_username}@{domain}"
$$

O exemplo a seguir aplica esse UDF em uma definição dinâmica do view:

-- First, create the view
CREATE OR REPLACE VIEW my_catalog.my_schema.masked_customer_view AS
SELECT
  id,
  name,
  my_catalog.my_schema.mask_email(email) AS email
FROM my_catalog.my_schema.customer_data;

-- Now you can query the view
SELECT * FROM my_catalog.my_schema.masked_customer_view;

+---+------------+------------------------+------------------------+
| id|        name|                   email|           masked_email |
+---+------------+------------------------+------------------------+
|  1|    John Doe|   john.doe@example.com |  j*******e@example.com |
|  2| Alice Smith|alice.smith@company.com |a**********h@company.com|
|  3|   Bob Jones|    bob.jones@email.org |   b********s@email.org |
+---+------------+------------------------+------------------------+

Limitações

  • O senhor pode definir qualquer número de funções Python em uma UDF Python, mas todas devem retornar um valor escalar.

  • Python devem tratar os valores NULL de forma independente, e todos os mapeamentos de tipos devem seguir os mapeamentos da linguagem Databricks SQL.

  • Você pode importar bibliotecas Python padrão incluídas pelo Databricks, mas não pode incluir bibliotecas personalizadas ou dependências externas.

  • Se nenhum catálogo ou esquema for especificado, as UDFs do Python serão registradas no esquema ativo atual.

  • As UDFs do Python são executadas em um ambiente seguro e isolado e não têm acesso a sistemas de arquivos ou serviços internos.