La balise Concours regroupe les publications liées à tout concours de codage qui se déroule sur la communauté des développeurs d'InterSystems.
Bonjour les développeurs,
Suite au succès retentissant du concours de l'année dernière, nous avons décidé de le renouveler. Bienvenue au
🏆 Concours « Réalisation des idées » 🏆
Soumettez une application mettant en œuvre une idée issue du portail InterSystems Ideas, ayant le statut Community Opportunity ou Future Consideration, créée avant la publication de cette annonce et nécessitant une programmation 😉
Durée : 17 novembre - 7 décembre 2025
Prix : $12,000$
.jpg)
Salut la Communauté,
Nous sommes ravis de vous annoncer le deuxième concours de rédaction d'articles techniques en français !
✍️ Concours d'articles techniques ✍️
C'est l'occasion idéale pour tous les passionnés de technologie InterSystems de partager leurs connaissances et d'exposer leurs talents de rédacteur. Peu importe votre niveau d'expérience, tout le monde est invité à participer. Les articles peuvent traiter de nombreux sujets : de la mise en œuvre technique jusqu’à vos impressions et retours d'expérience sur l’utilisation des produits ou services InterSystems. Alors laissez libre cours à votre créativité et à votre expertise !
📅 Période du concours : du 15 septembre au 2 novembre
👉 Bonne nouvelle ! Le concours est prolongé jusqu’au 30 novembre !
🎁 Cadeaux pour tous : un cadeau spécial pour chaque participant !
🏅 Prix pour les auteurs de meilleurs articles
.jpg)
Si vous avez jamais observé un véritable artisan, qu'il s'agisse d'un potier transformant de l'argile en chef-d'œuvre ou d'un luthier donnant vie à un morceau de bois brut pour en faire une magnifique guitare, vous savez que la magie ne réside pas dans les matériaux, mais dans le soin, le savoir-faire et le traitement. Je le sais d'expérience : ma guitare électrique faite à la main est une source d'inspiration quotidienne, mais je dois avouer que créer quelque chose de ce genre est un don qui me manque.
Pourtant, dans le monde numérique, je vois souvent des gens qui espèrent que l'IA générative leur apporte une "solution miracle" en leur proposant des instructions vagues et hors contexte telles que "créez une application". Les résultats sont généralement décevants, sans aucune finesse ni créativité. Trop de gens attendent de l'IA qu'elle fasse des miracles sans contexte ni structure. Voilà ce qui nous a poussés à créer dc-artisan, un outil destiné aux artisans du prompt numérique. Notre objectif est de permettre à quiconque de transformer des prompts approximatifs et vagues en chefs-d'œuvre efficaces, fonctionnels et riches en contexte..
Tout comme lorsqu'on observe un grand artisan transformer des matières premières en œuvres d'art, créer avec GenAI est une question d'intention, de préparation et de travail minutieux. Le problème ne réside pas dans l'IA en soi, mais dans la manière dont nous l'utilisons. Tout comme un luthier doit sélectionner et façonner chaque morceau de bois avec soin, une ingénierie efficace des prompts nécessite un contexte, une structure et une intention bien définis.
Nous pensons que le monde mérite mieux que des "suggestions magiques" qui mènent à la déception. Une IA générative puissante est le fruit d'un accompagnement humain minutieux : un contexte précis, des objectifs concrets et une structure élaborée. Aucun artisan ne crée de la beauté par hasard : pour être fiables, les résultats d'une IA doivent être préparés avec soin.
dc-artisan aborde l'ingénierie rapide comme un véritable artisanat : de manière systématique, didactique et vérifiable. Il offre une boîte à outils complète pour aller au-delà des essais, des erreurs et des conjectures.
La première chose que fait dc-artisan est de chercher à comprendre votre prompt comme le ferait un collaborateur attentif. Lorsque vous commencez à rédiger, l'outil interagit directement avec vos entrées:
Ces interactions vous aident à clarifier non seulement ce que vous voulez que votre prompt dise, mais aussi pourquoi il le fait.
Une fois votre intention claire, dc-artisan examine la structure et propose des suggestions personnalisées afin d'améliorer la clarté, le ton et de compléter les détails manquants essentiels à un résultat riche en contexte et prêt à l'emploi.
Le meilleur dans tout ça? Vous pouvez utiliser toutes ces fonctionnalités directement dans votre éditeur préféré, VS Code ! Vous pouvez insérer des variables directement dans votre prompt (comme {task} ou {audience}) pour plus de flexibilité et de réutilisabilité, et prévisualiser instantanément le résultat final avec différentes substitutions. Vous voyez ainsi exactement comment cela fonctionnera dans la pratique.
Mais ce n'est pas tout. dc-artisan prend en charge le réglage rapide des prompts pour des performances optimales. Téléchargez un fichier CSV contenant des cas de test afin d'évaluer automatiquement la cohérence, la qualité des résultats et l'impact de la structure de vos prompts sur des entrées variées. dc-artisan évalue chaque réponse et génère des rapports complets avec des scores de qualité et des mesures de similarité, afin que vous puissiez mesurer et optimiser l'efficacité de vos prompts en toute confiance.
L'ingénierie des prompts sans structure revient à sculpter du bois les yeux bandés. Vous obtiendrez peut-être quelque chose, mais cela ne produira probablement pas un air mélodieux.
De nombreuses personnes ont recours à des prompts vagues ou surchargés, c'est-à-dire des commandes courtes et ambiguës ou des pages de contenu brut sans structure. Soit le modèle n'a aucune idée de ce que vous voulez, soit il se perd dans un marécage de bruit.
Lorsque le contexte du prompt devient trop long ou trop confus, même les LLM avancés peuvent se perdre. Au lieu de raisonner ou de générer de nouvelles stratégies, ils se laissent souvent déconcentrer, répétant le contenu précédent ou s'en tenant à des schémas familiers issus du début de l'historique des prompts. Ironiquement, les modèles plus volumineux avec des fenêtres contextuelles plus grandes (comme 32 000 tokens) sont encore plus sensibles à ce phénomène. Le simple fait de fournir plus de contexte (plus de documents, des prompts plus longs, des bases de connaissances entières) se retourne souvent contre vous, entraînant une surcharge contextuelle, des objectifs manqués et des résultats confus.
C'est précisément cette lacune que le RAG ( Génération augmentée par la récupération) vise à remplir : non pas en donnant plus d'informations aux LLM, mais en leur fournissant les connaissances les plus pertinentes au bon moment.
dc-artisan unifie la création rapide de prompts et la gestion du contexte. Il vous aide non seulement à rédiger de meilleurs prompts, mais garantit également que votre IA reçoit des informations pertinentes et sélectionnées, et non un flot incessant d'informations futiles.
Avec le mode pipeline RAG vous pouvez:
Ce flux de travail est inspiré par le portail InterSystems Ideas Portal (see DPI-I-557)
Voici comment vous pouvez intégrer en toute simplicité une nouvelle section sur l'architecture backend de dc-artisan juste avant la section "Conclusion", en mettant en avant l'intégration avec l'interopérabilité InterSystems IRIS et notre adaptateur liteLLM personnalisé.
Ce qui distingue vraiment dc-artisan, c'est son backend robuste, conçu pour offrir à la fois interopérabilité et flexibilité. Le moteur de l'extension fonctionne sur L'interopérabilité InterSystems IRIS, en utilisant un adaptateur liteLLM personnalisé que nous avons développé.
Cette architecture signifie que vous n'êtes pas lié à un seul fournisseur de modèles linguistiques de grande taille (LLM). Au contraire, vous pouvez vous connecter et passer de manière transparente entre une large gamme de plateformes LLM de premier plan, notamment OpenAI, Gemini, Claude, Azure OpenAI, et bien d'autres, toutes gérées à partir d'un backend unifié de niveau entreprise.
De plus en plus de développeurs découvrent que la suggestion ne consiste pas à deviner les "mots magiques". Il s'agit plutôt de définir des objectifs réfléchis, d'utiliser un langage clair et de fournir un contexte pertinent, en rédigeant des prompts comme des ingénieurs, et non comme des magiciens. Tout comme les luthiers façonnent le bois pour créer des instruments dotés d'une âme, vous pouvez façonner des prompts pour créer des flux de travail IA à la fois fiables et riches en contexte à l'aide d'outils conçus spécialement pour votre métier.
dc-artisan est plus qu'un outil, c'est un changement de mentalité qui passe du codage intuitif à la clarté, la précision et au véritable art numérique.
🎸 Prêt à créer vos propres prompts?
⚙️ Lancez VS Code, installez dc-artisan et commencez à façonner votre IA comme un artisan, pas comme un magicien.
🗳️ Et si vous aimez ce que nous avons créé, votez pour nous dans le cadre du concours InterSystems IRIS Dev Tools Contest. Votre soutien compte beaucoup pour nous!
Bonjour à tous et a toutes,
Nous sommes heureux d'annoncer le nouveau concours de programmation en ligne InterSystems :
🏆 Concours InterSystems sur .Net, Java, Python et JavaScript 🏆
Durée : du 22 septembre au 12 octobre 2025
Prix : 12 000 $
(3).jpg)
Bonjour à tous,
Nous avons le plaisir d’annoncer qu’un membre apprécié de notre communauté, @Antoine.Dh, a participé au concours d'outils de développement InterSystems avec son application PyObjectscript Gen !
Bonjour la communauté,
Il est temps d'annoncer les gagnants du concours d'outils de développement InterSystems !
Merci à tous nos incroyables participants qui ont soumis 17 applications🔥
%20(2)(1).jpg)
Il est maintenant temps d’annoncer les gagnants !
Bonjour à tous et a toutes,
Nous sommes heureux d'annoncer le nouveau concours de programmation en ligne InterSystems dédié à la création d'outils utiles pour faciliter la vie de vos collègues développeurs :
🏆 Concours d'outils de développement InterSystems 🏆
Durée : du 14 juillet au 3 août 2025
Prix : 12 000 $
(1).jpg)
Tel un coup de grâce, sans laisser aucune chance à l'adversaire, Kubernetes, plateforme open source, offre un univers de possibilités grâce à sa disponibilité (c'est-à-dire la facilité d'accès au support, aux services et aux outils). Cette plateforme permet de gérer les tâches et les services dans des conteneurs, ce qui simplifie grandement la configuration et l'automatisation de ces processus.
Justifions l'image du titre et donnons à l'outil en question le nom « correct » : InterSystems Kubernetes Operator.
Le principe est simple : vous choisissez les services et définissez les règles du jeu (en faisant ici encore référence à Knockout), et tout est fourni de la manière la plus transparente et la plus efficace possible, que ce soit pour l'installation, la réparation ou la restauration éventuelle, lorsque les exigences prédéfinies ne sont pas respectées.
Mais qu'est-ce qui différencie IKO des autres opérateurs ? En tant qu'extension de l'API Kubernetes (appelons-la K8s pour faire court), le composant personnalisé IrisCluster permet de déployer un cluster IRIS verrouillé, un cluster Caché distribué ou même une instance anonyme. Le tout sur les plateformes Kubernetes les plus diverses. Enfin, il intègre des fonctionnalités de gestion de cluster InterSystems, permettant d'automatiser certaines tâches en ajoutant des nœuds, ce qui auparavant ne pouvait être réalisé que manuellement.
Tout cela est bien beau, cela fait référence à un sport ou à un jeu, mais pourquoi en ai-je besoin ? La réponse est relativement simple. Je n'ai pas besoin d'IrisCluster pour intégrer InterSystems IRIS à K8s. Cependant, comme K8s est une application autonome, il serait nécessaire de créer les définitions et les éventuels scripts pour configurer ces instances IRIS. IKO automatise ainsi ce processus, facilitant ainsi la maintenance. L'utilisation de conteneurs est un excellent moyen de regrouper ces activités.
Mais, profitant de cette opportunité, savez-vous ce qu'est un conteneur ? Un indice : ce n'est pas qu'un jeu de société.
La réponse est bien plus liée au « transport » d'un package, car il empaquete et isole les applications et les services afin qu'ils puissent être exécutés séparément du reste. Cela facilite le « transport » d'un environnement à un autre, selon les besoins.
En exploitant la vaste documentation d'InterSystems, vous trouverez ci-dessous le lien vers l'installation d'IKO et les étapes de configuration et d'ajustement qui s'ensuivent.
https://docs.intersystems.com/components/csp/docbook/DocBook.UI.Page.cls...
Pour que personne ne s'interroge sur le surnom K8s, le nom Kubernetes vient du grec et signifie ni plus ni moins que pilote ou timonier, autrement dit, celui qui dirige. Le nombre de caractères entre les lettres « K » et « S » est de 8. D'où le nom « K8s ».
Bonjour à tous et a toutes,
Nous sommes heureux d'annoncer le nouveau concours de programmation InterSystems dédié à la santé :
🏆 Concours d'interopérabilité InterSystems FHIR et santé numérique 🏆
Durée : du 12 mai au 1er juin 2025
Prix : 12 000 $
.jpg)
.png)
À mesure que l'automatisation pilotée par l'IA devient un élément essentiel des systèmes d'information modernes, l'intégration des capacités d'IA dans les plateformes existantes doit être transparente et efficace. Le projet IRIS Agent montre comment l'IA générative peut fonctionner sans effort avec InterSystems IRIS, grâce à son puissant cadre d'interopérabilité, sans qu'il soit nécessaire d'apprendre Python ou de créer des workflows d'IA distincts à partir de zéro.
Ce projet examine la manière dont ChatGPT et Anthropic Claude, deux modèles d'IA parmi les plus avancés, peuvent interagir avec IRIS à l'aide de GPT personnalisés et du protocole MCP (Model Context Protocol). Plutôt que de créer des pipelines d'IA isolés, IRIS Agent traite l'IA comme un service d'interopérabilité, permettant ainsi aux organisations d'améliorer l'automatisation, la prise de décision et le traitement des données sans perturber leur architecture existante.
En s'appuyant sur des outils d'interopérabilité natifs d'IRIS, les développeurs peuvent intégrer des modèles d'IA de manière transparente, comme n'importe quel autre composant du système. Cette approche garantit la stabilité, la sécurité, l'évolutivité et l'auditabilité, tout en permettant une interaction en langage naturel, la récupération de données en temps réel et l'administration automatisée du système, le tout dans l'environnement familier d'IRIS.
Le projet IRIS Agent s'appuie sur un ensemble de technologies puissantes pour garantir efficacité, évolutivité et intégration transparente:
Voici à quoi ressemble notre projet sous le capot IRIS:
.png)
La Production comprend les éléments suivants:
Le fonctionnement du service est particulièrement visible dans l'afficheur de messages et les traces. Il peut nous aider à suivre les opérations et à diagnostiquer les problèmes, par exemple les requêtes:
.png)
…et les réponses:
.png)
L'un des points forts de ce projet réside dans le fait que le service LanguageModelIn génère automatiquement une documentation API ouverte pour les opérations métier dans le cadre de la production IRIS Interoperability. Cette API nous permet de connecter facilement les GPT personnalisés à ChatGPT et au serveur MCP (Model Context Protocol) à Claude AI Desktop.
.png)
Après avoir terminé tous les processus d'installation et de configuration, que vous trouverez dans notre fichier ReadMe, ReadMe, demandons à notre agent IRIS GPT d'OpenAI quelles sont ses fonctionnalités actuelles:
Et créez un nouvel utilisateur…
Vérification des mises à jour...
L'une des fonctionnalités remarquables de l'agent IRIS est sa capacité à interroger de manière transparente non seulement les données stockées dans la base de données InterSystems IRIS, mais également des sources de données externes. Dans notre exemple, l'agent s'intègre à l'OpenFDA API pour fournir des informations en temps réel sur les médicaments. Cela permet aux utilisateurs de rechercher des informations sur les médicaments, des rapports de sécurité et des données de conformité réglementaire directement dans le système.
Dans notre projet, l'API offre la possibilité de rechercher des médicaments par leur nom. Recherchons donc les médicaments dont le nom contient le mot "flu".
Si vous souhaitez l'essayer dès maintenant, suivez le lien et engagez une conversation avec notre IRIS Agent démo.
L'une des fonctionnalités clés de l'agent IRIS est sa capacité à interagir avec Claude AI Desktop, un assistant IA local développé par Anthropic. L'intégration est assurée par le protocole MCP (Model Context Protocol), qui facilite la communication entre Claude et les applications externes. Pour ce faire, l'agent IRIS utilise un serveur MCP Node.js dédié qui sert d'intermédiaire, traitant les requêtes entrantes et les acheminant entre Claude et le système IRIS.
Cette configuration permet aux utilisateurs d'interagir directement avec l'agent IRIS via l'interface Claude, en émettant des commandes en langage naturel pour récupérer des données système, gérer les configurations et exécuter des tâches administratives. Le serveur MCP garantit un échange de données fluide, tout en maintenant l'efficacité et la sécurité, et fournit aux administrateurs un assistant puissant basé sur l'IA pour la gestion du système.
Le projet IRIS Agent présente le potentiel de l'automatisation pilotée par l'IA dans les environnements d'entreprise modernes. En intégrant de manière transparente InterSystems IRIS, Claude AI et Custom GPT, il simplifie la gestion des systèmes, améliore l'efficacité et ouvre la voie à de futures innovations. Notre projet démontre également que vous êtes déjà prêt pour la révolution de l'IA avec InterSystems IRIS!
Si vous avez apprécié la découverte d'IRIS Agent et de ses fonctionnalités et que vous souhaitez nous soutenir, veuillez prendre quelques instants pour voter pour notre application ici https://openexchange.intersystems.com/contest/40. Je vous remercie!
Développeurs de projet:
.png)
Banksia Global est une société de conseil technologique de premier plan qui aide les organisations à exploiter pleinement le potentiel des solutions modernes de gestion des données. En mettant l'accent sur la plateforme InterSystems IRIS, Banksia Global fournit des conseils stratégiques, des services d'intégration de systèmes et de développement de logiciels personnalisés à des clients issus de divers secteurs. Son expertise réside dans la fourniture de solutions hautement performantes et évolutives qui permettent aux entreprises de stimuler l'innovation, de rationaliser leurs opérations et de saisir de nouvelles opportunités. Réputée pour son approche collaborative et agile, Banksia Global travaille en étroite collaboration avec ses clients afin de s'assurer que chaque solution est adaptée à leurs besoins spécifiques, favorisant ainsi des partenariats à long terme et une croissance durable.
Bonjour à tous,
Cet article fait suite à la question que j'avais posée à la communauté L'adaptateur UDP ne fonctionne pas
Dans cet article, je vais vous présenter les points suivants
1) Qu'est-ce que "UDP"?
2) L'état actuel d'Iris avec UDP
3) Ma solution avec l'adaptateur UDP
L'acronyme UDP signifie User Datagram Protocol (protocole de datagramme utilisateur). Il s'agit de l'un des principaux protocoles composant la suite IP (Internet Protocol), utilisé pour la transmission de données sur un réseau. Voici quelques fonctionnalités clés de l'UDP:
En général, l'UDP est un protocole léger qui est utile pour des applications spécifiques où une faible latence est essentielle.
Bien entendu, InterSystems IRIS permet d'utiliser ce protocole pour envoyer et recevoir des données.
En tant que protocole REST, il y a deux façons de le faire :
- avec ##class(%Net.UDP).%New().
- avec EnsLib.UDP.OutboundAdapter et EnsLib.UDP.InboundAdapter
Même si la documentation de la classe et très détaillée, voici le lien de la documentation d'InterSystems sur la façon de l'utiliser.
Pour envoyer/recevoir des données, il faut utiliser une instance de class(%Net.UDP).%New() et une méthode associée.
En résumé, pour envoyer des données (sur localhost avec le port 3001) :
SET client = ##class(%Net.UDP).%New()
SET addrbin = ##class(%Net.UDP).GetHostAddr("127.0.0.1")
Set status = client.Send("message text", addrbin, 3001)Pour recevoir des données (sur localhost avec le port 3001) :
Set sobj = ##class(%Net.UDP).%New(3001,"127.0.0.1")
Set data = sobj.Recv()
Ce dernier est plus simple : c'est un adaptateur.
La documentation : EnsLib.UDP.OutboundAdapter et EnsLib.UDP.InboundAdapter
Pour envoyer des données :
Set status = ..Adapter.SendStream(stream)
Pour obtenir des données :
Set status = ..Adapter.Receive(stream)
Cependant, cela ne fonctionne pas. J'ai posé ma question à la communauté "L'adaptateur UDP ne fonctionne pas" et j'ai créé un ticket pour le WRC.
La réponse a été formulée comme suit :
Cet exécutable sous-jacent n'est plus installé dans le produit depuis Ensemble 2018.1.
J'ai vérifié au niveau interne et le JIRA DP-437486 a été soumis pour mettre à jour ces adaptateurs afin d'utiliser la classe %Net.UDP, mais cela sera soumis à l'approbation de la gestion des produits et aux ressources de développement disponibles.
Malheureusement, la seule option possible actuellement est de créer votre propre adaptateur personnalisé en utilisant la classe %Net.UDP.
Voici les deux principales différences entre la classe (%Net.UDP) et l'adaptateur EnsLib.UDP.OutboundAdapter
J'ai donc écrit ma propre méthode (approuvée par le service d'assistance) pour envoyer des données :
/// Adaptateur pour l'envoi de données avec une connexion UDPClass USER.UDP.OutboundAdapter Extends Ens.Adapter
{
/// Hôte du serveur UDPProperty Host As%String [ Required ];/// Port du serveur UDPProperty Port As%Integer [ Required ];/// si 1, le texte qui sera envoyé est affichéProperty UDPTrace As%Integer(VALUELIST = ",0,1") [ InitialExpression = 0, Required ];Parameter SETTINGS = "Host:Basic,Port:Basic,UDPTrace:Basic";/// Envoi de "texte" par le biais de la connexion UDP
Method SendDataText(text As%String) As%Status
{
Try {
Set status = $$$OKIf..UDPTrace=1
{
Do..ShowText(text)
}
<span class="hljs-keyword">Set</span> udpClient = <span class="hljs-keyword">##class</span>(<span class="hljs-built_in">%Net.UDP</span>).<span class="hljs-built_in">%New</span>()
<span class="hljs-keyword">Set</span> addrbin = <span class="hljs-keyword">##class</span>(<span class="hljs-built_in">%Net.UDP</span>).GetHostAddr(<span class="hljs-built_in">..Host</span>)
<span class="hljs-keyword">Set</span> sentBytes = udpClient.Send(text, addrbin, <span class="hljs-built_in">..Port</span>)
}
<span class="hljs-keyword">Catch</span> exception {
<span class="hljs-keyword">Set</span> status = exception.AsStatus()
}
<span class="hljs-keyword">Return</span> status
}
/// Conversion du "stream" en texte et son envoi via la connexion UDP
Method SendDataStream(stream As%Stream.Object) As%Status
{
Try {
Do stream.Rewind()
Set text = ""While 'stream.AtEnd{
Set text = text _ stream.Read()
}
<span class="hljs-keyword">Set</span> status = <span class="hljs-built_in">..SendDataText</span>(text)
}
<span class="hljs-keyword">Catch</span> exception {
<span class="hljs-keyword">Set</span> status = exception.AsStatus()
}
<span class="hljs-keyword">Return</span> status
}
/// Conversion de l'"objet" en json et son envoi via la connexion UDP
Method SendDataJSONObject(object As%RegisteredObject, format As%String = "iw") As%Status
{
Try {
Set status = ##class(%ZEN.Auxiliary.jsonProvider).%WriteJSONStreamFromObject(.stream,object,,,,format)
$$$ThrowOnError(status)
<span class="hljs-keyword">Set</span> status = <span class="hljs-built_in">..SendDataStream</span>(stream)
}
<span class="hljs-keyword">Catch</span> exception {
<span class="hljs-keyword">Set</span> status = exception.AsStatus()
}
<span class="hljs-keyword">Return</span> status
}
/// Un texte est pris en entrée,/// Les traces de l'objet associé sont affichées
Method ShowText(text As%String)
{
Set nbParty = $SYSTEM.SQL.CEILING($LENGTH(text)/1100)
For ii=1:1:nbParty
{
$$$TRACE($EXTRACT(text,ii,ii+1100))
}
}
}
J'espère que cet article a été, sinon utile, du moins intéressant.
Je n'ai pas testé EnsLib.UDP.InboundAdapter, donc n'hésitez pas à ajouter plus d'informations à la discussion.
Corentin
Après tant d'années d'attente, nous avons enfin un pilote officiel disponible sur Pypi
.png)
De plus, j'ai découvert que le pilote JDBC était enfin disponible sur Maven depuis déjà 3 mois, et le pilote .Net driver - surNuget depuis plus d'un mois.
La mise en œuvre de la DB-API et que les fonctions devraient au moins être définies par cette norme. La seule différence devrait se situer au niveau de SQL.
Et ce qui est intéressant dans l'utilisation de bibliothèques existantes, c'est qu'elles ont déjà mis en œuvre d'autres bases de données en utilisant le standard DB-API, et que ces bibliothèques s'attendent déjà à ce que le pilote fonctionne.
J'ai décidé de tester le pilote officiel d'InterSystems en mettant en œuvre son support dans la bibliothèque SQLAlchemy-iris.
Préparez une opération de base de données (requête ou commande) et exécutez-la en fonction de toutes les séquences de paramètres ou de mappages trouvées dans la séquence seq_of_parameters.
Cette fonction très utile permet d'insérer plusieurs lignes à la fois. Commençons par un exemple simple
import iris
host = "localhost"
port = 1972
namespace = "USER"
username = "_SYSTEM"
password = "SYS"
conn = iris.connect(
host,
port,
namespace,
username,
password,
)
with conn.cursor() as cursor:
cursor = conn.cursor()
res = cursor.execute(<span class="hljs-string">"DROP TABLE IF EXISTS test"</span>)
res = cursor.execute(
<span class="hljs-string">"""
CREATE TABLE test (
id IDENTITY NOT NULL,
value VARCHAR(50)
) WITH %CLASSPARAMETER ALLOWIDENTITYINSERT = 1
"""</span>
)
cursor = conn.cursor()
res = cursor.executemany(
<span class="hljs-string">"INSERT INTO test (id, value) VALUES (?, ?)"</span>, [
(<span class="hljs-number">1</span>, <span class="hljs-string">'val1'</span>),
(<span class="hljs-number">2</span>, <span class="hljs-string">'val2'</span>),
(<span class="hljs-number">3</span>, <span class="hljs-string">'val3'</span>),
(<span class="hljs-number">4</span>, <span class="hljs-string">'val4'</span>),
]
)</code></pre>
Cela fonctionne bien, mais que se passe-t-il s'il faut insérer une seule valeur par ligne.
res = cursor.executemany(
"INSERT INTO test (value) VALUES (?)", [
('val1', ),
('val2', ),
('val3', ),
('val4', ),
]
)
Cela conduit malheureusement à une exception inattendue
RuntimeError: Cannot use list/tuple for single values (Impossible d'utiliser une liste/tuple pour des valeurs uniques)
Pour certaines raisons, une seule valeur par ligne est autorisée, et InterSystems demande d'utiliser une méthode différente
res = cursor.executemany(
"INSERT INTO test (value) VALUES (?)", [
'val1',
'val2',
'val3',
'val4',
]
)
De cette façon, cela fonctionne bien
fetchone
Récupère la ligne suivante d'un ensemble de résultats de requête, en renvoyant une seule séquence, ou None lorsqu'il n'y a plus de données disponibles.
Un exemple simple sur sqlite
import sqlite3
con = sqlite3.connect(":memory:")
cur = con.cursor()
cur.execute("SELECT 1 one, 2 two")
onerow = cur.fetchone()
print('onerow', type(onerow), onerow)
cur.execute("SELECT 1 one, 2 two union all select '01' as one, '02' as two")
allrows = cur.fetchall()
print('allrows', type(allrows), allrows)
fournit
onerow <class 'tuple'> (1, 2)
allrows <class 'list'> [(1, 2), ('01', '02')]Et avec le pilote InterSystems
import iris
con = iris.connect(
hostname="localhost",
port=1972,
namespace="USER",
username="_SYSTEM",
password="SYS",
)
cur = con.cursor()
cur.execute("SELECT 1 one, 2 two")
onerow = cur.fetchone()
print("onerow", type(onerow), onerow)
cur.execute("SELECT 1 one, 2 two union all select '01' as one, '02' as two")
allrows = cur.fetchall()
print("allrows", type(allrows), allrows)
par certaines raisons fournit
onerow <class 'iris.dbapi.DataRow'> <iris.dbapi.DataRow object at 0x104ca4e10>
allrows <class 'tuple'> ((1, 2), ('01', '02'))Qu'est-ce que DataRow, et pourquoi ne pas utiliser un tuple ou au moins une liste
SLa norme décrit une variété de classes d'exceptions que le pilote est censé utiliser, au cas où quelque chose ne fonctionnerait pas. Or, le pilote InterSystems ne les utilise pas du tout, se contentant de déclencher une erreur RunTime pour toute raison, ce qui, de toute façon, est contraire à la norme.
L'application peut s'appuyer sur le type d'exception qui se produit et se comporter en conséquence. Mais le pilote InterSystems ne fournit aucune différence. Par ailleurs, SQLCODE serait utile, mais il doit être extrait du message d'erreur
Conclusion
Au cours des tests, j'ai donc trouvé plusieurs bogues
- Erreurs aléatoires survenant à tout moment <LIST ERROR> Format de liste incorrect, type non supporté pour IRISList; Détails : type détecté : 32
- fonctionnent correctement, si vous réessayez juste après l'erreur
- Des erreurs de segmentation ont été détectées, je ne sais même pas comment cela se produit
- Résultat inattendu de la fonction fetchone
- Fonctionnement inattendu de la fonction executemany, pour une seule ligne de valeur
- Les exceptions ne sont pas du tout implémentées, des exceptions différentes devraient être générées en cas d'erreurs différentes, et les applications s'appuient sur ces exceptions
- Python intégré peut être interrompu en cas d'installation à côté d'IRIS
- en raison du même nom utilisé par Python intégré et ce pilote, il remplace ce qui est déjà installé avec IRIS et peut l'interrompre
SQLAlchemy-iris supporte maintenant le pilote officiel d'InterSystems, mais ceci en raison d'une incompatibilité avec Python intégré et de plusieurs bogues découverts lors des tests. Installation à l'aide de cette commande, avec l'option définie
pip install sqlalchemy-iris[intersystems]
Et pour une utilisation simple, l'URL devrait être iris+intersystems://
from sqlalchemy import Column, MetaData, Table
from sqlalchemy.sql.sqltypes import Integer, VARCHAR
from sqlalchemy import create_engine
from sqlalchemy.orm import DeclarativeBase
DATABASE_URL = "iris+intersystems://_SYSTEM:SYS@localhost:1972/USER"
engine = create_engine(DATABASE_URL, echo=True)
# Create a table metadata
metadata = MetaData()
classBase(DeclarativeBase):passdefmain():
demo_table = Table(
"demo_table",
metadata,
Column("id", Integer, primary_key=True, autoincrement=True),
Column("value", VARCHAR(50)),
)
demo_table.drop(engine, checkfirst=<span class="hljs-keyword">True</span>)
demo_table.create(engine, checkfirst=<span class="hljs-keyword">True</span>)
<span class="hljs-keyword">with</span> engine.connect() <span class="hljs-keyword">as</span> conn:
conn.execute(
demo_table.insert(),
[
{<span class="hljs-string">"id"</span>: <span class="hljs-number">1</span>, <span class="hljs-string">"value"</span>: <span class="hljs-string">"Test"</span>},
{<span class="hljs-string">"id"</span>: <span class="hljs-number">2</span>, <span class="hljs-string">"value"</span>: <span class="hljs-string">"More"</span>},
],
)
conn.commit()
result = conn.execute(demo_table.select()).fetchall()
print(<span class="hljs-string">"result"</span>, result)
main()
En raison de bogues dans le pilote InterSystems, certaines fonctionnalités peuvent ne pas fonctionner comme prévu. J'espère que cela sera corrigé à l'avenir
IRIS propose une fonctionnalité dédiée à la gestion des documents JSON, appelée DocDB.
Plateforme de données DocDB d'InterSystems IRIS® est une fonctionnalité permettant de stocker et de récupérer des données de base de données. Elle est compatible avec le stockage et la récupération de données de tables et de champs SQL traditionnels (classe et propriété), mais en est distincte. Elle est basée sur JSON (JavaScript Object Notation) qui prend en charge l'échange de données sur le Web. InterSystems IRIS prend en charge le développement de bases de données et d'applications DocDB en REST et en ObjectScript, ainsi que le support SQL pour la création ou l'interrogation de données DocDB.
De par sa nature, la base de données documentaire InterSystems IRIS est une structure de données sans schéma. Cela signifie que chaque document a sa propre structure, qui peut différer de celle des autres documents de la même base de données. Cela présente plusieurs avantages par rapport au SQL, qui nécessite une structure de données prédéfinie.
Le mot « document » est utilisé ici comme un terme technique spécifique à l'industrie, en tant que structure de stockage de données dynamique. Le « document », tel qu'utilisé dans DocDB, ne doit pas être confondu avec un document textuel ou avec la documentation.
Voyons comment DocDB peut permettre de stocker JSON dans la base de données et de l'intégrer dans des projets qui reposent uniquement sur des protocoles xDBC.
DocDB définit deux composants clés:
Passons maintenant à la création de notre première table, ou plutôt de notre première « base de données ». Il semble que l'on ne s'attendait pas à la création d'une base de données DocDB.Database uniquement à l'aide de SQL. Par conséquent, il n'est pas possible de créer une nouvelle « base de données » en utilisant uniquement SQL. Pour le vérifier, nous allons utiliser une approche ObjectScript classique. Voici un exemple de définition d'une classe qui étend %DocDB.Document:
Class User.docdb Extends%DocDB.Document [ DdlAllowed ]
{
}
La vérification de la table nouvellement créée à l'aide de SQL permet de s'assurer de son bon fonctionnement.
.png)
Il est temps de faire un premier essai et d'insérer quelques données
.png)
Nous pouvons insérer n'importe quelles données sans validation, ce qui signifie qu'il n'y a aucune restriction sur ce qui peut être inséré dans %Doc. La mise en place d'une validation serait bénéfique.
La base de données %DocDB.Database permet d'extraire des propriétés des documents et de les rendre disponibles sous forme de colonnes dédiées. Cela permet également d'effectuer une indexation sur ces propriétés.
Il faudrait d'abord obtenir la base de données.
USER>set docdb=##class(%DocDB.Database).%GetDatabase("User.docdb")
<THROW>%GetDatabase+5^%DocDB.Database.1 *%Exception.StatusException ERROR #25351: DocDB Database 'User.docdb' does not exist.
USER 2e1>w $SYSTEM.DocDB.Exists("User.docdb")
0
Euh, la base de données "n'existe pas", d'accord, créons-la alors
USER>set docdb=##class(%DocDB.Database).%CreateDatabase("User.docdb")
<THROW>%CreateDatabase+13^%DocDB.Database.1 *%Exception.StatusException ERROR #25070: The generated class name for the database 'User.docdb' conflicts with another class: User.docdb
USER 2e1>
Ainsi, une simple définition de classe ne suffit pas. Il faut utiliser %DocDB.Database dès le début, ce qui n'est pas pratique, surtout lors de l'utilisation du contrôle de code source.
Pour résoudre ce problème, nous supprimons la classe existante et créons correctement la base de données:
USER>do $system.OBJ.Delete("User.docdb")
Deleting class User.docdb
USER>set docdb=##class(%DocDB.Database).%CreateDatabase("User.docdb")
USER>zwrite docdb
docdb=6@%DocDB.Database ; <OREF,refs=1>
+----------------- general information ---------------
| oref value: 6
| class name: %DocDB.Database
| %%OID: $lb("3","%DocDB.Database")
| reference count: 1
+----------------- attribute values ------------------
| %Concurrency = 1 <Set>
| ClassName = "User.docdb"
| DocumentType = ""
| Name = "User.docdb"
| Resource = ""
| SqlNameQualified = "SQLUser.docdb"
+-----------------------------------------------------
Cette fois, cela fonctionne et les données précédemment insérées restent intactes.
Supposons que nous ayons un document comme celui-ci
{"name":"test", "some_value":12345}Extrayons ces deux champs à l'aide de la méthode %CreateProperty
USER>do docdb.%CreateProperty("name","%String","$.name",0)
USER>do docdb.%CreateProperty("someValue","%String","$.some_value",0)
Et vérifions la table
.png)
En vérifiant cette table, nous constatons que deux nouvelles colonnes ont été ajoutées, mais que celles-ci contiennent des valeurs nulles. Il semble que ces propriétés ne s'appliquent pas rétroactivement aux données existantes. Si un développeur ajoute ultérieurement des propriétés et des index à des fins d'optimisation, les données existantes ne refléteront pas automatiquement ces modifications.
.png)
Mettez à jour en utilisant la même valeur et vérifiez si %doc est json. Et nous obtenons notre valeur.
Jetons maintenant un coup d'œil à la classe, qui est entièrement créée et mise à jour par %DocDB.Database
Class User.docdb Extends%DocDB.Document [ Owner = {irisowner}, ProcedureBlock ]
{
Property name As%String [ SqlComputeCode = { set {}=$$%EvaluatePathOne^%DocDB.Document({%Doc},"$.name")
}, SqlComputed, SqlComputeOnChange = %Doc ];Property someValue As%String [ SqlComputeCode = { set {}=$$%EvaluatePathOne^%DocDB.Document({%Doc},"$.some_value")
}, SqlComputed, SqlComputeOnChange = %Doc ];
Index name On name;
Index someValue On someValue;
}
Ainsi, les propriétés créées contiennent un code pour extraire la valeur de %Doc, et oui, elles ne sont remplies que lorsque %Doc est modifié. Et des index ont été créés pour les deux champs, sans que personne ne le demande. Le fait d'avoir de nombreuses valeurs extraites augmentera l'utilisation des variables globales simplement par le nombre d'index.
Il sera possible de mettre à jour ces propriétés créées, sans nuire au %Doc original, mais les valeurs deviendront inutiles.
.png)
Chaîne vide ou tout texte non-json.
.png)
Réponse franchement moche, rien à ajouter, la validation des tentatives d'insertion de quelque chose d'illégal dans une table semble raisonnable, donc, le message d'erreur serait au moins quelque chose de significatif.
La base de données %DocDB.Database avec une méthode %GetProperty
USER>zw docdb.%GetPropertyDefinition("someValue")
{"Name":"someValue","Type":"%Library.String"} ; <DYNAMIC OBJECT>
USER>zw docdb.%GetPropertyDefinition("name")
{"Name":"name","Type":"%Library.String"} ; <DYNAMIC OBJECT>
Le chemin d'accès à la valeur qui a été utilisé dans %CreateProperty a disparu, il n'y a aucun moyen de le valider. Si le chemin d'accès est incorrect, pour le mettre à jour, il faut d'abord appeler %DropProperty puis à nouveau %CreateProperty.
%%DocDB.Database vous permet de rechercher des documents
Pour trouver un ou plusieurs documents dans une base de données et renvoyer ceux-ci au format JSON, appelez la méthode %FindDocuments(). Cette méthode accepte n'importe quelle combinaison de trois prédicats positionnels facultatifs : une matrice de restriction, une matrice de projection et une paire clé/valeur limite.
Plus important encore, %FindDocuments ne se soucie pas de %Doc lui-même, il ne fonctionne que sur les propriétés. Assez fragile, il lève des exceptions sur tout ce qui ne correspond pas à ce qui est attendu. En fait, il construit simplement une requête SQL et l'exécute.
USER>do docdb.%FindDocuments(["firstName","B","%STARTSWITH"]).%ToJSON()<THROW>%FindDocuments+37^%DocDB.Database.1 *%Exception.StatusException ERROR #25541: DocDB Property 'firstName' does not exist in 'User.docdb'
USER>do docdb.%FindDocuments(["name","test","in"],["name"]).%ToJSON()
{"sqlcode":100,"message":null,"content":[{"name":"test"}]} USER>do docdb.%FindDocuments(["name","","in"],["name"]).%ToJSON()
<THROW>%FindDocuments+37^%DocDB.Database.1 *%Exception.SQL -12 -12 A term expected, beginning with either of: identifier, constant, aggregate, $$, (, :, +, -, %ALPHAUP, %EXACT, %MVR %SQLSTRING, %SQLUPPER, %STRING, %TRUNCATE, or %UPPER^ SELECT name FROM SQLUser . docdb WHERE name IN ( )
USER>do docdb.%FindDocuments(["name","test","="]).%ToJSON()
{"sqlcode":100,"message":null,"content":[{"%Doc":"{"name":"test", "some_value":12345}","%DocumentId":"1","%LastModified":"2025-02-05 12:25:02.405"}]} USER 2e1>do docdb.%FindDocuments(["Name","test","="]).%ToJSON()
<THROW>%FindDocuments+37^%DocDB.Database.1 *%Exception.StatusException ERROR #25541: DocDB Property 'Name' does not exist in 'User.docdb'
USER>do docdb.%FindDocuments(["%Doc","JSON","IS"]).%ToJSON()
<THROW>%FindDocuments+37^%DocDB.Database.1 *%Exception.StatusException ERROR #25540: DocDB Comparison operator is not valid: 'IS' USER 2e1>do docdb.%FindDocuments(["%Doc","","IS JSON"]).%ToJSON()
<THROW>%FindDocuments+37^%DocDB.Database.1 *%Exception.StatusException ERROR #25540: DocDB Comparison operator is not valid: 'IS JSON'
L'utilisation de SQL simple serait bien plus fiable
Un autre aspect très intéressant est l'efficacité avec laquelle JSON est enregistré dans la base de données.
^poCN.bvx3.1(1)=$lb("","2025-02-05 12:25:02.405","test",12345)
^poCN.bvx3.1(1,"%Doc")="{""name"":""test"", ""some_value"":12345}"
^poCN.bvx3.1(2)=$lb("","2025-02-05 12:25:02.405")
^poCN.bvx3.1(2,"%Doc")="[1,2,3]"
^poCN.bvx3.1(3)=$lb("","2025-02-05 12:01:18.542")
^poCN.bvx3.1(3,"%Doc")="test"
^poCN.bvx3.1(4)=$lb("","2025-02-05 12:01:19.445")
^poCN.bvx3.1(4,"%Doc")=$c(0)
^poCN.bvx3.1(5)=$lb("","2025-02-05 12:01:20.794")Le JSON est stocké sous forme de texte brut, tandis que d'autres bases de données utilisent des formats binaires pour un enregistrement et une recherche plus efficaces. La base de données DocDB d'IRIS ne prend pas en charge la recherche directe dans le contenu des documents, sauf si JSON_TABLE est utilisé, ce qui nécessite tout de même l'analyse du JSON dans un format binaire interne.
Dans la version 2025.1, %DynamicAbstractObject introduit les méthodes %ToPVA et %FromPVA, ce qui semble enregistrer le JSON dans un format binaire.
USER>do ({"name":"value"}).%ToPVA($name(^JSON.Data(1)))
USER>zw ^JSON.Data
^JSON.Data(1,0,0)="PVA1"$c(134,0,6,0,2,0,0,0,0,0,14,0,15,0,2,0,21,9,6,136,0,1,6,0,1,0,2,1,137,0,1,5,8,1,6)"value"$c(6,0,6)"name"_$c(5)
USER>zw {}.%FromPVA($name(^JSON.Data(1)))
{"name":"value"} ; <DYNAMIC OBJECT,refs=1>
Cependant, le traitement de certaines structures présente des incohérences.
USER>do ({}).%ToPVA($name(^JSON.Data(1)))
<SYSTEM>%ToPVA+1^%Library.DynamicAbstractObject.1
USER>do ({"name":{}}).%ToPVA($name(^JSON.Data(1)))
<SYSTEM>%ToPVA+1^%Library.DynamicAbstractObject.1
Actuellement, %DocDB n'est vraiment pratique qu'avec ObjectScript et a des limites en SQL. Des problèmes de performances apparaissent lorsqu'il s'agit de traiter de grands ensembles de données. Tout ce que %DocDB offre peut être réalisé en utilisant du SQL de base tout en conservant un support SQL complet. Compte tenu de l'implémentation actuelle, il y a peu d'intérêt à utiliser DocDB plutôt que des approches SQL de base.
L'API REST avec Swagger dans InterSystems IRIS
Salut
Le protocole HTTP permet de récupérer des ressources, telles que des documents HTML. Il est à la base de tout échange de données sur le Web et constitue un protocole client-serveur, ce qui signifie que les requêtes sont initiées par le destinataire, généralement un navigateur Web.
Les API REST tirent parti de ce protocole pour échanger des messages entre le client et le serveur. Cela rend les API REST rapides, légères et flexibles. Les API REST utilisent les verbes HTTP GET, POST, PUT, DELETE et d'autres pour indiquer les actions qu'elles veulent effectuer.
Lorsque nous appelons une API REST, il s'agit en réalité d'un appel HTTP. L'API reçoit cet appel et, conformément au verbe et au chemin demandés, elle effectue l'action souhaitée. Dans le cas de l'implémentation d'Iris, nous pouvons le voir clairement dans la zone de définition de l'URLMap:
XData UrlMap
{
<Routes>
<Route Url="/cliente" Method="POST" Call="Incluir" Cors="true"/>
<Route Url="/cliente/:chave" Method="PUT" Call="Alterar" Cors="true"/>
<Route Url="/cliente/:chave" Method="DELETE" Call="Deletar" Cors="true"/>
<Route Url="/cliente/:chave" Method="GET" Call="Pesquisar" Cors="true"/>
<Route Url="/cliente" Method="GET" Call="Listar" Cors="true"/>
<Route Url="/openapi" Method="GET" Call="OpenAPI" Cors="true"/>
<Route Url="/test" Method="GET" Call="Test" Cors="true"/>
</Routes>
}
Notez que nous avons le chemin (Url) et le verbe (Method) définis pour chaque appel (Call). Ainsi, le code qui rencontre l'API sait ce qu'il doit faire.
Cette structure de l'API REST ne sert pas seulement à acheminer les actions qui arrivent à l'API.
Elle sert également de base à la création du fichier Swagger de l'API, comme on peut le voir dans la documentation de la classe %REST.API,méthode GetWebRESTApplication: https://docs.intersystems.com/irislatest/csp/documatic/%25CSP.Documatic.cls?LIBRARY=%25SYS&CLASSNAME=%25REST.API#GetWebRESTApplication
Examinons maintenant comment générer cette documentation.
Commençons par publier notre API. Utilisons la même API que dans l'article https://community.intersystems.com/post/using-rest-api-flask-and-iam-intersystems-iris-part-1-rest-api
Il suffit de suivre les instructions et d'utiliser le code que l'article fournit pour avoir notre API publiée.
Une fois l'API publiée, nous inclurons un nouvel chemin dans URLMap et une nouvelle méthode dans notre code:
<Route Url="/openapi" Method="GET" Call="OpenAPI" Cors="true"/>
ClassMethod OpenAPI() As %Status
{
Do ##class(%REST.Impl).%SetContentType("application/json")
Set sc = ##class(%REST.API).GetWebRESTApplication("", "/rest/servico", .swagger)
If $$$ISERR(sc) {
Quit sc // If an error occurred, exit the method
}
Write swagger.%ToJSON()
Quit $$$OK
}
Incluez le nouvel chemin et la méthode qui lui est associée dans votre code API. Passons maintenant au test. Ouvrons Postman et appelons l'endpoint de génération de Swagger, qui est /openapi:
Ci-dessous, nous avons la définition complète du Swagger généré par notre appel:
{
"info": {
"title": "",
"description": "",
"version": "",
"x-ISC_Namespace": "DEMO"
},
"basePath": "/rest/servico",
"paths": {
"/customer": {
"post": {
"parameters": [
{
"name": "payloadBody",
"in": "body",
"description": "Request body contents",
"required": false,
"schema": {
"type": "string"
}
}
],
"operationId": "Include",
"x-ISC_ServiceMethod": "Include",
"x-ISC_CORS": true,
"responses": {
"default": {
"description": "(Unexpected Error)"
},
"200": {
"description": "(Expected Result)"
}
}
},
"get": {
"operationId": "List",
"x-ISC_ServiceMethod": "List",
"x-ISC_CORS": true,
"responses": {
"default": {
"description": "(Unexpected Error)"
},
"200": {
"description": "(Expected Result)"
}
}
}
},
"/customer/{key}": {
"put": {
"parameters": [
{
"name": "key",
"in": "path",
"required": true,
"type": "string"
},
{
"name": "payloadBody",
"in": "body",
"description": "Request body contents",
"required": false,
"schema": {
"type": "string"
}
}
],
"operationId": "Change",
"x-ISC_ServiceMethod": "Change",
"x-ISC_CORS": true,
"responses": {
"default": {
"description": "(Unexpected Error)"
},
"200": {
"description": "(Expected Result)"
}
}
},
"delete": {
"parameters": [
{
"name": "key",
"in": "path",
"required": true,
"type": "string"
}
],
"operationId": "Delete",
"x-ISC_ServiceMethod": "Delete",
"x-ISC_CORS": true,
"responses": {
"default": {
"description": "(Unexpected Error)"
},
"200": {
"description": "(Expected Result)"
}
}
},
"get": {
"parameters": [
{
"name": "key",
"in": "path",
"required": true,
"type": "string"
}
],
"operationId": "Search",
"x-ISC_ServiceMethod": "Search",
"x-ISC_CORS": true,
"responses": {
"default": {
"description": "(Unexpected Error)"
},
"200": {
"description": "(Expected Result)"
}
}
}
},
"/openapi": {
"get": {
"operationId": "OpenAPI",
"x-ISC_ServiceMethod": "OpenAPI",
"x-ISC_CORS": true,
"responses": {
"default": {
"description": "(Unexpected Error)"
},
"200": {
"description": "(Expected Result)"
}
}
}
},
"/test": {
"get": {
"operationId": "Test",
"x-ISC_ServiceMethod": "Test",
"x-ISC_CORS": true,
"responses": {
"default": {
"description": "(Unexpected Error)"
},
"200": {
"description": "(Expected Result)"
}
}
}
}
},
"Swagger": "2.0"
}
Le lien suivant nous permet d'accéder à la documentation d'Iris qui pointe vers un outil qui reçoit le résultat de notre appel API et le transforme en une interface conviviale pour la documentation et le test du service: https://docs.intersystems.com/irislatest/csp/docbook/DocBook.UI.Page.cls?KEY=GREST_discover_doc#GREST_gendoc
Exécutons cette URL et fournissons le chemin pour récupérer la définition Swagger de notre API: https://swagger.io/tools/swagger-ui/
Remplaçons l'appel de démonstration sur la page (l'appel petstore) par notre appel: http://127.0.0.1/iris_iss/rest/servico/openapi et voyons l'écran avec la documentation Swagger générée:
En haut de l'appel, nous avons les informations de base de notre API:
Nous pouvons également naviguer dans les appels et consulter des informations importantes, comme dans l'appel POST pour inclure un nouvel utilisateur:
Mais, comme nous l'avons vu un peu plus haut, la définition Swagger est en réalité un fichier au format JSON qui nous est disponible sous la forme d'un %DynamicObject (voir la documentation dans https://docs.intersystems.com/irislatest/csp/documatic/%25CSP.Documatic.cls?LIBRARY=%25SYS&CLASSNAME=%25Library.DynamicObject) après le ##class(%REST.API).GetWebRESTApplication() que nous effectuons dans notre méthode OpenAPI. De cette façon, en nous basant sur la définition de l'OpenAPI 2.0, nous pouvons inclure ou supprimer des renseignements de notre Swagger. Enrichissons, par exemple, les renseignements de base de l'API. Selon la définition de la version 2.0 (https://swagger.io/specification/v2/ ), les informations suivantes peuvent être mises à disposition:
Complétons alors les informations que nous pouvons rendre disponibles. Pour ce faire, nous allons modifier notre méthode OpenAPI, en incluant les informations de base, le protocole accepté, l'authentification et les données d'accès (hôte et basePath):
ClassMethod OpenAPI() As %Status
{
Do ##class(%REST.Impl).%SetContentType("application/json")
Set sc = ##class(%REST.API).GetWebRESTApplication("", "/rest/servico", .swagger)
If $$$ISERR(sc) {
Quit sc // If an error occurred, exit the method
}
Set info = {
"title": "Cliente",
"description": "API de Manipulação de Cliente",
"version": "1.00"
}
Do swagger.%Set("info", info)
Do swagger.%Set("host", "127.0.0.1")
Do swagger.%Set("basePath", "/iris_iss/rest/servico")
Set schemes = []
Do schemes.%Push("http")
Do swagger.%Set("schemes", schemes)
Set security = [{"basicAuth":[]}]
Do swagger.%Set("security", security)
Set securityDefinitions = {}
Do securityDefinitions.%Set("basicAuth", {})
Do securityDefinitions.basicAuth.%Set("type", "basic")
Do swagger.%Set("securityDefinitions", securityDefinitions)
Write swagger.%ToJSON()
Quit $$$OK
}
Si nous appelons à nouveau la documentation Swagger sur la page d'aperçu, nous avons maintenant le résultat suivant:
Veillez à ce que notre documentation soit beaucoup plus complète, avec des informations plus détaillées sur l'API, telles que le mécanisme d'authentification (Basic Auth), le protocole accepté (HTTP) et les définitions de version, de description et d'URL.
Nous pouvons désormais enrichir la définition des appels en mettant la structure attendue dans les payloads et les exemples de données pour l'appel. Pour ce faire, superposons les informations dans les chemins pour "/client":
ClassMethod OpenAPI() As %Status
{
Do ##class(%REST.Impl).%SetContentType("application/json")
Set sc = ##class(%REST.API).GetWebRESTApplication("", "/rest/servico", .swagger)
If $$$ISERR(sc) {
Quit sc // If an error occurred, exit the method
}
Set info = {
"title": "Cliente",
"description": "API de Manipulação de Cliente",
"version": "1.00"
}
Do swagger.%Set("info", info)
Do swagger.%Set("host", "127.0.0.1")
Do swagger.%Set("basePath", "/iris_iss/rest/servico")
Set schemes = []
Do schemes.%Push("http")
Do swagger.%Set("schemes", schemes)
Set security = [{"basicAuth":[]}]
Do swagger.%Set("security", security)
Set securityDefinitions = {}
Do securityDefinitions.%Set("basicAuth", {})
Do securityDefinitions.basicAuth.%Set("type", "basic")
Do swagger.%Set("securityDefinitions", securityDefinitions)
Set incluirPesquisar = {
"post": {
"summary": "Criar um novo cliente",
"description": "Recebe os dados de um cliente e cadastra no sistema.",
"parameters": [
{
"name": "body",
"in": "body",
"required": true,
"schema": {
"type": "object",
"properties": {
"nome": {
"type": "string",
"description": "Nome do cliente"
},
"idade": {
"type": "integer",
"description": "Idade do cliente"
}
},
"required": ["nome", "idade"],
"example": {
"nome": "João Silva",
"idade": 30
}
}
}
],
"responses": {
"default": {
"description": "Falha na chamada da API"
},
"200": {
"description": "Cliente criado com sucesso"
},
"406": {
"description": "Falha na inclusão do cliente"
}
}
},
"get": {
"summary": "Recupera todos os clientes",
"description": "Retorna a lista de clientes com suas informações.",
"responses": {
"default": {
"description": "Falha na chamada da API"
},
"200": {
"description": "Lista de clientes",
"schema": {
"type": "object",
"properties": {
"clientes": {
"type": "array",
"items": {
"type": "object",
"properties": {
"chave": {
"type": "string",
"description": "Chave única do cliente"
},
"nome": {
"type": "string",
"description": "Nome do cliente"
},
"idade": {
"type": "integer",
"description": "Idade do cliente"
}
},
"required": ["chave", "nome", "idade"]
}
}
},
"example": {
"clientes": [
{
"chave": "1",
"nome": "Maria",
"idade": 35
},
{
"chave": "2",
"nome": "Julio",
"idade": 57
},
{
"chave": "4",
"nome": "Julia",
"idade": 25
},
{
"chave": "5",
"nome": "Julia",
"idade": 22
}
]
}
}
}
}
}
}
Do swagger.paths.%Set("/cliente", incluirPesquisar)
Write swagger.%ToJSON()
Quit $$$OK
}
En rappelant la page de documentation, nous pouvons maintenant voir les méthodes POST pour inclure un client, et GET pour récupérer une liste:
Notez que nous avons déjà une explication de chacune des méthodes disponibles pour POST et GET qui ont été remplacées.
Notez que nous n'avons plus non plus les balises "x-ISC_ServiceMethod" and "x-ISC_Namespace" qui n'ont pas été incluses dans notre nouvelle définition.
En cliquant pour développer la méthode POST par exemple, nous disposons maintenant visuellement d'un exemple d'appel (Valeur d'exemple):
Et le format du payload de l'appel (Modèle):
Dans le cas de la récupération pour les utilisateurs, nous avons la définition de la réponse renvoyée avec un exemple:
Ainsi qu'avec le modèle prévu comme réponse:
Nous pouvons également tester les appels API à partir de la page de documentation elle-même. Pour cela, le bouton “Try it out” (Essayez-le) doit être disponible sur la page. Appuyez-le , puis appuyez sur Execute et vous verrez le résultat:
Les possibilités de l'approche Code-first d'une API REST ouvrent de nombreuses possibilités de documentation, nous permettant de contrôler ce qui sera diffusé, en ajoutant ou en supprimant les informations que nous jugeons utiles dans le matériel publié.
La définition de l'OpenAPI est très complète et détaillée. Il existe une variété d'informations que nous pouvons inclure ou retirer, selon nos besoins ou ce que nous voulons y rendre disponible.
À très bientôt!
.png)
Si votre besoin concerne les interactions entre le client et l'application (et par conséquent la base de données), le Dynamic SQL peut être plus approprié, car il s'adapte très facilement à ces changements de requête. Cependant, ce dynamisme a un coût : à chaque nouvelle requête, elle est remodelée, ce qui peut entraîner un coût d'exécution plus élevé. Voici un exemple simple d'extrait de code Python.
Bonjour à tous,
Voici le premier concours de programmation de l'année, et une surprise vous attend ! Lisez la suite !
🏆 Concours de programmation InterSystems IA : Recherche vectorielle, GenAI et agents IA 🏆
Durée : du 17 mars au 6 avril 2025
Prix : 12 000 $ + une chance d'être invité au Sommet mondial 2025 !
.jpg)
Bonjour la communauté,
Nous avons des nouvelles passionnantes ! Il est temps de participer au prochain concours d'écriture InterSystems :
✍️ Concours d'articles techniques en anglais 2025 ✍️
Rédigez un article sur n'importe quel sujet lié aux produits et services InterSystems.
🎁 Des prix pour tous : Un prix spécial pour chaque auteur participant au concours !
Préférez-vous ne pas lire? Regardez la vidéo de démonstration que j'ai créée:
<iframe allowfullscreen="" frameborder="0" height="360" src="https://www.youtube.com/embed/-OwOAHC5b3s" width="640"></iframe>
En tant que développeur d'interfaces, je reçois souvent des questions qui nécessitent d'étudier de grandes quantités de messages. Par exemple, lors d'une réunion récente, notre chef de projet m'a demandé combien de sites utilisaient réellement notre nouvelle interface de commandement.
D'habitude, j'essaie de copier la sortie de la visionneuse de messages pour la coller dans Excel ou simplement d'exécuter un rapport de messages pour chaque site qui passe des commandes et d'utiliser le nombre de messages renvoyés…
Cette fois-ci, en utilisant l'extension de navigateur Iris Whiz browser extension j'avais des options.
Option 1 - Simple: Exportation de CSV
Une idée mise en œuvre à partir du portail InterSystems Ideas, il suffit de cliquer sur le bouton Export (Exporter) en tant que CSV dans la barre de boutons d'IRIS Whiz pour télécharger la recherche en cours en tant que fichier CSV pour une manipulation facile d'Excel/Sheets.
Option 2 - Chic: Analyse
Dans ce cas, je venais de compléter l'outil d'analyse dans mon extension de navigateur Iris Whiz.
En ajoutant la valeur PV1-3.2 à mes critères de recherche de messages dans la visionneuse de messages (Message Viewer), j'ai pu facilement exécuter le rapport, cliquer sur Analyse et avoir instantanément les renseignements sous la forme d'un simple diagramme en forme de beignet - aucune exportation n'a été nécessaire.
Ensuite, le chef de projet a voulu savoir quels types d'examens étaient commandés par ces sites. J'ai ajouté la valeur OBR-4.2 à mes critères de recherche et j'ai relancé le rapport. En cliquant sur le bouton d'analyse, j'ai pu voir les sites qui passaient commande et les examens commandés. (Chaque critère de recherche de message est présenté sous la forme d'un graphique en anneau, étiqueté à la fin de la partie graphique de la page d'analyse)
La troisième question se pose.
Quelles commandes sont passées par quels sites?
En cliquant sur le site voulu dans le graphique interactif en anneau, j'ai pu visualiser les données dans la visionneuse de données de la page d'analyse. Un autre clic sur le bouton de filtrage à l'intérieur de cette boîte applique cette sélection de données comme filtre à tous les graphiques - ce qui signifie que le graphique en anneau des examens ne montre plus que les examens commandés pour ce site.
Graphique de site et graphique d'examen filtré par site:
Et enfin, la question la plus difficile.
Quand tout cela se produit-il?
Passer en revue les messages dans la page de visualisation des messages pour voir quand les commandes sont passées n'est pas une bonne idée...
Heureusement, j'ai ajouté une chronologie à la page d'analyse.
J'ai supprimé le filtre et cliqué sur le bouton 'Show on Line Graph' (Affichage du graphique linéaire) (activé pour le graphique PV1-3 dans la capture d'écran ci-dessus) afin d'afficher les données du site sur le graphique chronologique en haut de la page.
Une rapide capture d'écran nous a permis d'envoyer ce rapport à nos sites afin qu'ils puissent confirmer le nombre de commandes pour chaque jour et s'assurer que tout fonctionnait comme prévu.
Ces rapports devaient être exécutés chaque semaine, mais heureusement pour moi, cette tâche avait été simplifiée, notamment grâce à la fonction de recherche sauvegardée dans la page de visualisation des messages, qui me permettait de ne jamais avoir à me soucier des critères de recherche à ajouter.
Conclusions
1. Données sensibles:
Les données de votre recherche dans la visionneuse de messages (Message Viewer) sont envoyées dans un nouvel onglet du navigateur et disparaissent dès que l'onglet est fermé - vous n'avez donc pas à vous soucier de l'enregistrement de données sensibles dans le navigateur. Si vous souhaitez enregistrer un rapport utilisez la fonctionnalité par défaut d'InterSystems pour les recherches enregistrées et exécutez simplement le rapport à nouveau à une date ultérieure. J'avais prévu un mécanisme d'enregistrement des recherches à partir de la page d'analyse, mais il n'a pas été retenu dans cette version.
2. Vitesse:
La page d'analyse est alimentée par la recherche de messages et je n'ai pas mis de limites strictes à la quantité de données pouvant être affichées. Plus vous ajoutez de messages et de critères de recherche, plus la page d'analyse ralentira. C'est pourquoi j'ai ajouté une fenêtre contextuelle si vous essayez de charger plus de 200 messages, ce qui vous permet de choisir de charger ou non le diagramme à barres en haut de la page.
Le diagramme à barres présente chaque message sous la forme d'une case à sélectionner. En cliquant sur une case du diagramme, le message est ajouté à la liste des messages sélectionnés dans la fenêtre de visualisation des données (à gauche de la page). Vous pouvez alors cliquer sur le bouton 'View Selected Messages' (Voir les messages sélectionnés) pour ouvrir ces messages dans une nouvelle page et profiter des fonctionnalités de comparaison des messages de l'extension.
Lorsque vous cliquez sur ce bouton, essayez de ne pas sélectionner trop de messages. Un maximum de 10 devrait suffire.
Si vous téléchargez le diagramme à barres avec de grands ensembles de données (10 000), cela ne sera certainement pas bon pour votre navigateur, mais je vous laisse le soin de choisir.
Lors du dernier concours InterSystems "Bringing Ideas to Reality", j'ai parcouru le portail d'idées à la recherche de problèmes d'interface utilisateur à traiter.
<iframe allowfullscreen="" frameborder="0" height="360" src="https://www.youtube.com/embed/zw51X1JQhQ0" width="640"></iframe>
J'ai implémenté les idées suivantes dans l'extension de navigateur IRIS Whiz browser extension, so if you use the management portal to help with your day-to-day integration management this extension could be for you!
Iris a désormais une liste déroulante de rafraîchissement automatique pour la page des files d'attente (Queues). Cette option permet de rafraîchir la file d'attente à l'intervalle sélectionné. Cette fonctionnalité ne s'applique pas à Ensemble, qui en dispose déjà.
C'est utile si vous avez un concours de clics à venir et que vous avez besoin du repos de votre doigt de clic.
Implémenté à partir de l'idée: https://ideas.intersystems.com/ideas/DPI-I-487
Dans la page de la visionneuse de messages Message Viewer, vous pouvez cliquer sur le bouton Iris Whiz Export pour télécharger une copie CSV des données contenues actuellement dans votre table de recherche.
Utile si vous voulez faire une analyse rapide de vos données sans utiliser la nouvelle page Chart.JS que j'ai mis une éternité à créer (voir ici en action!).
Implémenté à partir de l'idée: https://ideas.intersystems.com/ideas/DPI-I-566
Ajout d'options de tri pour l'onglet "file d'attente" de la page de production. Le tri par défaut est le nombre d'erreurs. Cliquez sur l'en-tête d'un table pour passer de l'ordre de tri asc à l'ordre de tri desc. Utilisez la barre de recherche pour trouver rapidement des éléments.
Utile si vous ne voulez pas faire défiler sur l'écran pour accéder à la plus grande file d'attente.
Implémenté à partir de l'idée: https://ideas.intersystems.com/ideas/DPI-I-628
Permet de classer par ordre alphabétique la liste déroulante des catégories dans la page de production, quel que soit la casse. Sans cela, l'ordre est dépendant de la casse.
Utile si vous voulez trouver des choses dans la liste des catégories, sans avoir à tout recatégoriser dans la même casse pour y parvenir.
Implémenté à partir de l'idée: https://ideas.intersystems.com/ideas/DPI-I-625
Bonus!
Il existe également un taux de rafraîchissement dans l'onglet de la visionneuse de messages dans la page de production. Cela rafraîchira également votre onglet de file d'attente si vous sélectionnez un intervalle et naviguez vers l'onglet de la file d'attente.
Si l'une de ces idées vous plaît, téléchargez l'extension de navigateur et communiquez moi vos commentaires. Vous trouverez une vidéo d'installation sur la liste d'OpenExchange que je vous recommande de regarder car vous devrez en réaliser une partie pour que la plupart des fonctionnalités fonctionnent!
Dans le cadre du concours Open Exchange, l'hôpital Salford Royal (Dean White et Mark O'Reilly) a développé une API REST pour SharePoint, un modèle qui fonctionne mais qui peut aussi servir de point de départ à vos propres applications REST
Lorsque vous utilisez la v1 du service REST de l'API de Sharepoint, vous avez besoin d'un identifiant locataire, d'un identifiant client, d'un code secret client et d'un nom de locataire
.png)
Le code au milieu est l'identifiant locataire
Créez un nom de config client comme vous le souhaitez
.png)
Configurer votre client oauth en remplaçant l'adresse IP de votre serveur par l'adresse IP du serveur sur lequel vous vous trouvez (pas l'adresse VIP - si vous ne faites pas partie d'un VIP, l'adresse locale peut fonctionner)
.png)
Ajouter les informations d'identification client
modifiez les paramètres sur SharepointRESTConnector comme HTTPSERVER,SHAREPOINT-SITENAME- SHAREPOINT FILEPATH- SSL (vierge jusqu'à la v. 1.3) les paramètres remplacent le nom locataire et l'identifiant locataire.
Code
OAuth Scope n'est pas utilisateur dans cet exemple mais est laissé ici comme modèle si vous en avez besoin pour d'autres implémentations rest
Il utilise et s'appuie sur rest par défaut Set tSC=..AddAccessToken(.tHttpRequest) qui gère le jeton et transmet toutes les propriétés supplémentaires requises pour l'API. Pour l'API SharePoint, une ressource est nécessaire et cette dernière est ajoutée dans les paramètres dans les notes de commentaires
/// Pour SPO, les paramètres doivent être {"resource":"00000003-0000-0ff1-ce00-000000000000/{TennantName}.sharepoint.com@{TennantID}"} <p>/// 00000003-0000-0ff1-ce00-000000000000 est l'identifiant ResourceID attribué à SPO par Microsoft et ne doit pas être modifié <p>/// {TennantName} doit être modifié pour être identique à celui du serveur HTTP, par exemple intersystems.sharepoint.com <p>/// {TennantID} est l'identifiant de votre nom de serveur Appelle la liste des fichiers dans le répertoire dont vous disposez. Cette fonction peut indiquer le temps écoulé depuis le dernier téléchargement ou la durée totale des fichiers Elle interroge l'en-tête
Elle appelle GetFolderByServerRealativeURL
Set..Adapter.URL="/sites/"_$$$URLENCODE(..SharepointSitename)_"/_api/web/GetFolderByServerRelativeUrl('"_$$$URLENCODE(..SharepointFilePath)_"')/Files"_filter Set..Adapter.URL="/sites/"_$$$URLENCODE(..SharepointSitename)_"/_api/web/GetFolderByServerRelativeUrl('"_$$$URLENCODE(..SharepointFilePath)_"')/Files"_filterLa réponse est lue par le processeur.
Il envoie des messages http comme le ferait POSTMAN
Une méthode de réponse Constuct a été tirée de l'opération générique écrite par intersystems pour renvoyer des réponses http
Appelle une demande d'envoi de suppression à getfolderbyserverrelativeurl/files getfolderbyserverrelativeurl/files
lignes clés ci-dessous
Set..Adapter.URL="/sites/"_$$$URLENCODE(..SharepointSitename)_"/_api/web/GetFolderByServerRelativeUrl('"_$$$URLENCODE(..SharepointFilePath)_"')/Files('"_$$$URLENCODE(pRequest.FileName)_"')"Set tSC=..AddAccessToken(.tHttpRequest)
s tSC = ..SendRequest(.tHttpResponse,send,tHttpRequest, .pResponse)
Quit..constructResponse(.tHttpResponse,.pResponse)Si c'est un Ens.StringContainer (vous pourriez en faire un message sur mesure qui l'étendrait, comme Messages.DownloadSharpointFile), il lit le nom et l'envoie dans l'url de l'api. Il lit le paquet de réponses et ajoute le flux binaire à un steamcontainer. Comme toujours, il faut créer le flux et l'empaqueter dans le streamcontainer.
Code clé ci-dessous (quelques s ont été modifiés pour être affichés ici)
set binaryStream =##Class(%Stream.FileBinary).%New()
Set tSC=..AddAccessToken(.tHttpRequest)
Set..Adapter.URL="/sites/"_$$$URLENCODE(..SharepointSitename)_"/_api/web/GetFolderByServerRelativeUrl('"_$$$URLENCODE(..SharepointFilePath)_"')/Files('"_$$$URLENCODE(pRequest.StringValue)_"')/OpenBinaryStream()"Set tHttpResponse = ##class(%Net.HttpResponse).%New()
set send="GET"set tSC = ..SendRequest(.tHttpResponse,send,tHttpRequest, .pResponse)
set pDownloadResponse =##Class(Ens.StreamContainer).%New(binaryStream)
set pDownloadResponse.OriginalFilename=pRequest.StringValue
GetFolderByServerRelativeUrl/filepath/Files/add(url=filename,overwrite?)
Lignes clées
Set..Adapter.URL="/sites/"_$$$URLENCODE(..SharepointSitename)_"/_api/web/GetFolderByServerRelativeUrl('"_$$$URLENCODE(..SharepointFilePath)_"')/Files/add(url='"_fn_"',overwrite="_$$$URLENCODE(..OverwriteExistingFile)_")"Set tSC=..AddAccessToken(.tHttpRequest)
s tHttpRequest.EntityBody=##Class(%Stream.FileBinary).%New()
s sc=tHttpRequest.EntityBody.CopyFromAndSave(pFileToUpload.Stream)
Set tHttpResponse = ##class(%Net.HttpResponse).%New()
S send="POST"s tSC = ..SendRequest(.tHttpResponse,send,tHttpRequest, .pResponse)Cette fonction permet d'envoyer toute requête qui attend une réponse http.
Assure le transfert des réponses et l'envoi de ENSLIB.HTTP.GenericMessage. De nombreux en-têtes sont renvoyés et une case à cocher permet de simplifier la réponse pour qu'elle ne contienne qu'un code d'erreur et des données.
Utilisé ailleurs dans l'EIT et non dans le code original de cette méthode
C'était le véritable apprentissage. il s'agit d'un code par défaut pour utiliser les paramètres OAuth Intersystems et non pas un code en dur à chaque fois que nous avons besoin de l'utiliser.
Tout est construit autour de trois appels
est autorisé et
Set isAuthorised = ##class(%SYS.OAuth2.AccessToken).IsAuthorized(..OAuthClientApplicationName,sessionId,..OAuthScope,.accessToken,,.responseProperties,.error)Obtenez un jeton d'accès
Set tSC = ##class(%SYS.OAuth2.Authorization).GetAccessTokenClient(..OAuthClientApplicationName,..OAuthScope,.properties,.error,.sessionId)et un jeton d'ajout qui l'ajoute à l'en-tête - malheureusement, il ne semble pas qu'il puisse l'ajouter au corps du message si l'identifiant est requis par d'autres API
;La valeur par défaut de sslConfiguration provient de l'instance OAuth2.Client. Set tSC = ##class(%SYS.OAuth2.AccessToken).AddAccessToken(pHttpRequest,sendType,,..OAuthClientApplicationName,sessionId)En outre, l'API Sharepoint nécessite une ressource. Nous avons généralisé l'utilisation de JSON, et si vous avez besoin d'autres paramètres, nous avons pensé à les ajouter en JSON afin de pouvoir réutiliser le modèle à l'avenir.
il l'ajoute à l'objet chaîne de caractères utilisé par les propriétés. il s'agit d'une chaîne de caractères sérialisée sous forme de tableau ou similaire
s paramsarr = [].%FromJSON(..Params)
s iterator = paramsarr.%GetIterator()
s properties=""While iterator.%GetNext(.key,.value)
{
s properties(key)=value
}
.png)
Téléchargement de fichiers
.png)
suppression de fichiers
si vous cochez cette case
.png)
Ajout de fichiers
.png)
Remerciements à @Dean White
https://youtu.be/485dTXYp2BUMise à jour - ajout d'un lien YouTube et correction du lien d'échange ouvert;
Salut les developpeurs,
🎄 L'ambiance de Noël est dans l'air et nous avons décidé d'essayer quelque chose de nouveau pour le dernier concours de programmation de l'année. Bienvenue au concours
Durée : 2 - 22 décembre 2024
Prix : $14,000$
Bonjour les Développeurs !
Nous avons de nouveaux articles super intéressants à lire grâce aux merveilleux participants du Concours d'Articles Techniques InterSystems !
Et maintenant, il est temps d'annoncer les gagnants !
Pour les développeurs axés sur le backend, le développement du frontend peut être une tâche intimidante, voire cauchemardesque. Au début de ma carrière, les frontières entre frontend et backend étaient brouillées et tout le monde était censé s'occuper des deux. Le CSS, en particulier, a été une lutte constante ; il a été ressenti comme une mission impossible.
Bien que j'apprécie le travail sur le front-end, CSS reste un défi complexe pour moi, d'autant plus que je l'ai appris par essais et erreurs. Le mème de Peter Griffin s'efforçant d'ouvrir des stores illustre parfaitement mon expérience de l'apprentissage du CSS.
Mais aujourd'hui, tout est changé. Des outils comme Streamlit ont révolutionné le jeu pour les développeurs qui, comme moi, préfèrent le confort de l'écran noir d'un terminal. Fini le temps où l'on se débattait avec des lignes de code qui ressemblaient à des messages cryptiques d'extraterrestres (je te regarde, CSS!). Comme le dit toujours le docteur Károly Zsolnai-Fehér de Two Minute Papers, "Quelle époque pour être en vie !". Avec Streamlit, vous pouvez créer une application web complète en utilisant uniquement du code Python. Voulez-vous le voir à l'œuvre? Attachez vos ceintures, car je suis sur le point de partager ma tentative de création d'un frontend pour SQLZilla en utilisant cet outil génial.
Pour l'installer, il suffit d'ouvrir votre terminal et de lancer le sort suivant:
pip install streamlit
(Ou vous pouvez l'ajouter à votre fichier requirements.txt.)
Créez un fichier, app.py et ajoutez cet extrait de code pour afficher un titre "SQLZilla":
import streamlit as st
st.title("SQLZilla")
L'événement est à vous!
Ouvrez à nouveau votre terminal et tapez la commande suivante pour activer votre création:
streamlit run app.py
Voila! Votre application Streamlit devrait apparaître dans votre navigateur web, affichant fièrement le titre "SQLZilla".
Ajoutez une image en utilisant la méthode d'image, pour la centraliser j'ai juste créé 3 colonnes et je les ajouté au centre (honte à moi)
st.title("SQLZilla")
left_co, cent_co, last_co = st.columns(3)
with cent_co:
st.image("small_logo.png", use_column_width=True)
Pour gérer les configurations et les résultats des requêtes, vous pouvez utiliser l'état de la session. Vous trouverez ci-dessous la manière d'enregistrer les valeurs de configuration et de stocker les résultats des requêtes:
if 'hostname' not in st.session_state:
st.session_state.hostname = 'sqlzilla-iris-1'
if 'user' not in st.session_state:
st.session_state.user = '_system'
if 'pwd' not in st.session_state:
st.session_state.pwd = 'SYS'
# Add other session states as needed
Pour connecter SQLZilla à une base de données IRIS InterSystems, vous pouvez utiliser SQLAlchemy. Tout d'abord, installez SQLAlchemy avec:
pip install sqlalchemy
Ensuite, configurez la connexion dans votre fichier app.py:
from sqlalchemy import create_engine
import pandas as pd
# Remplacez par vos propres données de connexion
engine = create_engine(f"iris://{user}:{password}@{host}:{port}/{namespace}")
def run_query(query):
with engine.connect() as connection:
result = pd.read_sql(query, connection)
return result
Une fois connecté à la base de données, vous pouvez utiliser Pandas et Streamlit pour afficher les résultats de vos requêtes. Voici un exemple d'affichage d'un DataFrame dans votre application Streamlit:
if 'query' in st.session_state:
query = st.session_state.query
df = run_query(query)
st.dataframe(df)
Pour rendre votre application plus interactive, vous pouvez utiliser st.rerun() pour rafraîchir l'application à chaque changement de la requête:
if 'query' in st.session_state and st.button('Run Query'):
df = run_query(st.session_state.query)
st.dataframe(df)
st.rerun()
Vous pouvez trouver des composants Streamlit variés à utiliser. Dans SQLZilla, j'ai ajouté une version de l'éditeur de code ACE appelée streamlit-code-editor:
from code_editor import code_editor
editor_dict = code_editor(st.session_state.code_text, lang="sql", height=[10, 100], shortcuts="vscode")
if len(editor_dict['text']) != 0:
st.session_state.code_text = editor_dict['text']
Comme l'assistant SQLZilla est écrit en Python, j'ai simplement appelé la classe:
from sqlzilla import SQLZilla
def assistant_interaction(sqlzilla, prompt):
response = sqlzilla.prompt(prompt)
st.session_state.chat_history.append({"role": "user", "content": prompt})
st.session_state.chat_history.append({"role": "assistant", "content": response})
if "SELECT" in response.upper():
st.session_state.query = response
return response
Bravo! Vous avez créé votre propre SQLZilla. Continuez à explorer Streamlit et améliorez votre application avec d'autres fonctionnalités. Et si vous aimez SQLZilla, votez pour cet incroyable assistant qui convertit le texte en requêtes!
Salut les developpeurs,
Nous aimerions vous inviter à participer à notre prochain concours dédié à la création d'outils utiles pour faciliter la vie de vos collègues développeurs :
🏆 Concours d'outils de développement InterSystems 🏆
Durée : 9 - 29 septembre 2024
Prix : $14,000$
.jpg)
Salut la Communauté,
Nous sommes heureux de vous inviter au prochain concours de programmation en ligne InterSystems, axé sur Python !
🏆 Concours InterSystems Python 🏆
Durée : 15 juillet - 4 août 2024
Prix : $14,000$
.jpg)
Salut la Communauté,
Nous sommes ravis de vous annoncer le tout premier concours de rédaction d'articles techniques en français !
✍️ Concours d'articles techniques ✍️
C'est l'occasion idéale pour tous les passionnés de technologie InterSystems de partager leurs connaissances et d'exposer leurs talents de rédacteur. Peu importe votre niveau d'expérience, tout le monde est invité à participer. Les articles peuvent couvrir une vaste gamme de sujets techniques liés aux produits ou services InterSystems. Alors laissez libre cours à votre créativité et à votre expertise !
📅 Période du concours : du 2 au 29 septembre
🎁 Cadeaux pour tous : un cadeau spécial pour chaque participant !
🏅 Prix pour les auteurs de meilleurs articles
%20(2).jpg)
Salut la Communauté,
Nous avons des nouvelles excitantes ! Le nouveau concours de programmation en ligne InterSystems dédié à l'IA générative, à la recherche de vecteurs et au Machine Learning démarre très bientôt !
🏆 Concours InterSystems Vector Search, GenAI et ML 🏆
Durée : avril 22 - mai 19, 2024
Prix : $14,000
.jpg)
L'intelligence artificielle (IA) attire beaucoup d'attention dernièrement car elle peut changer de nombreux domaines de nos vies. Une meilleure puissance informatique et plus de données ont aidé l'IA à réaliser des choses incroyables, comme l'amélioration des tests médicaux et la création de voitures autonomes. L'IA peut également aider les entreprises à prendre de meilleures décisions et à travailler plus efficacement, c'est pourquoi elle devient de plus en plus populaire et largement utilisé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.
Salut la communauté,
Nous avons des nouvelles passionnantes! C'est l'heure du prochain concours de rédaction d'articles techniques InterSystems !
✍️ Concours d'articles techniques : Tutoriels InterSystems IRIS ✍️
Rédigez un article qui peut être considéré comme un tutoriel pour les programmeurs InterSystems IRIS de tout niveau : débutant/intermédiaire/sénior du 19 février au 17 mars24 mars !
🎁 Des prix pour tous : Un prix spécial pour chaque participant au concours !
(4).jpg)