Articles
Contrôler l’existence d’un fichier stream (IFS)
Lorsque l’on doit tester l’existence d’un objet dans QSYS.LIB la question ne se pose pas, on utilise la commande prévue à cet effet CHKOBJ. Pour l’IFS par contre il n’y a pas de commande toute faite.
Voici donc trois exemples de solutions pour tester l’existence d’un fichier dans l’IFS en CL et en SQLRPGLE.
(Il existe d’autres méthodes, mais celles-ci sont les plus simples).
CHKOUT / CHKIN (clle)
La commande CHKOUT permet de verrouiller un objet, ainsi les autres utilisateurs et travaux ne peuvent plus que le lire ou le copier. Il suffit de monitorer cette commande en attendant le message CPFA0A9 qui indique que le fichier n’existe pas.
Cette méthode est donc utile lorsque l’on souhaite par la même occasion verrouiller l’objet recherché.
Il ne faut pas oublier de déverrouiller l’objet une fois votre opération terminée avec la commande CHKIN.
PGM PARM(&FILEPATH)
DCL VAR(&FILEPATH) TYPE(*CHAR) LEN(256)
DCL VAR(&EXISTS) TYPE(*LGL)
CHGVAR VAR(&EXISTS) VALUE('1')
/* Verrouillage de l'objet */
CHKOUT OBJ(&FILEPATH)
MONMSG MSGID(CPFA0A9) EXEC(DO)
/* Fichier non trouvé */
/* Traitement de l'exception... */
CHGVAR VAR(&EXISTS) VALUE('0')
SNDPGMMSG MSG('Fichier inexistant')
ENDDO
/* Libération de l'objet si existant */
IF COND(&EXISTS) THEN(DO)
CHKIN OBJ(&FILEPATH)
ENDDO
ENDPGM
MOV (clle)
Une solution plus simple encore, lorsque l’on n’a pas besoin de gérer le verrouillage de l’objet, est l’utilisation de la commande MOV. Initialement, elle permet de déplacer un objet, mais en indiquant le chemin de l’objet d’origine comme objet de destination, aucune action ne sera effectuée sur l’objet (pas de changement de la date de dernière modification) et on pourra encore une fois tester le message CPFA0A9.
PGM PARM(&FILEPATH)
DCL VAR(&FILEPATH) TYPE(*CHAR) LEN(256)
MOV OBJ(&FILEPATH) TOOBJ(&FILEPATH)
MONMSG MSGID(CPFA0A9) EXEC(DO)
/* Fichier non trouvé */
/* Traitement de l'exception... */
SNDPGMMSG MSG('Fichier inexistant')
ENDDO
ENDPGM
IFS_OBJECT_STATISTICS (SQL/SQLRPGLE)
En SQL et SQLRPGLE, le plus simple reste d’utiliser la fonction table IFS_OBJECT_STATISTICS. Pour s’assurer ne pas tomber sur un répertoire portant le nom du fichier ou autre, il est préférable de renseigner les paramètres subtree_directories et object_type_list (bien entendu en renseignant *DIR si on cherche un répertoire).
Il suffit ensuite de tester le sqlCode, s’il est égal à 100 cela signifie que le fichier est inexistant.
SELECT path_name
FROM TABLE (
qsys2.ifs_object_statistics(
start_path_name => '/home/jl/file.txt',
subtree_directories => 'NO',
object_type_list => '*STMF'
)
);
Remarque
Il faut tout de même prendre en compte les droits de l’utilisateur qui réalise ces tests, en fonction de la méthode utilisée, un autre message pourrait être émit ou le fichier pourrait lui apparaitre comme inexistant.
Pour plus de détails
Documentation IBM – CHKOUT : https://www.ibm.com/docs/en/i/7.5?topic=ssw_ibm_i_75/cl/chkout.html
Documentation IBM – CHKIN : https://www.ibm.com/docs/en/i/7.5?topic=ssw_ibm_i_75/cl/chkin.html
Documentation IBM – MOV : https://www.ibm.com/docs/en/i/7.5?topic=ssw_ibm_i_75/cl/mov.html
Documentation IBM – IFS_OBJECT_STATISTICS : https://www.ibm.com/docs/en/i/7.5?topic=services-ifs-object-statistics-table-function
Préambule
Cet article est une suite à l’article de Pierre-Louis BERTHOIN qui présente les fonctions géospatiales intégrées à DB2.
Choix de l’API
Sur le site https://adresse.data.gouv.fr/ En cliquant sur l’item « Outils et API », on accède librement à la documentation des API en rapport avec les adresses. Nous choisissons donc celle sobrement intitulée « API Adresse ». La documentation montre différentes manières d’utiliser cette API. Le retour est un geojson FeatureCollection respectant la spec GeoCodeJSON.
Récupération et manipulation des données
But du programme
Nous allons réaliser un programme qui permettra, en écrivant partiellement une adresse, de récupérer une adresse complète d’après une liste déroulante de 50 occurrences.
Nous choisirons pour notre programme une interrogation relativement simple et nous n’extrairons qu’une partie des données du geojson.
Nous écrirons les adresses dans un fichier, sous forme d’une fiche client contenant les éléments suivants :
- Identifiant (integer auto incrémenté)
- Raison Sociale (varchar)
- Adresse (varchar)
- Code Postal (varchar)
- Ville (varchar)
- Coordonnées géographiques (ST_POINT)
Préparation du fichier
create table GGEOLOC.MESCLIENTS (ID int GENERATED ALWAYS AS IDENTITY ( START WITH 1 INCREMENT BY 1 NO MINVALUE NO MAXVALUE NO CYCLE NO ORDER CACHE 20 ), RAISOC varchar(64), ADRESSE varchar(128), CODEPOS varchar(16), VILLE varchar(64), COORDGEO QSYS2.ST_POINT);
Programme de saisie
**free ctl-opt dftactgrp(*no) ; // Fichiers dcl-f FORMCLIE workstn indds(DS_Ind) usropn; // Procédures dcl-pr Touche_F4 EXTPGM('TOUCHE_F4'); p_Sql char(1024) ; p_Titre char(35); p_Ret char(116); end-pr; // Variables dcl-s reqSqlDelete varchar(2000); dcl-s reqSqlCreate varchar(2000); dcl-s reqSqlDrop varchar(2000); dcl-s coordonees varchar(64) ; dcl-s queryapi varchar(64); dcl-s httpText varchar(256); dcl-s pIndicators Pointer Inz(%Addr(*In)); // Pour F4 : liste des fichiers dcl-s w_Sql char(1024) ; dcl-s w_Titre char(35); dcl-s w_Ret char(116); // DS Informations Programme dcl-ds *N PSDS; nom_du_pgm CHAR(10) POS(1); nom_du_prf CHAR(10) POS(358); end-ds; // Déclaration des indicateurs de l'écran Dcl-DS DS_Ind based(pIndicators); Ind_Sortie ind pos(3); Ind_Liste ind pos(4); Ind_Annuler ind pos(12); Ind_Valider ind pos(17); Ind_SFLCLR ind pos(40); Ind_SFLDSP ind pos(41); Ind_SFLDSPCTL ind pos(42); Ind_SFLEnd ind pos(43); Ind_DisplayCoord ind pos(80); Ind_RaisonS ind pos(81); Ind_5Lettres ind pos(82); Ind_CodePos ind pos(84); Ind_Ville ind pos(85); Indicators char(99) pos(1); End-DS; // Paramètres en entrée dcl-pi *N; end-pi; // SQL options --------------------------------------------- // Exec SQL Set Option Naming=*Sys, Commit=*None, UsrPrf=*User, DynUsrPrf=*User, Datfmt=*iso, CloSqlCsr=*EndMod; //--------------------------------------------------------- // // Contrôle taille écran Monitor; Open FORMCLIE; On-Error; Dsply 'Nécessite un écran 27 * 132'; *inlr=*on; Return; EndMon; Dou Ind_Sortie or Ind_Annuler; znompgm = nom_du_pgm; znomprf = nom_du_prf; Exfmt FMT01; select ; when Ind_Sortie ; leave; when Ind_Annuler; leave; when Ind_Liste; if %len(%trim(zadresse)) <= 4 ; Ind_5Lettres = *on; iter; endif; traitementListe(); when Ind_Valider; if zraisoc = *blanks; Ind_RaisonS = *on ; endif; if zcodpos = *blanks; Ind_CodePos= *on ; endif; if zville = *blanks; Ind_Ville = *on ; endif; if %subst(indicators:81:4) <> '0000'; iter ; endif; Exec SQL insert into MESCLIENTS (RAISOC, ADRESSE, CODEPOS, VILLE, COORDGEO) values (:zraisoc, :zadresse, :zcodpos, :zville, QSYS2.ST_POINT(:zlongit, :zlatit)) ; Ind_DisplayCoord = *off; clear FMT01; endsl ; Enddo; *inlr = *on; //======================================================================== // // Procédures // //======================================================================== // //------------------------------------------------------------------------ // // Nom : rechercheAdresse // // But : lister des adresses recueillies via une API // // à partir d'une chaine de plus de 4 caractères // // Retour : N/A // //------------------------------------------------------------------------ // dcl-proc rechercheAdresse ; dcl-pi *n ; l_httpText varchar(256) value; end-pi; reqSqlDrop = 'drop table QTEMP/WADRESSE' ; Exec sql Execute immediate :reqSqlDrop ; reqSqlCreate = 'create table QTEMP/WADRESSE' + ' (address varchar(128), numero varchar(8), street varchar(128), ' + 'postcode varchar(16), city varchar(64), coordinates blob)' ; Exec sql Execute immediate :reqSqlCreate ; reqSqlDelete = 'delete from QTEMP/WADRESSE' ; Exec sql Execute immediate :reqSqlDelete ; Exec sql insert into QTEMP/WADRESSE (select ltrim(ifnull(numero, '') || ' ' || coalesce(street, locality, '') || ' ' || postcode || ' ' || city), ifnull(numero, ''), coalesce(street, locality, ''), postcode, city, QSYS2.ST_POINT(longitude, latitude) from json_table(QSYS2.HTTP_GET(:l_httpText, ''), '$.features[*]' COLUMNS (numero varchar(8) PATH '$.properties.housenumber', street varchar(128) PATH '$.properties.street', locality varchar(128) PATH '$.properties.locality', name varchar(128) PATH '$.properties.name', municipality varchar(128) PATH '$.properties.municipality', postcode varchar(8) PATH '$.properties.postcode', city varchar(64) PATH '$.properties.city', longitude float PATH '$.geometry.coordinates[0]', latitude float PATH '$.geometry.coordinates[1]')) ); end-proc ; //------------------------------------------------------------------------ // // Nom : traitementListe // // But : Affichage d'une liste de 50 adresses maximum // // Retour : N/A // //------------------------------------------------------------------------ // dcl-proc traitementListe ; queryapi = %scanrpl(' ':'+':%trim(zadresse)) ; httpText ='https://api-adresse.data.gouv.fr/search/?q=' + queryapi + '&limit=50' ; rechercheAdresse(httpText); clear w_ret ; w_sql = 'select address from QTEMP/WADRESSE' ; w_titre = 'Adresses proposées'; touche_f4(W_Sql: W_titre : w_ret) ; if (w_ret <> ' ') ; clear zadresse; clear zcodpos; clear zville; Exec SQL select ltrim(ifnull(numero, '') || ' ' || street), postcode, city, REPLACE( REPLACE(QSYS2.ST_asText(COORDINATES), 'POINT (', ''), ')', '') into :zadresse, :zcodpos, :zville, :coordonees from QTEMP.WADRESSE where address = :w_ret ; if sqlcode = 0 ; Ind_DisplayCoord = *on ; zlongit = %dec(%subst(coordonees: 1 : %scan(' ':coordonees)):15:12) ; zlatit = %dec(%subst(coordonees: %scan(' ':coordonees) + 1 : %len(%trim(coordonees)) - %scan(' ':coordonees)):15:12) ; endif; endif ; end-proc ;
Quelques explications sur les fonctions SQL utilisées
Tout d’abord nous choisissons de ne pas utiliser la propriété « label » proposée par l’API Adresse. En effet, si celle-ci semble pratique de prime abord, elle n’est pas toujours significative (voir photo du milieu qui où elle ne contient que le nom de la municipalité)
![](https://www.gaia.fr/wp-content/uploads/2023/07/exemples_Adresse_JSON-1030x331.png)
Nous, préférerons donc reconstituer cette adresse en concaténant des zones que l’on retrouve dans chaque occurrence du fichier JSON.
QSYS2.ST_POINT : Cette fonction est utilisée lors de la collecte des données fournie par l’API Adresse.
Elle permet de transformer les coordonnées longitude, latitude en une variable de type BLOB qui représente un point précis et qui est utilisable par les fonctions Géospatiales du SQL.
QSYS2.ST_ASTEXT : Cette fonction permet de transformer un champ géométrique (ST_POINT, ST_LINESTRING, ST_POLYGON, …) en un champ WKT (well-known-text) qui nous sera plus compréhensible.
Cinématique du programme
Ce programme est un simple écran qui nous permet la saisie d’un formulaire avec la possibilité de rechercher ou compléter une adresse en utilisant la touche F4 (la fonction externe appelée n’est pas décrite dans cet article). Une fois le formulaire validé, on l’efface.
Tout d’abord on commence à remplir le formulaire mais on ne connait pas précisément l’adresse.
![](https://www.gaia.fr/wp-content/uploads/2023/07/FORMCLI01-1030x421.png)
Donc, après avoir tapé un morceau d’adresse on presse F4
![](https://www.gaia.fr/wp-content/uploads/2023/07/FORMCLI_F4-1030x421.png)
On valide, le formulaire est alors complétement rempli
![](https://www.gaia.fr/wp-content/uploads/2023/07/FORMCLI02-1030x425.png)
On presse F17 pour valider celui-ci (et réinitialiser l’écran).
Vérification des données enregistrées
Version BLOB
![](https://www.gaia.fr/wp-content/uploads/2023/07/FORMCLI_req01-3-1030x75.png)
Version WKT (well-known-text)
![](https://www.gaia.fr/wp-content/uploads/2023/07/FORMCLI_req02-1-1030x154.png)
Conclusion
Nous avons montré ici un exemple simple de l’utilisation d’une API couplée avec les fonctions géospatiales proposées par IBM. Il est possible d’envisager des requêtes plus complexes incluant le code postal, la ville ou encore le type de donnée (rue, lieu-dit ou municipalité). On peut aussi envisager des requêtes d’après les coordonnées géographiques pour retrouver une adresse. Le champ des possibles, comme le monde, est vaste …
Bien que le MD5 ne soit plus utilisé pour l’encryption, il est toujours utilisé pour valider l’authenticité et la conformité des fichiers.
Qu’est-ce qu’un MD5
Un md5 est une chaine de 16 caractères composée de symboles hexadécimaux. Il s’agit en réalité du nom de l’algorithme utilisé pour générer la chaine.
Comme indiqué précédemment son usage est le contrôle d’intégrité des fichier, par exemple lors du partage d’un fichier, on peut mettre à disposition le MD5 afin de contrôler que le téléchargement du fichier s’est bien passé ou que le fichier n’a pas été modifié entre temps.
Pour la suite nous aurons besoin d’un fichier, par simplicité j’utiliserai un simple .txt qui contient la phrase « This is not a test! » présent dans mon répertoire de l’ifs.
Fichier dans l’ifs | /home/jl/file.txt |
Contenu du fichier | This is not a test! |
md5 | EDA20FB86FE23401A5671734E4E55A12 |
QSH – md5sum
La première méthode pour générer le MD5 d’un fichier est d’utiliser la commande unix md5sum via QSH :
$ /QOpenSys/pkgs/bin/md5sum /home/jl/file.txt
eda20fb86fe23401a5671734e4e55a12 /home/jl/md5.txt
La fonction retourne le hash et le chemin du fichier.
RPGLE – _cipher
Il est également possible de générer le MD5 via RPG en exploitant la procédure externe cipher.
Je ne m’épancherai pas sur son implémentation complète ici, car bien plus complexe que les deux autres méthodes présentées. De plus, passer par cette méthode, n’est plus le sens de l’histoire.
// Déclaration de la procédure
dcl-pr cipher extproc('_cipher');
*n pointer value;
*n pointer value;
*n pointer value;
end-pr;
// Appel de la procédure
cipher(%ADDR(receiver) : %ADDR(controls) : %ADDR(source));
Lien vers la documentation IBM pour plus d’informations :
https://www.ibm.com/docs/en/i/7.4?topic=ssw_ibm_i_74/rzatk/CIPHER.htm
SQL – hash_md5
En sql on retrouve la fonction hash_md5, qui retourne le hash d’une chaine de caractère passée en paramètre.
❗ Attention à l’encodage de votre chaine de caractères. ❗
Pour que le résultat soit cohérent entre différents systèmes il faut commencer par convertir la chaine de caractère en UTF-8 :
VALUES CAST('This is not a test!' AS VARCHAR(512) CCSID 1208); -- 1208 = UTF-8
-- Retour : This is not a test!
Le résultat est plutôt flagrant ! D’accord pas vraiment… Par contre si on regarde la valeur hexadécimale de la chaine avec et sans conversion :
VALUES HEX('This is not a test!');
-- Retour : E38889A24089A2409596A3408140A385A2A34F
VALUES HEX(CAST('This is not a test!' AS VARCHAR(512) CCSID 1208));
-- Retour : 54686973206973206E6F742061207465737421
Le hachage se fait en hexadécimal, donc le résultat ne serait pas le même sans conversion préalable.
Il suffit maintenant de hacher notre chaine de caractères :
VALUES HASH_MD5(CAST('This is not a test!' AS VARCHAR(512) CCSID 1208));
-- Retour : EDA20FB86FE23401A5671734E4E55A12
On obtient donc la même valeur que celle que l’on a obtenu précédemment (puisque que le contenu de notre fichier est strictement égale à cette chaine de caractère).
La dernière étape est de générer le MD5 directement à partir du fichier, pour cela il suffit d’utiliser la fonction GET_BLOB_FROM_FILE :
VALUES HASH_MD5(GET_BLOB_FROM_FILE('/home/jl/file.txt')) WITH CS;
-- Retour : EDA20FB86FE23401A5671734E4E55A12
Autres algorithmes de hash
Il existe d’autres algorithmes de hash qui permettent de hacher du texte et des fichiers.
Trois autres algorithmes sont généralement disponibles :
- sha1 (qui génère une chaine de 20 de long)
- sha256 (qui génère une chaine de 32 de long)
- sha512 (qui génère une chaine de 64 de long)
QSH
Commande | Résultat |
/qopensys/pkgs/bin/sha1sum /home/jl/file.txt | 10e2e89feb9287eea7a4b7b849b7a380d95c05b9 /home/jl/file.txt |
/qopensys/pkgs/bin/sha256sum /home/jl/file.txt | ff8fb31c076b42fd63377e7ea4747f98c34291ac6e5f53cfd3940913bc9d7d37 /home/jl/file.txt |
/qopensys/pkgs/bin/sha512sum /home/jl/file.txt | 658efb990d2765ca65adb570daa198ef6bee55e39d3a7b7fa31270c35fdf9ee523ce638dea4796ea8923a2ad428e23d23b62175b26494fa8fdca49d5e85ce502 /home/jl/file.txt |
SQL
Syntaxe | Résultat |
VALUES HASH_SHA1(CAST(‘This is not a test!’ AS VARCHAR(512) CCSID 1208)); | 10E2E89FEB9287EEA7A4B7B849B7A380D95C05B9 |
VALUES HASH_SHA256(CAST(‘This is not a test!’ AS VARCHAR(512) CCSID 1208)); | FF8FB31C076B42FD63377E7EA4747F98C34291AC6E5F53CFD3940913BC9D7D37 |
VALUES HASH_SHA512(CAST(‘This is not a test!’ AS VARCHAR(512) CCSID 1208)); | 658EFB990D2765CA65ADB570DAA198EF6BEE55E39D3A7B7FA31270C35FDF9EE523CE638DEA4796EA8923A2AD428E23D23B62175B26494FA8FDCA49D5E85CE502 |
Pour plus de détails
MD5 : https://fr.wikipedia.org/wiki/MD5
md5sum : https://fr.wikipedia.org/wiki/Md5sum
Fonction sql HASH() : https://www.ibm.com/docs/en/i/7.4?topic=sf-hash-md5-hash-sha1-hash-sha256-hash-sha512
Fonction sql BLOB() : https://www.ibm.com/docs/en/i/7.4?topic=functions-get-blob-from-file
CCSID : https://www.ibm.com/docs/en/i/7.4?topic=information-ccsid-values-defined-i
cypher : https://www.ibm.com/docs/en/i/7.4?topic=ssw_ibm_i_74/rzatk/CIPHER.htm
Récupérer une API
Il existe un grand nombre d’API aux fonctionnalités diverses dont certaines nous permettent de récupérer des données structurées dans différents formats (XML, JSON, …).
Grace aux fonctions SQL de l’IBMi nous pouvons récupérer ces données pour les insérer dans les fichiers de la base de données.
Pour les exemples qui suivent, on se base sur trois API tirées du site https://openweathermap.org/ :
- Une première qui récupère la météo dans une ville donnée
https://api.openweathermap.org/data/2.5/weather?q={city name}&appid={API key}&mode=xml’
- Une qui récupère jusqu’à 50 communes autour de coordonnées choisies
https://api.openweathermap.org/data/2.5/find?lat=45.75&lon=4.5833&cnt=50&appid={API key}&mode=xml
- Une qui récupère jusqu’à des communes dans un rectangle de coordonnées choisies
https:// api.openweathermap.org/data/2.5/box/city?bbox=4,45,8,46,50&appid={API key}
Extraire les données de l’API
Sortie API en XML
![](https://www.gaia.fr/wp-content/uploads/2021/06/API_xml-1030x355.png)
La commande SQL suivante permet d’afficher les données dans un champ DATA
SELECT DATA FROM (values
char(SYSTOOLS.HTTPGETCLOB('https://api.openweathermap.org/data/2.5/weather?q={city name}&appid={API key}&mode=xml',''), 4096))
ws(data);
![](https://www.gaia.fr/wp-content/uploads/2021/06/extract_xml_to_DB2-1-1030x85.png)
Sortie API en JSON
![](https://www.gaia.fr/wp-content/uploads/2021/06/API_json-1030x105.png)
La commande SQL suivante permet d’afficher les données dans un champ DATA
SELECT DATA FROM (values
char(SYSTOOLS.HTTPGETCLOB('api.openweathermap.org/data/2.5/weather?q={city name}&appid={API key}',''), 4096))
ws(data);
![](https://www.gaia.fr/wp-content/uploads/2021/06/extract_json_to_DB2-1-1030x85.png)
Sortie API en HTML
![](https://www.gaia.fr/wp-content/uploads/2021/06/API_html-1030x184.png)
La commande SQL suivante permet d’afficher les données dans un champ DATA
SELECT DATA FROM (values
char(SYSTOOLS.HTTPGETCLOB('https://api.openweathermap.org/data/2.5/weather?q={city name}&appid={API key}&mode=html',''), 4096))
ws(data);
![](https://www.gaia.fr/wp-content/uploads/2021/06/extract_html_to_DB2-2-1030x76.png)
Récupération des données
En XML
On crée un fichier qui contiendra les colonnes que l’on veut récupérer (Ville, Température en cours, date, …)
CREATE TABLE GG/METEODB
;
(VILLE_ID DECIMAL (9, 0) NOT NULL WITH DEFAULT,
VILLE_NOM CHAR (50) NOT NULL WITH DEFAULT,
TEMPERATURE DECIMAL (5, 2) NOT NULL WITH DEFAULT,
TEMP_MIN DECIMAL (5, 2) NOT NULL WITH DEFAULT,
TEMP_MAX DECIMAL (5, 2) NOT NULL WITH DEFAULT,
DATE_MAJ CHAR (20) NOT NULL WITH DEFAULT)
Récupérer les données de l’API dans le fichier créé :
INSERT INTO GG.METEODB
select xdata.* FROM xmltable('$doc/cities/list/item'
PASSING XMLPARSE(document SYSTOOLS.HTTPGETCLOB('https://api.openweathermap.org/data/2.5/find?lat=45.75&lon=4.5833&cnt=10&appid={API key}&mode=xml','')) AS "doc"
COLUMNS
ville_id decimal(9, 0) PATH 'city/@id',
ville_nom varchar(50) PATH 'city/@name',
temperature decimal(5, 2) PATH 'temperature/@value',
temp_min decimal(5, 2) PATH 'temperature/@min',
temp_max decimal(5, 2) PATH 'temperature/@max',
date_maj varchar(20) PATH 'lastupdate/@value' ) as xdata;
![](https://www.gaia.fr/wp-content/uploads/2021/06/3_1_xml.png)
![](https://www.gaia.fr/wp-content/uploads/2021/06/3_1_db2.png)
En JSON
Contrairement à XML, on peut créer tout de suite un fichier qui contiendra les colonnes que l’on veut récupérer.
CREATE TABLE GG.METEOBD
(VILLE_ID DECIMAL (9, 0) NOT NULL WITH DEFAULT,
VILLE_NOM CHAR (50) NOT NULL WITH DEFAULT,
TEMPERATURE DECIMAL (5, 2) NOT NULL WITH DEFAULT,
TEMP_MIN DECIMAL (5, 2) NOT NULL WITH DEFAULT,
TEMP_MAX DECIMAL (5, 2) NOT NULL WITH DEFAULT,
DATE_UX_MAJ DECIMAL (12, 0) NOT NULL WITH DEFAULT)
Récupérer les données de l’API dans le fichier créé :
INSERT INTO GG.METEOBD
select * from JSON_TABLE(SYSTOOLS.HTTPGETCLOB('https://api.openweathermap.org/data/2.5/box/city?bbox=4,45,8,46,50&appid={API key}','') ,
'$.list[*]'
COLUMNS
(ville_id decimal(9, 0) PATH '$.id',
ville_nom varchar(50) PATH '$.name',
temperature decimal(5, 2) PATH '$.main.temp',
temp_min decimal(5, 2) PATH '$.main.temp_min',
temp_max decimal(5, 2) PATH '$.main.temp_max',
date_ux_maj decimal(12, 0) PATH '$.dt'));
![](https://www.gaia.fr/wp-content/uploads/2021/06/3_2_json.png)
![](https://www.gaia.fr/wp-content/uploads/2021/06/3_2_db2.png)
Pour aller plus loin
En utilisant une API de LA POSTE qui ne nécessite pas d’inscription au préalable, ni d’identification. Nous pouvons réaliser un programme qui nous aide à retrouver une commune à partir d’un code postal, dans l’optique d’aider au remplissage de certains formulaires.
On crée un fichier temporaire en interrogeant directement l’API.
![](https://www.gaia.fr/wp-content/uploads/2021/06/prog_01.png)
![](https://www.gaia.fr/wp-content/uploads/2021/06/prog_02.png)
![](https://www.gaia.fr/wp-content/uploads/2021/06/prog_03.png)
![](https://www.gaia.fr/wp-content/uploads/2021/06/prog_04.png)
![](https://www.gaia.fr/wp-content/uploads/2021/06/prog_05.png)