Python UDFs, UDFs do Scala e tipos de dados complexos no mecanismo de execução nativo

O mecanismo de execução nativo no Microsoft Fabric agora dá suporte a Python UDFs (funções definidas pelo usuário), UDFs do Scala e tipos de dados complexos (matrizes, mapas e structs). Esses recursos permitem que você escreva aplicativos Expressivos do Spark sem sacrificar o desempenho.

suporte à UDF Python

Python é uma das linguagens mais populares em engenharia de dados e ciência de dados. Historicamente, as UDFs em Python introduziram uma sobrecarga significativa no Spark devido aos custos de serialização entre a JVM e os processos de trabalho do Python. O mecanismo de execução nativo minimiza essas transições caras, permitindo uma execução mais rápida sem alterações de código.

Como Python UDFs funcionam no mecanismo de execução nativo

Em um modelo de execução convencional do Spark, a execução de UDFs em Python envolve:

1. Conversão de dados a partir do formato interno do Spark.
2. Serialização e transferência para processos de trabalho do Python.
3. Execução de UDFs em Python.
4. Serialização de resultados de volta para a JVM.
5. O Spark retoma a execução.

Esse movimento entre ambientes de execução cria custos de serialização e desserialização, uso ineficiente da CPU e pipelines de execução colunar interrompidos. O mecanismo de execução nativo reduz essa sobrecarga otimizando o caminho de transferência de dados e mantendo o processamento vetorizado sempre que possível.

Tipos de UDF de Python com suporte

O mecanismo de execução nativo dá suporte a:

• Scalar UDFs: funções de Python linha por linha registradas com udf().
• UDFs vetorizadas (Pandas): Funções decoradas com @pandas_udf que operam em lotes de dados usando o Apache Arrow para transferência eficiente.

As UDFs vetorizadas veem os maiores ganhos de desempenho porque se alinham naturalmente com o modelo de processamento columnar do mecanismo de execução nativo.

Exemplo: UDF de Python vetorizado

import pandas as pd
from pyspark.sql.functions import pandas_udf
from pyspark.sql.types import DoubleType

@pandas_udf(DoubleType())
def calculate_discount(price: pd.Series, rate: pd.Series) -> pd.Series:
    return price * (1 - rate)

df = spark.table("sales.transactions")
result = df.withColumn("discounted_price", calculate_discount(df.price, df.discount_rate))
result.show()

Nenhuma configuração adicional é necessária além de habilitar o mecanismo de execução nativo. Os UDFs de Python existentes se beneficiam automaticamente.

Suporte a UDF do Scala

O mecanismo de execução nativo também acelera UDFs do Scala. Como as UDFs em Scala são executadas nativamente na JVM, o mecanismo pode encaminhar as operações compatíveis para o caminho de execução vetorizado em C++, mantendo a avaliação das UDFs em Scala eficiente no mesmo ambiente de execução.

Exemplo: UDF do Scala

import org.apache.spark.sql.functions.udf

val toUpperCase = udf((s: String) => s.toUpperCase)
val df = spark.table("catalog.customers")
val result = df.withColumn("name_upper", toUpperCase(df("name")))
result.show()

As UDFs do Scala que operam em tipos de dados com suporte são aceleradas sem alterações de código quando o mecanismo de execução nativo está habilitado.

Suporte a tipos de dados complexos

As arquiteturas modernas do lakehouse dependem de dados semiestruturados e aninhados. O mecanismo de execução nativo agora fornece suporte otimizado para:

Operações com suporte para tipos complexos

O mecanismo de execução nativo acelera operações comuns em tipos de dados complexos:

• Funções de matriz: explode, , array_contains, size, , flattentransform
• Funções de mapa: map_keys, , map_valueselement_at
• Acesso ao struct: acesso ao campo de notação de ponto, getField
• Combinações aninhadas: matrizes de structs, mapas com valores de matriz

Exemplo: Trabalhando com arrays e estruturas

from pyspark.sql.functions import explode, col, size

# Read data with nested schema
df = spark.table("events.telemetry")

# Operations on arrays - accelerated by native engine
result = (df
    .filter(size(col("tags")) > 0)
    .select(
        col("event_id"),
        col("metadata.source"),  # Struct field access
        explode(col("tags")).alias("tag")
    )
)
result.show()

Exemplo: Trabalhando com mapas

from pyspark.sql.functions import map_keys, map_values, col

df = spark.table("config.settings")

# Map operations - accelerated by native engine
result = (df
    .select(
        col("setting_id"),
        map_keys(col("properties")).alias("keys"),
        map_values(col("properties")).alias("values")
    )
)
result.show()

Resultados de desempenho

O benchmarking interno demonstra melhorias significativas nas cargas de trabalho que usam UDFs Python e tipos de dados complexos:

Esses ganhos resultam da redução da sobrecarga de serialização, da vetorização aprimorada e da execução colunar de ponta a ponta.

Benefícios para padrões avançados de lakehouse

A aceleração de tipos de dados complexos é especialmente importante para:

• Otimização Z-ORDER: as colunas aninhadas participam da disposição otimizada dos dados.
• Clustering líquido: colunas de tipo complexo se beneficiam do clustering sem nivelamento.
• Análises semiestruturadas: payloads JSON e fluxos de eventos permanecem aninhados para consulta natural.
• Arquiteturas orientadas a eventos: os dados de Telemetria e IoT mantêm sua estrutura hierárquica.

Em vez de achatar dados ou reestruturar pipelines para melhorar o desempenho, trabalhe naturalmente com esquemas complexos, mantendo alta eficiência de execução.

habilitar o recurso

Python UDF, UDF do Scala e suporte a tipos de dados complexos estão disponíveis quando o mecanismo de execução nativo está habilitado. Nenhuma configuração adicional é necessária.

Para habilitar o mecanismo de execução nativo, consulte o mecanismo de execução nativo para Engenharia de Dados do Fabric.

Pré-requisitos

• Runtime 1.3 (Apache Spark 3.5) ou Runtime 2.0 (Apache Spark 4.0).
• Mecanismo de execução nativo habilitado no nível do ambiente, do notebook ou da definição do trabalho do Spark.

Limitações

• Nem todas as bibliotecas Python têm suporte no caminho vetorizado. Bibliotecas que exigem serialização arbitrária de objetos Python ainda podem acionar o fallback.
• Tipos complexos profundamente aninhados (por exemplo, matrizes de mapas de structs) podem voltar ao mecanismo JVM para determinadas operações.
• O modo ANSI não tem suporte com o mecanismo de execução nativo.

Conteúdo relacionado

• Mecanismo de execução nativa para Engenharia de Dados do Fabric
• Ambientes de execução do Apache Spark no Azure Fabric
• O que é o Autotune para configurações do Apache Spark no Fabric?