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