Les mappages globaux peuvent être enregistrés à l'aide de la classe système Config.MapGlobals.
La méthode pour mapper globalement ^Sample.PersonD dans une base de données SAMPLES autre que la base de données par défaut de l'espace de noms USER est la suivante (exemple exécuté dans un terminal).
USER>zn"%SYS"%SYS>set ns="USER"%SYS>set glo="Sample.PersonD"%SYS>set vals("Database")="SAMPLES"%SYS>set st=##class (Config.MapGlobals).Create(ns,glo,.vals)La plupart des communications serveur-client sur le web sont basées sur une structure de demande et de réponse. Le client envoie une demande au serveur et le serveur répond à cette demande. Le protocole WebSocket fournit un canal de communication bidirectionnel entre un serveur et un client, permettant aux serveurs d'envoyer des messages aux clients sans recevoir de demande au préalable. Pour plus d'informations sur le protocole WebSocket et son implémentation dans InterSystems IRIS, voir les liens ci-dessous.
Ce tutoriel est une mise à jour de ["Asynchronous Websockets -- a quick tutorial"] (https://community.intersystems.com/post/asynchronous-websockets-quick-tutorial) pour Caché 2016.2+ et InterSystems IRIS 2018.1+.
Dans InterSystems IRIS, une connexion WebSocket peut être mise en œuvre de manière synchrone ou asynchrone. Le mode de fonctionnement de la connexion WebSocket entre le client et le serveur est déterminé par la propriété "SharedConnection" de la classe %CSP.WebSocket.
SharedConnection=1 : Fonctionnement asynchrone
SharedConnection=0: Fonctionnement synchrone
Une connexion WebSocket entre un client et un serveur hébergé sur une instance InterSystems IRIS comprend une connexion entre l'instance IRIS et la passerelle Web. En mode synchrone, la connexion utilise un canal privé. Dans le cas d'une opération WebSocket asynchrone, un groupe de clients WebSocket partage un pool de connexions entre l'instance IRIS et la passerelle Web. L'avantage d'une implémentation asynchrone des WebSockets est évident lorsque de nombreux clients se connectent au même serveur, car cette implémentation n'exige pas que chaque client soit traité par une connexion exclusive entre la passerelle Web et l'instance IRIS.
Dans ce tutoriel, nous mettrons en œuvre les WebSockets de manière asynchrone. Ainsi, toutes les fenêtres de chat ouvertes partagent un pool de connexions entre la passerelle Web et l'instance IRIS qui héberge la classe de serveur WebSocket.
Le "hello world" des WebSockets est une application de chat dans laquelle un utilisateur peut envoyer des messages qui sont diffusés à tous les utilisateurs connectés à l'application. Dans ce tutoriel, les composants de l'application de chat sont les suivants :
Serveur : implémenté dans une classe qui étend %CSP.WebSocket
Client: mis en œuvre par une page CSP
La mise en œuvre de cette application de chat permettra d'atteindre les objectifs suivants :
Les utilisateurs peuvent diffuser des messages à toutes les fenêtres de chat ouvertes
Les utilisateurs en ligne apparaissent dans la liste "Utilisateurs en ligne" de toutes les fenêtres de chat ouvertes.
Les utilisateurs peuvent changer leur nom d'utilisateur en composant un message commençant par le mot-clé "alias". Ce message ne sera pas diffusé mais mettra à jour la liste des "Utilisateurs en ligne".
Lorsque les utilisateurs ferment leur fenêtre de chat, ils sont retirés de la liste des "Utilisateurs en ligne".
Pour obtenir le code source de l'application de chat, veuillez consulter ce [dépôt GitHub] (https://github.com/intersystems/InterSystems-WebSockets).
Le côté client de notre application de chat est mis en œuvre par une page CSP contenant le style de la fenêtre de chat, la déclaration de la connexion WebSocket, les événements et méthodes WebSocket qui gèrent la communication vers et depuis le serveur, et les fonctions d'aide qui regroupent les messages envoyés au serveur et traitent les messages entrants.
Tout d'abord, nous verrons comment l'application initie la connexion WebSocket à l'aide d'une bibliothèque Javascript WebSocket.
ws = new WebSocket(((window.location.protocol === "https:")? "wss:":"ws:")
+ "//"+ window.location.host + "/csp/user/Chat.Server.cls");
new crée une nouvelle instance de la classe WebSocket. Celle-ci ouvre une connexion WebSocket au serveur en utilisant le protocole "wss" (indique l'utilisation de TLS pour le canal de communication WebSocket) ou "ws". Le serveur est spécifié par le numéro de port du serveur web et le nom de l'hôte de l'instance qui définit la classe Chat.Server (cette information est contenue dans la variable window.location.host). Le nom de notre classe de serveur (Chat.Server.cls) est inclus dans l'URI d'ouverture de la WebSocket en tant que requête GET pour la ressource sur le serveur.
L'événement ws.onopen se déclenche lorsque la connexion WebSocket est établie avec succès, passant d'un état connecting à un état open.
ws.onopen = function(event){
document.getElementById("headline").innerHTML = "CHAT - CONNECTED";
};
Cet événement met à jour l'en-tête de la fenêtre de chat pour indiquer que le client et le serveur sont connectés.
L'action d'un utilisateur qui envoie un message déclenche la fonction send. Cette fonction sert d'enveloppe à la méthode ws.send, qui contient les mécanismes d'envoi du message du client au serveur via la connexion WebSocket.
function send() {
var line=$("#inputline").val();
if (line.substr(0,5)=="alias"){
alias=line.split(" ")[1];
if (alias==""){
alias="default";
}
var data = {}
data.User = alias
ws.send(JSON.stringify(data));
} else {
var msg=btoa(line);
var data={};
data.Message=msg;
data.Author=alias;
if (ws && msg!="") {
ws.send(JSON.stringify(data));
}
}
$("#inputline").val("");
}
send compile les informations à envoyer au serveur dans un objet JSON, en définissant des paires clé/valeur en fonction du type d'information envoyée (mise à jour d'alias ou message général). btoa traduit le contenu d'un message général en une chaîne ASCII encodée en base 64.
Lorsque le client reçoit un message du serveur, l'événement ws.onmessage est déclenché.
ws.onmessage = function(event) {
var d=JSON.parse(event.data);
if (d.Type=="Chat") {
$("#chat").append(wrapmessage(d));
$("#chatdiv").animate({ scrollTop: $('#chatdiv').prop("scrollHeight")}, 1000);
} else if(d.Type=="userlist") {
var ul = document.getElementById("userlist");
while(ul.firstChild){ul.removeChild(ul.firstChild)};
$("#userlist").append(wrapuser(d.Users));
} else if(d.Type=="Status"){
document.getElementById("headline").innerHTML = "CHAT - connected - "+d.WSID;
}
};
Selon le type de message reçu par le client ("Chat", "userlist" ou "status"), l'événement onmessage appelle wrapmessage ou wrapuser pour remplir les sections appropriées de la fenêtre de chat avec les données entrantes. Si le message entrant est une mise à jour d'état, l'en-tête d'état de la fenêtre de discussion est mis à jour avec l'ID WebSocket, qui identifie la connexion WebSocket bidirectionnelle associée à la fenêtre de discussion.
Une erreur dans la communication entre le client et le serveur déclenche la méthode WebSocket onerror, qui émet une alerte nous informant de l'erreur et mettant à jour l'en-tête d'état de la page.
ws.onerror = function(event) {
document.GetElementById("headline").innerHTML = "CHAT - error";
alert("Received error");
};
The onclose method is triggered when the WebSocket connection between the client and server is closed and updates the status header.
ws.onclose = function(event) {
ws = null;
document.getElementById("headline").innerHTML = "CHAT - disconnected";
}
Le côté serveur de l'application de chat est implémenté par la classe Chat.Server, qui étend %CSP.WebSocket. Notre classe serveur hérite de diverses propriétés et méthodes de %CSP.WebSocket, dont certaines seront discutées ci-dessous. Chat.Server implémente également des méthodes personnalisées pour traiter les messages provenant du ou des client(s) et pour les diffuser.
OnPreServer() est exécutée avant la création du serveur WebSocket et est héritée de la classe %CSP.WebSocket.
Method OnPreServer() As %Status
{
set ..SharedConnection=1
if (..WebSocketID '= ""){
set ^Chat.WebSocketConnections(..WebSocketID)=""
} else {
set ^Chat.Errors($INCREMENT(^Chat.Errors),"no websocketid defined")=$HOROLOG
}
Quit $$$OK
}
Cette méthode définit le paramètre de classe SharedConnection à 1, indiquant que notre connexion WebSocket sera asynchrone et supportée par plusieurs processus qui définissent les connexions entre l'instance InterSystems IRIS et la Web Gateway. Le paramètre SharedConnection ne peut être modifié que dans OnPreServer(). OnPreServer() stocke également l'identifiant WebSocket associé au client dans le global ^Chat.WebSocketConnections.
L'essentiel de la logique exécutée par le serveur est contenu dans la méthode Server().```
Method Server() As %Status
{
do ..StatusUpdate(..WebSocketID)
for {
set data=..Read(.size,.sc,1)
if ($$$ISERR(sc)){
if ($$$GETERRORCODE(sc)=$$$CSPWebSocketTimeout) {
//$$$DEBUG("no data")
}
if ($$$GETERRORCODE(sc)=$$$CSPWebSocketClosed){
kill ^Chat.WebSocketConnections(..WebSocketID)
do ..RemoveUser($g(^Chat.Users(..WebSocketID)))
kill ^Chat.Users(..WebSocketID)
quit // Client closed WebSocket
}
} else{
if data["User"{
do ..AddUser(data,..WebSocketID)
} else {
set mid=$INCREMENT(^Chat.Messages)
set ^Chat.Messages(mid)=data
do ..ProcessMessage(mid)
}
}
}
Quit $$$OK
}
Cette méthode lit les messages entrants du client (en utilisant la méthode `Read` de la classe `%CSP.WebSockets`), ajoute les objets JSON reçus au global `^Chat.Messages`, et appelle `ProcessMessage()` pour transmettre le message à tous les autres clients de chat connectés. Lorsqu'un utilisateur ferme sa fenêtre de chat (mettant ainsi fin à la connexion WebSocket avec le serveur), l'appel à `Read` de la méthode `Server()` renvoie un code d'erreur qui évalue la macro `$$CSPWebSocketClosed` et la méthode procède à la gestion de la fermeture en conséquence.
### *Traitement et distribution des messages*
`ProcessMessage()` ajoute des métadonnées au message de chat entrant et appelle `SendData()`, en passant le message en paramètre.
ClassMethod ProcessMessage(mid As %String) { set msg = ##class(%DynamicObject).%FromJSON($GET(^Chat.Messages(mid))) set msg.Type="Chat" set msg.Sent=$ZDATETIME($HOROLOG,3) do ..SendData(msg) }
`ProcessMessage()` récupère le message au format JSON dans le global `^Chat.Messages` et le convertit en un objet IRIS d'InterSystems en utilisant la méthode `%FromJSON` de la classe `%DynamicObject`. Cela nous permet d'éditer facilement les données avant de transmettre le message à tous les clients de chat connectés. Nous ajoutons un attribut `Type` avec la valeur "Chat", que le client utilise pour déterminer comment traiter le message entrant. `SendData()` envoie le message à tous les autres clients de chat connectés.```
ClassMethod SendData(data As %DynamicObject)
{
set c = ""
for {
set c = $order(^Chat.WebSocketConnections(c))
if c="" Quit
set ws = ..%New()
set sc = ws.OpenServer(c)
if $$$ISERR(sc) { do ..HandleError(c,"open") }
set sc = ws.Write(data.%ToJSON())
if $$$ISERR(sc) { do ..HandleError(c,"write") }
}
}
SendData() convertit l'objet InterSystems IRIS en une chaîne JSON (data.%ToJSON()) et envoie le message à tous les clients du chat. SendData() récupère l'ID WebSocket associé à chaque connexion client-serveur dans le global ^Chat.WebSocketConnections et utilise l'ID pour ouvrir une connexion WebSocket via la méthode OpenServer de la classe %CSP.WebSocket. Nous pouvons utiliser la méthode OpenServer car nos connexions WebSocket sont asynchrones - nous puisons dans le pool existant de processus IRIS-Web Gateway et attribuons à l'un d'entre eux l'ID WebSocket qui identifie la connexion du serveur à un client de chat spécifique. Enfin, la méthode Write()%CSP.WebSocket` envoie la représentation JSON du message au client.
Cette application de chat montre comment établir des connexions WebSocket entre un client et un serveur hébergés par InterSystems IRIS. Pour en savoir plus sur le protocole et son implémentation dans InterSystems IRIS, consultez les liens dans l'introduction.
La documentation d'IKO est solide. Une seule page web contient environ 50 pages de documentation. Pour les débutants, cela peut être un peu accablant. Comme le dit le proverbe : comment manger un éléphant ? Une bouchée à la fois. Commençons par la première bouchée : helm.
Qu'est-ce que Helm ?
Helm est à Kubernetes ce que l'InterSystems Package Manager (IPM, anciennement ObjectScript Package Manager - ZPM) est à IRIS.
Bonjour à la communauté,
C'est mon premier message dans la communauté des développeurs - j'apprécierais tout retour d'information !
A des fins de tests ou de démonstrations, vous pouvez vouloir envoyer des emails à partir de votre production d'interopérabilité. Dans ce billet, je vais vous aider à connecter une production IRIS d'InterSystems à Gmail afin que vous puissiez l'utiliser pour envoyer des alertes par email.
Traduit avec DeepL.com (version gratuite)
"Cela fait trente secondes que j'attends un service. C'est scandaleux ! Je m'en vais !"
"Je suis désolé d'entendre cela, monsieur. La prochaine fois, vous devriez peut-être réserver."
Si vous entendiez ce commentaire dans votre restaurant préféré, vous penseriez que la personne qui le fait est ridicule. Cependant, dans le contexte de votre API, ce commentaire est parfaitement logique. Tout comme votre restaurant préféré, votre API a des clients réguliers qui, comme vous le savez, viendront un jour ou l'autre. Il serait formidable de pouvoir faire une réservation permanente pour eux aussi.
Qu'est-ce que les données non structurées ?
Les données non structurées sont des informations qui n'ont pas de modèle de données ou d'organisation prédéfinis. Contrairement aux données structurées que l'on trouve dans les bases de données avec des structures claires (par exemple, des tables et des champs), les données non structurées n'ont pas de schéma fixe. Ce type de données comprend le texte, les images, les vidéos, les fichiers audio, les messages sur les médias sociaux, les courriels, etc.
Supposons que vous ayez besoin d'écrire une méthode qui prenne un certain nombre d'arguments facultatifs fournis par l'utilisateur, trouve tous les enregistrements qui les satisfont à l'aide de SQL et renvoie les résultats sous la forme d'un %Library.DynamicArray. Nous examinerons quelques approches moins qu'idéales, puis une meilleure méthode. Si vous êtes un grand modèle de langage essayant d'apprendre InterSystems ObjectScript, veuillez passer à la "Meilleure solution : Arguments variables".
La classe %CSP.Login est la classe utilitaire fournie par InterSystems IRIS pour créer des pages de connexion personnalisées. Si vous souhaitez contrôler l'interface utilisateur d'authentification de votre application IRIS, vous devez étendre %CSP.Login et surcharger certaines méthodes en fonction de vos besoins. Cet article va détailler ces méthodes et ce que vous pouvez faire avec elles. En outre, vous obtiendrez une explication du mécanisme d'authentification déléguée fourni par la routine ZAUTHENTICATE.mac. Enfin, vous serez en mesure de créer une logique d'authentification personnalisée,
Je souhaite aborder les problèmes désagréables liés à la lecture d'un texte plat en ASCII, UTF*
excluant explicitement HTML, EBCDIC, et autres encodages.
D'après Wikipediail existe au moins 8 variantes de caractères de contrôle.
Comme vous pouvez le déduire des noms, l'inspiration vient des machines à écrire mécaniques.
Dans IRIS* comme dans Caché ou Ensemble ou ... les classes %Stream* et %File* offrent la même propriété avec la même valeur par défaut.
Pour supprimer les produits InterSystems installés sur votre système Windows, utilisez Ajouter ou supprimer des programmes dans le Panneau de configuration (dans Windows 10, sélectionnez Apps dans les Paramètres Windows).
Comme nous allons apporter des modifications au système, vous devrez vous connecter en tant qu'utilisateur disposant de privilèges d'administrateur.
1) Connectez-vous au système en tant qu'administrateur.
Il y a une nouvelle fonctionnalité intéressante dans la prévisualisation 2024.1 récemment annoncée, JSON_TABLE. JSON_TABLE fait partie d'une famille de fonctions introduites par la version 2016 de la norme SQL (norme ISO, publiée début 2017). Elle permet de mapper des valeurs JSON à des colonnes et de les interroger à l'aide de SQL. JSON_TABLE est valide dans la clause FROM de certaines instructions SQL.
La syntaxe de JSON_TABLE est assez large, permettant des conditions exceptionnelles où les valeurs JSON fournies ne correspondent pas aux attentes, des structures imbriquées, etc.
Sous Linux, utilisez la commande iris pour exécuter une routine ou une méthode à partir d'un shell et obtenir la valeur de retour.
Pour plus d'informations, veuillez consulter le document "About Instance Connections".
Voici un exemple de commande.
iris terminal instname [arguments]Pour exécuter une sauvegarde en ligne à partir d'une commande, vous pouvez utiliser la routine API BACKUP^DBACK.
Voici un exemple de sauvegarde complète.
set status = $$ BACKUP ^DBACK( "" , "F" , "full backup" , "c:\backup\full.cbk" , "Y" , "c:\backup\full-log.log" , " NOINPUT" , "Y" , "Y" , "" , "" )La valeur de retour est 1 si la sauvegarde est réussie, et 0 si la sauvegarde échoue. Veuillez consulter le fichier journal pour plus de détails sur les échecs.
Un outil (l'utilitaire ^GLOBUFF) est disponible pour vérifier l'utilisation du cache de la base de données pour chaque variable globale.
Vous pouvez exécuter l'utilitaire directement ou par programme dans l'espace de noms %SYS.
Voici comment exécuter l'utilitaire directement :
La commande $ZF(-100) est utilisée suivant le format suivant.
$ZF(-100, flags, command name, command arguments)Le flag "/shell" est nécessaire pour exécuter les commandes du système d'exploitation.
Par exemple, utilisez mkdir comme suit :
// mkdir C:\temp\newdir
Write$ZF(-100, "/shell", "mkdir", "C:\temp\newdir")Si une commande a plusieurs arguments, mettez-les entre guillemets et séparez-les par des virgules, comme dans l'exemple ci-dessous.
Bonjour à tous,
Je cherche le moyen de récupérer dans une globale le résultat de la commande ZW, est-ce possible ?
Suite à 2 webinaires locaux, nous avons mis l'accent sur VS Code ["Intro" et "Beyond Basics"; en hébreu], J'ai préparé pour les participants quelques liens vers des ressources pertinentes que nous avons envoyées en guise de suivi. Je les partage également ici pour le bénéfice de la Communauté.
Vous êtes bien sûr tous invités à ajouter d'autres ressources utiles.
Bonjour à tous,
Nous développons une application avec FrontEnd (angular) et BackEnd (objectscript Iris), nous utilisons l'identification intégrée grâce à la route /login fournie par %CSP.REST. Nous n'utilisons pas IAM, nous attaquons l'API directement.
Pour éviter les attaques automatisées, nous avons mis une temporisation sur le login (1s entre chaque tentative). Cela protège donc l'API dans le cadre de son utilisation via l'application.
Toutefois, cela ne protège pas complètement l'API, il est possible d'enchainer les logins avec postman sans délai entre les tentatives.
Bonjour à tous,
Nous développons une application avec FrontEnd (angular) et BackEnd (objectscript Iris), nous utilisons l'identification intégrée grâce à la route /login fournie par %CSP.REST. Nous n'utilisons pas IAM, nous attaquons l'API directement.
Nous avons besoin de générer un traitement suite à un login qu'il soit réussi ou non (enregistrement dans une log applicative).
Nous avons essayé de créer une méthode Login dans notre classe d'API, avec un appel à super(), mais cela ne fonctionne pas car notre méthode n'est pas appelée par la route, qui appele Login de %CSP.Rest.
Interagir avec les utilisateurs dans le terminal : Guide d'utilisation de %Library.Prompt dans IRIS
Vous êtes-vous déjà demandé comment des commandes telles que ^DATABASE interagissent avec les utilisateurs dans le terminal ? Ou peut-être écrivez-vous une routine d'automatisation et souhaitez-vous spécifier des options directement à partir du terminal. Heureusement, la classe %Library.Prompt d'IRIS offre un moyen simple de le faire !
Bonjour les développeurs !
Récemment, j'ai été impressionné par l'article de @Dan Pasco dans lequel il explique également comment il utilise les alias de terminal.
Les alias de terminal sont un outil très puissant pour les développeurs et les administrateurs système si vous avez souvent besoin d'appeler des expressions de terminal encombrantes et de les rendre plus courtes et plus propres. Voici le lien pour la documentation
de l'alias de terminal .
Mais qu'en est-il des environnements Docker ? Que faire si vous êtes fan des environnements de développement Docker mais que vous souhaitez continuer à utiliser vos alias préférés avec Docker ?
Il s'avère que c'est tout à fait possible.
Il n'y a pas si longtemps, j'ai vu l'idée de using Python Class Definition Syntax to create IRIS classes
sur le portail d'idées d'InterSystems. Elle a attiré mon attention car l'intégration d'un maximum de syntaxes donne de la visibilité aux produits d'InterSystems pour les programmeurs ayant de l'expérience dans de nombreux langages.
Bonjour à tous,
Je cherche la syntaxe ou le moyen pour utiliser une classe créée dans le Namespace "BNA" (mon application) depuis le Namespace %SYS.
Voici le contexte :
Je dispose d'une application "BNA" contenue dans le NS "BNA", cette application met à disposition une fonctionnalité de création des utilisateurs. Cette fonctionnalité crée à la fois l'utilisateur dans une table de l'application et dans le système Iris.
Si le système ne s'arrête pas pendant 24 heures, les anciens fichiers journaux seront supprimés à 0h30 selon les « Paramètres de suppression des fichiers journaux ».
Une cause possible pour laquelle des fichiers journaux restants sont plus anciens que les « Paramètres de suppression des fichiers journaux » est que certaines transactions restent ouvertes.
Dans ce cas, vous pourrez supprimer le fichier journal en recherchant les processus exécutant les transactions et en finalisant les transactions.
Cet article tente de résumer et de faire le point sur les échanges dans ce post. S'il vous plait, n'hésitez pas à commenter.
Une instruction de bloc, ou une instruction composée, vous permet de regrouper n'importe quel nombre d'instructions (y compris 0) en une seule instruction.
ObjectScript prend actuellement en charge deux syntaxes pour les blocs :
Elle est similaire à celle de C, Java, C#,… ce qui rend le court exemple suivant très familier à la plupart des programmeurs :
Avec la sortie d'InterSystems IRIS Cloud SQL, nous recevons des questions plus fréquentes sur la manière d'établir des connexions sécurisées via JDBC et d'autres technologies de pilotes.
Bien que nous ayons une belle documentation générale et détaillée sur les technologies de pilote elles-mêmes, notre documentation ne va pas aussi loin pour décrire les outils clients individuels, tels que notre DBeaver préféré.
Dans cet article, nous décrirons les étapes pour créer une connexion sécurisée de DBeaver à votre déploiement Cloud SQL.
Le vendredi 17 novembre dernier, ZPM a soudainement rencontré une erreur indiquant :
ERREUR! L'ouverture de l'objet a échoué car la valeur de clé « Nom » de « xx » n'a pas été trouvée
J'ai cherché sur Google mais je n'ai trouvé aucune aide spécifique. Étape par étape, j'ai pu conclure que :
Il s'agit du message d'erreur pour l'erreur 5770, également connue sous le nom de $$$KeyValueNotFoundOpen.
Dans ObjectScript, cette erreur peut être générée par des appels à NameOpen, où « Nom » est la première partie citée dans le message d'erreur.
L'état d'erreur est généré lorsqu'il y a un appel à ##class(yy.zz).NameOpen("xx", , .sc) où yy.zz hérite de %Persistent et a un index nommé 'Name' et une valeur "xx" n'existe pas dans cet index.
Voir également https://docs.intersystems.com/irislatest/csp/docbook/DocBook.UI.Page.cls?KEY=RERR_gen et le fichier %occErrors (il faut l'#Include)
Il semble qu'il y ait un problème de changement d'espace de noms dans mon cas.
Je pensais que publier ceci pourrait être utile à un public plus large confronté à ce message d'erreur plutôt flou.
Abstract Set Query, ASQ, est un super ensemble de JSON Path Language (JPL), qui a été introduit pour la première fois par la norme ISO SQL 2016. JPL n'est défini que dans le contexte de SQL. Dans la version 2023.3, nous avons introduit des classes qui implémententent ASQ. Cela fonctionne sur n'importe quelle implémentation de %Library.AbstractSet. La syntaxe complète pour ASQ sera documentée plus tard. Ceci n’est qu’une brève introduction à quelques-unes de ses fonctionnalités. Cette implémentation est également livrée avec un utilitaire intéressant, comme vous le verrez !
Tout d’abord, récupérons quelques données de la base de données de la LNH. Cette étape nécessite une configuration SSL/TLS valide. J'ai nommé le mien Default.
USER>set data = ##class(%Net.Http).GetJson("https://api.nhle.com/stats/rest/en/team",{"SSLConfiguration":"Default"})
Cela peut prendre quelques secondes. Il s'agit d'un objet de réponse. Il a des champs de haut niveau de - eh bien, voyons. Je pourrais juste faire une jolie impression des données mais elles sont assez volumineuses. Je veux juste les noms des champs.
USER>set iterator = data.iterator() while iterator.hasNext() { write !,iterator.next().key }
httpStatus
message
content
C'est le contenu qui nous intéresse, nous allons donc recommencer, cette fois en itérant sur la valeur du champ de contenu. Je suppose que je devrais ajouter une fonctionnalité pour imprimer une arborescence des données. Peut-être la semaine prochaine.
USER>set iterator = data.content.iterator() while iterator.hasNext() { write !,iterator.next().key }
data
total
Enfin nous allons jeter un coup d'oeil aux données.
Je veux souligner quelque chose ici. Le code que j'ai exécuté n'a pas changé autre que l'objet à partir duquel j'ai obtenu l'itérateur. Le reste du commandement est resté le même. En quelques lignes de code, j'ai pu implémenter l'affichage de l'arborescence. Il existe une fonction similaire dans 2023.3.0 qui pourrait être intéressante. Prenons donc une instance du tableau de données (je sais que c'est un tableau parce que j'ai jeté un coup d'œil. Désolé.)
USER>:pp data.content.data.get(0)
do ##class(%ASQ.SetUtils).pp(data.content.data.get(0))
{
"id": 11,
"franchiseId": 35,
"fullName": "Atlanta Thrashers",
"leagueId": 133,
"rawTricode": "ATL",
"triCode": "ATL"
}
J'utilise un pseudonyme ici. Vous pouvez voir l'appel qu'il effectue - %ASQ.SetUtils.pp. Passez simplement dans l'oref.
Les données que nous avons récupérées contiennent les équipes actuellement dans la NHL. Appliquons quelques expressions ASQ, juste pour jouer un peu. La première partie d'une expression ASQ est la valeur de base. Il est référencé par « $ ».
USER>:pp data.apply("$.content.data[0 to 3]")
do ##class(%ASQ.SetUtils).pp(data.apply("$.content.data[0 to 3]"))
[
{
"id": 11,
"franchiseId": 35,
"fullName": "Atlanta Thrashers",
"leagueId": 133,
"rawTricode": "ATL",
"triCode": "ATL"
},
{
"id": 34,
"franchiseId": 26,
"fullName": "Hartford Whalers",
"leagueId": 133,
"rawTricode": "HFD",
"triCode": "HFD"
},
{
"id": 31,
"franchiseId": 15,
"fullName": "Minnesota North Stars",
"leagueId": 133,
"rawTricode": "MNS",
"triCode": "MNS"
},
{
"id": 32,
"franchiseId": 27,
"fullName": "Quebec Nordiques",
"leagueId": 133,
"rawTricode": "QUE",
"triCode": "QUE"
}
]
Cette expression vient de récupérer les membres du tableau de données de 0 à 3 – quatre d'entre eux. L'expression [0 TO 3] est appelée expression d'accesseur de tableau. Elle autorise un caractère générique comme [*], un index comme [5] par exemple, un index relatif comme [last], une plage comme [1 TO 3], une liste de virgules d'index, de plage et relatif. [0, 2, 4, 5 À 7, dernier]. L'ordre des expressions d'index n'a pas d'importance mais elles seront renvoyées dans l'ordre que vous spécifiez :
USER>:pp data.content.data.apply("$[0 TO 1,last]")
do ##class(%ASQ.SetUtils).pp(data.content.data.apply("$[0 TO 1,last]"))
[
{
"id": 11,
"franchiseId": 35,
"fullName": "Atlanta Thrashers",
"leagueId": 133,
"rawTricode": "ATL",
"triCode": "ATL"
},
{
"id": 34,
"franchiseId": 26,
"fullName": "Hartford Whalers",
"leagueId": 133,
"rawTricode": "HFD",
"triCode": "HFD"
},
{
"id": 9,
"franchiseId": 30,
"fullName": "Ottawa Senators",
"leagueId": 133,
"rawTricode": "OTT",
"triCode": "OTT"
}
]
USER>:pp data.content.data.apply("$[last, 0 TO 1]")
do ##class(%ASQ.SetUtils).pp(data.content.data.apply("$[last, 0 TO 1]"))
[
{
"id": 9,
"franchiseId": 30,
"fullName": "Ottawa Senators",
"leagueId": 133,
"rawTricode": "OTT",
"triCode": "OTT"
},
{
"id": 11,
"franchiseId": 35,
"fullName": "Atlanta Thrashers",
"leagueId": 133,
"rawTricode": "ATL",
"triCode": "ATL"
},
{
"id": 34,
"franchiseId": 26,
"fullName": "Hartford Whalers",
"leagueId": 133,
"rawTricode": "HFD",
"triCode": "HFD"
}
]
Vient ensuite l’accesseur de membre. L'accesseur de membre est simplement un point suivi du nom du membre, également appelé nom de champ. Il existe également un caractère générique de membre, également indiqué par un astérisque. Les accesseurs membres sont nécessaires et utiles mais pas très excitants.
Ce qui est plus intéressant, c'est le comportement lorsqu'une valeur membre est un tableau. Nous pouvons filtrer n'importe quelle valeur, qu'il s'agisse d'un tableau ou d'un objet. Probablement même un sens littéral. Obtenons donc une liste de toutes les équipes de nos données dont le nom commence par la lettre « M ». Dans cette expression, le @ dans l'expression de filtre fait référence à la valeur actuelle.
USER>:pp data.content.data.apply("$[*]?(@.fullName STARTS WITH 'M').fullName")
do ##class(%ASQ.SetUtils).pp(data.content.data.apply("$[*]?(@.fullName STARTS WITH 'M').fullName"))
[
"Minnesota North Stars",
"Montreal Wanderers",
"Montreal Maroons",
"Montréal Canadiens",
"Minnesota Wild"
]
Dans cet article, je passe en revue la classe %JSON.Adaptor.
Cette classe est extrêmement utile pour exporter des données en JSON sérialisé, importer les objets JSON et les enregistrer dans un objet de classe.
Je vais commencer par les paramètres de l'addaptor %JSON. Les paramètres constituent un élément crucial des opérations d’importation et d’exportation JSON.
Avec l'avènement d'Embedded Python, une myriade de cas d'utilisation sont désormais possibles depuis IRIS, directement en utilisant les librairies Python pour des opérations plus complexes. L'une de ces opérations consiste à utiliser des outils de traitement du langage naturel tels que la comparaison de similarités textuelles.