PostgreSQLLa base de données la plus sophistiquée au monde.

Version anglaise

35.15. Mode de Compatibilité Informix

ecpg peut être exécuté dans un mode appelé mode de compatibilité Informix. Si ce mode est actif, il essaye 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]

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'essaye 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.

35.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;
   

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

35.15.3. Zones de Descripteurs SQLDA Compatibles Informix

Le mode de compatibilité Informix supporte une structure différente de celle décrite dans Section 35.7.2, « Zones de Descripteurs SQLDA ». 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 32 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'informatinos, voyez l'entête sqlda.h et le test de non-régression src/interfaces/ecpg/test/compat_informix/sqlda.pgc.

35.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 decimale 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 chiffers 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çoin 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 utilisante 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 intere, 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 caracè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);

       

35.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™).