Demander un pointeur vers une variable numérique nouvellement allouée.

numeric *PGTYPESnumeric_new(void);
        

Désallouer un type numérique, libérer toute sa mémoire.

void PGTYPESnumeric_free(numeric *var);
        

Convertir un type numérique à partir de sa notation chaîne.

numeric *PGTYPESnumeric_from_asc(char *str, char **endptr);
        

Les formats valides sont par exemple: -2, .794, +3.44, 592.49E07 or -32.84e-4. Si la valeur peut être convertie correctement, un pointeur valide est retourné, sinon un pointeur NULL. À l'heure actuelle ECPG traite toujours la chaine en entier, il n'est donc pas possible pour le moment de stocker l'adresse du premier caractère invalide dans *endptr. Vous pouvez sans risque positionner endptr à NULL.

Retourne un pointeur vers la chaîne allouée par malloc qui contient la représentation chaîne du type numérique num.

char *PGTYPESnumeric_to_asc(numeric *num, int dscale);
        

La valeur numérique sera affichée avec dscale chiffres décimaux, et sera arrondie si nécessaire. Le résultat doit être libéré avec PGTYPESchar_free().

Ajoute deux variables numériques à une troisième.

int PGTYPESnumeric_add(numeric *var1, numeric *var2, numeric *result);
        

La fonction additionne les variables var1 et var2 dans la variable résultat result. La fonction retourne 0 en cas de succès et -1 en cas d'erreur.

Soustrait deux variables numériques et retourne le résultat dans une troisième.

int PGTYPESnumeric_sub(numeric *var1, numeric *var2, numeric *result);
        

La fonction soustrait la variable var2 de la variable var1. Le résultat de l'opération est stocké dans la variable result. La fonction retourne 0 en cas de succès et -1 en cas d'erreur.

Multiplie deux valeurs numeric et retourne le résultat dans une troisième.

int PGTYPESnumeric_mul(numeric *var1, numeric *var2, numeric *result);
        

La fonction multiplie la variable var2 de la variable var1. Le résultat de l'opération est stocké dans la variable result. La fonction retourne 0 en cas de succès et -1 en cas d'erreur.

Divise deux valeurs numeric et retourne le résultat dans une troisième.

int PGTYPESnumeric_div(numeric *var1, numeric *var2, numeric *result);
        

La fonction divise la variable var2 de la variable var1. Le résultat de l'opération est stocké dans la variable result. La fonction retourne 0 en cas de succès et -1 en cas d'erreur.

Compare deux variables numeric.

int PGTYPESnumeric_cmp(numeric *var1, numeric *var2)
        

Cette fonction compare deux variables numeric. En cas d'erreur, INT_MAX est retourné. En cas de réussite, la fonction retourne un des trois résultats suivants :

Convertit une variable int en variable numeric.

int PGTYPESnumeric_from_int(signed int int_val, numeric *var);
        

Cette fonction accepte une variable de type signed int et la stocke dans la variable numeric var. La fonction retourne 0 en cas de réussite, et -1 en cas d'échec.

Convertit une variable long int en variable numeric.

int PGTYPESnumeric_from_long(signed long int long_val, numeric *var);
        

Cette fonction accepte une variable de type signed long int et la stocke dans la variable numeric var. La fonction retourne 0 en cas de réussite, et -1 en cas d'échec.

Copie une variable numeric dans une autre.

int PGTYPESnumeric_copy(numeric *src, numeric *dst);
        

Cette fonction copie la valeur de la variable vers laquelle src pointe dans la variable vers laquelle dst. Elle retourne 0 en cas de réussite et -1 en cas d'échec.

Convertit une variable de type double en variable numeric.

int  PGTYPESnumeric_from_double(double d, numeric *dst);
        

Cette fonction accepte une variable de type double et la stocke dans la variable numeric dst. La fonction retourne 0 en cas de réussite, et -1 en cas d'échec.

Convertit une variable de type numeric en double.

int PGTYPESnumeric_to_double(numeric *nv, double *dp)
        

Cette fonction convertit la valeur numeric de la variable vers la quelle nv pointe vers la variable double vers laquelle dp pointe. Elle retourne 0 en cas de réussite et -1 en cas d'échec, les cas de dépassement de capacité inclus. En cas de dépassement, la variable globale errno sera positionnée à PGTYPES_NUM_OVERFLOW en plus.

Convertit une variable de type numeric en int.

int PGTYPESnumeric_to_int(numeric *nv, int *ip);
        

Cette fonction convertit la valeur numeric de la variable vers la quelle nv pointe vers la variable int vers laquelle ip pointe. Elle retourne 0 en cas de réussite et -1 en cas d'échec, les cas de dépassement de capacité inclus. En cas de dépassement, la variable globale errno sera positionnée à PGTYPES_NUM_OVERFLOW en plus.

Convertit une variable de type numeric en long.

int PGTYPESnumeric_to_long(numeric *nv, long *lp);
        

Cette fonction convertit la valeur numeric de la variable vers la quelle nv pointe vers la variable long vers laquelle lp pointe. Elle retourne 0 en cas de réussite et -1 en cas d'échec, les cas de dépassement de capacité inclus. En cas de dépassement, la variable globale errno sera positionnée à PGTYPES_NUM_OVERFLOW en plus.

Convertit une variable de type numeric en decimal.

int PGTYPESnumeric_to_decimal(numeric *src, decimal *dst);
        

Cette fonction convertit la valeur numeric de la variable vers la quelle src pointe vers la variable decimal vers laquelle dst pointe. Elle retourne 0 en cas de réussite et -1 en cas d'échec, les cas de dépassement de capacité inclus. En cas de dépassement, la variable globale errno sera positionnée à PGTYPES_NUM_OVERFLOW en plus.

Convertit une variable de type decimal en numeric.

int PGTYPESnumeric_from_decimal(decimal *src, numeric *dst);
        

Cette fonction convertit la valeur decimal de la variable vers la quelle src pointe vers la variable numeric vers laquelle dst pointe. Elle retourne 0 en cas de réussite et -1 en cas d'échec. Comme le type decimal est implémentée comme une version limitée du type numeric, un dépassement ne peut pas se produire lors de cette conversion.

Extraire la partie date d'un timestamp.

date PGTYPESdate_from_timestamp(timestamp dt);
        

Cette fonction reçoit un timestamp comme seul argument et retourne la partie date extraite de ce timestamp.

Convertit une date à partir de sa représentation textuelle.

date PGTYPESdate_from_asc(char *str, char **endptr);
        

Cette fonction reçoit une chaîne char* C str et un pointeur vers une chaîne char* C endptr. À l'heure actuelle ECPG traite toujours intégralement la chaîne, et ne supporte donc pas encore l'adresse du premier caractère invalide dans *endptr. Vous pouvez positionner endptr à NULL sans risque.

Notez que la fonction attend toujours une date au format MDY et qu'il n'y a aucune variable à l'heure actuelle pour changer cela dans ECPG.

Tableau 36.2 montre les formats autorisés en entrée.

Retourne la représentation textuelle d'une variable date.

char *PGTYPESdate_to_asc(date dDate);
        

La fonction reçoit la date dDate comme unique paramètre. Elle retournera la date dans la forme 1999-01-18, c'est-à-dire le format YYYY-MM-DD. Le résultat doit être libéré avec PGTYPESchar_free().

Extrait les valeurs pour le jour, le mois et l'année d'une variable de type date.

void PGTYPESdate_julmdy(date d, int *mdy);
        

La fonction reçoit la date d et un pointeur vers un tableau de 3 valeurs entières mdy. Le nom de variable indique l'ordre séquentiel: mdy[0] contiendra le numéro du mois, mdy[1] contiendra le numéro du jour et mdy[2] contiendra l'année.

Crée une valeur date à partir d'un tableau de 3 entiers qui spécifient le jour, le mois et l'année de la date.

void PGTYPESdate_mdyjul(int *mdy, date *jdate);
        

Cette fonction reçoit le tableau des 3 entiers (mdy) comme premier argument, et son second argument est un pointeur vers la variable de type date devant contenir le résultat de l'opération.

Retourne un nombre représentant le jour de la semaine pour une valeur date.

int PGTYPESdate_dayofweek(date d);
        

La fonction reçoit la variable date d comme seul argument et retourne un entier qui indique le jour de la semaine pour cette date. this date.

Récupérer la date courante.

void PGTYPESdate_today(date *d);
        

Cette fonction reçoit un pointeur vers une variable date (d) qu'il positionne à la date courante.

Convertir une variable de type date vers sa représentation textuelle en utilisant un masque de formatage.

int PGTYPESdate_fmt_asc(date dDate, char *fmtstring, char *outbuf);
        

La fonction reçoit la date à convertir (dDate), le masque de formatage (fmtstring) et la chaîne qui contiendra la représentation textuelle de la date (outbuf).

En cas de succès, 0 est retourné, et une valeur négative si une erreur s'est produite.

Les littéraux suivants sont les spécificateurs de champs que vous pouvez utiliser:

Tout autre caractère est recopié tel quel dans la chaîne de sortie.

Tableau 36.3 indique quelques formats possibles. Cela vous donnera une idée de comment utiliser cette fonction. Toutes les lignes de sortie reposent sur la même date : Le 23 novembre 1959.

Utiliser un masque de formatage pour convertir une chaîne de caractère char* en une valeur de type date.

int PGTYPESdate_defmt_asc(date *d, char *fmt, char *str);
        

La fonction reçoit un pointeur vers la valeur de date qui devrait stocker le résultat de l'opération (d), le masque de formatage à utiliser pour traiter la date (fmt) et la chaîne de caractères char* C contenant la représentation textuelle de la date (str). La représentation textuelle doit correspondre au masque de formatage. Toutefois, vous n'avez pas besoin d'avoir une correspondance exacte entre la chaîne et le masque de formatage. La fonction n'analyse qu'en ordre séquentiel et cherche les litéraux yy ou yyyy qui indiquent la position de l'année, mm qui indique la position du mois et dd qui indique la position du jour.

Tableau 36.4 indique quelques formats possibles. Cela vous donnera une idée de comment utiliser cette fonction

Transformer un timestamp de sa représentation texte vers une variable timestamp.

timestamp PGTYPEStimestamp_from_asc(char *str, char **endptr);
        

La fonction reçoit la chaîne à analyser (str) et un pointeur vers un char* C (endptr). À l'heure actuelle ECPG traite toujours intégralement la chaîne, et ne supporte donc pas encore l'adresse du premier caractère invalide dans *endptr. Vous pouvez positionner endptr à NULL sans risque.

La fonction retourne le timestamp identifié en cas de réussite. En cas d'erreur, PGTYPESInvalidTimestamp est retourné et error est positionné à PGTYPES_TS_BAD_TIMESTAMP. Voyez PGTYPESInvalidTimestamp pour des informations importantes sur cette valeur.

En général, la chaîne d'entrée peut contenir toute combinaison d'une spécification de date autorisée, un caractère espace et une spécification de temps (time) autorisée. Notez que les timezones ne sont pas supportées par ECPG. Il peut les analyzer mais n'applique aucune calcul comme le ferait le serveur PostgreSQL par exemple. Les spécificateurs de timezone sont ignorées en silence.

Tableau 36.5 contient quelques exemples pour les chaînes d'entrée.

Convertit une date vers une chaîne char* C.

char *PGTYPEStimestamp_to_asc(timestamp tstamp);
        

Cette fonction reçoit le timestamp tstamp comme seul argument et retourne une chaîne allouée qui contient la représentation textuelle du timestamp. Le résultat doit être libéré avec PGTYPESchar_free().

Récupère le timestamp courant.

void PGTYPEStimestamp_current(timestamp *ts);
        

Cette fonction récupère le timestamp courant et le sauve dans la variable timestamp vers laquelle ts pointe.

Convertit une variable timestamp vers un char* C en utilisant un masque de formatage.

int PGTYPEStimestamp_fmt_asc(timestamp *ts, char *output, int str_len, char *fmtstr);
        

Cette fonction reçoit un pointeur vers le timestamp à convertir comme premier argument (ts), un pointeur vers le tampon de sortie (output), la longueur maximale qui a été allouée pour le tampon de sortie (str_len) et le masque de formatage à utiliser pour la conversion (fmtstr).

En cas de réussite, la fonction retourne 0, et une valeur négative en cas d'erreur.

Vous pouvez utiliser les spécificateurs de format suivant pour le masque de formatage. Les spécificateurs sont les mêmes que ceux utilisés dans la fonction strftime de la libc. Tout spécificateur ne correspondant pas à du formatage sera copié dans le tampon de sortie.

Soustraire un timestamp d'un autre et sauver le résultat dans une variable de type interval.

int PGTYPEStimestamp_sub(timestamp *ts1, timestamp *ts2, interval *iv);
        

Cette fonction soustrait la variable timestamp vers laquelle pointe ts2 de la variable de timestamp vers laquelle ts1 pointe, et stockera le résultat dans la variable interval vers laquelle iv pointe.

En cas de succès, la fonction retourne 0, et une valeur négative si une erreur s'est produite.

Convertit une valeur timestamp de sa représentation textuelle en utilisant un masque de formatage.

int PGTYPEStimestamp_defmt_asc(char *str, char *fmt, timestamp *d);
        

Cette fonction reçoit la représentation textuelle d'un timestamp dans la variable str ainsi que le masque de formatage à utiliser dans la variable fmt. Le résultat sera stocké dans la variable vers laquelle d pointe.

Si le masque de formatage fmt est NULL, la fonction se rabattra vers le masque de formatage par défaut qui est %Y-%m-%d %H:%M:%S.

C'est la fonction inverse de PGTYPEStimestamp_fmt_asc. Voyez la documentation à cet endroit pour découvrir toutes les entrées possibles de masque de formatage.

Ajouter une variable interval à une variable timestamp.

int PGTYPEStimestamp_add_interval(timestamp *tin, interval *span, timestamp *tout);
        

Cette fonction reçoit un pointeur vers une variable timestamp tin et un pointeur vers une variable interval span. Elle ajoute l'intervalle au timestapm et sauve le timestamp résultat dans la variable vers laquelle tout pointe.

En cas de succès, la fonction retourne 0, et une valeur négative si une erreur s'est produite.

Soustrait une variable interval d'une variable timestamp.

int PGTYPEStimestamp_sub_interval(timestamp *tin, interval *span, timestamp *tout);
        

Cette fonction soustrait la variable interval vers laquelle span pointe de la variable timestamp vers laquelle tin pointe et sauve le résultat dans la variable vers laquelle tout pointe.

En cas de succès, la fonction retourne 0, et une valeur négative si une erreur s'est produite.

Retourne un pointeur vers une variable interval nouvellement allouée.

interval *PGTYPESinterval_new(void);
        

Libère la mémoire d'une variable interval précédemment allouée.

void PGTYPESinterval_free(interval *intvl);
        

Convertit un interval à partir de sa représentation textuelle.

interval *PGTYPESinterval_from_asc(char *str, char **endptr);
        

Cette fonction traite la chaîne d'entrée str et retourne un pointeur vers une variable interval allouée. À l'heure actuelle ECPG traite toujours intégralement la chaîne, et ne supporte donc pas encore l'adresse du premier caractère invalide dans *endptr. Vous pouvez positionner endptr à NULL sans risque.

Convertit une variable de type interval vers sa représentation textuelle.

char *PGTYPESinterval_to_asc(interval *span);
        

Cette fonction convertit la variable interval vers laquelle span pointe vers un char* C. La sortie ressemble à cet exemple : @ 1 day 12 hours 59 mins 10 secs. Le résultat doit être libéré avec PGTYPESchar_free().

Copie une variable de type interval.

int PGTYPESinterval_copy(interval *intvlsrc, interval *intvldest);
        

Cette fonction copie la variable interval vers laquelle intvlsrc pointe vers la variable vers laquelle intvldest pointe. Notez que vous devrez allouer la mémoire pour la variable destination auparavant.

Demande un pointeur vers une variable decimal nouvellement allouée.

decimal *PGTYPESdecimal_new(void);
        

Libère un type decimal, libère toute sa mémoire.

void PGTYPESdecimal_free(decimal *var);
        

Un argument devrait contenir une variable numeric (ou pointer vers une variable numeric) mais en fait sa représentation en mémoire était invalide.

Un dépassement de capacité s'est produit. Comme le type numeric peut travailler avec une précision quasi-arbitraire, convertir une variable numeric vers d'autres types peut causer un dépassement.

Un soupassement de capacité s'est produit. Comme le type numeric peut travailler avec une précision quasi-arbitraire, convertir une variable numeric vers d'autres types peut causer un soupassement.

Il y a eu une tentative de division par zéro.

Une chaîne de date invalide a été passée à la fonction PGTYPESdate_from_asc.

Des arguments invalides ont été passés à la fonction PGTYPESdate_defmt_asc.

Un indicateur invalide a été trouvé dans la chaîne d'entrée par la fonction PGTYPESdate_defmt_asc.

Une chaîne invalide d'interval a été passée à la fonction PGTYPESinterval_from_asc, ou une valeur invalide d'interval a été passée à la fonction PGTYPESinterval_to_asc.

Il n'a pas été possible de trouver la correspondance dans l'assignement jour/mois/année de la fonction PGTYPESdate_defmt_asc.

Un jour de mois invalide a été trouvé par la fonction PGTYPESdate_defmt_asc.

Une valeur de mois invalide a été trouvée par la fonction PGTYPESdate_defmt_asc.

Une chaîne de timestamp invalide a été passée à la fonction PGTYPEStimestamp_from_asc, ou une valeur invalide de timestamp a été passée à la fonction PGTYPEStimestamp_to_asc.

Une valeur infinie de timestamp a été rencontrée dans un context qui ne peut pas la manipuler.

Une valeur de timestamp représentant un timestamp invalide. C'est retourné par la fonction PGTYPEStimestamp_from_asc en cas d'erreur de conversion. Notez qu'en raison de la représentation interne du type de données timestamp, PGTYPESInvalidTimestamp est aussi un timestamp valide en même temps. Il est positionné à 1899-12-31 23:59:59. Afin de detecter les erreurs, assurez vous que votre application teste non seulement PGTYPESInvalidTimestamp mais aussi error != 0 après chaque appel à PGTYPEStimestamp_from_asc.