Pour créer une fonction dans le langage PL/Tcl, utilisez la syntaxe standard de CREATE FUNCTION :
CREATE FUNCTIONnom_fonction
(types_arguments
) RETURNStype_en_retour
AS $$ # corps de la fonction PL/Tcl $$ LANGUAGE pltcl;
PL/TclU est identique sauf que le langage doit être
pltclu
.
Le corps de la fonction est simplement un bout de script Tcl. Quand la
fonction est appelée, les valeurs d'argument sont passées au script Tcl
comme des variables nommées 1
...
. Le résultat est retournée
depuis le code Tcl de la manière habituelle, avec un ordre
n
return
. Pour une procédure, la valeur de retour du code
Tcl est ignorée.
Par exemple, une fonction renvoyant le plus grand de deux valeurs entières pourrait être définie ainsi :
CREATE FUNCTION tcl_max(integer, integer) RETURNS integer AS $$ if {$1 > $2} {return $1} return $2 $$ LANGUAGE pltcl STRICT;
Notez la clause STRICT
qui nous permet d'éviter de penser aux
valeurs NULL en entrées : si une valeur NULL est passée, la
fonction ne sera pas appelée du tout mais renverra automatiquement un
résultat nul.
Dans une fonction non stricte, si la valeur réelle d'un argument est
NULL, la variable $
correspondante sera initialisée avec une chaîne vide. Pour détecter si un
argument particulier est NULL, utilisez la fonction n
argisnull
.
Par exemple, supposez que nous voulons tcl_max
avec un
argument NULL et un non NULL pour renvoyer l'argument non NULL plutôt que
NULL :
CREATE FUNCTION tcl_max(integer, integer) RETURNS integer AS $$ if {[argisnull 1]} { if {[argisnull 2]} { return_null } return $2 } if {[argisnull 2]} { return $1 } if {$1 > $2} {return $1} return $2 $$ LANGUAGE pltcl;
Comme indiqué ci-dessus, pour renvoyer une valeur NULL à partir d'une
fonction PL/Tcl, exécutez return_null
. Ceci
peut être fait que la fonction soit stricte ou non.
Les arguments de type composé sont passés à la fonction comme des tableaux Tcl. Les noms des éléments du tableau sont les noms d'attribut du type composite. Si un attribut dans la ligne passée a la valeur NULL, il n'apparaîtra pas dans le tableau. Voici un exemple :
CREATE TABLE employe ( nom text, salaire integer, age integer ); CREATE FUNCTION surpaye(employe) RETURNS boolean AS $$ if {200000.0 < $1(salaire)} { return "t" } if {$1(age) < 30 && 100000.0 < $1(salaire)} { return "t" } return "f" $$ LANGUAGE pltcl;
Les fonctions PL/Tcl peuvent également retourner des résultats de type composite. Pour cela, le code Tcl doit retourner une liste de paires nom de colonnes / valeurs correspondant au type de résultat attendu. Tout nom de colonne omis de la liste sera retourné comme NULL, et une erreur est levée s'il y a un nom de colonne inattendu. Voici un exemple :
CREATE FUNCTION square_cube(in int, out squared int, out cubed int) AS $$ return [list squared [expr {$1 * $1}] cubed [expr {$1 * $1 * $1}]] $$ LANGUAGE pltcl;
Les arguments en sortie des procédures sont renvoyées de la même façon. Par exemple :
CREATE PROCEDURE tcl_triple(INOUT a integer, INOUT b integer) AS $$ return [list a [expr {$1 * 3}] b [expr {$2 * 3}]] $$ LANGUAGE pltcl; CALL tcl_triple(5, 10);
La liste résultat peut être faite à partir d'une représentation de
tableau du tuple désiré avec la commande Tcl array
get
. Par exemple:
CREATE FUNCTION raise_pay(employee, delta int) RETURNS employee AS $$ set 1(salary) [expr {$1(salary) + $2}] return [array get 1] $$ LANGUAGE pltcl;
Les fonctions PL/Tcl peuvent retourner des ensembles. Pour cela, le code
Tcl devrait appeler return_next
une fois par ligne à
être retournée, passant soit la valeur appropriée quand un type scalaire
est retourné, soit une liste de paires de nom de colonne / valeur quand un
type composite est retourné. Voici un exemple retournant un type scalaire
:
CREATE FUNCTION sequence(int, int) RETURNS SETOF int AS $$ for {set i $1} {$i < $2} {incr i} { return_next $i } $$ LANGUAGE pltcl;
et voici un exemple retournant un type composite :
CREATE FUNCTION table_of_squares(int, int) RETURNS TABLE (x int, x2 int) AS $$ for {set i $1} {$i < $2} {incr i} { return_next [list x $i x2 [expr {$i * $i}]] } $$ LANGUAGE pltcl;