Fonction scalaire en langage Python

L'exemple suivant montre une fonction scalaire simple qui additionne un ensemble de nombres. Cet exemple commence par la construction d'un AE simple. Il utilise le nom de fichier suivant : " applyop.py

Coder

  1. Dériver une classe de " nzae.Ae. La classe de base s'occupe de la plus grande partie du travail, de sorte que vous appelez généralement la classe " class-method "run()"" . La fonction " run() instancie la classe, met en place la gestion des erreurs et appelle la fonction dérivée appropriée. Pour les AE basés sur l'UDF comme celui-ci, la fonction " _getFunctionResult() doit être remplacée, car elle est appelée une fois pour chaque ligne d'entrée. Enregistrez le code suivant dans un fichier appelé " applyop.py:
    import nzae
    class ApplyOpUdfAe(nzae.Ae):
    def _getFunctionResult(self, row):
    # OUR CUSTOM CODE WILL GO HERE.
    ApplyOpUdfAe.run()
  2. Compléter le code Python personnalisé. Dans cet UDF, vous transmettez un opérateur de chaîne, qui est soit un signe plus (+) pour ajouter, soit un astérisque (*) pour multiplier, ainsi que deux nombres entiers. Le code renvoie soit le produit, soit la somme des nombres entiers. En SQL, une version simple de cette fonction peut être appelée par l'une ou l'autre des méthodes suivantes :
    SELECT applyop('+', 3, 5);
    ou
    SELECT applyop('*', 3, 5);
    Bien que l'exemple mentionné ne comporte qu'une seule entrée, le système NPS traite des flux d'entrées. Par conséquent, le système NPS est plus susceptible d'être utilisé :
    SELECT applyop(mytable.operator, mytable.value1, mytable.value2) FROM mytable;

    Dans le premier exemple, le système NPS prend les constantes "+", 3 et 5 et les transforme en un flux de longueur 1 contenant trois éléments. Une ligne est "vue" par " _getFunctionResult() avec les trois éléments qu'elle contient. En interne, tous les cas mentionnés sont traités de la même manière et l'on peut supposer qu'il y a plusieurs entrées dans l'AE " applyop

  3. Saisir un code personnalisé pour gérer une ligne d'entrée, car la gestion de la boucle d'entrée est nécessaire pour transmettre une ligne à la fonction à la fois :
    import nzae
    class ApplyOpUdfAe(nzae.Ae):
    def _getFunctionResult(self, row):
    # BREAK APART OUR ROW OF INPUT.
    operator, leftInput, rightInput = row
    # HANDLE ADDITION.
    if operator == "+":
    return leftInput + rightInput
    # HANDLE MULTIPLICATION.
    if operator == "*":
    return leftInput * rightInput
    # ERROR ON ALL OTHER.
    self.userError("Unhandled operator to ApplyOp: '" + operator + "'.")
    ApplyOpUdfAe.run()

    La fonction 'self.userError() signale une erreur à l'utilisateur SQL. Ce qui est renvoyé par " _getFunctionResult() est le résultat de l'opération SQL. Comme il s'agit d'un UDF, le résultat ne peut comporter qu'une seule colonne. Un exemple ultérieur montre comment utiliser les UDTF pour éditer plusieurs colonnes. Lorsque le code est complet, il doit être déployé et enregistré.

Compilation

Les AE Python ne nécessitent pas de compilation.

Déploiement

Bien que les AE Python ne nécessitent pas de compilation, ils doivent être déployés. La commande " compile_ae est toujours utilisée avec l'option de déploiement " --template pour déployer le script à l'emplacement par défaut sur le lecteur d'exportation partagé.
$NZ_EXPORT_DIR/ae/utilities/bin/compile_ae --language python64 \
--template deploy ./applyop.py --version 3

Enregistrement

Enregistrer le fichier Python:
$NZ_EXPORT_DIR/ae/utilities/bin/register_ae --language python64 --version 3 \
--template udf --exe applyop.py --sig "applyop(varchar(1), int4, int4)" \
--return int4

En cours d'exécution

L'AE peut maintenant être exécuté en SQL :
SELECT applyop('+', 4, 10);
APPLYOP
---------
14
(1 row)
Notez que pour valider les types dans " _getFunctionResult(), " self.userError() est appelé. L'exemple suivant déclenche une erreur :
SELECT applyop('-', 1, 2);
ERROR: Unhandled operator TO ApplyOp: '-'.