SPI_prepare — prépare une instruction sans l'exécuter tout de suite
SPIPlanStr SPI_prepare(const char *command, intnargs, Oid *argtypes)
SPI_prepare crée et retourne une requête préparée
pour la commande spécifiée mais ne lance pas la commande.
La requête préparée peut être appelée plusieurs fois en utilisant
SPI_execute_plan.
Lorsque la même commande ou une commande semblable doit être lancée à
plusieurs reprises, il est généralement avantageux de réaliser une
analyse du plan d'exécution une fois et de réutiliser le plan
d'exécution pour la commande.
SPI_prepare convertit une chaîne de commande en une
requête préparée qui encapsule le résultat de l'analyse du plan. La
requête préparée fournit aussi une place pour mettre en cache un plan
d'exécution s'il s'avère que la génération d'un plan personnalisé pour
chaque exécution n'est pas utile.
Une commande préparée peut être généralisée en utilisant les paramètres
($1, $2, etc.) en lieu et place de ce qui serait des
constantes dans une commande normale. Les valeurs actuelles des paramètres
sont alors spécifiées lorsque SPI_executeplan est appelée.
Ceci permet à la commande préparée d'être utilisée sur une plage plus grande
de situations que cela ne serait possible sans paramètres.
La requête renvoyée par SPI_prepare ne peut être utilisé
que dans l'invocation courante de la fonction C puisque
SPI_finish libère la mémoire allouée pour la requête.
Mais l'instruction peut être sauvegardée plus longtemps par l'utilisation des
fonctions SPI_keepplan ou SPI_saveplan.
const char * commandchaîne contenant la commande à planifier
int nargs
nombre de paramètres d'entrée ($1, $2, etc.)
Oid * argtypespointeur vers un tableau contenant les OID des types de données des paramètres
SPI_prepare retourne un pointeur non nul vers un
plan d'exécution. En cas d'erreur, NULL sera retourné
et SPI_result sera positionnée à un des mêmes codes
d'erreur utilisés par SPI_execute sauf qu'il
est positionné à SPI_ERROR_ARGUMENT si
command est NULL ou si
nargs est inférieur à 0 ou si nargs est
supérieur à 0 et typesargs est NULL.
Si aucun paramètre n'est défini, un plan générique sera créé lors de la
première utilisation de SPI_execute_plan, et utilisé
aussi pour toutes les exécutions suivantes. Si des paramètres sont fournis,
les premières utilisations de SPI_execute_plan génèreront
des plans personnalisés qui sont spécifiques aux valeurs fournies pour les
paramètres. Après suffisamment d'utilisation de la même requête préparée,
SPI_execute_plan construira un plan générique et, si
ce n'est pas beaucoup plus coûteux que les plans personnalisés, cette fonction
commencera à utiliser le plan générique au lieu de re-planifier à chaque fois.
Si le comportement par défaut n'est pas tenable, vous pouvez le modifier en
passant le drapeau CURSOR_OPT_GENERIC_PLAN ou
CURSOR_OPT_CUSTOM_PLAN à
SPI_prepare_cursor pour forcer l'utilisation,
respectivement, de plans génériques ou personnalisés.
Bien que le but principal d'une requête préparée est d'éviter les étapes
d'analyse et de planification d'une requête,
PostgreSQL forcera l'analyse et la planification
de la requête avant de l'utiliser quand les objets de la base utilisés
dans la requête ont subi des changements de définition (à partir de
requêtes DDL) depuis la dernière utilisation de la requête préparée. De
plus, si la valeur de search_path change d'une
exécution à une autre, la requête sera de nouveau planifiée en utilisant
le nouveau search_path (ce dernier comportement est une
nouveauté de la version 9.3 de PostgreSQL). Voir
PREPARE pour plus d'informations sur le comportement
des requêtes préparées.
Cette fonction doit seulement être appelée à partir d'une fonction C connectée.
SPIPlanPtr est déclaré comme un pointeur vers un type de
structure opaque dans spi.h. Il est déconseillé d'essayer
d'accéder à son contenu directement car cela rend votre code plus fragile aux
futures versions de PostgreSQL.
Le nom SPIPlanPtr est historique principalement car la structure
des données ne contient plus nécessairement un plan d'exécution.