MaxCompute:Développer une UDF en Python 2

Vous pouvez utiliser MaxCompute Studio pour écrire le code d'une UDF en Python 2. Le code de l'UDF peut contenir les éléments suivants :

• Déclaration d'encodage : facultative.

  Le format de déclaration est #coding:utf-8 ou # -*- coding: utf-8 -*-. Ces deux formats sont équivalents. Si des caractères chinois apparaissent dans le code d'une UDF écrite en Python 2, une erreur se produit lors de l'exécution de l'UDF. Pour résoudre ce problème, vous devez ajouter une déclaration d'encodage dans l'en-tête du code.

• Importation de module : obligatoire.

  Le code de l'UDF doit inclure from odps.udf import annotate, qui sert à importer la signature de fonction. Cela permet à MaxCompute d'identifier la signature de fonction définie dans le code. Si vous souhaitez référencer des fichiers ou des tables dans le code de l'UDF, celui-ci doit inclure from odps.distcache import get_cache_file ou from odps.distcache import get_cache_table.

• Signature de fonction : obligatoire.

  La signature de fonction suit le format @annotate(<signature>). Le paramètre signature définit les types de données des paramètres d'entrée et de la valeur de retour de l'UDF. Pour plus d'informations sur les signatures de fonction, consultez la section Signatures de fonction et types de données.

• Classe Python personnalisée : obligatoire.

  Une classe Python personnalisée constitue l'unité organisationnelle du code de l'UDF. Cette classe définit les variables et les méthodes nécessaires pour répondre à vos besoins métier. Dans le code de l'UDF, vous pouvez également référencer des bibliothèques tierces installées dans MaxCompute, ainsi que des fichiers ou des tables. Pour plus d'informations, consultez les sections Bibliothèques tierces ou Ressources de référence.

• Méthode evaluate : obligatoire.

  La méthode evaluate est contenue dans la classe Python personnalisée. La méthode evaluate définit les paramètres d'entrée et la valeur de retour de l'UDF. Chaque classe Python ne peut contenir qu'une seule méthode evaluate.

Exemple de code :

#coding:utf-8
# Import the function signature. 
from odps.udf import annotate
# The function signature. 
@annotate("bigint,bigint->bigint")
# The custom Python class. 
class MyPlus(object):
# The evaluate method. 
   def evaluate(self, arg0, arg1):
       if None in (arg0, arg1):
           return None
       return arg0 + arg1

MaxCompute vous permet d'écrire des UDF Python 2 en Python 2.7 et d'exécuter le code de l'UDF dans un environnement sandbox. Dans cet environnement, les opérations suivantes sont interdites :

• Lire des données depuis des fichiers locaux et y écrire des données.

• Démarrer des sous-processus.

• Démarrer des threads.

• Activer la communication socket.

• Utiliser d'autres systèmes pour appeler des UDF Python 2.

En raison de ces limites, le code que vous téléchargez doit être écrit à l'aide des bibliothèques standard de Python. Si des modules ou des modules d'extension C des bibliothèques standard de Python sont impliqués dans les opérations mentionnées ci-dessus, ces modules ne peuvent pas être utilisés. Tenez compte des points suivants concernant les modules des bibliothèques standard de Python :

• Tous les modules implémentés sur la base des bibliothèques standard de Python et ne dépendant pas de modules d'extension sont disponibles.

• Les modules d'extension C suivants sont disponibles :

  • array et audioop

  • binascii et bisect

  • cmath, _codecs_cn, _codecs_hk, _codecs_iso2022, _codecs_jp, _codecs_kr, _codecs_tw, _collections et cStringIO

  • datetime

  • _functools et future_builtins

  • _heapq et _hashlib

  • itertools

  • _json

  • _locale et _lsprof

  • math, _md5 et _multibytecodec

  • operator

  • _random

  • _sha256, _sha512, _sha, _struct et strop

  • time

  • unicodedata

  • _weakref

  • cPickle

• Lorsque vous exécutez le code d'une UDF dans un environnement sandbox, la taille maximale des données pouvant être écrites dans la sortie standard (sys.stdout) ou la sortie d'erreur standard (sys.stderr) est de 20 Ko. Si la taille dépasse 20 Ko, les caractères supplémentaires sont ignorés.

Des bibliothèques tierces, telles que NumPy, sont installées dans l'environnement Python 2 de MaxCompute en complément des bibliothèques standard.

Format des signatures de fonction :

@annotate(<signature>)

Le paramètre signature est une chaîne qui spécifie les types de données des paramètres d'entrée et de la valeur de retour. Lors de l'exécution d'une UDF, les types de données des paramètres d'entrée et de la valeur de retour de l'UDF doivent correspondre aux types de données spécifiés dans la signature de fonction. La cohérence des types de données est vérifiée lors de l'analyse sémantique. Si les types de données ne correspondent pas, une erreur est renvoyée. Format d'une signature :

'arg_type_list -> type'

description des paramètres :

• arg_type_list : spécifie les types de données des paramètres d'entrée. Si plusieurs paramètres d'entrée sont utilisés, leurs types de données sont séparés par des virgules (,). Les types de données suivants sont pris en charge : BIGINT, STRING, DOUBLE, BOOLEAN, DATETIME, DECIMAL, FLOAT, BINARY, DATE, DECIMAL(precision,scale), CHAR et VARCHAR. Les types de données complexes, tels que ARRAY, MAP et STRUCT, ainsi que les types de données complexes imbriqués, sont également pris en charge.

  arg_type_list peut être représenté par un astérisque (*) ou laissé vide ('').

  • Si arg_type_list est représenté par un astérisque (*), un nombre aléatoire de paramètres d'entrée est autorisé.

  • Si arg_type_list est laissé vide (''), aucun paramètre d'entrée n'est utilisé.

• type : spécifie le type de données de la valeur de retour. Pour une UDF, une seule colonne de valeurs est renvoyée. Les types de données suivants sont pris en charge : BIGINT, STRING, DOUBLE, BOOLEAN, DATETIME, DECIMAL, FLOAT, BINARY, DATE et DECIMAL(precision,scale). Les types de données complexes, tels que ARRAY, MAP et STRUCT, ainsi que les types de données complexes imbriqués, sont également pris en charge.

Le tableau suivant fournit des exemples de signatures de fonction valides.

Après avoir développé une UDF Python 2, vous pouvez utiliser MaxCompute SQL pour appeler cette UDF. Vous pouvez appeler une UDF Python 2 en utilisant l'une des méthodes suivantes :

• Utiliser une UDF dans un projet MaxCompute : la méthode est similaire à celle d'utilisation des fonctions intégrées. Vous pouvez utiliser une fonction définie par l'utilisateur de la même manière qu'une fonction intégrée.

• Utiliser une UDF entre projets : utilisez une UDF du projet B dans le projet A. L'instruction suivante montre un exemple : select B:udf_in_other_project(arg0, arg1) as res from table_t;. Pour plus d'informations sur le partage entre projets, consultez la section Accès aux ressources entre projets basé sur les packages.