GDG (Generic Database Gateway) est une solution qui permet conserver telles quelles vos applications COBOL MVS et porter/migrer votre base de données DB/2 vers un système ouvert, supprimant ainsi les coûts de licences DB/2 mainframe
|
|
|
|
G
D
G
|
|
|
- Applications COBOL
- base DB/2 Mainframe
1 licence DB/2 Mainframe
|
|
- Applications COBOL
- base DB/2 UDB, Oracle,
PostGres, MySQL
sous Unix, z/Linux
1 licence DB/2 Mainframe
|
1 - ORGANISATION GENERALE
GDG permet à des programmes situés sur un
système A d'accéder à une base de données
située sur un système B, sans utilitaires ou API's
spéciaux autres que ceux fournis avec GDG.
GDG fonctionne en mode Client/Serveur.
La partie
Serveur :
Elle est mise en oeuvre sur un système UNIX capable
d'accéder normalement à la base de données
via les API SQL standard ("exec sql ..."), normalement fournis avec la
base de données dans sa partie 'Client'.
Elle est implémentée sous forme d'un service TCP/IP
standard, en écoute sur un port arbitraire..
Fig.1 Organisation générale en Client/Serveur.
La partie
Client :
Elle peut être utilisée sur toute plateforme TCP/IP
standard.
Elle est matérialisée par un utilitaire
, un pré-compilateur COBOL,
et un API
propriétaire (librairie de sous-programmes, statique
ou dynamique selon les plateformes.)
Le Précompilateur
COBOL lit en entrée un programme COBOL contenant des
clauses du type 'EXEC
GDG ...', et fourni en sortie le programme COBOL avec les appels
correspondant à l'API GDG.
L'utilitaire GDGUTIL utilise
lui-même l'API GDG : il lit les requêtes sur l'entrée
logique du système (SYSIN, stdin ...), les transmet au serveur
GDG via l'api GDG, et renvoie les résultats sur la sortie logique
du système (SYSPRINT, stdout ...).
L'API permet
d'invoquer des procédures catologuées coté
serveur, ou de lui envoyer des requètes en format libre, puis de
récupérer les résultats rang par rang , soit sous
forme d'une seule ligne de resutats (avec le séparateur '|'),
soit rangés dans les champs choisis par l'utilisateur.
Plateformes disponibles ou en cours de
réalisation :
Exemple
1 :
| Database |
POSTGRESQL |
| Plateforme Serveur |
z/Linux |
| Plateforme Client |
MVS |
L'API permet à des programmes COBOL MVS d'accéder
à la Base POSTGRESQL sur z/Linux.
L'utilitaire GDGUTIL permet le lancement de commandes SQL en mode
batch (lues depuis le ddname 'SYSIN'), et de produire les
résultats en SYSOUT ou dans un un fichier (par le ddname
'SYSPRINT').
Exemple 2 :
| Database |
DB/2 UDB |
| Plateforme Serveur |
Linux 386 + DB2/Connect |
| Plateforme Client |
Solaris |
L'API permet à des programmes du système
Solaris d'accéder à une Base DB2 via la
machine Linux.
L'utilitaire GDGUTIL permet de lire des commandes SQL
depuis 'le standard input', de les envoyer au serveur GDG Linux,
et d'afficher les résultats obtenus sur le 'standard output' .
2 - Le PREPROCESSEUR GDG
Le préprocesseur GDG est destiné aux Développeurs
COBOL.
Il traite les clauses 'EXEC GDG' dans les programmes COBOL et les
transforme en appels à l'API GDG correspondant.
Il se charge également de l'insertion des zones de
manoeuvre nécessésaires dans la WORKING-STORAGE SECTION, notamment
de la zone de communication 'GDG-AREA',
avec ses 2 codes-retour : GDGRC
et SQLRC.
En MVS, il lit le programme à transformer par le
DDNAME 'FGDG',
et produit le résultat par le DDNAME 'FCOB'.
Sour les autres plateformes, ces deux fichiers sont passés
en paramètres dans la ligne de commande, et valent par
défaut stdin et stdout :
gdg2cob fichier-gdg fichier-cobol
ou
gdg2cob <fichier-gdg >fichier-cobol
Le préprocesseur reconnait et traite les primitives
suivantes (c.f. Fig.2):
Début / fin de session :
3 primitives.
- EXEC GDG 'INIT'.
- EXEC GDG 'CONNECT' USING dbalias
connectstring.
- EXEC GDG 'CLOSE'.
Exécution de
Procédure ou commande SQL : 2 primitives.
- EXEC GDG 'CALLPROC' USING procname [ param1 [
param2 ...] ].
- EXEC GDG 'SENDSQL' USING requete.
Lecture des résultats :
1 primitive.
- EXEC GDG 'SETREPLY' USING { 'GDG-PARSE' |
'GDG-NO-PARSE' } .
- EXEC GDG 'GETREPLY' [ USING champ1 [champ2 ...] ].
Fig. 2 - Structure générale d'un programme COBOL
en API GDG.
Une clause EXEC GDG suit les
règles de présentation des programmes COBOL
: elle peut occuper plusieurs lignes et elle doit se terminer par un '.'
Les divers paramètres (dbalias, connectstring, procname, param1
...) s'expriment :
- soit directement sous forme d'une constante
alphanumérique,
- soit sous forme d'une variable COBOL (qui doit etre
définie avec le type USAGE IS DISPLAY
), et précédée de ":"
La primitive 'INIT'
permet à l'API d'initialiser sa zone de communication
('GDG-AREA'), automatiquement générée avec toutes
les autres zone de travail de l'API par le préprocesseur 'GDG2COB'.
Codes-retour :
néant
La primitive 'CONNECT'
etabli la liaison avec le serveur GDG, et authentifie le programme vis
à vis de la base de données concernée:
- le paramètre dbalias (variable ou constante
alphanumérique) indique la base, l'instance ou l'alias à
utiliser;
- le paramètre connectstring (variable ou constante
alphanumérique) est de la forme 'userid[:passwd]@hostname[:port]';
noter que certaines valeurs de ce paramètre sont facultatives et
que les valeurs par défaut sont des constantes d'installation.
Codes-retour :
GDGRC
: 0 si OK, <> 0 si liaison TCPIP ou accés
à la database impossible.
SQLRC :
néant.
La primitive 'CALLPROC'
admet au moins un paramètre : le nom de la procédure
cataloguée à executer (variable ou constante
alphanumérique).
Les arguments, facultatifs, sont passés sous forme de constantes
alpahanumériques ou de variables.
Codes-retour :
GDGRC :
0 si OK,
1001, 1002, ... (1000 + n) : le n-ième paramètre
est invalide.
autres : liaison TCPIP interompue.
SQLRC
: néant.
La primitive 'SENDSQL'
n'admet qu'un seul paramètre : la requète SQL, soit sous
forme d'une contante alpahnumérique, soit sous forme d'une
variable.
Codes-retour :
GDGRC
= 0 si OK, <> 0 si liaison TCPIP ou accés à la
database interrompue.
SQLRC
: néant.
La primitive 'SETREPLY'
permet d'indiquer à l'API la manière de traiter les
résultats d'une commande SQL de type 'SELECT' :
- Le paramètre 'GDG-PARSE'
indique que ces résultats seront découpés champ par champ dans les
variables COBOL de la prochaine commande 'GETREPLY'.
- Le paramètre 'GDG-NO-PARSE'
indique que chaque ligne de resultat est à ranger telle quelle
dans la
variable COBOL de la prochaine commande 'GETREPLY',
ou bien que ces résultats sont sans intérêt (pas de
variable.).
Codes-retour :
néant.
La primitive 'GETREPLY'
n'admet aucune constante, mais seulement une liste facultative de
variables où l'API doit déposer les résultats de la
requète precédente.
Elle est obligatoire
aprés chaque primitive 'SENDSQL'
ou 'CALLPROC'.
Codes-retour :
GDGRC
:
0 si OK,
1001, 1002, ... (1000 + n) : le n-ième paramètre
est invalide.
autres : liaison TCPIP interompue.
SQLRC :
0 : Ok
100 : plus de résultats en magasin.
autres ( en général < 0) : codes propres au moteur SQL
impliqué.
Exemples :
EXEC GDG 'INIT'.
EXEC GDG 'CONNECT' USING 'MYBASE' :MYUSERID
IF GDGRC NOT = 0 GO TO NO-CONNECT.
EXEC GDG 'CALLPROC' USING 'PROCSEL1' :PARAM1 'VALEUR-PARAM2'.
IF GDGRC NOT = 0 GO TO BROKEN-CONN.
MOVE 'procsel2' TO PROCNAME
EXEC GDG 'CALLPROC" USING :PROCNAME.
EXEC GDG 'SENDSQL' USING :MYREQUEST.
EXEC GDG 'SENDSQL' USING 'UPDATE mytab set F1=v1 where F2=v2'.
EXEC GDG 'SETREPLY' USING 'GDG-PARSE'.
EXEC GDG 'GETREPLY' USING :FLD1 :FLD2 :FLD3.
IF SQLRC = 100 GO TO NO-MORE.
EXEC GDG 'SETREPLY' USING 'GDG-NO-PARSE'.
EXEC GDG 'GETREPLY'.
3 - L'utilitaire GDGUTIL
Le programme GDGUTIL permet d'envoyer des requètes à un
serveur GDG.
Il traite des sous-commandes GDG ou SQL en entrée, les envoie au
serveur, et affiche les résultats.
Les sous-commandes sont lues sur le DDNAME 'SYSIN' pour MVS, ou le
standard input pour les autres plate-formes.
Les résultats sont affichés sur le DDNAME
'SYSPRINT' pour MVS, ou le standard output pour les autres
plate-formes.
GDGUTIL reconnait et traite explicetement les sous-commandes suivantes :
echo
texte quelconque
connect
dbalias [userid[:password]@hostname[:port]]
(MVS : dbalias [userid[:password]!hostname[:port]] )
Toutes les autres clauses sont
considérées comme commandes SQL valides, et sont
envoyées 'ex-abrupto' au serveur GDG, qui se charge de les
reconnaitre et de les traiter.
Voir exemples d'utilisation an Annexes D
et E .
4 - L'API GDG en langage C
L'API se compose :
- D'un 'header' pour les programmes C (gdgbase.h, cf en
annexe)
- D'une librairie, livrée sous forme de DLL (Windows),
de 'shared object' ( UNIX), et d'une librairie statique d'objets
traditionnels ( Librairie objet MVS, librairie statique UNIX ou Windows)
La librairie implémente 5 points d'entrée ou routines :
Début / fin de session :
2 routines
Exécution de
Procédure ou commande SQL : 2 routines
Lecture des résultats :
1 routine.
Elles prennent en commun la GDG_AREA en premier paramètre, et au
retour, présentent 1 ou 2 codes retour :
- le code GDGRC, qui matérialise
l'état de la connexion,
- le code SQLRC,
donné par le moteur SQL lors de la lecture des
résultats.
La routine
GDGOPEN
But : établissement de la
connexion avec le serveur GDG
Arguments : GDG_AREA, nom de la base ou de l'instance,
chaine d'identification
nom de la base : 20 caractères.
identification : 50 caractères, de la forme
userid[:password]@machine_IP[:port_GDG]
code retour GDGRC : = 0 si ok et liaison établie, sinon
problème de connexion ou parmètres incorrects.
La routine
GDGCLOSE
But : coupure de la connexion avec le
serveur GDG
Arguments : GDG_AREA
pas de code retour significatif
La routine
GDGSPROC
But : lancement d'un procedure
cataloguée SQL au serveur GDG
Arguments : GDG_AREA, liste de parametres et leur longueur,
paramètre NULL
code retour : GDGRC = 0 si ok et liaison établie, sinon
problème de connexion ou parmètres incorrects.
Le ou les résultat de la procédure sont à
disposition via la routine GDGGRPLY,obligatoire.
La routine
GDGSRQST
But : envoi d'une commande SQL
arbitraire au serveur GDG
Arguments : GDG_AREA, cde SQL, longueur
code retour GDGRC : = 0 si ok et liaison établie, sinon
problème de connexion ou parmètres incorrects.
Le ou les résultat de la commande sont à disposition via
la routine GDGGRPLY, obligatoire.
La routine
GDGGRPLY
But : lecture d'une ligne de
résultat en provenance du serveur GDG, aprés GDGSPROC ou GDGSRQST.
Arguments : GDG_AREA, liste de champs et leur longueur, champ NULL
code retour GDGRC : = 0 si ok et liaison établie, sinon
problème de connexion ou parmètres incorrects.
code retour SQLRC : = 0 si ok, = 100 si pas de résultat
sigificatif, ou code renvoyé par le moteur SQL
Le code retour GDGRC
matérialise l'état de la connexion, et la validité
des paramètres :
0 : la connexion est ou reste
établie, et les paramètres sont bons.
1 : la connexion n'est pas établie, ou a été
coupée.
1001, 1002, .... : le couple de paramètres [zone,
longueur] n.1, 2, ... est incorrect.
Le code retour SQLRC
n'est établi que pour la routine GDGGRPLY.
Il est donné par le moteur SQL concerné, et
restitué par le serveur GDG tel quel pour les commandes de
type 'SELECT' ou procédure assimilées.
Pour les autres commandes SQL, qui ne renvoient pas de résultat
à propremnt parlé, la valeur 0 est remplacé
par 100 (plus de résultat disponibles), de manière
à unifier la programmation; les autres valeur sont transmises
inchangées.
| Annexe A : structure COBOL de la 'GDG AREA' |
|
* Zone automatiquement
generee par le preprocesseur GDG :
01
GDG-AREA.
05 SQLRC PIC S9(9) COMP.
05 GDGRC PIC S9(9) COMP.
05 CNXFD PIC S9(9) COMP.
05 REQNO PIC S9(9) COMP.
05 GDGDBG PIC X.
05 GDGRQTYP PIC X.
05 GDGPRG PIC X(8).
05 FILLER PIC X.
|
| Annexe B : header pour les programmes C (gdgbase.h) |
typedef struct t_gdg {
int sqlrc; /*
retcode sql */
int gdgrc; /*
retcode GDG */
int cnxfd; /*
handle (0, 1, ... */
int reqno; /* n.
requete, future extension */
char gdgdbg; /* 'D' = debug
GDG */
char reqtyp; /* 'S' =
resultat global, autre = par champ */
char prgname[8]; /* pour les
traces
*/
char filler; /*
internal
*/
} T_GDG, * PGDG;
#define LGDG sizeof(T_GDG)
void GDGOPEN(PGDG pgdg,
char * dbn, char * cnxstr);
void GDGCLOSE(PGDG pgdg);
void GDGSPROC(PGDG pgdg,
char * procname, ... );
void GDGSRQST(PGDG pgdg,
char * rqst, int * plg);
void GDGGRPLY(PGDG pgdg,
... );
#define
GDG_ERR_OK 0
#define
GDG_ERR_NOPIPE 1
#define
GDG_ERR_BROKEN 2
#define
GDG_ERR_BADARG 1000 |
| Annexe C : Exemple d'utilisation du préprocesseur GDG en COBOL |
//PRECOMP JOB
XYZ,'ACCOUNT',MSGLEVEL=(1,1),MSGCLASS=X,CLASS=A
//PREGDG EXEC PGM=GDG2COB
//STEPLIB DD DISP=SHR,DSN=XYZ.GDG.LOADLIB
//FCOB
DD DISP=SHR,DSN=XYZ.DEVEL.COB(ESGDGCB)
//FGDG DD
*
IDENTIFICATION
DIVISION.
PROGRAM-ID.
ESGDGCB.
*----------------------------------------------------------------
*
* Ce programme demontre l'utilisation du
preprocesseur GDG COBOL :
*
* 1) connexion a la database
* 2) envoyer une procedure cataloguee
avec ses arguments,
* lire les resultats
ligne a ligne dans des champs determines.
* 3) envoyer une cde select en format
libre,
* lire les resultats
ligne a ligne, par ligne complete.
* 4) envoyer une cde update en format
libre,
* lire le resultat
pour le retcode SQL unisquement
* 5) couper la connexion.
*
*----------------------------------------------------------------
ENVIRONMENT DIVISION.
*
CONFIGURATION SECTION.
SPECIAL-NAMES.
DECIMAL-POINT IS COMMA.
INPUT-OUTPUT SECTION.
FILE-CONTROL.
*
DATA DIVISION.
FILE SECTION.
*
*
WORKING-STORAGE SECTION.
*
*------ LES ZONES DE MANOEUVRE
------------------
*
* Zones pour connexion
77 ESGDGV PIC
X(8) VALUE 'V 3.12A'.
77 CNXSTR PIC X(50).
77 DBNAME PIC X(10)
VALUE 'archives'.
* Champs pour resultats select
77
JD PIC X(15).
77
PATH PIC X(40).
77
NUM PIC 9999.
77
SIZ PIC 9999.
77
DAT PIC X(12).
* Divers
77
CATEG PIC X(12).
77
STMT PIC X(1000).
77
RESULTAT PIC X(1000).
*
PROCEDURE DIVISION.
MAIN SECTION.
*
*--------------------------------------------------------------*
*
DISPLAY
"Debut programme " ESGDGV
ACCEPT
CNXSTR
DISPLAY
"Database archives on " CNXSTR.
*--------------------------------------------------------------*
*
PRIMITIVE
INIT
*
EXEC GDG
'INIT'.
*--------------------------------------------------------------*
*
*--------------------------------------------------------------*
*--------------------------------------------------------------*
*--------------------------------------------------------------*
*
PRIMITIVE
CONNECT
*
*
BUT : ETABLIR LA
CONNEXION
*
*
ARGS: NOM de la base, chaine
d'identification *
*
RETCODE : GDGRC = 0 : Ok, <> 0 :
KO
*
*--------------------------------------------------------------*
*--------------------------------------------------------------*
*--------------------------------------------------------------*
*
DISPLAY
"GDG CONNECT " DBNAME " + " CNXSTR " ..."
EXEC GDG
'CONNECT' USING :DBNAME :CNXSTR.
DISPLAY
"gdgopen -> GDGRC=" GDGRC.
IF GDGRC
NOT = 0 GO TO FIN.
*
*
*
*--------------------------------------------------------------*
*--------------------------------------------------------------*
*--------------------------------------------------------------*
*
PRIMITIVE CALLPROC
:
*
*
BUT : DEMANDE D'EXEC D'UNE
PROCEDURE
*
*
ARGS: NOM de la proc, params_proc
...
*
*
NOM DE LA PROC :
procsel1
*
*
Param de la PROC: CATEG, 12
octets
*
*
RETCODE : GDGRC = 0 : Ok, <> 0 :
KO
*
*--------------------------------------------------------------*
*--------------------------------------------------------------*
*--------------------------------------------------------------*
*
DISPLAY
"GDG CallProc for procsel1 ..."
MOVE
'DBMS' TO CATEG
EXEC GDG
'CALLPROC' USING 'procsel1' :CATEG.
DISPLAY
"gdg Callproc : retcode GDGRC=" GDGRC.
IF GDGRC
NOT = 0 GO TO CLOSE-IT.
*
*--------------------------------------------------------------*
*--------------------------------------------------------------*
*--------------------------------------------------------------*
*
PRIMITIVE GETREPLY
:
*
*
BUT : LIRE UNE LIGNE DE
RESULTATS
*
*
ARGS: Liste de
champs
*
*
ex : JD, NUM, PATH,
SIZ
*
*
NOTE: mettre GDGRQTYP a blanc pour la lecture par champ*
*
RETCODES : GDGRC = 0 : Ok, <> 0 :
KO
*
*
SQLRC = 0 : Ok, <> 0 (100) : plus
rien *
*--------------------------------------------------------------*
*--------------------------------------------------------------*
*--------------------------------------------------------------*
*
DISPLAY
"gdg getreply for procsel1 ...".
* Pour dire qu'on veut les resultats
champ/champ :
EXEC GDG
'SETREPLY' USING 'GDG-PARSE'.
LEC.
* Lecture une ligne de resultats dans
les champs designes :
EXEC GDG
'GETREPLY' USING :JD :NUM :PATH :SIZ :DAT.
IF GDGRC
NOT = 0 GO TO CLOSE-IT.
IF SQLRC =
0
DISPLAY JD "+" NUM "+" PATH "+" SIZ "+" DAT
GO TO LEC.
* On s'arrete quand SQLRC est different
de 0
*
*--------------------------------------------------------------*
*--------------------------------------------------------------*
*--------------------------------------------------------------*
*
PRIMITIVE SENDSQL
:
*
*
BUT : ENVOYER UN PHRASE SQL
ARBITRAIRE
*
*
ARGS: La cde
sql
*
*
RETCODES : GDGRC = 0 : Ok, <> 0 :
KO
*
*--------------------------------------------------------------*
*--------------------------------------------------------------*
*--------------------------------------------------------------*
*
* Une select en format libre :
DISPLAY
"gdg sendsql select EIFFEL 1 ..."
EXEC GDG
'SENDSQL' USING
"select id, num, dat, siz from arch where ID='EIFFEL'".
IF GDGRC
NOT = 0 GO TO CLOSE-IT.
DISPLAY
"Gdg Select : retcode SQL=" SQLRC.
*--------------------------------------------------------------
* GETREPLY : lecture d'une ligne
complete de resultat
*--------------------------------------------------------------
DISPLAY
"gdg getreply for select ...".
* Pour dire qu'on veut les resultats
bruts de fonderie :
EXEC GDG
'SETREPLY' USING 'GDG-NO-PARSE'.
LEC2.
* Lecture une ligne de resultats, telle
quelle :
EXEC GDG
'GETREPLY' USING :RESULTAT.
IF GDGRC
NOT = 0 GO TO CLOSE-IT.
IF SQLRC =
0
DISPLAY RESULTAT
GO TO LEC2.
* On s'arrete quand SQLRC est different
de 0
*
*--------------------------------------------------------------
*------- idem pour une cde update :
*--------------------------------------------------------------
DISPLAY
"gdg sendsql update EIFFEL ..."
* Mettre en place la commande SQL :
MOVE
"update arch set dat='200-05-14' where ID='EIFFEL'"
TO STMT
* Envoyer la commande par la routine
GDGSRQST :
EXEC GDG
'SENDSQL' USING :STMT.
IF GDGRC
NOT = 0 GO TO CLOSE-IT.
* Lecture du resultat, seul les retcodes
sont interessants :
EXEC GDG
'SETREPLY' USING 'GDG-NO-PARSE'.
* Appel de la routine GDGGRPLY, sans
arguments,
* juste pour les return codes :
DISPLAY
"gdg getreply for update EIFFEL ..."
EXEC GDG
'GETREPLY'.
IF GDGRC
NOT = 0 GO TO CLOSE-IT.
DISPLAY
"Gdg Update : retcode SQL=" SQLRC.
*
DISPLAY
"gdg sendsql select EIFFEL 2 ..."
*--------------------------------------------------------------
* Une autre select en format libre :
*--------------------------------------------------------------
EXEC GDG
'SENDSQL' USING
"select dat from arch where ID='EIFFEL'".
IF GDGRC
NOT = 0 GO TO CLOSE-IT.
DISPLAY
"Gdg Select : retcode SQL=" SQLRC.
*--------------------------------------------------------------
* GETREPLY : lecture d'une ligne
complete de resultat
*--------------------------------------------------------------
DISPLAY "gdg getreply for select EIFFEL ...".
* Pour dire qu'on veut les resultats par
champ :
EXEC GDG
'SETREPLY' USING 'GDG-PARSE'.
LEC3.
* Lecture une ligne de resultats, telle
quelle :
EXEC GDG
'GETREPLY' USING :DAT.
IF GDGRC
NOT = 0 GO TO CLOSE-IT.
IF SQLRC =
0
DISPLAY "DAT For EIFEEL : " dat
GO TO LEC3.
* On s'arrete quand SQLRC est different
de 0
*--------------------------------------------------------------*
*--------------------------------------------------------------*
*--------------------------------------------------------------*
*
PRIMITIVE CLOSE
:
*
*
BUT : COUPER LA
CONNEXION
*
*
ARGS:
NEANT.
*
*--------------------------------------------------------------*
*--------------------------------------------------------------*
*--------------------------------------------------------------*
*
CLOSE-IT.
EXEC GDG
'CLOSE'.
FIN.
STOP RUN.
/*
|
| Annexe D : Exemple d'utilisation de l'utilitaire GDGUTIL sous MVS |
//JHHEUTL
JOB
1,'PP5645-001',MSGLEVEL=(1,1),MSGCLASS=X,CLASS=A
//*------ EXEC
GDGUTIL
//GDGUTIL EXEC
PGM=GDGUTIL
//STEPLIB DD
DISP=SHR,DSN=XYZ.GDG.LOADLIB
//SYSUDUMP DD
SYSOUT=*
//SYSTERM DD
SYSOUT=*
//SYSPRINT DD
SYSOUT=*
//SYSIN DD
*
echo ------------ connexion ... ------------------
connect archives myuserid:mypasswd!mygdgsrv:5432
echo ------------ procedure procsel1 ... ---------
select procsel1('MMEDIA')
echo ------------ select DBMS ... ----------------
select id, num, path, dat from arch where cat='DBMS'
echo ------------ update EIFFEL ... --------------
update arch set dat='2003-08-10' where id='EIFFEL'
echo ------------ display EIFFEL ... -------------
select id, num, path, dat from arch where id='EIFFEL'
echo ============ End of Job =====================
/*
|
| Annexe E : Exemple d'utilisation de l'utilitaire GDGUTIL sous UNIX |
#/bin/sh
#--------------------------------------------------------------------
# lancer quelques
commandes SQL,
# ranger les
résultats dans le fichier tstgdg.data
#---------------------------------------------------------------------
gdgutil >
tstgdg.data <<EOF_IN
echo ------------
connexion ... ------------------
connect archives myuserid:mypasswd@mygdgsrv:5432
echo ------------ procedure procsel1 ... ---------
select procsel1('MMEDIA')
echo ------------ select DBMS ... ----------------
select id, num, path, dat from arch where cat='DBMS'
echo ------------ update EIFFEL ... --------------
update arch set dat='2003-08-10' where id='EIFFEL'
echo ------------ display EIFFEL ... -------------
select id, num, path, dat from arch where id='EIFFEL'
echo ============ End of Job =====================
EOF_IN |
|
