Documentation PostgreSQL 14.22 » Interfaces client » ECPG -- SQL embarqué en C » Librairie pgtypes

Précédent | Niveau supérieur | Suivant
36.5. SQL Dynamique | Sommaire | 36.7. Utiliser les Zones de Descripteur

## 36.6. Librairie pgtypes

La librairie pgtypes met en correspondance les types de la base de données PostgreSQL avec des équivalents en C qui peuvent être utilisés dans des programmes en C. Elle fournit aussi des fonctions pour effectuer les calculs de base avec ces types en C, c'est à dire, sans l'aide du serveur PostgreSQL. Voyez l'exemple suivant :

    EXEC SQL BEGIN DECLARE SECTION;
       date date1;
       timestamp ts1, tsout;
       interval iv1;
       char *out;
    EXEC SQL END DECLARE SECTION;

    PGTYPESdate_today(&date1);
    EXEC SQL SELECT started, duration INTO :ts1, :iv1 FROM datetbl WHERE d=:date1;
    PGTYPEStimestamp_add_interval(&ts1, &iv1, &tsout);
    out = PGTYPEStimestamp_to_asc(&tsout);
    printf("Started + duration: %s\n", out);
    PGTYPESchar_free(out);

### 36.6.1. Chaîne de caractères

Certaines fonctions comme `PGTYPESnumeric_to_asc` renvoient un pointeur vers une chaîne de caractères fraichement allouée. Ces allocations doivent être libérées avec `PGTYPESchar_free` plutôt que `free`. (Ceci est seulement important sur Windows où l'allocation et la désallocation de la mémoire ont parfois besoin d'être réalisées par la même bibliothèque.)

### 36.6.2. Le type numeric

Le type numeric permet de faire des calculs de précision arbitraire. Voyez Section 8.1 pour le type équivalent dans le serveur PostgreSQL. En raison de cette précision arbitraire cette variable doit pouvoir s'étendre et se réduire dynamiquement. C'est pour cela que vous ne pouvez créer des variables numeric que sur le tas, en utilisant les fonctions `PGTYPESnumeric_new` et `PGTYPESnumeric_free`. Le type décimal, qui est similaire mais de précision limitée, peut être créé sur la pile ou sur le tas.

Les fonctions suivantes peuvent être utilisées pour travailler avec le type numeric :

`PGTYPESnumeric_new`

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

      numeric *PGTYPESnumeric_new(void);

`PGTYPESnumeric_free`

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

      void PGTYPESnumeric_free(numeric *var);

`PGTYPESnumeric_from_asc`

  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.

`PGTYPESnumeric_to_asc`

  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()`.

`PGTYPESnumeric_add`

  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.

`PGTYPESnumeric_sub`

  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.

`PGTYPESnumeric_mul`

  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.

`PGTYPESnumeric_div`

  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.

`PGTYPESnumeric_cmp`

  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 :

  - 1, si `var1` est plus grand que `var2`

  - -1, si `var1` est plus petit que `var2`

  - 0, si `var1` et `var2` sont égaux

`PGTYPESnumeric_from_int`

  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.

`PGTYPESnumeric_from_long`

  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.

`PGTYPESnumeric_copy`

  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.

`PGTYPESnumeric_from_double`

  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.

`PGTYPESnumeric_to_double`

  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.

`PGTYPESnumeric_to_int`

  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.

`PGTYPESnumeric_to_long`

  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.

`PGTYPESnumeric_to_decimal`

  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.

`PGTYPESnumeric_from_decimal`

  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.

### 36.6.3. Le Type date

Le type date en C permet à votre programme de traiter les données type type SQL date. Voyez Section 8.5 pour le type équivalent du serveur PostgreSQL.

Les fonctions suivantes peuvent être utilisées pour travailler avec le type date :

`PGTYPESdate_from_timestamp`

  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.

`PGTYPESdate_from_asc`

  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.

  Tableau 36.2. Formats d'Entrée Valides pour `PGTYPESdate_from_asc`

  Entrée | Sortie
  --- | ---
  `January 8, 1999` | `January 8, 1999`
  `1999-01-08` | `January 8, 1999`
  `1/8/1999` | `January 8, 1999`
  `1/18/1999` | `January 18, 1999`
  `01/02/03` | `February 1, 2003`
  `1999-Jan-08` | `January 8, 1999`
  `Jan-08-1999` | `January 8, 1999`
  `08-Jan-1999` | `January 8, 1999`
  `99-Jan-08` | `January 8, 1999`
  `08-Jan-99` | `January 8, 1999`
  `08-Jan-06` | `January 8, 2006`
  `Jan-08-99` | `January 8, 1999`
  `19990108` | `ISO 8601; January 8, 1999`
  `990108` | `ISO 8601; January 8, 1999`
  `1999.008` | `year and day of year`
  `J2451187` | `Julian day`
  `January 8, 99 BC` | `year 99 before the Common Era`

`PGTYPESdate_to_asc`

  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()`.

`PGTYPESdate_julmdy`

  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.

`PGTYPESdate_mdyjul`

  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.

`PGTYPESdate_dayofweek`

  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.

  - 0 - Dimanche

  - 1 - Lundi

  - 2 - Mardi

  - 3 - Mercredi

  - 4 - Jeudi

  - 5 - Vendredi

  - 6 - Samedi

`PGTYPESdate_today`

  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.

`PGTYPESdate_fmt_asc`

  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:

  - `dd` - Le numéro du jour du mois.

  - `mm` - Le numéro du mois de l'année.

  - `yy` - Le numéro de l'année comme nombre à deux chiffres.

  - `yyyy` - Le numéro de l'année comme nombre à quatre chiffres.

  - `ddd` - Le nom du jour (abrégé).

  - `mmm` - Le nom du mois (abrégé).

  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.

  Tableau 36.3. Formats d'Entrée Valides pour `PGTYPESdate_fmt_asc`

  Format | Résultat
  --- | ---
  `mmddyy` | `112359`
  `ddmmyy` | `231159`
  `yymmdd` | `591123`
  `yy/mm/dd` | `59/11/23`
  `yy mm dd` | `59 11 23`
  `yy.mm.dd` | `59.11.23`
  `.mm.yyyy.dd.` | `.11.1959.23.`
  `mmm. dd, yyyy` | `Nov. 23, 1959`
  `mmm dd yyyy` | `Nov 23 1959`
  `yyyy dd mm` | `1959 23 11`
  `ddd, mmm. dd, yyyy` | `Mon, Nov. 23, 1959`
  `(ddd) mmm. dd, yyyy` | `(Mon) Nov. 23, 1959`

`PGTYPESdate_defmt_asc`

  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

  Tableau 36.4. Formats d'Entrée Valides pour `rdefmtdate`

  Format | Chaîne | Résultat
  --- | --- | ---
  `ddmmyy` | `21-2-54` | `1954-02-21`
  `ddmmyy` | `2-12-54` | `1954-12-02`
  `ddmmyy` | `20111954` | `1954-11-20`
  `ddmmyy` | `130464` | `1964-04-13`
  `mmm.dd.yyyy` | `MAR-12-1967` | `1967-03-12`
  `yy/mm/dd` | `1954, February 3rd` | `1954-02-03`
  `mmm.dd.yyyy` | `041269` | `1969-04-12`
  `yy/mm/dd` | `In the year 2525, in the month of July, mankind will be alive on the 28th day` | `2525-07-28`
  `dd-mm-yy` | `I said on the 28th of July in the year 2525` | `2525-07-28`
  `mmm.dd.yyyy` | `9/14/58` | `1958-09-14`
  `yy/mm/dd` | `47/03/29` | `1947-03-29`
  `mmm.dd.yyyy` | `oct 28 1975` | `1975-10-28`
  `mmddyy` | `Nov 14th, 1985` | `1985-11-14`

### 36.6.4. Le Type timestamp

Le type timestamp en C permet à vos programmes de manipuler les données du type SQL timestamp. Voyez Section 8.5 pour le type équivalent dans le serveur PostgreSQL.

Les fonctions suivantes peuvent être utilisées pour manipuler le type timestamp :

`PGTYPEStimestamp_from_asc`

  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.

  Tableau 36.5. Formats d'Entrée Valide pour `PGTYPEStimestamp_from_asc`

  Entrée | Résultat
  --- | ---
  `1999-01-08 04:05:06` | `1999-01-08 04:05:06`
  `January 8 04:05:06 1999 PST` | `1999-01-08 04:05:06`
  `1999-Jan-08 04:05:06.789-8` | `1999-01-08 04:05:06.789 (time zone specifier ignored)`
  `J2451187 04:05-08:00` | `1999-01-08 04:05:00 (time zone specifier ignored)`

`PGTYPEStimestamp_to_asc`

  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()`.

`PGTYPEStimestamp_current`

  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.

`PGTYPEStimestamp_fmt_asc`

  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.

  - `%A` - est remplacé par la représentation nationale du nom complet du jour de la semaine.

  - `%a` - est remplacé par la représentation nationale du nom abrégé du jour de la semaine.

  - `%B` - est remplacé par la représentation nationale du nom complet du mois.

  - `%b` - est remplacé par la représentation nationale du nom abrégé du mois.

  - `%C` - est remplacé par (année / 100) sous forme de nombre décimal; les chiffres seuls sont précédés par un zéro.

  - `%c` - est remplacé par la représentation nationale de time et date.

  - `%D` - est équivalent à `%m/%d/%y`.

  - `%d` - est remplacé par le jour du mois sous forme de nombre décimal (01–31).

  - `%E*` `%O*` - Extensions locales POSIX Les séquences: `%Ec` `%EC` `%Ex` `%EX` `%Ey` `%EY` `%Od` `%Oe` `%OH` `%OI` `%Om` `%OM` `%OS` `%Ou` `%OU` `%OV` `%Ow` `%OW` `%Oy` sont supposées fournir des représentations alternatives.

    De plus, `%OB` est implémenté pour représenter des noms de mois alternatifs (utilisé seul, sans jour mentionné).

  - `%e` - est remplacé par le jour du mois comme nombre décimal (1–31) ; les chiffres seuls sont précédés par un blanc.

  - `%F` - est équivalent à `%Y-%m-%d`.

  - `%G` - est remplacé par une année comme nombre décimal avec le siècle. L'année courante est celle qui contient la plus grande partie de la semaine (Lundi est le premier jour de la semaine).

  - `%g` - est remplacé par la même année que dans `%G`, mais comme un nombre décimal sans le siècle. (00–99).

  - `%H` - est remplacé par l'heure (horloge sur 24 heures) comme nombre décimal (00–23).

  - `%h` - comme `%b`.

  - `%I` - est remplacé par l'heure (horloge sur 12 heures) comme nombre décimal(01–12).

  - `%j` - est remplacé par le jour de l'année comme nombre décimal (001–366).

  - `%k` - est remplacé par l'heure (horloge sur 24 heures) comme nombre décimal (0–23) ; les chiffres seuls sont précédés par un blanc.

  - `%l` - est remplacé par l'heure (horloge sur 12 heures) comme nombre décimal (1–12) ; les chiffres seuls sont précédés par un blanc.

  - `%M` - est remplacé par la minute comme nombre décimal (00–59).

  - `%m` - est remplacé par le mois comme nombre décimal (01–12).

  - `%n` - est remplacé par un caractère nouvelle ligne.

  - `%O*` - comme `%E*`.

  - `%p` - est remplacé par la représentation nationale de « ante meridiem » ou « post meridiem » suivant la valeur appropriée.

  - `%R` - est équivalent à `%H:%M`.

  - `%r` - est équivalent à `%I:%M:%S %p`.

  - `%S` - est remplacé par la seconde comme nombre décimal (00–60).

  - `%s` - est remplacé par le nombre de secondes depuis l'Epoch, en UTC.

  - `%T` - est équivalent à `%H:%M:%S`

  - `%t` - est remplacé par une tabulation.

  - `%U` - est remplacé par le numéro de la semaine dans l'année (Dimanche est le premier jour de la semaine) comme nombre décimal (00–53).

  - `%u` - est remplacé par le jour de la semaine (Lundi comme premier jour de la semaine) comme nombre décimal (1–7).

  - `%V` - est remplacé par le numéro de la semaine dans l'année (Lundi est le premier jour de la semaine) comme nombre décimal (01–53). Si l'année contenant le 1er Janvier a 4 jours ou plus dans la nouvelle année, alors c'est la semaine numéro 1; sinon, c'est la dernière semaine de l'année précédente, et la semaine suivante est la semaine 1.

  - `%v` - est équivalent à `%e-%b-%Y`.

  - `%W` - est remplacé par le numéro de la semaine dans l'année (Lundi est le premier jour de la semaine) comme nombre décimal (00–53).

  - `%w` - est remplacé par le jour de la semaine (Dimanche comme premier jour de la semaine) comme nombre décimal (0–6).

  - `%X` - est remplacé par la représentation nationale du temps.

  - `%x` - est remplacé par la représentation nationale de la date.

  - `%Y` - est remplacé par l'année avec le siècle comme un nombre décimal.

  - `%y` - est remplacé par l'année sans le siècle comme un nombre décimal (00–99).

  - `%Z` - est remplacé par le nom de la zone de temps.

  - `%z` - est remplacé par le décalage de la zone de temps par rapport à UTC; un signe plus initial signifie à l'est d'UTC, un signe moins à l'ouest d'UTC, les heures et les minutes suivent avec deux chiffres chacun et aucun délimiteur entre eux (forme commune pour les entêtes de date spécifiés par la RFC 822).

  - `%+` - est remplacé par la représentation nationale de la date et du temps.

  - `%-*` - extension de la libc GNU. Ne pas faire de padding (bourrage) sur les sorties numériques.

  - $_* - extension de la libc GNU. Spécifie explicitement l'espace pour le padding.

  - `%0*` - extension de la libc GNU. Spécifie explicitement le zéro pour le padding.

  - `%%` - est remplacé par `%`.

`PGTYPEStimestamp_sub`

  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.

`PGTYPEStimestamp_defmt_asc`

  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.

`PGTYPEStimestamp_add_interval`

  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.

`PGTYPEStimestamp_sub_interval`

  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.

### 36.6.5. Le Type interval

Le type interval en C permet à vos programmes de manipuler des données du type SQL interval. Voyez Section 8.5 pour le type équivalent dans le serveur PostgreSQL.

Les fonctions suivantes peuvent être utilisées pour travailler avec le type interval :

`PGTYPESinterval_new`

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

      interval *PGTYPESinterval_new(void);

`PGTYPESinterval_free`

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

      void PGTYPESinterval_free(interval *intvl);

`PGTYPESinterval_from_asc`

  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.

`PGTYPESinterval_to_asc`

  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()`.

`PGTYPESinterval_copy`

  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.

### 36.6.6. Le Type decimal

Le type decimal est similaire au type numeric. Toutefois il est limité à une précision maximale de 30 chiffres significatifs. À l'opposeé du type numeric que ne peut être créé que sur le tas, le type decimal peur être créé soit sur la pile soit sur le tas (au moyen des fonctions `PGTYPESdecimal_new` et `PGTYPESdecimal_free`). Il y a beaucoup d'autres fonctions qui manipulent le type decimal dans le mode de compatibilité Informix décrit dans Section 36.15.

Les fonctions suivantes peut être utilisée pour travailler avec le type decimal et ne sont pas seulement contenues dans la librairie `libcompat`.

`PGTYPESdecimal_new`

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

      decimal *PGTYPESdecimal_new(void);

`PGTYPESdecimal_free`

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

      void PGTYPESdecimal_free(decimal *var);

### 36.6.7. errno Valeurs de pgtypeslib

`PGTYPES_NUM_BAD_NUMERIC`

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

`PGTYPES_NUM_OVERFLOW`

  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.

`PGTYPES_NUM_UNDERFLOW`

  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.

`PGTYPES_NUM_DIVIDE_ZERO`

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

`PGTYPES_DATE_BAD_DATE`

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

`PGTYPES_DATE_ERR_EARGS`

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

`PGTYPES_DATE_ERR_ENOSHORTDATE`

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

`PGTYPES_INTVL_BAD_INTERVAL`

  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`.

`PGTYPES_DATE_ERR_ENOTDMY`

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

`PGTYPES_DATE_BAD_DAY`

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

`PGTYPES_DATE_BAD_MONTH`

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

`PGTYPES_TS_BAD_TIMESTAMP`

  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`.

`PGTYPES_TS_ERR_EINFTIME`

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

### 36.6.8. Constantes Spéciales de pgtypeslib

`PGTYPESInvalidTimestamp`

  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`.