Documentation PostgreSQL 14.22 » Interfaces client » ECPG -- SQL embarqué en C » Mode de Compatibilité Informix

Précédent | Niveau supérieur | Suivant
WHENEVER | Sommaire | 36.16. Mode de compatibilité Oracle

## 36.15. Mode de Compatibilité Informix

`ecpg` peut être exécuté dans un mode appelé mode de compatibilité Informix. Si ce mode est actif, il essaie de se comporté comme s'il était le précompilateur Informix pour Informix E/SQL. En gros, cela va vous permettre d'utiliser le signe dollar au lieu de la primitive `EXEC SQL` pour fournir des commandes SQL embarquées:

    $int j = 3;
    $CONNECT TO :dbname;
    $CREATE TABLE test(i INT PRIMARY KEY, j INT);
    $INSERT INTO test(i, j) VALUES (7, :j);
    $COMMIT;

### Note

Il ne doit par y avoir d'espace entre le `$` et la directive de préprocesseur qui le suit, c'est à dire `include`, `define`, `ifdef`, etc. Sinon, le préprocesseur comprendra le mot comme une variable hôte.

Il y a deux modes de compatibilité: `INFORMIX`, `INFORMIX_SE`

Quand vous liez des programmes qui sont dans ce mode de compatibilité, rappelez vous de lier avec `libcompat` qui est fournie avec ECPG.

En plus du liant syntaxique expliqué précédemment, le mode de compatibilité Informix porte d'ESQL vers ECPG quelques fonctions pour l'entrée, la sortie et la transformation des données, ainsi que pour le SQL embarqué.

Le mode de compatibilité Informix est fortement connecté à la librairie pgtypeslib d'ECPG. pgtypeslib met en correspondance les types de données SQL et les types de données du programme hôte C et la plupart des fonctions additionnelles du mode de compatibilité Informix vous permettent de manipuler ces types C des programmes hôtes. Notez toutefois que l'étendue de cette compatibilité est limitée. Il n'essaie pas de copier le comportement d'Informix; il vous permet de faire plus ou mois les mêmes opérations et vou fournit des fonctions qui ont le même nom et ont à la base le même comportement, mais ce n'est pas un produit de remplacement transparent si vous utilisez Informix à l'heure actuelle. De plus, certains types de données sont différents. Par exemple, les types datetime et interval de PostgreSQL ne savent pas traiter des ranges comme par exemple `YEAR TO MINUTE`, donc vous n'aurez pas de support pour cela dans ECPG non plus.

### 36.15.1. Types supplémentaires

Le pseudo-type "string" spécifique à Informix pour stocker des chaînes de caractères ajustées à droite est maintenant supporté dans le mode Informix sans avoir besoin d'utiliser `typedef`. En fait, en mode Informix, ECPG refuse de traiter les fichiers sources qui contiennent `typedef untype string;`

    EXEC SQL BEGIN DECLARE SECTION;
    string userid; /* cette variable contient des données ajustées */
    EXEC SQL END DECLARE SECTION;

    EXEC SQL FETCH MYCUR INTO :userid;

### 36.15.2. Ordres SQL Embarqués Supplémentaires/Manquants

`CLOSE DATABASE`

  Cet ordre ferme la connexion courante. En fait, c'est un synonyme du `DISCONNECT CURRENT` d'ECPG:

      $CLOSE DATABASE;                /* ferme la connexion courante */
      EXEC SQL CLOSE DATABASE;

`FREE nom_curseur`

  En raison des différences sur la façon dont ECPG fonctionne par rapport à l'ESQL/C d'Informix (c'est à dire quelles étapes sont purement des transformations grammaticales et quelles étapes s'appuient sur la librairie sous-jacente), il n'y a pas d'ordre `FREE nom_curseur` dans ECPG. C'est parce que, dans ECPG, `DECLARE CURSOR` ne génère pas un appel de fonction à la librairie qui utilise le nom du curseur. Ce qui implique qu'il n'y a pas à gérer les curseurs SQL à l'exécution dans la librairie ECPG, seulement dans le serveur PostgreSQL.

`FREE nom_requete`

  `FREE nom_requete` est un synonyme de `DEALLOCATE PREPARE nom_requete`.

### 36.15.3. Zones de Descripteurs SQLDA Compatibles Informix

Le mode de compatibilité Informix supporte une structure différente de celle décrite dans Section 36.7.2. Voyez ci-dessous:

    struct sqlvar_compat
    {
        short   sqltype;
        int     sqllen;
        char   *sqldata;
        short  *sqlind;
        char   *sqlname;
        char   *sqlformat;
        short   sqlitype;
        short   sqlilen;
        char   *sqlidata;
        int     sqlxid;
        char   *sqltypename;
        short   sqltypelen;
        short   sqlownerlen;
        short   sqlsourcetype;
        char   *sqlownername;
        int     sqlsourceid;
        char   *sqlilongdata;
        int     sqlflags;
        void   *sqlreserved;
    };

    struct sqlda_compat
    {
        short  sqld;
        struct sqlvar_compat *sqlvar;
        char   desc_name[19];
        short  desc_occ;
        struct sqlda_compat *desc_next;
        void  *reserved;
    };

    typedef struct sqlvar_compat    sqlvar_t;
    typedef struct sqlda_compat     sqlda_t;

Les propriétés globales sont:

`sqld`

  Le nombre de champs dans le descripteur `SQLDA`.

`sqlvar`

  Un pointeur vers les propriétés par champ.

`desc_name`

  Inutilisé, rempli d'octets à zéro.

`desc_occ`

  La taille de la structure allouée.

`desc_next`

  Un pointeur vers la structure SQLDA suivante si le jeu de résultat contient plus d'un enregistrement.

`reserved`

  Pointeur inutilisé, contient NULL. Gardé pour la compatibilité Informix.

Les propriétés par champ sont ci-dessous, elles sont stockées dans le tableau `sqlvar`:

`sqltype`

  Type du champ. Les constantes sont dans `sqltypes.h`

`sqllen`

  La longueur du champ de données.

`sqldata`

  Un pointeur vers le champ de données. Ce pointeur est de type `char*`, la donnée pointée par lui est en format binaire. Par exemple:

      int intval;

      switch (sqldata->sqlvar[i].sqltype)
      {
          case SQLINTEGER:
              intval = *(int *)sqldata->sqlvar[i].sqldata;
              break;
        ...
      }

`sqlind`

  Un pointeur vers l'indicateur NULL. Si retourné par DESCRIBE ou FETCH alors c'est toujours un pointeur valide. Si utilisé comme valeur d'entrée pour `EXECUTE ... USING sqlda;` alors une valeur de pointeur NULL signifie que la valeur pour ce champ est non nulle. Sinon, un pointeur valide et `sqlitype` doivent être positionnés correctement. Par exemple:

      if (*(int2 *)sqldata->sqlvar[i].sqlind != 0)
          printf("value is NULL\n");

`sqlname`

  Le nom du champ. Chaîne terminée par 0.

`sqlformat`

  Réservé dans Informix, valeurs de `PQfformat` pour le champ.

`sqlitype`

  Type de l'indicateur de données NULL. C'est toujours SQLSMINT quand les données sont retournées du serveur. Quand la `SQLDA` est utilisée pour une requête paramétrique, la donnée est traitée en fonction du type de donnée positionné.

`sqlilen`

  Longueur de l'indicateur de données NULL.

`sqlxid`

  Type étendu du champ, résultat de `PQftype`.

`sqltypename`
`sqltypelen`
`sqlownerlen`
`sqlsourcetype`
`sqlownername`
`sqlsourceid`
`sqlflags`
`sqlreserved`

  Inutilisé.

`sqlilongdata`

  C'est égal à `sqldata` si `sqllen` est plus grand que 32nbsp;ko.

Par exemple:

    EXEC SQL INCLUDE sqlda.h;

        sqlda_t        *sqlda; /* Ceci n'a pas besoin d'être dans la DECLARE SECTION embarquée */

        EXEC SQL BEGIN DECLARE SECTION;
        char *prep_stmt = "select * from table1";
        int i;
        EXEC SQL END DECLARE SECTION;

        ...

        EXEC SQL PREPARE mystmt FROM :prep_stmt;

        EXEC SQL DESCRIBE mystmt INTO sqlda;

        printf("# of fields: %d\n", sqlda->sqld);
        for (i = 0; i < sqlda->sqld; i++)
          printf("field %d: \"%s\"\n", sqlda->sqlvar[i]->sqlname);

        EXEC SQL DECLARE mycursor CURSOR FOR mystmt;
        EXEC SQL OPEN mycursor;
        EXEC SQL WHENEVER NOT FOUND GOTO out;

        while (1)
        {
          EXEC SQL FETCH mycursor USING sqlda;
        }

        EXEC SQL CLOSE mycursor;

        free(sqlda); /* La structure principale doit être totalement libérée par free()
                      * sqlda and sqlda->sqlvar sont dans une seule zone allouée */

Pour plus d'informations, voyez l'entête `sqlda.h` et le test de non-régression `src/interfaces/ecpg/test/compat_informix/sqlda.pgc`.

### 36.15.4. Fonctions Additionnelles

`decadd`

  Ajoute deux valeurs décimales.

      int decadd(decimal *arg1, decimal *arg2, decimal *sum);

  La fonction reçoit un poiteur sur la première opérande de type decimal (`arg1`), un pointeur sur la seconde opérande de type decimal (`arg2`) et un pointeur sur la valeur de type decimal qui contiendra la somme (`sum`). En cas de succès, la fonction retourne 0. `ECPG_INFORMIX_NUM_OVERFLOW` est retourné en cas de dépassement et `ECPG_INFORMIX_NUM_UNDERFLOW` en cas de soupassement. -1 est retourné pour les autres échecs et `errno` est positionné au nombre correspondant `errno` de pgtypeslib. pgtypeslib.

`deccmp`

  Compare deux variables de type decimal.

      int deccmp(decimal *arg1, decimal *arg2);

  La fonction reçoit un pointeur vers la première valeur decimal (`arg1`), un pointeur vers la seconde valeur decimal (`arg2`) et retourne une valeur entière qui indique quelle elle la plus grosse valeur.

  - 1, si la valeur pointée par `arg1` est plus grande que celle pointée par `arg2`.

  - -1 si la valeur pointée par `arg1` est plus petite que la valeur pointée par `arg2`.

  - 0 si les deux valeurs pointées par `arg1` et `arg2` sont égales.

`deccopy`

  Copie une valeur decimal.

      void deccopy(decimal *src, decimal *target);

  La fonction reçoit un pointeur vers la valeur decimal qui doit être copiée comme premier argument (`src`) et un pointeur vers la structure de type décimale cible (`target`) comme second argument.

`deccvasc`

  Convertit une valeur de sa représentation ASCII vers un type decimal.

      int deccvasc(char *cp, int len, decimal *np);

  La fonction reçoit un pointeur vers une chaîne qui contient la représentation chaîne du nombre à convertir (`cp`) ainsi que sa longueur `len`. `np` est un pointeur vers la valeur decimal dans laquelle sauver le résultat de l'opération.

  Voici quelques formats valides: `-2`, `.794`, `+3.44`, `592.49E07` ou `-32.84e-4`.

  La fonction retourne 0 en cas de succès. Si un dépassement ou un soupassement se produisent, `ECPG_INFORMIX_NUM_OVERFLOW` ou `ECPG_INFORMIX_NUM_UNDERFLOW` est retourné. Si la représentation ASCII n'a pas pu être interprétée, `ECPG_INFORMIX_BAD_NUMERIC` est retourné ou `ECPG_INFORMIX_BAD_EXPONENT` si le problème s'est produit lors de l'analyse de l'exposant.

`deccvdbl`

  Convertit une valeur de type double vers une valeur de type decimal.

      int deccvdbl(double dbl, decimal *np);

  La fonction reçoit la variable de type double qui devrait être convertie comme premier argument (`dbl`). Comme second argument (`np`), la fonction reçoit un pointeur vers la variable decimal qui recevra le résultat de l'opération.

  La fonction retourne 0 en cas de succès et une valeur négative si la conversion a échoué.

`deccvint`

  Convertit une valeur de type int vers une valeur de type decimal.

      int deccvint(int in, decimal *np);

  La fonction reçoit la variable de type int à convertir comme premier argument (`in`). Comme second argument (`np`), la fonction reçoit un pointeur vers la variable decimal qui recevra le résultat de l'opération.

  La fonction retourne 0 en cas de succès et une valeur négative si la conversion a échoué.

`deccvlong`

  Convertit une valeur de type long vers une valeur de type decimal.

      int deccvlong(long lng, decimal *np);

  La fonction reçoit la variable de type long à convertir comme premier argument (`lng`). Comme second argument (`np`), la fonction reçoit un pointeur vers la variable decimal qui recevra le résultat de l'opération.

  La fonction retourne 0 en cas de succès et une valeur négative si la conversion a échoué.

`decdiv`

  Divise deux variables de type decimal.

      int decdiv(decimal *n1, decimal *n2, decimal *result);

  La fonction reçoit des pointeurs vers les deux variables qui sont le premier (`n1`) et le second (`n2`) opérandes et calcule `n1`/`n2`. `result` est un pointeur vers la variable qui recevra le résultat de l'opération.

  En cas de succès, 0 est retourné, et une valeur négative si la division échoue. En cas de dépassement ou de soupassement, la fonction retourne `ECPG_INFORMIX_NUM_OVERFLOW` ou `ECPG_INFORMIX_NUM_UNDERFLOW` respectivement. Si une tentative de division par zéro se produit, la fonction retourne `ECPG_INFORMIX_NUM_OVERFLOW`.

`decmul`

  Multiplie deux valeurs decimal.

      int decmul(decimal *n1, decimal *n2, decimal *result);

  La fonction reçoit des pointeurs vers les deux variables qui sont le premier (`n1`) et le second (`n2`) opérandes et calcule `n1`/`n2`. `result` est un pointeur vers la variable qui recevra le résultat de l'opération.

  En cas de succès, 0 est retourné, et une valeur négative si la division échoue. En cas de dépassement ou de soupassement, la fonction retourne `ECPG_INFORMIX_NUM_OVERFLOW` ou `ECPG_INFORMIX_NUM_UNDERFLOW` respectivement.

`decsub`

  Soustrait une valeur decimal d'une autre.

      int decsub(decimal *n1, decimal *n2, decimal *result);

  La fonction reçoit des pointeurs vers les deux variables qui sont le premier (`n1`) et le second (`n2`) opérandes et calcule `n1`/`n2`. `result` est un pointeur vers la variable qui recevra le résultat de l'opération.

  En cas de succès, 0 est retourné, et une valeur négative si la division échoue. En cas de dépassement ou de soupassement, la fonction retourne `ECPG_INFORMIX_NUM_OVERFLOW` ou `ECPG_INFORMIX_NUM_UNDERFLOW` respectivement.

`dectoasc`

  Convertit une variable de type decimal vers sa représentation ASCII sous forme de chaîne C char*.

      int dectoasc(decimal *np, char *cp, int len, int right)

  La fonction reçoit un pointeur vers une variable de type decimal (`np`) qu'elle convertit vers sa représentation textuelle. `cp` est le tampon qui devra contenir le résultat de l'opération. Le paramètre `right` spécifie combien de chiffres après la virgule doivent être inclus dans la sortie. Le résultat sera arrondi à ce nombre de chiffres décimaux. Positionner `right` à -1 indique que tous les chiffres décimaux disponibles devraient être inclus dans la sortie. Si la longueur du tampon de sortie, qui est indiquée par `len` n'est pas suffisante pour contenir toute la représentation en incluant le caractère NUL final, seul un caractère unique `*` est stocké dans le résultat, et -1 est retourné.

  La fonction retourne -1 si le tampon `cp` était trop petit ou `ECPG_INFORMIX_OUT_OF_MEMORY` si plus de mémoire n'était disponible.

`dectodbl`

  Convertit une variable de type decimal vers un double.

      int dectodbl(decimal *np, double *dblp);

  La fonction reçoit un pointeur vers la valeur decimal à convertir (`np`) et un pointeur vers la variable double qui devra recevoir le résultat de l'opération (`dblp`).

  La fonction retourne 0 en cas de succès et une valeur négative si la conversion a échoué.

`dectoint`

  Convertit une variable de type decimal vers un integer.

      int dectoint(decimal *np, int *ip);

  La fonction reçoit un pointeur vers la valeur decimal à convertir (`np`) et un pointeur vers la variable integer qui devra recevoir le résultat de l'opération (`ip`).

  La fonction retourne 0 en cas de succès et une valeur négative si la conversion a échoué. Si un dépassement s'est produit, `ECPG_INFORMIX_NUM_OVERFLOW` est retourné.

  Notez que l'implémentation d'ECPG diffère de celle d'Informix. Informix limite un integer entre -32767 et 32767, alors que la limite de l'implémentation d'ECPG dépend de l'architecture (`-INT_MAX .. INT_MAX`).

`dectolong`

  Convertit une variable de type decimal vers un long integer.

      int dectolong(decimal *np, long *lngp);

  La fonction reçoit un pointeur vers la valeur decimal à convertir (`np`) et un pointeur vers la variable long qui devra recevoir le résultat de l'opération (`lngp`).

  La fonction retourne 0 en cas de succès et une valeur négative si la conversion a échoué. Si un dépassement s'est produit, `ECPG_INFORMIX_NUM_OVERFLOW` est retourné.

  Notez que l'implémentation d'ECPG diffère de celle d'Informix. Informix limite un integer entre --2,147,483,647 à 2,147,483,647 alors que la limite de l'implémentation d'ECPG dépend de l'architecture (`-LONG_MAX .. LONG_MAX`).

`rdatestr`

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

      int rdatestr(date d, char *str);

  La fonction reçoit deux arguments, le premier est la date à convertir (`d`) et le second est un pointeur vers la chaîne cible. Le format de sortie est toujours `yyyy-mm-dd`, vous aurez donc à allouer au moins 11 octets (en incluant le terminateur NUL) pour la chaîne.

  La fonction retourne 0 en cas de succès et une valeur négative si la conversion a échoué.

  Notez que l'implémentation d'ECPG diffère de celle de Informix. Dans Informix le format peut être modifié par le positionnement de variable d'enregistrement. Dans ECPG par contre, vous ne pouvez pas changer le format de sortie.

`rstrdate`

  Convertit la représentation textuelle d'une date.

      int rstrdate(char *str, date *d);

  La fonction reçoit la représentation textuelle d'une date à convertir (`str`) et un pointeur vers une variable de type date (`d`). Cette fonction ne vous permet pas de fournir un masque de formatage. Il utilise le format par défaut d'Informix qui est `mm/dd/yyyy`. En interne, cette fonction est implémentée au travers de `rdefmtdate`. Par conséquent, `rstrdate` n'est pas plus rapide et si vous avez le choix, vous devriez opter pour `rdefmtdate`, qui vous permet de spécifier le masque de formatage explicitement.

  La fonction retourne les mêmes valeurs que `rdefmtdate`.

`rtoday`

  Récupère la date courante.

      void rtoday(date *d);

  La fonction reçoit un poiteur vers une variable de type date (`d`) qu'elle positionne à la date courante.

  En interne, cette fonction utilise la fonction `PGTYPESdate_today`.

`rjulmdy`

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

      int rjulmdy(date d, short mdy[3]);

  La fonction reçoit la date `d` et un pointeur vers un tableau de 3 entiers courts `mdy`. Le nom de la 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.

  La fonction retourne toujours 0 pour le moment.

  En interne, cette fonction utilise la fonction `PGTYPESdate_julmdy`.

`rdefmtdate`

  Utilise un masque de formatage pour convertir une chaîne de caractère vers une valeur de type date.

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

  La fonction reçoit un pointeur vers une valeur date qui devra contenir le résultat de l'opération (`d`), le masque de formatage à utiliser pour traiter la date (`fmt`) et la chaîne de caractère char* C qui contient la représentation textuelle de la date (`str`). La représentation textuelle doit correspondre au masque de formatage. La fonction n'analyse qu'en ordre séquentiel et recherche les litté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.

  La fonction retourne les valeurs suivantes:

  - 0 - La fonction s'est terminée avec succès.

  - `ECPG_INFORMIX_ENOSHORTDATE` - La date ne contient pas de délimiteur entre le jour, le mois et l'année. Dans ce cas, la chaîne en entrée doit faire exactement 6 ou 8 caractères, mais ce n'est pas le cas.

  - `ECPG_INFORMIX_ENOTDMY` - La chaîne de formatage n'indique pas correctement l'ordre séquentiel de l'année, du mois, et du jour.

  - `ECPG_INFORMIX_BAD_DAY` - La chaîne d'entrée ne contient pas de jour valide.

  - `ECPG_INFORMIX_BAD_MONTH` - La chaîne d'entrée ne contient pas de mois valide.

  - `ECPG_INFORMIX_BAD_YEAR` - La chaîne d'entrée ne contient pas d'année valide.

  En interne, cette fonction est implémentée en utilisant la fonction `PGTYPESdate_defmt_asc`. Voyez la référence à cet endroi pour la table d'exemples.

`rfmtdate`

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

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

  La fonction reçoit une date à convertir (`d`), le masque de formatage (`fmt`) et la chaîne qui contiendra la représentation textuelle de la date (`str`).

  La fonction retourne 0 en cas de succès et une valeur négative

  En interne, cette fonction utilise la fonction `PGTYPESdate_fmt_asc`, voyez la référence pour des exemples.

`rmdyjul`

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

      int rmdyjul(short mdy[3], date *d);

  La fonction reçoit le tableau des 3 entiers courst (`mdy`) et un pointeur vers une variable de type date qui contiendra le résultat de l'opération.

  La fonction retourne toujours 0 à l'heure actuelle.

  En interne la fonction est implémentée en utilisant la fonction `PGTYPESdate_mdyjul`.

`rdayofweek`

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

      int rdayofweek(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.

  - 0 - Dimanche

  - 1 - Lundi

  - 2 - Mardi

  - 3 - Mercredi

  - 4 - Jeudi

  - 5 - Vendredi

  - 6 - Samedi

  En interne, cette fonction est implémentée en utilisant la fonction `PGTYPESdate_dayofweek`.

`dtcurrent`

  Récupère le timestamp courant.

      void dtcurrent(timestamp *ts);

  La fonction récupère le timestamp courant et l'enregistre dans la variable timestamp vers laquelle `ts` pointe.

`dtcvasc`

  Convertit un timestamp de sa représentation textuelle vers une variable timestamp.

      int dtcvasc(char *str, timestamp *ts);

  La fonction reçoit la chaîne à traiter (`str`) et un pointeur vers la variable timestamp qui contiendra le résultat de l'opération (`ts`).

  La fonction retourne 0 en cas de succès et une valeur négative

  En interne, cette fonction utilise la fonction `PGTYPEStimestamp_from_asc`. Voyez la référence pour un tableau avec des exemples de formats.

`dtcvfmtasc`

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

      dtcvfmtasc(char *inbuf, char *fmtstr, timestamp *dtvalue)

  La fonction reçoit la chaîne à traiter (`inbuf`), le masque de formatage à utiliser (`fmtstr`) et un pointeur vers la variable timestamp qui contiendra le résultat de l'opération (`dtvalue`).

  Cette fonction est implémentée en utilisant la fonction `PGTYPEStimestamp_defmt_asc`. Voyez la documentation à cet endroit pour la liste des spécificateurs de formats qui peuvent être utilisés.

  La fonction retourne 0 en cas de succès et une valeur négative

`dtsub`

  Soustrait un timestamp d'un autre et retourne une variable de type interval.

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

  La fonction soustrait la variable timestamp vers laquelle `ts2` pointe de la variable timestamp vers laquelle `ts1` pointe et stockera le résultat dans la variable intervalle vers laquelle `iv` pointe.

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

`dttoasc`

  Convertit une variable timestamp vers une chaîne char* C.

      int dttoasc(timestamp *ts, char *output);

  La fonction reçoit un pointeur vers une variable timestamp à convertir (`ts`) et la chaîne qui devra contenir le résultat de l'opération (`output`). Elle convertit `ts` vers sa représentation textuelle comme spécifié par le standard SQL, qui est `YYYY-MM-DD HH:MM:SS`.

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

`dttofmtasc`

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

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

  La 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 succès, la fonction retourne 0, et une valeur négative si une erreur s'est produite.

  En interne, cette fonction utilise la fonction `PGTYPEStimestamp_fmt_asc`. Voyez la référence pour des informations sur les spécifications de masque de formatage qui sont utilisables.

`intoasc`

  Convertit une variable interval en chaîne char* C.

      int intoasc(interval *i, char *str);

  La fonction reçoit un pointeur vers la variable interval à convertir (`i`) et la chaîne qui contiendra le résultat de l'opération (`str`). Elle convertit `i` vers sa représentation textuelle suivant le standard SQL, qui est `YYYY-MM-DD HH:MM:SS`.

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

`rfmtlong`

  Convertit une valeur long integer vers sa représentation textuelle en utilisant un masque de formatage.

      int rfmtlong(long lng_val, char *fmt, char *outbuf);

  La fonction reçoit la valeur long `lng_val`, le masque de formatage `fmt` et un pointeur vers le tampon de sortie `outbuf`. Il convertit la valeur long vers sa représentation textuelle en fonction du masque de formatage.

  Le masque de formatage peut être composé des caractères suivants de spécification:

  - `*` (asterisk) - si cette position était blanc sans cela, mettez y un astérisque.

  - `&` (ampersand) - si cette position était blanc sans cela, mettez y un zéro.

  - `#` - transforme les zéros initiaux en blancs.

  - `<` - justifie à gauche le nombre dans la chaîne.

  - `,` (virgule) - Groupe les nombres de 4 chiffres ou plus en groupes de 3 chiffres séparés par des virgules.

  - `.` (point) - Ce caractère sépare la partie entière du nombre de sa partie fractionnaire.

  - `-` (moins) - le signe moins apparaît si le nombre est négatif.

  - `+` (plus) - le signe plus apparaît si le nombre est positif.

  - `(` - ceci remplace le signe moins devant une valeur négative. Le signe moins n'apparaîtra pas.

  - `)` - Ce caractère remplace le signe moins et est affiché après la valeur négative.

  - `$` - le symbole monétaire.

`rupshift`

  Passe une chaîne en majuscule.

      void rupshift(char *str);

  La fonction reçoit un pointeur vers une chaîne et convertit tous ses caractères en majuscules.

`byleng`

  Retourne le nombre de caractères dans une chaîne sans compter les blancs finaux.

      int byleng(char *str, int len);

  La fonction attend une chaîne de longueur fixe comme premier argument (`str`) et sa longueur comme second argument (`len`). Elle retourne le nombre de caractères significatifs, c'est à dire la longueur de la chaîne sans ses blancs finaux.

`ldchar`

  Copie une chaîne de longueur fixe vers une chaîne terminée par un NUL.

      void ldchar(char *src, int len, char *dest);

  La fonction reçoit la chaîne de longueur fixe à copier (`src`), sa longueur (`len`) et un pointeur vers la mémoire destinataire (`dest`). Notez que vous aurez besoin de réserver au moins `len+1` octets pour la chaine vers laquelle pointe `dest`. Cette fonction copie au plus `len` octets vers le nouvel emplacement (moins si la chaîne source a des blancs finaux) et ajoute le terminateur NUL.

`rgetmsg`

      int rgetmsg(int msgnum, char *s, int maxsize);

  Cette fonction existe mais n'est pas implémentée pour le moment!

`rtypalign`

      int rtypalign(int offset, int type);

  Cette fonction existe mais n'est pas implémentée pour le moment!

`rtypmsize`

      int rtypmsize(int type, int len);

  Cette fonction existe mais n'est pas implémentée pour le moment!

`rtypwidth`

      int rtypwidth(int sqltype, int sqllen);

  Cette fonction existe mais n'est pas implémentée pour le moment!

`rsetnull`

  Set a variable to NULL.

      int rsetnull(int t, char *ptr);

  La fonction reçoit un entier qui indique le type de variable et un pointeur vers la variable elle même, transtypé vers un pointeur char*.

  Les types suivants existent :

  - `CCHARTYPE` - Pour une variable de type `char` ou `char*`

  - `CSHORTTYPE` - Pour une variable de type `short int`

  - `CINTTYPE` - Pour une variable de type `int`

  - `CBOOLTYPE` - Pour une variable de type `boolean`

  - `CFLOATTYPE` - Pour une variable de type `float`

  - `CLONGTYPE` - Pour une variable de type `long`

  - `CDOUBLETYPE` - Pour une variable de type `double`

  - `CDECIMALTYPE` - Pour une variable de type `decimal`

  - `CDATETYPE` - Pour une variable de type `date`

  - `CDTIMETYPE` - Pour une variable de type `timestamp`

  Voici un exemple d'appel à cette fonction:

      $char c[] = "abc       ";
      $short s = 17;
      $int i = -74874;

      rsetnull(CCHARTYPE, (char *) c);
      rsetnull(CSHORTTYPE, (char *) &s);
      rsetnull(CINTTYPE, (char *) &i);

`risnull`

  Teste si une variable est NULL.

      int risnull(int t, char *ptr);

  Cette fonction reçoit le type d'une variable à tester (`t`) ainsi qu'un pointeur vers cette variable (`ptr`). Notez que ce dernier doit être transtypé vers un char*. Voyez la fonction `rsetnull` pour une liste de types de variables possibles.

  Voici un exemple de comment utiliser cette fonction:

      $char c[] = "abc       ";
      $short s = 17;
      $int i = -74874;

      risnull(CCHARTYPE, (char *) c);
      risnull(CSHORTTYPE, (char *) &s);
      risnull(CINTTYPE, (char *) &i);

### 36.15.5. Constantes Supplémentaires

Notez que toutes les constantes ici décrivent des erreurs et qu'elles sont toutes définies pour représenter des valeurs négatives. Dans les descriptions des différentes constantes vous pouvez aussi trouver la valeur que les constantes représentent dans l'implémentation actuelle. Toutefois, vous ne devriez pas vous fier à ce nombre. Vous pouvez toutefois vous appuyer sur le faite que toutes sont définies comme des valeurs négatives. values.

`ECPG_INFORMIX_NUM_OVERFLOW`

  Les fonctions retournent cette valeur si un dépassement s'est produit dans un calcul. En interne, elle est définie à -1200 (la définition Informix).

`ECPG_INFORMIX_NUM_UNDERFLOW`

  Les fonctions retournent cette valeur si un soupassement s'est produit dans un calcul. En interne, elle est définie à -1201 (la définition Informix).

`ECPG_INFORMIX_DIVIDE_ZERO`

  Les fonctions retournent cette valeur si une division par zéro a été tentée. En interne, elle est définie à -1202 (la définition Informix).

`ECPG_INFORMIX_BAD_YEAR`

  Les fonctions retournent cette valeur si une mauvaise valeur pour une année a été trouvée lors de l'analyse d'une date. En interne elle est définie à -1204 (la définition Informix).

`ECPG_INFORMIX_BAD_MONTH`

  Les fonctions retournent cette valeur si une mauvaise valeur pour un mois a été trouvée lors de l'analyse d'une date. En interne elle est définie à -1205 (la définition Informix).

`ECPG_INFORMIX_BAD_DAY`

  Les fonctions retournent cette valeur si une mauvaise valeur pour un jour a été trouvée lors de l'analyse d'une date. En interne elle est définie à -1206 (la définition Informix).

`ECPG_INFORMIX_ENOSHORTDATE`

  Les fonctions retournent cette valeur si une routine d'analyse a besoin d'une représentation courte de date mais que la chaîne passée n'était pas de la bonne longueur. En interne elle est définie à -1206 (la définition Informix).

`ECPG_INFORMIX_DATE_CONVERT`

  Les fonctions retournent cette valeur si une erreur s'est produite durant un formatage de date. En interne, elle est définie à -1210 (la définition Informix).

`ECPG_INFORMIX_OUT_OF_MEMORY`

  Les fonctions retournent cette valeur si elles se sont retrouvées à court de mémoire durant leur fonctionnement. En interne, elle est définie à -1211 (la définition Informix).

`ECPG_INFORMIX_ENOTDMY`

  Les fonctions retournent cette valeur si la routine d'analyse devait recevoir un masque de formatage (comme `mmddyy`) mai que tous les champs n'étaient pas listés correctement. En interne, elle est définie à -1212 (la définition Informix).

`ECPG_INFORMIX_BAD_NUMERIC`

  Les fonctions retournent cette valeur soit parce qu'une routine d'analyse ne peut pas analyser la représentation textuelle d'une valeur numérique parce qu'elle contient des erreurs, soit parce qu'une routine ne peut pas terminer un calcul impliquant des variables numeric parce qu'au moins une des variables numeric est invalide. En interne, elle est définie à -1213 (la définition Informix).

`ECPG_INFORMIX_BAD_EXPONENT`

  Les fonctions retournent cette valeur si elles n'ont pas réussi à analyser l'exposant de la représentation textuelle d'une valeur numérique. En interne, elle est définie à -1216 (la définition Informix).

`ECPG_INFORMIX_BAD_DATE`

  Les fonctions retournent cette valeur si une chaîne de date invalide leur a été passée. En interne, elle est définie à -1218 (la définition Informix).

`ECPG_INFORMIX_EXTRA_CHARS`

  Les fonctions retournent cette valeur si trop de caractères ont été trouvés dans la représentation textuelle d'un format date. En interne, elle est définie à -1264 (la définition Informix).