MaxCompute:Visão geral de UDTs

Quando usar UDTs em vez de UDFs

Tanto os UDTs quanto as funções definidas pelo usuário (UDFs) estendem o SQL do MaxCompute com lógica personalizada. Escolha a abordagem adequada conforme seu fluxo de trabalho:

Casos de uso

• Chame métodos da biblioteca padrão Java sem definir uma função. Quando uma tarefa precisa de um método de classe Java integrado que o MaxCompute SQL não expõe nativamente, o UDT permite chamá-lo diretamente em uma expressão.

• Referencie bibliotecas de terceiros inline. Em vez de encapsular uma função de biblioteca de terceiros dentro de uma UDF, referencie a classe diretamente na instrução SQL.

• Incorpore código source compilado no SQL. Para linguagens como Java que exigem compilação, os UDTs permitem referenciar objetos e classes em expressões SQL sem uma etapa separada de registro. Consulte SELECT TRANSFORM para alternativas baseadas em scripts.

Pré-requisitos

Antes de usar UDTs, certifique-se de que:

• O JDK 1.8 esteja disponível no seu ambiente. Versões posteriores ao JDK 1.8 podem não ser suportadas.

• Os novos tipos de dados estejam ativados caso utilize tipos como INT: set odps.sql.type.system.odps2=true;

Como funciona

Diferentemente dos UDTs em outros mecanismos SQL (que geralmente definem aliases de tipos semelhantes ao tipo STRUCT), os UDTs do MaxCompute funcionam como uma instrução CREATE TYPE — eles contêm tanto campos quanto métodos, e você os referencia diretamente no SQL sem escrever DDL.

O exemplo a seguir ilustra essa diferença. Para acessar Integer.MAX_VALUE do pacote java.lang do Java:

Usando um UDT (referência direta):

-- Enable new data types (required for types such as INTEGER).
set odps.sql.type.system.odps2=true;
SELECT java.lang.Integer.MAX_VALUE;

Como o pacote java.lang é importado automaticamente (assim como no Java), isso equivale a:

set odps.sql.type.system.odps2=true;
SELECT Integer.MAX_VALUE;

Resultado:

+-----------+
| max_value |
+-----------+
| 2147483647 |
+-----------+

Usando uma UDF (para comparação):

1. Escreva a classe da UDF:

   package com.aliyun.odps.test;
   public class IntegerMaxValue extends com.aliyun.odps.udf.UDF {
     public Integer evaluate() {
        return Integer.MAX_VALUE;
     }
   }

2. Compile, faça o upload e registre:

   add jar odps-test.jar;
   create function integer_max_value as 'com.aliyun.odps.test.IntegerMaxValue' using 'odps-test.jar';

3. Execute a chamada:

   select integer_max_value();

Os UDTs reduzem esse processo a uma única instrução SQL.

-- Sample data.
@table1 := select * from values ('100000000000000000000') as t(x);
@table2 := select * from values (100L) as t(y);

-- Create an object with the new method.
@a := select new java.math.BigInteger(x) x from @table1;
-- Call a static method.
@b := select java.math.BigInteger.valueOf(y) y from @table2;
-- Call an instance method across the join.
select /*+mapjoin(b)*/ x.add(y).toString() from @a a join @b b;

-- Output:
100000000000000000100

Referenciar pacotes JAR e definir imports Java

Todas as classes do SDK for Java estão disponíveis para UDTs por padrão. Para referenciar pacotes JAR adicionais ou definir caminhos de importação padrão, utilize os seguintes sinalizadores de sessão.

Referenciar um pacote JAR:

set odps.sql.type.system.odps2=true;
set odps.sql.session.resources=odps-test.jar;
-- The JAR must be uploaded to the project beforehand.
select new com.aliyun.odps.test.IntegerMaxValue().evaluate();

É possível especificar vários recursos separados por vírgulas: set odps.sql.session.resources=foo.sh,bar.txt;

O parâmetro odps.sql.session.resources controla tanto UDTs quanto SELECT TRANSFORM. Um JAR definido aqui fica disponível para ambos os recursos.

Definir um caminho de importação Java padrão:

set odps.sql.type.system.odps2=true;
set odps.sql.session.resources=odps-test.jar;
set odps.sql.session.java.imports=com.aliyun.odps.test.*;
-- With the import set, you can omit the full package prefix.
select new IntegerMaxValue().evaluate();

O parâmetro odps.sql.session.java.imports aceita um classpath (por exemplo, java.math.BigInteger) ou um curinga (*). Imports estáticos não são suportados.

Operações suportadas

Os UDTs suportam as seguintes operações em expressões SQL:

• Criação de objetos usando new — exemplo: new java.math.BigInteger('123')

• Criação de arrays usando new com listas de inicialização — exemplo: new Integer[] { 1, 2, 3 }

• Chamada de métodos de instância e estáticos

• Acesso a campos públicos de instância e estáticos

Apenas métodos e campos públicos são acessíveis. Todos os identificadores (nomes de pacotes, classes, métodos e campos) diferenciam maiúsculas de minúsculas. Classes anônimas e expressões lambda não são suportadas. Funções que não retornam valores não podem ser chamadas em expressões.

Tipos de dados

set odps.sql.udt.display.tostring=true;

-- Returns java.util.List<java.math.BigInteger>
java.util.Arrays.asList(new java.math.BigInteger('1'))

-- ArrayList<Object>
new java.util.ArrayList(java.util.Arrays.asList('1', '2'))

-- ArrayList<String>
new java.util.ArrayList<String>(java.util.Arrays.asList('1', '2'))

Limitações

Os UDTs não podem ser usados como chaves de redistribuição nas cláusulas JOIN, GROUP BY, DISTRIBUTE BY, SORT BY, ORDER BY ou CLUSTER BY. Os UDTs são válidos em expressões nessas etapas, mas não podem ser a saída. Por exemplo:

• group by new java.math.BigInteger('123') — não suportado

• group by new java.math.BigInteger('123').hashCode() — suportado, pois hashCode() retorna int.class, que é mapeado para o tipo integrado INT

UDFs, funções de agregação definidas pelo usuário (UDAFs) e UDTs não podem ler dados dos seguintes tipos de tabela:

• Tabelas nas quais foi realizada evolução de schema

• Tabelas que contêm tipos de dados complexos

• Tabelas que contêm tipos de dados JSON

• Tabelas transacionais

Acessar recursos

No MaxCompute SQL, chame o método estático com.aliyun.odps.udf.impl.UDTExecutionContext.get() para obter o objeto ExecutionContext. Utilize esse objeto para acessar o contexto de execução atual, incluindo arquivos e tabelas registrados como recursos.

Considerações sobre desempenho

O desempenho dos UDTs é semelhante ao das UDFs. O mecanismo de computação otimizado oferece melhorias adicionais em cenários específicos:

• Sem sobrecarga de serialização para operações locais. Quando um objeto UDT é usado dentro do mesmo processo (sem necessidade de redistribuição de dados, como em estágios JOIN ou AGGREGATE), a serialização e a desserialização são ignoradas.

• Runtime baseado em Codegen. Os UDTs são executados via Codegen em vez de reflexão, eliminando a sobrecarga associada à reflexão. Múltiplas chamadas UDT são agrupadas em uma única chamada de função — por exemplo, values[x].add(values[y]).divide(java.math.BigInteger.valueOf(2)) é chamado apenas uma vez, evitando a sobrecarga de interface por chamada.

Segurança

Os UDTs estão sujeitos ao mesmo modelo de sandbox Java que as UDFs. Para realizar operações restritas pela sandbox, cancele o isolamento da sandbox para essas operações ou solicite inclusão na lista de permissões da sandbox.

Recursos a serem aprimorados

Os seguintes recursos estão planejados para versões futuras:

• Chamada de funções que não retornam valores e funções que usam diretamente os dados transferidos (onde o valor de retorno é ignorado, como o método add da interface List).

• Uso de classes anônimas e expressões lambda.

• Uso de UDTs como chaves de redistribuição.

• Suporte a mais linguagens de programação, como Python.

Próximos passos

• UDFs Java — tabela de mapeamento de tipos de dados e referência de implementação de UDF

• Novos tipos de dados integrados — tipos que exigem set odps.sql.type.system.odps2=true;

• SELECT TRANSFORM — incorpore scripts em instruções SQL

• COLLECT_SET e outras funções de agregação — use com UDTs para implementar comportamento de funções de agregação e funções com valor de tabela

• Sandbox Java — modelo de sandbox e solicitação de lista de permissões